ember-source 4.3.0-beta.1 → 4.4.0-alpha.3

package/dist/packages/@ember/-internals/routing/lib/system/router.js

@@ -1,6 +1,7 @@
 import { privatize as P } from '@ember/-internals/container';
 import { computed, get, set } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
+import { BucketCache } from '@ember/-internals/routing';
 import { A as emberA, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
 import { assert, deprecate, info } from '@ember/debug';
 import EmberError from '@ember/error';
@@ -16,6 +17,7 @@ import RouterState from './router_state';
 */
 
 import Router, { logAbort, STATE_SYMBOL } from 'router_js';
+import EngineInstance from '@ember/engine/instance';
 
 function defaultDidTransition(infos) {
   updatePaths(this);
@@ -77,7 +79,7 @@ const {
 
 class EmberRouter extends EmberObject.extend(Evented) {
   constructor(owner) {
-    super(...arguments);
+    super(owner);
     this._didSetupRouter = false;
     this._initialTransitionStarted = false;
     this.currentURL = null;
@@ -92,6 +94,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
     this._handledErrors = new Set();
     this._engineInstances = Object.create(null);
     this._engineInfoByRoute = Object.create(null);
+    this._slowTransitionTimer = null;
     this.currentState = null;
     this.targetState = null;
 
@@ -99,7 +102,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     this.namespace = owner.lookup('application:main');
     let bucketCache = owner.lookup(P`-bucket-cache:main`);
-    assert('BUG: BucketCache should always be present', bucketCache !== undefined);
+    assert('BUG: BucketCache should always be present', bucketCache instanceof BucketCache);
     this._bucketCache = bucketCache;
     let routerService = owner.lookup('service:router');
     assert('BUG: RouterService should always be present', routerService !== undefined);
@@ -699,11 +702,13 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let instances = this._engineInstances;
 
     for (let name in instances) {
-      let instance = instances[name];
-      assert('has instance', instance);
+      let instanceMap = instances[name];
+      assert('has instanceMap', instanceMap);
 
-      for (let id in instance) {
-        run(instance[id], 'destroy');
+      for (let id in instanceMap) {
+        let instance = instanceMap[id];
+        assert('has instance', instance);
+        run(instance, 'destroy');
       }
     }
   }
@@ -916,7 +921,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
     }
   }
 
-  _doTransition(_targetRouteName, models, _queryParams, _keepDefaultQueryParamValues) {
+  _doTransition(_targetRouteName, models, _queryParams, _fromRouterService) {
     let targetRouteName = _targetRouteName || getActiveTargetName(this._routerMicrolib);
 
     assert(`The route ${targetRouteName} was not found`, Boolean(targetRouteName) && this._routerMicrolib.hasRoute(targetRouteName));
@@ -927,7 +932,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     Object.assign(queryParams, _queryParams);
 
-    this._prepareQueryParams(targetRouteName, models, queryParams, Boolean(_keepDefaultQueryParamValues));
+    this._prepareQueryParams(targetRouteName, models, queryParams, Boolean(_fromRouterService));
 
     let transition = this._routerMicrolib.transitionTo(targetRouteName, ...models, {
       queryParams
@@ -1165,7 +1170,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
   _scheduleLoadingEvent(transition, originRoute) {
     this._cancelSlowTransitionTimer();
 
-    this._slowTransitionTimer = scheduleOnce('routerTransitions', this, '_handleSlowTransition', transition, originRoute);
+    this._slowTransitionTimer = scheduleOnce('routerTransitions', this, this._handleSlowTransition, transition, originRoute);
   }
 
   _handleSlowTransition(transition, originRoute) {
@@ -1221,7 +1226,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     if (!engineInstance) {
       let owner = getOwner(this);
-      assert('Router is unexpectedly missing an owner', owner);
+      assert('Expected router to have EngineInstance as owner', owner instanceof EngineInstance);
       assert(`You attempted to mount the engine '${name}' in your router map, but the engine can not be found.`, owner.hasRegistration(`engine:${name}`));
       engineInstance = owner.buildChildEngineInstance(name, {
         routable: true,
@@ -1526,16 +1531,6 @@ function updatePaths(router) {
   set(router, 'currentPath', path);
   set(router, 'currentRouteName', currentRouteName);
   set(router, 'currentURL', currentURL);
-  let owner = getOwner(router);
-  assert('Router is unexpectedly missing an owner', owner);
-  let appController = owner.lookup('controller:application');
-
-  if (!appController) {
-    // appController might not exist when top-level loading/error
-    // substates have been entered since ApplicationRoute hasn't
-    // actually been entered at that point.
-    return;
-  }
 }
 
 function didBeginTransition(transition, router) {

package/dist/packages/@ember/-internals/routing/lib/utils.js

@@ -1,6 +1,7 @@
 import { get } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
 import { assert, deprecate } from '@ember/debug';
+import EngineInstance from '@ember/engine/instance';
 import EmberError from '@ember/error';
 import { STATE_SYMBOL } from 'router_js';
 const ALL_PERIODS_REGEX = /\./g;
@@ -219,7 +220,7 @@ export function resemblesURL(str) {
 export function prefixRouteNameArg(route, args) {
   let routeName;
   let owner = getOwner(route);
-  assert('Route is unexpectedly missing an owner', owner);
+  assert('Expected route to have EngineInstance as owner', owner instanceof EngineInstance);
   let prefix = owner.mountPoint; // only alter the routeName if it's actually referencing a route.
 
   if (owner.routable && typeof args[0] === 'string') {

package/dist/packages/@ember/-internals/runtime/lib/compare.js

@@ -1,5 +1,6 @@
 import { typeOf } from './type-of';
 import Comparable from './mixins/comparable';
+import { assert } from '@ember/debug';
 const TYPE_ORDER = {
   undefined: 0,
   null: 1,
@@ -31,8 +32,9 @@ const TYPE_ORDER = {
 //                                              SSt  `------'`
 
 function spaceship(a, b) {
-  let diff = a - b;
-  return (diff > 0) - (diff < 0);
+  let diff = a - b; // SAFETY: Number casts true into 1 and false into 0. Therefore, this must end up as one of the Compare values.
+
+  return Number(diff > 0) - Number(diff < 0);
 }
 /**
  @module @ember/utils
@@ -94,11 +96,12 @@ export default function compare(v, w) {
   let type1 = typeOf(v);
   let type2 = typeOf(w);
 
-  if (type1 === 'instance' && Comparable.detect(v) && v.constructor.compare) {
+  if (type1 === 'instance' && isComparable(v) && v.constructor.compare) {
     return v.constructor.compare(v, w);
   }
 
-  if (type2 === 'instance' && Comparable.detect(w) && w.constructor.compare) {
+  if (type2 === 'instance' && isComparable(w) && w.constructor.compare) {
+    // SAFETY: Multiplying by a negative just changes the sign
     return w.constructor.compare(w, v) * -1;
   }
 
@@ -111,14 +114,20 @@ export default function compare(v, w) {
 
   switch (type1) {
     case 'boolean':
+      assert('both are boolean', typeof v === 'boolean' && typeof w === 'boolean');
+      return spaceship(Number(v), Number(w));
+
     case 'number':
+      assert('both are numbers', typeof v === 'number' && typeof w === 'number');
       return spaceship(v, w);
 
     case 'string':
+      assert('both are strings', typeof v === 'string' && typeof w === 'string');
       return spaceship(v.localeCompare(w), 0);
 
     case 'array':
       {
+        assert('both are arrays', Array.isArray(v) && Array.isArray(w));
         let vLen = v.length;
         let wLen = w.length;
         let len = Math.min(vLen, wLen);
@@ -137,16 +146,21 @@ export default function compare(v, w) {
       }
 
     case 'instance':
-      if (Comparable.detect(v)) {
+      if (isComparable(v) && v.compare) {
         return v.compare(v, w);
       }
 
       return 0;
 
     case 'date':
+      assert('both are dates', v instanceof Date && w instanceof Date);
       return spaceship(v.getTime(), w.getTime());
 
     default:
       return 0;
   }
+}
+
+function isComparable(value) {
+  return Comparable.detect(value);
 }

package/dist/packages/@ember/-internals/runtime/lib/mixins/comparable.js

@@ -18,13 +18,13 @@ import { Mixin } from '@ember/-internals/metal';
 export default Mixin.create({
   /**
     __Required.__ You must implement this method to apply this mixin.
-       Override to return the result of the comparison of the two parameters. The
+     Override to return the result of the comparison of the two parameters. The
     compare method should return:
-       - `-1` if `a < b`
+     - `-1` if `a < b`
     - `0` if `a == b`
     - `1` if `a > b`
-       Default implementation raises an exception.
-       @method compare
+     Default implementation raises an exception.
+     @method compare
     @param a {Object} the first object to compare
     @param b {Object} the second object to compare
     @return {Number} the result of the comparison

package/dist/packages/@ember/-internals/runtime/lib/mixins/container_proxy.js

@@ -15,7 +15,7 @@ import { Mixin } from '@ember/-internals/metal';
 let containerProxyMixin = {
   /**
    The container stores state.
-      @private
+    @private
    @property {Ember.Container} __container__
    */
   __container__: null,
@@ -23,16 +23,16 @@ let containerProxyMixin = {
   /**
    Returns an object that can be used to provide an owner to a
    manually created instance.
-      Example:
-      ```
+    Example:
+    ```
    import { getOwner } from '@ember/application';
-      let owner = getOwner(this);
-      User.create(
+    let owner = getOwner(this);
+    User.create(
      owner.ownerInjection(),
      { username: 'rwjblue' }
    )
    ```
-      @public
+    @public
    @method ownerInjection
    @since 2.3.0
    @return {Object}
@@ -43,30 +43,30 @@ let containerProxyMixin = {
 
   /**
    Given a fullName return a corresponding instance.
-      The default behavior is for lookup to return a singleton instance.
+    The default behavior is for lookup to return a singleton instance.
    The singleton is scoped to the container, allowing multiple containers
    to all have their own locally scoped singletons.
-      ```javascript
+    ```javascript
    let registry = new Registry();
    let container = registry.container();
-      registry.register('api:twitter', Twitter);
-      let twitter = container.lookup('api:twitter');
-      twitter instanceof Twitter; // => true
-      // by default the container will return singletons
+    registry.register('api:twitter', Twitter);
+    let twitter = container.lookup('api:twitter');
+    twitter instanceof Twitter; // => true
+    // by default the container will return singletons
    let twitter2 = container.lookup('api:twitter');
    twitter2 instanceof Twitter; // => true
-      twitter === twitter2; //=> true
+    twitter === twitter2; //=> true
    ```
-      If singletons are not wanted an optional flag can be provided at lookup.
-      ```javascript
+    If singletons are not wanted an optional flag can be provided at lookup.
+    ```javascript
    let registry = new Registry();
    let container = registry.container();
-      registry.register('api:twitter', Twitter);
-      let twitter = container.lookup('api:twitter', { singleton: false });
+    registry.register('api:twitter', Twitter);
+    let twitter = container.lookup('api:twitter', { singleton: false });
    let twitter2 = container.lookup('api:twitter', { singleton: false });
-      twitter === twitter2; //=> false
+    twitter === twitter2; //=> false
    ```
-      @public
+    @public
    @method lookup
    @param {String} fullName
    @param {Object} options
@@ -91,32 +91,32 @@ let containerProxyMixin = {
 
   /**
   Given a fullName return a factory manager.
-     This method returns a manager which can be used for introspection of the
+   This method returns a manager which can be used for introspection of the
   factory's class or for the creation of factory instances with initial
   properties. The manager is an object with the following properties:
-     * `class` - The registered or resolved class.
+   * `class` - The registered or resolved class.
   * `create` - A function that will create an instance of the class with
     any dependencies injected.
-     For example:
-     ```javascript
+   For example:
+   ```javascript
   import { getOwner } from '@ember/application';
-     let owner = getOwner(otherInstance);
+   let owner = getOwner(otherInstance);
   // the owner is commonly the `applicationInstance`, and can be accessed via
   // an instance initializer.
-     let factory = owner.factoryFor('service:bespoke');
-     factory.class;
+   let factory = owner.factoryFor('service:bespoke');
+   factory.class;
   // The registered or resolved class. For example when used with an Ember-CLI
   // app, this would be the default export from `app/services/bespoke.js`.
-     let instance = factory.create({
+   let instance = factory.create({
     someProperty: 'an initial property value'
   });
   // Create an instance with any injections and the passed options as
   // initial properties.
   ```
-     Any instances created via the factory's `.create()` method *must* be destroyed
+   Any instances created via the factory's `.create()` method *must* be destroyed
   manually by the caller of `.create()`. Typically, this is done during the creating
   objects own `destroy` or `willDestroy` methods.
-     @public
+   @public
   @method factoryFor
   @param {String} fullName
   @param {Object} options

package/dist/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.js

@@ -16,62 +16,62 @@ export default Mixin.create({
 
   /**
    Given a fullName return the corresponding factory.
-      @public
+    @public
    @method resolveRegistration
    @param {String} fullName
    @return {Function} fullName's factory
    */
-  resolveRegistration(fullName, options) {
+  resolveRegistration(fullName) {
     assert('fullName must be a proper full name', this.__registry__.isValidFullName(fullName));
-    return this.__registry__.resolve(fullName, options);
+    return this.__registry__.resolve(fullName);
   },
 
   /**
     Registers a factory that can be used for dependency injection (with
     `inject`) or for service lookup. Each factory is registered with
     a full name including two parts: `type:name`.
-       A simple example:
-       ```javascript
+     A simple example:
+     ```javascript
     import Application from '@ember/application';
     import EmberObject from '@ember/object';
-       let App = Application.create();
-       App.Orange = EmberObject.extend();
+     let App = Application.create();
+     App.Orange = EmberObject.extend();
     App.register('fruit:favorite', App.Orange);
     ```
-       Ember will resolve factories from the `App` namespace automatically.
+     Ember will resolve factories from the `App` namespace automatically.
     For example `App.CarsController` will be discovered and returned if
     an application requests `controller:cars`.
-       An example of registering a controller with a non-standard name:
-       ```javascript
+     An example of registering a controller with a non-standard name:
+     ```javascript
     import Application from '@ember/application';
     import Controller from '@ember/controller';
-       let App = Application.create();
+     let App = Application.create();
     let Session = Controller.extend();
-       App.register('controller:session', Session);
-       // The Session controller can now be treated like a normal controller,
+     App.register('controller:session', Session);
+     // The Session controller can now be treated like a normal controller,
     // despite its non-standard name.
     App.ApplicationController = Controller.extend({
       needs: ['session']
     });
     ```
-       Registered factories are **instantiated** by having `create`
+     Registered factories are **instantiated** by having `create`
     called on them. Additionally they are **singletons**, each time
     they are looked up they return the same instance.
-       Some examples modifying that default behavior:
-       ```javascript
+     Some examples modifying that default behavior:
+     ```javascript
     import Application from '@ember/application';
     import EmberObject from '@ember/object';
-       let App = Application.create();
-       App.Person = EmberObject.extend();
+     let App = Application.create();
+     App.Person = EmberObject.extend();
     App.Orange = EmberObject.extend();
     App.Email = EmberObject.extend();
     App.session = EmberObject.create();
-       App.register('model:user', App.Person, { singleton: false });
+     App.register('model:user', App.Person, { singleton: false });
     App.register('fruit:favorite', App.Orange);
     App.register('communication:main', App.Email, { singleton: false });
     App.register('session', App.session, { instantiate: false });
     ```
-       @method register
+     @method register
     @param  fullName {String} type:name (e.g., 'model:user')
     @param  factory {any} (e.g., App.Person)
     @param  options {Object} (optional) disable instantiation or singleton usage
@@ -81,17 +81,17 @@ export default Mixin.create({
 
   /**
    Unregister a factory.
-      ```javascript
+    ```javascript
    import Application from '@ember/application';
    import EmberObject from '@ember/object';
-      let App = Application.create();
+    let App = Application.create();
    let User = EmberObject.extend();
    App.register('model:user', User);
-      App.resolveRegistration('model:user').create() instanceof User //=> true
-      App.unregister('model:user')
+    App.resolveRegistration('model:user').create() instanceof User //=> true
+    App.unregister('model:user')
    App.resolveRegistration('model:user') === undefined //=> true
    ```
-      @public
+    @public
    @method unregister
    @param {String} fullName
    */
@@ -99,7 +99,7 @@ export default Mixin.create({
 
   /**
    Check if a factory is registered.
-      @public
+    @public
    @method hasRegistration
    @param {String} fullName
    @return {Boolean}
@@ -108,7 +108,7 @@ export default Mixin.create({
 
   /**
    Return a specific registered option for a particular factory.
-      @public
+    @public
    @method registeredOption
    @param  {String} fullName
    @param  {String} optionName
@@ -118,7 +118,7 @@ export default Mixin.create({
 
   /**
    Register options for a particular factory.
-      @public
+    @public
    @method registerOptions
    @param {String} fullName
    @param {Object} options
@@ -127,7 +127,7 @@ export default Mixin.create({
 
   /**
    Return registered options for a particular factory.
-      @public
+    @public
    @method registeredOptions
    @param  {String} fullName
    @return {Object} options
@@ -136,22 +136,22 @@ export default Mixin.create({
 
   /**
    Allow registering options for all factories of a type.
-      ```javascript
+    ```javascript
    import Application from '@ember/application';
-      let App = Application.create();
+    let App = Application.create();
    let appInstance = App.buildInstance();
-      // if all of type `connection` must not be singletons
+    // if all of type `connection` must not be singletons
    appInstance.registerOptionsForType('connection', { singleton: false });
-      appInstance.register('connection:twitter', TwitterConnection);
+    appInstance.register('connection:twitter', TwitterConnection);
    appInstance.register('connection:facebook', FacebookConnection);
-      let twitter = appInstance.lookup('connection:twitter');
+    let twitter = appInstance.lookup('connection:twitter');
    let twitter2 = appInstance.lookup('connection:twitter');
-      twitter === twitter2; // => false
-      let facebook = appInstance.lookup('connection:facebook');
+    twitter === twitter2; // => false
+    let facebook = appInstance.lookup('connection:facebook');
    let facebook2 = appInstance.lookup('connection:facebook');
-      facebook === facebook2; // => false
+    facebook === facebook2; // => false
    ```
-      @public
+    @public
    @method registerOptionsForType
    @param {String} type
    @param {Object} options
@@ -160,7 +160,7 @@ export default Mixin.create({
 
   /**
    Return the registered options for all factories of a type.
-      @public
+    @public
    @method registeredOptionsForType
    @param {String} type
    @return {Object} options
@@ -170,41 +170,42 @@ export default Mixin.create({
   /**
     Define a dependency injection onto a specific factory or all factories
     of a type.
-       When Ember instantiates a controller, view, or other framework component
+     When Ember instantiates a controller, view, or other framework component
     it can attach a dependency to that component. This is often used to
     provide services to a set of framework components.
-       An example of providing a session object to all controllers:
-       ```javascript
+     An example of providing a session object to all controllers:
+     ```javascript
     import { alias } from '@ember/object/computed';
     import Application from '@ember/application';
     import Controller from '@ember/controller';
     import EmberObject from '@ember/object';
-       let App = Application.create();
+     let App = Application.create();
     let Session = EmberObject.extend({ isAuthenticated: false });
-       // A factory must be registered before it can be injected
+     // A factory must be registered before it can be injected
     App.register('session:main', Session);
-       // Inject 'session:main' onto all factories of the type 'controller'
+     // Inject 'session:main' onto all factories of the type 'controller'
     // with the name 'session'
     App.inject('controller', 'session', 'session:main');
-       App.IndexController = Controller.extend({
+     App.IndexController = Controller.extend({
       isLoggedIn: alias('session.isAuthenticated')
     });
     ```
-       Injections can also be performed on specific factories.
-       ```javascript
+     Injections can also be performed on specific factories.
+     ```javascript
     App.inject(<full_name or type>, <property name>, <full_name>)
     App.inject('route', 'source', 'source:main')
     App.inject('route:application', 'email', 'model:email')
     ```
-       It is important to note that injections can only be performed on
+     It is important to note that injections can only be performed on
     classes that are instantiated by Ember itself. Instantiating a class
     directly (via `create` or `new`) bypasses the dependency injection
     system.
-       @public
+     @public
     @method inject
     @param  factoryNameOrType {String}
     @param  property {String}
     @param  injectionName {String}
+    @deprecated
   **/
   inject: registryAlias('injection')
 });

package/dist/packages/@ember/-internals/utils/index.js

@@ -573,7 +573,7 @@ function lookupDescriptor(obj, keyName) {
   @private
 */
 function canInvoke(obj, methodName) {
-  return obj !== null && obj !== undefined && typeof obj[methodName] === 'function';
+  return obj != null && typeof obj[methodName] === 'function';
 }
 /**
   @module @ember/utils

package/dist/packages/@ember/application/instance.js

@@ -308,12 +308,12 @@ class BootOptions {
       @default auto-detected
       @private
     */
-    this.isInteractive = environment.hasDOM; // This default is overridable below
+    this.isInteractive = Boolean(environment.hasDOM); // This default is overridable below
 
     /**
       @property _renderMode
       @type string
-      @default false
+      @default undefined
       @private
     */
 
@@ -340,7 +340,7 @@ class BootOptions {
     if (options.isBrowser !== undefined) {
       this.isBrowser = Boolean(options.isBrowser);
     } else {
-      this.isBrowser = environment.hasDOM;
+      this.isBrowser = Boolean(environment.hasDOM);
     }
 
     if (!this.isBrowser) {

package/dist/packages/@ember/canary-features/index.js

@@ -11,15 +11,11 @@ import { ENV } from '@ember/-internals/environment';
 */
 
 export const DEFAULT_FEATURES = {
-  EMBER_LIBRARIES_ISREGISTERED: false,
-  EMBER_IMPROVED_INSTRUMENTATION: false,
-  EMBER_NAMED_BLOCKS: true,
-  EMBER_GLIMMER_HELPER_MANAGER: true,
-  EMBER_GLIMMER_INVOKE_HELPER: true,
-  EMBER_STRICT_MODE: true,
-  EMBER_DYNAMIC_HELPERS_AND_MODIFIERS: true,
+  EMBER_LIBRARIES_ISREGISTERED: null,
+  EMBER_IMPROVED_INSTRUMENTATION: null,
   EMBER_ROUTING_ROUTER_SERVICE_REFRESH: true,
-  EMBER_CACHED: true
+  EMBER_CACHED: true,
+  EMBER_UNIQUE_ID_HELPER: null
 };
 /**
   The hash of enabled Canary features. Add to this, any canary features
@@ -70,10 +66,6 @@ function featureValue(value) {
 
 export const EMBER_LIBRARIES_ISREGISTERED = featureValue(FEATURES.EMBER_LIBRARIES_ISREGISTERED);
 export const EMBER_IMPROVED_INSTRUMENTATION = featureValue(FEATURES.EMBER_IMPROVED_INSTRUMENTATION);
-export const EMBER_NAMED_BLOCKS = featureValue(FEATURES.EMBER_NAMED_BLOCKS);
-export const EMBER_GLIMMER_HELPER_MANAGER = featureValue(FEATURES.EMBER_GLIMMER_HELPER_MANAGER);
-export const EMBER_GLIMMER_INVOKE_HELPER = featureValue(FEATURES.EMBER_GLIMMER_INVOKE_HELPER);
-export const EMBER_STRICT_MODE = featureValue(FEATURES.EMBER_STRICT_MODE);
-export const EMBER_DYNAMIC_HELPERS_AND_MODIFIERS = featureValue(FEATURES.EMBER_DYNAMIC_HELPERS_AND_MODIFIERS);
 export const EMBER_ROUTING_ROUTER_SERVICE_REFRESH = featureValue(FEATURES.EMBER_ROUTING_ROUTER_SERVICE_REFRESH);
-export const EMBER_CACHED = featureValue(FEATURES.EMBER_CACHED);
+export const EMBER_CACHED = featureValue(FEATURES.EMBER_CACHED);
+export const EMBER_UNIQUE_ID_HELPER = featureValue(FEATURES.EMBER_UNIQUE_ID_HELPER);

package/dist/packages/@ember/debug/lib/capture-render-tree.js

@@ -18,6 +18,8 @@ import { expect } from '@glimmer/util';
 */
 
 export default function captureRenderTree(app) {
+  // SAFETY: Ideally we'd assert here but that causes awkward circular requires since this is also in @ember/debug.
+  // This is only for debug stuff so not very risky.
   let renderer = expect(app.lookup('renderer:-dom'), `BUG: owner is missing renderer`);
   return renderer.debugRenderTree.capture();
 }

package/dist/packages/@ember/debug/lib/handlers.js

@@ -1,7 +1,7 @@
 import { DEBUG } from '@glimmer/env';
 export let HANDLERS = {};
 
-let registerHandler = () => {};
+let registerHandler = function registerHandler(_type, _callback) {};
 
 let invoke = () => {};