Starting to get in to diminishing returns here

Author: NullVoxPopuli

package.json

@@ -321,6 +321,7 @@
       "@ember/enumerable/mutable.js": "ember-source/@ember/enumerable/mutable.js",
       "@ember/helper/index.js": "ember-source/@ember/helper/index.js",
       "@ember/instrumentation/index.js": "ember-source/@ember/instrumentation/index.js",
+      "@ember/instrumentation/lib/internal-instrument.js": "ember-source/@ember/instrumentation/lib/internal-instrument.js",
       "@ember/modifier/index.js": "ember-source/@ember/modifier/index.js",
       "@ember/modifier/on.js": "ember-source/@ember/modifier/on.js",
       "@ember/object/-internals.js": "ember-source/@ember/object/-internals.js",

packages/@ember/-internals/glimmer/lib/resolver.ts

@@ -1,7 +1,7 @@
 import type { InternalFactory, InternalOwner } from '@ember/-internals/owner';
 import { isFactory } from '@ember/-internals/owner';
 import { assert } from '@ember/debug';
-import { _instrumentStart } from '@ember/instrumentation';
+import { _instrumentStart } from '@ember/instrumentation/lib/internal-instrument';
 import { DEBUG } from '@glimmer/env';
 import type {
   ClassicResolver,

packages/@ember/instrumentation/index.ts

@@ -1,28 +1,21 @@
 /* eslint no-console:off */
 /* global console */
 
-import { ENV } from '@ember/-internals/environment/lib/env';
-import { assert } from '@ember/debug';
+import {
+  _instrumentStart,
+  NOOP,
+  resetCache,
+  subscribers,
+} from './lib/internal-instrument';
+import type { Listener, StructuredProfilePayload, Subscriber } from './lib/internal-instrument';
 
-export interface Listener<T> {
-  before: (name: string, timestamp: number, payload: object) => T;
-  after: (name: string, timestamp: number, payload: object, beforeValue: T) => void;
-}
-
-export interface Subscriber<T> {
-  pattern: string;
-  regex: RegExp;
-  object: Listener<T>;
-}
+export type { Listener, StructuredProfilePayload, Subscriber };
+export { _instrumentStart };
 
 export interface PayloadWithException {
   exception?: any;
 }
 
-export interface StructuredProfilePayload {
-  object: string | object;
-}
-
 /**
 @module @ember/instrumentation
 @private
@@ -78,23 +71,7 @@ export interface StructuredProfilePayload {
   @static
   @private
 */
-export let subscribers: Subscriber<any>[] = [];
-let cache: { [key: string]: Listener<any>[] } = {};
-
-function populateListeners(name: string) {
-  let listeners: Listener<any>[] = [];
-
-  for (let subscriber of subscribers) {
-    if (subscriber.regex.test(name)) {
-      listeners.push(subscriber.object);
-    }
-  }
-
-  cache[name] = listeners;
-  return listeners;
-}
-
-const time = (): number => performance.now();
+export { subscribers };
 
 type InstrumentCallback<Binding, Result> = (this: Binding) => Result;
 
@@ -196,67 +173,6 @@ function withFinalizer<Binding, Result>(
   }
 }
 
-function NOOP() {}
-
-// private for now
-export function _instrumentStart(name: string, payloadFunc: () => object): () => void;
-export function _instrumentStart<Arg>(
-  name: string,
-  payloadFunc: (arg: Arg) => object,
-  payloadArg: Arg
-): () => void;
-export function _instrumentStart<Arg>(
-  name: string,
-  payloadFunc: ((arg: Arg) => object) | (() => object),
-  payloadArg?: Arg
-): () => void {
-  if (subscribers.length === 0) {
-    return NOOP;
-  }
-
-  let listeners = cache[name];
-
-  if (!listeners) {
-    listeners = populateListeners(name);
-  }
-
-  if (listeners.length === 0) {
-    return NOOP;
-  }
-
-  let payload = payloadFunc(payloadArg!);
-
-  let STRUCTURED_PROFILE = ENV.STRUCTURED_PROFILE;
-  let timeName: string;
-  if (STRUCTURED_PROFILE) {
-    timeName = `${name}: ${(payload as StructuredProfilePayload).object}`;
-    console.time(timeName);
-  }
-
-  let beforeValues: any[] = [];
-  let timestamp = time();
-  for (let listener of listeners) {
-    beforeValues.push(listener.before(name, timestamp, payload));
-  }
-
-  const constListeners = listeners;
-
-  return function _instrumentEnd(): void {
-    let timestamp = time();
-    for (let i = 0; i < constListeners.length; i++) {
-      let listener = constListeners[i];
-      assert('has listener', listener); // Iterating over values
-      if (typeof listener.after === 'function') {
-        listener.after(name, timestamp, payload, beforeValues[i]);
-      }
-    }
-
-    if (STRUCTURED_PROFILE) {
-      console.timeEnd(timeName);
-    }
-  };
-}
-
 /**
   Subscribes to a particular event or instrumented block of code.
 
@@ -292,7 +208,7 @@ export function subscribe<T>(pattern: string, object: Listener<T>): Subscriber<T
   };
 
   subscribers.push(subscriber);
-  cache = {};
+  resetCache();
 
   return subscriber;
 }
@@ -317,7 +233,7 @@ export function unsubscribe(subscriber: Subscriber<any>): void {
   }
 
   subscribers.splice(index, 1);
-  cache = {};
+  resetCache();
 }
 
 /**
@@ -330,5 +246,5 @@ export function unsubscribe(subscriber: Subscriber<any>): void {
 */
 export function reset(): void {
   subscribers.length = 0;
-  cache = {};
+  resetCache();
 }

packages/@ember/instrumentation/lib/internal-instrument.ts

@@ -0,0 +1,116 @@
+// Hot-path bits of `@ember/instrumentation`, factored out so internal
+// callers (the resolver, component managers) don't have to drag in the
+// full subscribe/unsubscribe/instrument machinery — most of which is dead
+// code unless something actually subscribes (e.g. Ember Inspector).
+//
+// `subscribers` and `cache` live here; `index.ts` imports and mutates
+// them via `subscribe`/`unsubscribe`/`reset`.
+
+import { ENV } from '@ember/-internals/environment/lib/env';
+import { assert } from '@ember/debug';
+
+export interface Listener<T> {
+  before: (name: string, timestamp: number, payload: object) => T;
+  after: (name: string, timestamp: number, payload: object, beforeValue: T) => void;
+}
+
+export interface Subscriber<T> {
+  pattern: string;
+  regex: RegExp;
+  object: Listener<T>;
+}
+
+export interface StructuredProfilePayload {
+  object: string | object;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const subscribers: Subscriber<any>[] = [];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const cache: { [key: string]: Listener<any>[] } = {};
+
+export function resetCache(): void {
+  for (const key of Object.keys(cache)) {
+    delete cache[key];
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function populateListeners(name: string): Listener<any>[] {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let listeners: Listener<any>[] = [];
+
+  for (let subscriber of subscribers) {
+    if (subscriber.regex.test(name)) {
+      listeners.push(subscriber.object);
+    }
+  }
+
+  cache[name] = listeners;
+  return listeners;
+}
+
+const time = (): number => performance.now();
+
+export const NOOP = (): void => {};
+
+export function _instrumentStart(name: string, payloadFunc: () => object): () => void;
+export function _instrumentStart<Arg>(
+  name: string,
+  payloadFunc: (arg: Arg) => object,
+  payloadArg: Arg
+): () => void;
+export function _instrumentStart<Arg>(
+  name: string,
+  payloadFunc: ((arg: Arg) => object) | (() => object),
+  payloadArg?: Arg
+): () => void {
+  if (subscribers.length === 0) {
+    return NOOP;
+  }
+
+  let listeners = cache[name];
+
+  if (!listeners) {
+    listeners = populateListeners(name);
+  }
+
+  if (listeners.length === 0) {
+    return NOOP;
+  }
+
+  let payload = payloadFunc(payloadArg!);
+
+  let STRUCTURED_PROFILE = ENV.STRUCTURED_PROFILE;
+  let timeName: string;
+  if (STRUCTURED_PROFILE) {
+    timeName = `${name}: ${(payload as StructuredProfilePayload).object}`;
+    // eslint-disable-next-line no-console
+    console.time(timeName);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let beforeValues: any[] = [];
+  let timestamp = time();
+  for (let listener of listeners) {
+    beforeValues.push(listener.before(name, timestamp, payload));
+  }
+
+  const constListeners = listeners;
+
+  return function _instrumentEnd(): void {
+    let timestamp = time();
+    for (let i = 0; i < constListeners.length; i++) {
+      let listener = constListeners[i];
+      assert('has listener', listener);
+      if (typeof listener.after === 'function') {
+        listener.after(name, timestamp, payload, beforeValues[i]);
+      }
+    }
+
+    if (STRUCTURED_PROFILE) {
+      // eslint-disable-next-line no-console
+      console.timeEnd(timeName);
+    }
+  };
+}

packages/@glimmer/debug/lib/dism/operands.ts

@@ -68,7 +68,7 @@ class Disassembler<in out Added extends OperandType> {
   }
 }
 
-export const OPERANDS = Disassembler.build((d) => {
+export const OPERANDS = /*#__PURE__*/ Disassembler.build((d) => {
   return d
     .add(['imm/u32', 'imm/i32', 'imm/u32{todo}', 'imm/i32{todo}'], ({ value }) => ['number', value])
     .add(['const/i32[]'], ({ value, constants }) => [

packages/@glimmer/runtime/lib/debug-render-tree-register.ts

@@ -0,0 +1,13 @@
+// Side-effect-only module: registers `DebugRenderTreeImpl` as the factory
+// used by `EnvironmentImpl` when `delegate.enableDebugTooling` is true.
+//
+// Importing this file pulls `./debug-render-tree` into the bundle. Apps
+// that don't need render-tree introspection (anything not running the
+// Ember Inspector) shouldn't import this module — `EnvironmentImpl`'s
+// `debugRenderTree` will silently stay `undefined`, which is the same
+// behavior you'd get with `enableDebugTooling: false`.
+
+import DebugRenderTreeImpl from './debug-render-tree';
+import { registerDebugRenderTreeFactory } from './environment';
+
+registerDebugRenderTreeFactory(() => new DebugRenderTreeImpl());

packages/@glimmer/runtime/lib/environment.ts

@@ -2,6 +2,7 @@ import { DEBUG } from '@glimmer/env';
 import type {
   ClassicResolver,
   ComponentInstanceWithCreate,
+  DebugRenderTree,
   Environment,
   EnvironmentOptions,
   GlimmerTreeChanges,
@@ -19,10 +20,20 @@ import { ProgramImpl } from '@glimmer/program/lib/program';
 import { track } from '@glimmer/validator/lib/tracking';
 import { UPDATE_TAG as updateTag } from '@glimmer/validator/lib/validators';
 
-import DebugRenderTree from './debug-render-tree';
 import { DOMChangesImpl, DOMTreeConstruction } from './dom/helper';
 import { isArgumentError } from './vm/arguments';
 
+// Lazy registration: the DebugRenderTree implementation registers itself
+// here on import. Apps that don't need it (e.g. anything that isn't running
+// the Ember Inspector) won't pull `./debug-render-tree` into the bundle,
+// since this module no longer references it statically.
+type DebugRenderTreeFactory = () => DebugRenderTree<object>;
+let debugRenderTreeFactory: DebugRenderTreeFactory | null = null;
+
+export function registerDebugRenderTreeFactory(factory: DebugRenderTreeFactory): void {
+  debugRenderTreeFactory = factory;
+}
+
 export const TRANSACTION: TransactionSymbol = Symbol('TRANSACTION') as TransactionSymbol;
 
 class TransactionImpl implements Transaction {
@@ -114,7 +125,10 @@ export class EnvironmentImpl implements Environment {
     private delegate: EnvironmentDelegate
   ) {
     this.isInteractive = delegate.isInteractive;
-    this.debugRenderTree = this.delegate.enableDebugTooling ? new DebugRenderTree() : undefined;
+    this.debugRenderTree =
+      this.delegate.enableDebugTooling && debugRenderTreeFactory
+        ? debugRenderTreeFactory()
+        : undefined;
     this.isArgumentCaptureError = this.delegate.enableDebugTooling ? isArgumentError : undefined;
     if (options.appendOperations) {
       this.appendOperations = options.appendOperations;