diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts b/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
index 23d004c28f5..ab88e8ea278 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
@@ -28,7 +28,7 @@ import type {
 import type { Reference } from '@glimmer/reference';
 import { childRefFor, createComputeRef, createPrimitiveRef, valueForRef } from '@glimmer/reference';
 import { reifyPositional } from '@glimmer/runtime';
-import { EMPTY_ARRAY, unwrapTemplate } from '@glimmer/util';
+import { unwrapTemplate } from '@glimmer/utils';
 import {
   beginTrackFrame,
   beginUntrackFrame,
@@ -54,6 +54,7 @@ import { processComponentArgs } from '../utils/process-args';
 
 export const ARGS = enumerableSymbol('ARGS');
 export const HAS_BLOCK = enumerableSymbol('HAS_BLOCK');
+const EMPTY_ARRAY  = [];
 
 export const DIRTY_TAG = Symbol('DIRTY_TAG');
 export const IS_DISPATCHING_ATTRS = Symbol('IS_DISPATCHING_ATTRS');
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/mount.ts b/packages/@ember/-internals/glimmer/lib/component-managers/mount.ts
index 068d30c8fbf..e0d7e9dd9d5 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/mount.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/mount.ts
@@ -21,7 +21,7 @@ import type { Nullable } from '@ember/-internals/utility-types';
 import { capabilityFlagsFrom } from '@glimmer/manager';
 import type { Reference } from '@glimmer/reference';
 import { createConstRef, valueForRef } from '@glimmer/reference';
-import { unwrapTemplate } from '@glimmer/util';
+import { unwrapTemplate } from '@glimmer/utils';
 import type RuntimeResolver from '../resolver';
 
 interface EngineState {
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts b/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
index 4503ffcb43d..21912b6dda7 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
@@ -21,7 +21,7 @@ import { capabilityFlagsFrom } from '@glimmer/manager';
 import type { Reference } from '@glimmer/reference';
 import { createConstRef, valueForRef } from '@glimmer/reference';
 import { EMPTY_ARGS } from '@glimmer/runtime';
-import { unwrapTemplate } from '@glimmer/util';
+import { unwrapTemplate } from '@glimmer/utils';
 
 import type { DynamicScope } from '../renderer';
 import type { OutletState } from '../utils/outlet';
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/internal-helper.ts b/packages/@ember/-internals/glimmer/lib/helpers/internal-helper.ts
index f474a052e6e..a49f497c7fa 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/internal-helper.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/internal-helper.ts
@@ -1,7 +1,10 @@
 import type { InternalOwner } from '@ember/-internals/owner';
 import type { Helper, HelperDefinitionState } from '@glimmer/interfaces';
-import { setInternalHelperManager } from '@glimmer/manager';
+// import { setInternalHelperManager } from '@glimmer/manager';
 
 export function internalHelper(helper: Helper<InternalOwner>): HelperDefinitionState {
-  return setInternalHelperManager(helper, {});
+  return function () {
+    console.log('internal helper', this, [...arguments]);
+    return helper(...arguments);
+  }
 }
diff --git a/packages/@ember/-internals/glimmer/lib/renderer.ts b/packages/@ember/-internals/glimmer/lib/renderer.ts
index 1c9c0e44469..52736ac67fb 100644
--- a/packages/@ember/-internals/glimmer/lib/renderer.ts
+++ b/packages/@ember/-internals/glimmer/lib/renderer.ts
@@ -4,6 +4,7 @@ import type { InternalOwner } from '@ember/-internals/owner';
 import { getOwner } from '@ember/-internals/owner';
 import { guidFor } from '@ember/-internals/utils';
 import { getViewElement, getViewId } from '@ember/-internals/views';
+import { renderComponent, runDestructors } from '@lifeart/gxt';
 import { assert } from '@ember/debug';
 import { _backburner, _getCurrentRunLoop } from '@ember/runloop';
 import { destroy } from '@glimmer/destroyable';
@@ -31,14 +32,14 @@ import { createConstRef, UNDEFINED_REFERENCE, valueForRef } from '@glimmer/refer
 import type { CurriedValue } from '@glimmer/runtime';
 import {
   clientBuilder,
-  curry,
+  // curry,
   DOMChanges,
   DOMTreeConstruction,
   inTransaction,
   renderMain,
   runtimeContext,
 } from '@glimmer/runtime';
-import { unwrapTemplate } from '@glimmer/util';
+import { unwrapTemplate } from '@glimmer/utils';
 import { CURRENT_TAG, validateTag, valueForTag } from '@glimmer/validator';
 import type { SimpleDocument, SimpleElement, SimpleNode } from '@simple-dom/interface';
 import RSVP from 'rsvp';
@@ -64,6 +65,23 @@ export interface View {
   [BOUNDS]: Bounds | null;
 }
 
+function curry(
+  type: T,
+  spec: object | string | any,
+  owner: any,
+  args: any | null,
+  resolved = false
+) {
+  console.log('curry');
+  return {
+    type,
+    spec,
+    owner,
+    args,
+    resolved,
+  };
+}
+
 export class DynamicScope implements GlimmerDynamicScope {
   constructor(public view: View | null, public outletState: Reference<OutletState | undefined>) {}
 
@@ -129,13 +147,13 @@ class RootState {
   constructor(
     public root: Component | OutletView,
     public runtime: RuntimeContext,
-    context: CompileTimeCompilationContext,
+    _context: CompileTimeCompilationContext,
     owner: InternalOwner,
     template: Template,
     self: Reference<unknown>,
     parentElement: SimpleElement,
-    dynamicScope: DynamicScope,
-    builder: IBuilder
+    _dynamicScope: DynamicScope,
+    _builder: IBuilder
   ) {
     assert(
       `You cannot render \`${valueForRef(self)}\` without a template.`,
@@ -146,23 +164,16 @@ class RootState {
     this.result = undefined;
     this.destroyed = false;
 
-    this.render = errorLoopTransaction(() => {
-      let layout = unwrapTemplate(template).asLayout();
-
-      let iterator = renderMain(
-        runtime,
-        context,
-        owner,
-        self,
-        builder(runtime.env, { element: parentElement, nextSibling: null }),
-        layout,
-        dynamicScope
-      );
-
-      let result = (this.result = iterator.sync());
+    // console.log(layout);
 
-      // override .render function after initial render
-      this.render = errorLoopTransaction(() => result.rerender({ alwaysRevalidate: false }));
+    this.render = errorLoopTransaction(() => {
+      let layout = unwrapTemplate(template).asLayout().compile();
+      const layoutInstance = new layout(this);
+      // @ts-expect-error fine
+      this.result = renderComponent(layoutInstance, parentElement, owner);
+      this.render = errorLoopTransaction(() => {
+        // fine
+      });
     });
   }
 
@@ -195,7 +206,11 @@ class RootState {
 
        */
 
-      inTransaction(env, () => destroy(result!));
+      inTransaction(env, () => {
+        // @ts-expect-error foo-bar
+        runDestructors(result.ctx);
+        destroy(result!);
+      });
     }
   }
 }
@@ -370,6 +385,7 @@ export class Renderer {
   // renderer HOOKS
 
   appendOutletView(view: OutletView, target: SimpleElement): void {
+    console.log('appendOutletView', view, target);
     let definition = createRootOutlet(view);
     this._appendDefinition(
       view,
diff --git a/packages/@ember/-internals/glimmer/lib/templates/empty.ts b/packages/@ember/-internals/glimmer/lib/templates/empty.ts
index f5665d5f8b0..38d472ce04e 100644
--- a/packages/@ember/-internals/glimmer/lib/templates/empty.ts
+++ b/packages/@ember/-internals/glimmer/lib/templates/empty.ts
@@ -1,5 +1,4 @@
-import { precompileTemplate } from '@ember/template-compilation';
-export default precompileTemplate('', {
-  moduleName: 'packages/@ember/-internals/glimmer/lib/templates/empty.hbs',
-  strictMode: true,
-});
+import { hbs } from '@lifeart/gxt';
+export default function emptyTemplate() {
+  return hbs``;
+};
diff --git a/packages/@ember/-internals/glimmer/lib/templates/input.ts b/packages/@ember/-internals/glimmer/lib/templates/input.ts
index 295bb8d2a69..31058629491 100644
--- a/packages/@ember/-internals/glimmer/lib/templates/input.ts
+++ b/packages/@ember/-internals/glimmer/lib/templates/input.ts
@@ -1,7 +1,6 @@
-import { precompileTemplate } from '@ember/template-compilation';
-import { on } from '@ember/modifier';
-export default precompileTemplate(
-  `<input
+import { hbs } from '@lifeart/gxt';
+export default function InputTemplate() {
+  hbs`<input
   {{!-- for compatibility --}}
   id={{this.id}}
   class={{this.class}}
@@ -17,12 +16,5 @@ export default precompileTemplate(
   {{on "keyup" this.keyUp}}
   {{on "paste" this.valueDidChange}}
   {{on "cut" this.valueDidChange}}
-/>`,
-  {
-    moduleName: 'packages/@ember/-internals/glimmer/lib/templates/input.hbs',
-    strictMode: true,
-    scope() {
-      return { on };
-    },
-  }
-);
+/>`;
+}
diff --git a/packages/@ember/-internals/glimmer/lib/templates/link-to.ts b/packages/@ember/-internals/glimmer/lib/templates/link-to.ts
index 811ef33d63b..f34d6ad862a 100644
--- a/packages/@ember/-internals/glimmer/lib/templates/link-to.ts
+++ b/packages/@ember/-internals/glimmer/lib/templates/link-to.ts
@@ -1,30 +1,21 @@
-import { precompileTemplate } from '@ember/template-compilation';
-import { on } from '@ember/modifier';
+import { hbs } from '@lifeart/gxt';
 
-export default precompileTemplate(
-  `<a
-  {{!-- for compatibility --}}
-  id={{this.id}}
-  class={{this.class}}
+export default function LinkToTemplate() {
+  return hbs`<a
+    {{!-- for compatibility --}}
+    id={{this.id}}
+    class={{this.class}}
 
-  {{!-- deprecated attribute bindings --}}
-  role={{this.role}}
-  title={{this.title}}
-  rel={{this.rel}}
-  tabindex={{this.tabindex}}
-  target={{this.target}}
+    {{!-- deprecated attribute bindings --}}
+    role={{this.role}}
+    title={{this.title}}
+    rel={{this.rel}}
+    tabindex={{this.tabindex}}
+    target={{this.target}}
 
-  ...attributes
+    ...attributes
 
-  href={{this.href}}
+    href={{this.href}}
 
-  {{on 'click' this.click}}
->{{yield}}</a>`,
-  {
-    moduleName: 'packages/@ember/-internals/glimmer/lib/templates/link-to.hbs',
-    strictMode: true,
-    scope() {
-      return { on };
-    },
-  }
-);
+    {{on 'click' this.click}} >{{yield}}</a>`;
+}
diff --git a/packages/@ember/-internals/glimmer/lib/templates/outlet-helper-component.gts b/packages/@ember/-internals/glimmer/lib/templates/outlet-helper-component.gts
new file mode 100644
index 00000000000..70bad9c775f
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/lib/templates/outlet-helper-component.gts
@@ -0,0 +1,64 @@
+import { Component } from '@lifeart/gxt';
+
+interface State {
+  outlets: {
+    main: State | undefined,
+  },
+  render: {
+    template():  () => unknown,
+    controller: unknown,
+    name: string,
+  }
+}
+
+export default class OutletHelper extends Component {
+  get state() {
+    return this.args.state().outlets.main || this.args.state();
+  }
+  get nextState() {
+    return () => {
+      return this.hasNext;
+    }
+  }
+  get hasNext() {
+    return this.state.outlets.main;
+  }
+  get canRender() {
+    return !!this?.state?.render;
+  }
+  get MyComponent() {
+
+    const state = this.state;
+    const render = state.render;
+    const tpl = render.template();
+    const args = {
+      get model() {
+        return render.model;
+      }
+    }
+    if (tpl.instance) {
+      return tpl.instance.template;
+    }
+    render.controller['args'] = args;
+    const tplComponentInstance = new tpl(args);
+    tplComponentInstance.template = tplComponentInstance.template.bind(render.controller);
+    // we need to provide stable refs here to avoid re-renders
+    tpl.instance = tplComponentInstance;
+    return tplComponentInstance.template;
+  }
+  get model() {
+    const state = this.state;
+    const render = state.render;
+    return render.model;
+  }
+  <template>
+    {{#if this.canRender}}
+    <this.MyComponent @model={{this.model}}>
+ {{#if this.hasNext}}
+    <OutletHelper @state={{this.nextState}} @root={{false}} />
+    {{/if}}
+    </this.MyComponent>
+
+    {{/if}}
+  </template>
+}
diff --git a/packages/@ember/-internals/glimmer/lib/templates/outlet.ts b/packages/@ember/-internals/glimmer/lib/templates/outlet.ts
index 803be28628f..bd96fc3fc94 100644
--- a/packages/@ember/-internals/glimmer/lib/templates/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/templates/outlet.ts
@@ -1,10 +1,15 @@
 import { precompileTemplate } from '@ember/template-compilation';
+import { hbs } from '@lifeart/gxt';
 import { outletHelper } from '../syntax/outlet';
+import Outlet from './outlet-helper-component';
 
-export default precompileTemplate(`{{component (outletHelper)}}`, {
-  moduleName: 'packages/@ember/-internals/glimmer/lib/templates/outlet.hbs',
-  strictMode: true,
-  scope() {
-    return { outletHelper };
-  },
-});
+export default (owner) => {
+  console.log('outlet factory', owner);
+
+  return function(args) {
+    console.log('outlet', this, owner, ...arguments);
+    return hbs`{{#let (component Outlet state=(args.state)) as |Outlet|}}
+      <div>[main outlet template]<Outlet /></div>
+    {{/let}}`;
+  }
+}
diff --git a/packages/@ember/-internals/glimmer/lib/templates/root.ts b/packages/@ember/-internals/glimmer/lib/templates/root.ts
index bb4736d9214..e7981edcdc4 100644
--- a/packages/@ember/-internals/glimmer/lib/templates/root.ts
+++ b/packages/@ember/-internals/glimmer/lib/templates/root.ts
@@ -1,5 +1,22 @@
-import { precompileTemplate } from '@ember/template-compilation';
-export default precompileTemplate(`{{component this}}`, {
-  moduleName: 'packages/@ember/-internals/glimmer/lib/templates/root.hbs',
-  strictMode: true,
-});
+import { hbs, $_fin } from '@lifeart/gxt';
+export default function(owner) {
+  console.log('root-template init', owner);
+  return function(rootState) {
+    // console.log('root-template - render', [this], [...arguments]);
+    // temp1.root.template
+    // console.log(...arguments);
+    // return function() {
+    //   console.log(...arguments);
+    //   return $_fin([...rootState.root.template()], this);
+    // }
+    // debugger;
+    const state = rootState.root.ref;
+    console.log('rootState', state);
+    return hbs`
+      {{log 'root-template-create' this rootState}}
+      {{#let (component rootState.root.template state=state root=true) as |Layout|}}
+        <Layout />
+      {{/let}}
+    `;
+  }
+}
diff --git a/packages/@ember/-internals/glimmer/lib/templates/textarea.ts b/packages/@ember/-internals/glimmer/lib/templates/textarea.ts
index 1b4bdfc2d9b..b51ccb74dfb 100644
--- a/packages/@ember/-internals/glimmer/lib/templates/textarea.ts
+++ b/packages/@ember/-internals/glimmer/lib/templates/textarea.ts
@@ -1,8 +1,7 @@
-import { precompileTemplate } from '@ember/template-compilation';
-import { on } from '@ember/modifier';
+import { hbs } from '@lifeart/gxt';
 
-export default precompileTemplate(
-  `<textarea
+export default function TextareaTemplate() {
+  return hbs`<textarea
   {{!-- for compatibility --}}
   id={{this.id}}
   class={{this.class}}
@@ -16,12 +15,5 @@ export default precompileTemplate(
   {{on "keyup" this.keyUp}}
   {{on "paste" this.valueDidChange}}
   {{on "cut" this.valueDidChange}}
-/>`,
-  {
-    moduleName: 'packages/@ember/-internals/glimmer/lib/templates/textarea.hbs',
-    strictMode: true,
-    scope() {
-      return { on };
-    },
-  }
-);
+/>`;
+}
diff --git a/packages/@ember/-internals/glimmer/lib/views/outlet.ts b/packages/@ember/-internals/glimmer/lib/views/outlet.ts
index ced2115585d..935d4cd256a 100644
--- a/packages/@ember/-internals/glimmer/lib/views/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/views/outlet.ts
@@ -8,12 +8,14 @@ import { assert } from '@ember/debug';
 import { schedule } from '@ember/runloop';
 import type { Template, TemplateFactory } from '@glimmer/interfaces';
 import type { Reference } from '@glimmer/reference';
-import { createComputeRef, updateRef } from '@glimmer/reference';
+import { cellFor } from '@lifeart/gxt';
+// import { reference } from '@lifeart/gxt/glimmer-compatibility';
 import { consumeTag, createTag, dirtyTag } from '@glimmer/validator';
 import type { SimpleElement } from '@simple-dom/interface';
 import type { OutletDefinitionState } from '../component-managers/outlet';
 import type { Renderer } from '../renderer';
 import type { OutletState } from '../utils/outlet';
+// const { createComputeRef, updateRef } = reference;
 
 export interface BootEnvironment {
   hasDOM: boolean;
@@ -46,6 +48,7 @@ export default class OutletView {
     application: InternalOwner;
     template: TemplateFactory;
   }): OutletView {
+    console.log('outlet-view create', options);
     let { environment: _environment, application: namespace, template: templateFactory } = options;
     let owner = getOwner(options);
     assert('OutletView is unexpectedly missing an owner', owner);
@@ -75,17 +78,15 @@ export default class OutletView {
         template,
       },
     };
+    console.log('outletStateTag', outletStateTag);
 
-    let ref = (this.ref = createComputeRef(
-      () => {
-        consumeTag(outletStateTag);
-        return outletState;
-      },
-      (state: OutletState) => {
-        dirtyTag(outletStateTag);
-        outletState.outlets['main'] = state;
-      }
-    ));
+    cellFor(outletState.outlets, 'main');
+
+    let ref = (this.ref = outletState);
+
+    console.log('ref', ref);
+
+    // ref.compute();
 
     this.state = {
       ref,
@@ -117,7 +118,10 @@ export default class OutletView {
   }
 
   setOutletState(state: OutletState): void {
-    updateRef(this.ref, state);
+    // debugger;
+    //  @todo - fix re-renders
+    this.ref.outlets['main'] = state;
+    // updateRef(this.ref, state);
   }
 
   destroy(): void {
diff --git a/packages/@ember/-internals/metal/lib/decorator.ts b/packages/@ember/-internals/metal/lib/decorator.ts
index d2bf0ff2ccb..d5d498608fa 100644
--- a/packages/@ember/-internals/metal/lib/decorator.ts
+++ b/packages/@ember/-internals/metal/lib/decorator.ts
@@ -76,7 +76,7 @@ export abstract class ComputedDescriptor {
   abstract set(obj: object, keyName: string, value: any | null | undefined): any | null | undefined;
 }
 
-export let COMPUTED_GETTERS: WeakSet<() => unknown>;
+export let COMPUTED_GETTERS: WeakSet<() => unknown> = new WeakSet();
 
 if (DEBUG) {
   COMPUTED_GETTERS = new WeakSet();
diff --git a/packages/@ember/-internals/metal/lib/tracked.ts b/packages/@ember/-internals/metal/lib/tracked.ts
index f5f696997f5..0c5cac9c939 100644
--- a/packages/@ember/-internals/metal/lib/tracked.ts
+++ b/packages/@ember/-internals/metal/lib/tracked.ts
@@ -2,13 +2,44 @@ import { meta as metaFor } from '@ember/-internals/meta';
 import { isEmberArray } from '@ember/array/-internals';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-import { consumeTag, dirtyTagFor, tagFor, trackedData } from '@glimmer/validator';
+// import { consumeTag, dirtyTagFor, tagFor, trackedData } from '@glimmer/validator';
+import { validator } from '@lifeart/gxt/glimmer-compatibility';
+import { cellFor } from '@lifeart/gxt';
+
 import type { ElementDescriptor } from '..';
 import { CHAIN_PASS_THROUGH } from './chain-tags';
 import type { ExtendedMethodDecorator, DecoratorPropertyDescriptor } from './decorator';
 import { COMPUTED_SETTERS, isElementDescriptor, setClassicDecorator } from './decorator';
 import { SELF_TAG } from './tags';
 
+const {
+  consumeTag, dirtyTagFor, tagFor
+} = validator;
+
+
+function trackedData(key, initializer) {
+  let values = /* @__PURE__ */ new WeakMap();
+  let hasInitializer = typeof initializer === "function";
+  function getter(self) {
+    // consumeTag(cellFor(self, key));
+    let value;
+    if (hasInitializer && !values.has(self)) {
+      value = initializer.call(self);
+      values.set(self, value);
+    } else {
+      value = values.get(self);
+    }
+    return value;
+  }
+  function setter(self, value) {
+    dirtyTagFor(self, key);
+    values.set(self, value);
+  }
+  return {
+    getter,
+    setter
+  };
+}
 /**
   @decorator
   @private
diff --git a/packages/@ember/-internals/package.json b/packages/@ember/-internals/package.json
index 68ee335bd3f..84b15707e4f 100644
--- a/packages/@ember/-internals/package.json
+++ b/packages/@ember/-internals/package.json
@@ -64,6 +64,7 @@
     "expect-type": "^0.15.0",
     "internal-test-helpers": "workspace:*",
     "router_js": "^8.0.5",
-    "rsvp": "^4.8.5"
+    "rsvp": "^4.8.5",
+    "@lifeart/gxt": "^0.0.49"
   }
 }
diff --git a/packages/@ember/routing/router.ts b/packages/@ember/routing/router.ts
index f41a58d6a4e..5cef91f49d6 100644
--- a/packages/@ember/routing/router.ts
+++ b/packages/@ember/routing/router.ts
@@ -675,6 +675,7 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
         instance.didCreateRootView(this._toplevelView as any);
       }
     } else {
+      // here we need to figure out how to provide atomic reactivity per outlet level
       this._toplevelView.setOutletState(root);
     }
   }
diff --git a/packages/demo/compat/compile.ts b/packages/demo/compat/compile.ts
new file mode 100644
index 00000000000..77b5a8d4110
--- /dev/null
+++ b/packages/demo/compat/compile.ts
@@ -0,0 +1,8 @@
+export function precompileTemplate() {
+  console.log('precompile template', ...arguments);
+  return {};
+}
+export default function templateCompilation() {
+  console.log('templateCompilation', ...arguments);
+  return {};
+}
diff --git a/packages/demo/compat/deprecate.ts b/packages/demo/compat/deprecate.ts
new file mode 100644
index 00000000000..cfa1d111737
--- /dev/null
+++ b/packages/demo/compat/deprecate.ts
@@ -0,0 +1,8 @@
+export function deprecateUntil() {
+
+}
+export const DEPRECATIONS = {
+  DEPRECATE_IMPORT_EMBER() {
+    //
+  },
+};
diff --git a/packages/demo/compat/glimmer-application.ts b/packages/demo/compat/glimmer-application.ts
new file mode 100644
index 00000000000..40e0f69e365
--- /dev/null
+++ b/packages/demo/compat/glimmer-application.ts
@@ -0,0 +1,6 @@
+export function capabilities() {
+  return {};
+}
+export function setComponentManager() {
+  console.log('setComponentManager', ...arguments);
+}
diff --git a/packages/demo/compat/glimmer-util.ts b/packages/demo/compat/glimmer-util.ts
new file mode 100644
index 00000000000..fde865d533a
--- /dev/null
+++ b/packages/demo/compat/glimmer-util.ts
@@ -0,0 +1,14 @@
+export function unwrapTemplate(tpl) {
+  return {
+    asLayout(){
+      return {
+        compile() {
+          // debugger;
+          console.log('as-layout compile', ...arguments);
+            return tpl;
+        }
+      };
+    }
+  };
+};
+
diff --git a/packages/demo/index.html b/packages/demo/index.html
new file mode 100644
index 00000000000..458e7f7f465
--- /dev/null
+++ b/packages/demo/index.html
@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + TS</title>
+  </head>
+  <body>
+    <script>
+      // fix better way of doing this?
+      window.EmberENV = {
+        FEATURES: {},
+        EXTEND_PROTOTYPES: false,
+        _JQUERY_INTEGRATION: false,
+        _APPLICATION_TEMPLATE_WRAPPER: false,
+        _DEFAULT_ASYNC_OBSERVERS: true,
+        _TEMPLATE_ONLY_GLIMMER_COMPONENTS: true,
+      };
+    </script>
+    <div id="ember-basic-dropdown-wormhole"></div>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
diff --git a/packages/demo/package.json b/packages/demo/package.json
new file mode 100644
index 00000000000..0e853503985
--- /dev/null
+++ b/packages/demo/package.json
@@ -0,0 +1,53 @@
+{
+  "name": "demo",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite"
+  },
+  "dependencies": {
+    "@ember/-internals": "workspace:*",
+    "@ember/application": "workspace:*",
+    "@ember/array": "workspace:*",
+    "@ember/canary-features": "workspace:*",
+    "@ember/component": "workspace:*",
+    "@ember/controller": "workspace:*",
+    "@ember/debug": "workspace:*",
+    "ember": "workspace:*",
+    "@ember/destroyable": "workspace:*",
+    "@ember/engine": "workspace:*",
+    "@ember/enumerable": "workspace:*",
+    "@ember/helper": "workspace:*",
+    "@ember/instrumentation": "workspace:*",
+    "@ember/modifier": "workspace:*",
+    "@ember/object": "workspace:*",
+    "@ember/owner": "workspace:*",
+    "@ember/routing": "workspace:*",
+    "@ember/runloop": "workspace:*",
+    "@ember/service": "workspace:*",
+    "@ember/template": "workspace:*",
+    "@ember/template-compilation": "workspace:*",
+    "@ember/template-factory": "workspace:*",
+    "@ember/test": "workspace:*",
+    "@ember/utils": "workspace:*",
+    "@ember/version": "workspace:*",
+    "@glimmer/destroyable": "0.92.0",
+    "@glimmer/env": "^0.1.7",
+    "@glimmer/manager": "0.92.0",
+    "@glimmer/owner": "0.92.0",
+    "@glimmer/runtime": "0.92.0",
+    "@glimmer/tracking": "workspace:*",
+    "@glimmer/util": "0.92.0",
+    "@glimmer/validator": "0.92.0",
+    "@lifeart/gxt": "^0.0.49",
+    "backburner.js": "^2.7.0",
+    "dag-map": "^2.0.2",
+    "ember-template-compiler": "workspace:*",
+    "ember-testing": "workspace:*",
+    "expect-type": "^0.15.0",
+    "internal-test-helpers": "workspace:*",
+    "router_js": "^8.0.5",
+    "rsvp": "^4.8.5",
+    "vite": "^5.0.10"
+  }
+}
diff --git a/packages/demo/src/components/Application.gts b/packages/demo/src/components/Application.gts
new file mode 100644
index 00000000000..a84f7ea5986
--- /dev/null
+++ b/packages/demo/src/components/Application.gts
@@ -0,0 +1,15 @@
+import { Component } from '@lifeart/gxt';
+
+export default class ApplicationTemplate extends Component {
+  <template>
+    <div>
+    Hello world - this is application template; {{(Date.now)}}
+    {{#each @model as |item|}}
+      {{item}}
+    {{/each}}
+    <div>place for outlet
+      <div class="outlet">{{yield}}</div>
+    </div>
+    </div>
+  </template>
+}
diff --git a/packages/demo/src/components/Main.gts b/packages/demo/src/components/Main.gts
new file mode 100644
index 00000000000..57f3866b2af
--- /dev/null
+++ b/packages/demo/src/components/Main.gts
@@ -0,0 +1,15 @@
+import { Component } from '@lifeart/gxt';
+
+export default class MainTemplate extends Component {
+  <template>
+    <div>
+    Hello world - this is main template;
+    {{#each @model as |item|}}
+      {{item}}
+    {{/each}}
+    <div>place for outlet
+      <div class="outlet">{{yield}}</div>
+    </div>
+    </div>
+  </template>
+}
diff --git a/packages/demo/src/components/Profile.gts b/packages/demo/src/components/Profile.gts
new file mode 100644
index 00000000000..da0648639a4
--- /dev/null
+++ b/packages/demo/src/components/Profile.gts
@@ -0,0 +1,12 @@
+import { Component } from '@lifeart/gxt';
+
+export default class ProfileTemplate extends Component {
+  <template>
+    Profile {{this.now}}
+    {{#each @model as |item|}}
+      {{item}}
+    {{/each}}
+    {{yield}}
+    <button type="button" {{on "click" this.toMain}}>to main</button>
+  </template>
+}
diff --git a/packages/demo/src/config/application.ts b/packages/demo/src/config/application.ts
new file mode 100644
index 00000000000..a85dc1dd8d4
--- /dev/null
+++ b/packages/demo/src/config/application.ts
@@ -0,0 +1,11 @@
+import EmberApplication from '@ember/application';
+import ENV from './env';
+import Resolver from './resolver';
+
+export default class App extends EmberApplication {
+  rootElement = ENV.rootElement;
+  autoboot = ENV.autoboot;
+  modulePrefix = ENV.modulePrefix;
+  podModulePrefix = `${ENV.modulePrefix}/pods`;
+  Resolver = Resolver;
+}
diff --git a/packages/demo/src/config/class-factory.ts b/packages/demo/src/config/class-factory.ts
new file mode 100644
index 00000000000..4fc4768df25
--- /dev/null
+++ b/packages/demo/src/config/class-factory.ts
@@ -0,0 +1,11 @@
+export default function classFactory(klass) {
+  return {
+    create(injections) {
+      if (typeof klass.extend === 'function') {
+        return klass.extend(injections);
+      } else {
+        return klass;
+      }
+    },
+  };
+}
diff --git a/packages/demo/src/config/env.ts b/packages/demo/src/config/env.ts
new file mode 100644
index 00000000000..fdf5fadc5ad
--- /dev/null
+++ b/packages/demo/src/config/env.ts
@@ -0,0 +1,29 @@
+import packageJSON from '../../package.json';
+
+function config(environment: 'production' | 'development') {
+  const ENV = {
+    modulePrefix: packageJSON.name,
+    environment,
+    rootElement: '#app',
+    autoboot: false,
+    rootURL: '/',
+    locationType: 'history', // here is the change
+    EmberENV: {
+      FEATURES: {},
+      EXTEND_PROTOTYPES: false,
+      _JQUERY_INTEGRATION: false,
+      _APPLICATION_TEMPLATE_WRAPPER: false,
+      _DEFAULT_ASYNC_OBSERVERS: true,
+      _TEMPLATE_ONLY_GLIMMER_COMPONENTS: true,
+    },
+    APP: {
+      version: packageJSON.version,
+      globalName: 'MyApp',
+    },
+  };
+
+  return ENV;
+}
+
+const ENV = config(import.meta.env.MODE as 'production' | 'development');
+export default ENV;
diff --git a/packages/demo/src/config/helpers.ts b/packages/demo/src/config/helpers.ts
new file mode 100644
index 00000000000..4825cd12de3
--- /dev/null
+++ b/packages/demo/src/config/helpers.ts
@@ -0,0 +1,34 @@
+// import EmberGlimmerComponentManager from 'ember-component-manager';
+import Component from '@glimmer/component';
+import { setOwner, getOwner } from '@ember/owner';
+import { capabilities } from '@ember/component';
+import { setComponentManager } from '@ember/component';
+import { Ember } from '../../types/global';
+import config from './env';
+
+class CustomComponentManager {
+  constructor() {
+    debugger;
+  }
+  capabilities = capabilities('3.13');
+
+  createComponent(
+    ...args: Parameters<EmberGlimmerComponentManager['createComponent']>
+  ) {
+    const component = super.createComponent(...args);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    setOwner(component, getOwner(this)!);
+
+    return component;
+  }
+}
+
+export function setupApplicationGlobals(EmberNamespace: Ember) {
+  setComponentManager((owner) => {
+    return new CustomComponentManager(owner);
+  }, Component);
+
+  window.EmberENV = config.EmberENV;
+  window._Ember = EmberNamespace;
+  window.Ember = EmberNamespace;
+}
diff --git a/packages/demo/src/config/initializer.ts b/packages/demo/src/config/initializer.ts
new file mode 100644
index 00000000000..cd2b70f6cf3
--- /dev/null
+++ b/packages/demo/src/config/initializer.ts
@@ -0,0 +1,36 @@
+import ENV from './env';
+import registry from './registry';
+import type ApplicationClass from '@ember/application';
+import type RouteClass from './router';
+import { default as initializer } from '@/initializers/logger';
+import { default as logger } from '@/instance-initializers/logger';
+
+export function init(
+  Application: typeof ApplicationClass,
+  Router: typeof RouteClass
+) {
+  // Init initializers
+  Application.initializer(initializer);
+
+  // Init instance initializers
+  Application.instanceInitializer(logger);
+  // Application.instanceInitializer(modalDialog);
+
+  const app = Application.create({
+    name: ENV.modulePrefix,
+    version: ENV.APP.version,
+  });
+
+  const registryObjects = registry();
+  console.table(registryObjects);
+
+  Object.keys(registryObjects).forEach((key) => {
+    const value = registryObjects[key];
+    app.register(key, value);
+  });
+
+  app.register('config:environment', ENV);
+  app.register('router:main', Router);
+
+  return app;
+}
diff --git a/packages/demo/src/config/inspector.ts b/packages/demo/src/config/inspector.ts
new file mode 100644
index 00000000000..e98432dfc58
--- /dev/null
+++ b/packages/demo/src/config/inspector.ts
@@ -0,0 +1,92 @@
+import * as computed from '@ember/object/computed';
+import * as runloop from '@ember/runloop';
+import * as metal from '@ember/-internals/metal';
+import * as inst from '@ember/instrumentation';
+import * as view from '@ember/-internals/views';
+import * as ref from '@glimmer/reference';
+import * as val from '@glimmer/validator';
+
+let define = window.define,
+  requireModule = window.requireModule;
+if (typeof define !== 'function' || typeof requireModule !== 'function') {
+  (function () {
+    const registry = {
+        ember: window.Ember,
+      },
+      seen = {};
+
+    define = function (name, deps, callback) {
+      if (arguments.length < 3) {
+        callback = deps;
+        deps = [];
+      }
+      registry[name] = { deps, callback };
+    };
+
+    requireModule = function (name) {
+      if (name === '@ember/object/computed') {
+        return computed;
+      }
+      if (name === '@ember/runloop') {
+        return runloop;
+      }
+      if (name === '@ember/-internals/metal') {
+        return metal;
+      }
+      if (name === '@ember/instrumentation') {
+        return inst;
+      }
+      if (name === '@ember/-internals/views') {
+        return view;
+      }
+
+      if (name === '@glimmer/reference') {
+        return ref;
+      }
+      if (name === '@glimmer/validator') {
+        return val;
+      }
+
+      if (name === 'ember') {
+        return {
+          default: window.Ember,
+        };
+      }
+
+      if (seen[name]) {
+        return seen[name];
+      }
+
+      const mod = registry[name];
+      if (!mod) {
+        throw new Error(`Module: '${name}' not found.`);
+      }
+
+      seen[name] = {};
+
+      const deps = mod.deps;
+      const callback = mod.callback;
+      const reified = [];
+      let exports;
+
+      for (let i = 0, l = deps.length; i < l; i++) {
+        if (deps[i] === 'exports') {
+          reified.push((exports = {}));
+        } else {
+          reified.push(requireModule(deps[i]));
+        }
+      }
+
+      const value = callback.apply(this, reified);
+      seen[name] = exports || value;
+      return seen[name];
+    };
+
+    define.registry = registry;
+    define.seen = seen;
+  })();
+}
+requireModule.entries = define.registry;
+
+window.define = define;
+window.requireModule = requireModule;
diff --git a/packages/demo/src/config/registry.ts b/packages/demo/src/config/registry.ts
new file mode 100644
index 00000000000..a913771645a
--- /dev/null
+++ b/packages/demo/src/config/registry.ts
@@ -0,0 +1,40 @@
+import type { IRegistry } from './utils';
+
+import { ApplicationRoute } from '@/routes/application';
+import ApplicationTemplate from '@/components/Application';
+import ProfileTemplate from '@/components/Profile';
+import MainTemplate from '@/components/Main';
+
+import ProfileRoute from '@/routes/profile';
+
+
+/* imported controllers */
+import { ApplicationController } from '@/controllers/application';
+import { ProfileController } from '@/controllers/profile';
+
+function asTemplate(ComponentKlass: any) {
+  return (_owner: any) => {
+    // template lookup
+    return () => {
+      // template init
+      return ComponentKlass;
+    };
+  };
+}
+
+const InitialRegistry = {
+  'controller:application': ApplicationController,
+  'controller:profile': ProfileController,
+  'route:application': ApplicationRoute,
+  'route:profile': ProfileRoute,
+  'template:main': asTemplate(MainTemplate),
+  'template:application': asTemplate(ApplicationTemplate),
+  'template:profile': asTemplate(ProfileTemplate),
+
+};
+
+function registry(): IRegistry {
+  return InitialRegistry;
+}
+
+export default registry;
diff --git a/packages/demo/src/config/resolver.ts b/packages/demo/src/config/resolver.ts
new file mode 100644
index 00000000000..1d44f71f848
--- /dev/null
+++ b/packages/demo/src/config/resolver.ts
@@ -0,0 +1,548 @@
+/* globals requirejs, require */
+
+import { assert, deprecate, warn } from '@ember/debug';
+import EmberObject from '@ember/object';
+import { dasherize, classify, underscore } from './string';
+import { DEBUG } from '@glimmer/env';
+import classFactory from './class-factory';
+
+import { getOwner } from '@ember/owner';
+
+// if (typeof requirejs.entries === 'undefined') {
+//   requirejs.entries = requirejs._eak_seen;
+// }
+
+export class ModuleRegistry {
+  constructor(entries) {
+    this._entries = entries || {};
+  }
+  moduleNames() {
+    return Object.keys(this._entries);
+  }
+  has(moduleName) {
+    return moduleName in this._entries;
+  }
+  get(...args) {
+    return require(...args);
+  }
+}
+
+/**
+ * This module defines a subclass of Ember.DefaultResolver that adds two
+ * important features:
+ *
+ *  1) The resolver makes the container aware of es6 modules via the AMD
+ *     output. The loader's _moduleEntries is consulted so that classes can be
+ *     resolved directly via the module loader, without needing a manual
+ *     `import`.
+ *  2) is able to provide injections to classes that implement `extend`
+ *     (as is typical with Ember).
+ */
+class Resolver extends EmberObject {
+  static moduleBasedResolver = true;
+  moduleBasedResolver = true;
+
+  _deprecatedPodModulePrefix = false;
+  _normalizeCache = Object.create(null);
+
+  /**
+   A listing of functions to test for moduleName's based on the provided
+   `parsedName`. This allows easy customization of additional module based
+   lookup patterns.
+
+   @property moduleNameLookupPatterns
+   @returns {Ember.Array}
+   */
+  moduleNameLookupPatterns = [
+    this.podBasedModuleName,
+    this.podBasedComponentsInSubdir,
+    this.mainModuleName,
+    this.defaultModuleName,
+    this.nestedColocationComponentModuleName,
+  ];
+
+  constructor() {
+    super(...arguments);
+
+    if (!this._moduleRegistry) {
+      this._moduleRegistry = new ModuleRegistry();
+    }
+
+    this.pluralizedTypes = this.pluralizedTypes || Object.create(null);
+
+    if (!this.pluralizedTypes.config) {
+      this.pluralizedTypes.config = 'config';
+    }
+  }
+
+  makeToString(factory, fullName) {
+    return '' + this.namespace.modulePrefix + '@' + fullName + ':';
+  }
+
+  shouldWrapInClassFactory(/* module, parsedName */) {
+    return false;
+  }
+
+  parseName(fullName) {
+    if (fullName.parsedName === true) {
+      return fullName;
+    }
+
+    let prefix, type, name;
+    let fullNameParts = fullName.split('@');
+
+    if (fullNameParts.length === 3) {
+      if (fullNameParts[0].length === 0) {
+        // leading scoped namespace: `@scope/pkg@type:name`
+        prefix = `@${fullNameParts[1]}`;
+        let prefixParts = fullNameParts[2].split(':');
+        type = prefixParts[0];
+        name = prefixParts[1];
+      } else {
+        // interweaved scoped namespace: `type:@scope/pkg@name`
+        prefix = `@${fullNameParts[1]}`;
+        type = fullNameParts[0].slice(0, -1);
+        name = fullNameParts[2];
+      }
+
+      if (type === 'template:components') {
+        name = `components/${name}`;
+        type = 'template';
+      }
+    } else if (fullNameParts.length === 2) {
+      let prefixParts = fullNameParts[0].split(':');
+
+      if (prefixParts.length === 2) {
+        if (prefixParts[1].length === 0) {
+          type = prefixParts[0];
+          name = `@${fullNameParts[1]}`;
+        } else {
+          prefix = prefixParts[1];
+          type = prefixParts[0];
+          name = fullNameParts[1];
+        }
+      } else {
+        let nameParts = fullNameParts[1].split(':');
+
+        prefix = fullNameParts[0];
+        type = nameParts[0];
+        name = nameParts[1];
+      }
+
+      if (type === 'template' && prefix.lastIndexOf('components/', 0) === 0) {
+        name = `components/${name}`;
+        prefix = prefix.slice(11);
+      }
+    } else {
+      fullNameParts = fullName.split(':');
+      type = fullNameParts[0];
+      name = fullNameParts[1];
+    }
+
+    let fullNameWithoutType = name;
+    let namespace = this.namespace;
+    let root = namespace;
+
+    return {
+      parsedName: true,
+      fullName: fullName,
+      prefix: prefix || this.prefix({ type: type }),
+      type: type,
+      fullNameWithoutType: fullNameWithoutType,
+      name: name,
+      root: root,
+      resolveMethodName: 'resolve' + classify(type),
+    };
+  }
+
+  resolveOther(parsedName) {
+    assert('`modulePrefix` must be defined', this.namespace.modulePrefix);
+
+    let normalizedModuleName = this.findModuleName(parsedName);
+
+    if (normalizedModuleName) {
+      let defaultExport = this._extractDefaultExport(
+        normalizedModuleName,
+        parsedName
+      );
+
+      if (defaultExport === undefined) {
+        throw new Error(
+          ` Expected to find: '${parsedName.fullName}' within '${normalizedModuleName}' but got 'undefined'. Did you forget to 'export default' within '${normalizedModuleName}'?`
+        );
+      }
+
+      if (this.shouldWrapInClassFactory(defaultExport, parsedName)) {
+        defaultExport = classFactory(defaultExport);
+      }
+
+      return defaultExport;
+    }
+  }
+
+  normalize(fullName) {
+    return (
+      this._normalizeCache[fullName] ||
+      (this._normalizeCache[fullName] = this._normalize(fullName))
+    );
+  }
+
+  resolve(fullName) {
+    let parsedName = this.parseName(fullName);
+    let resolveMethodName = parsedName.resolveMethodName;
+    let resolved;
+
+    if (typeof this[resolveMethodName] === 'function') {
+      resolved = this[resolveMethodName](parsedName);
+    }
+
+    if (resolved == null) {
+      resolved = this.resolveOther(parsedName);
+    }
+
+    return resolved;
+  }
+
+  _normalize(fullName) {
+    // A) Convert underscores to dashes
+    // B) Convert camelCase to dash-case, except for components (their
+    //    templates) and helpers where we want to avoid shadowing camelCase
+    //    expressions
+    // C) replace `.` with `/` in order to make nested controllers work in the following cases
+    //      1. `needs: ['posts/post']`
+    //      2. `{{render "posts/post"}}`
+    //      3. `this.render('posts/post')` from Route
+
+    let split = fullName.split(':');
+    if (split.length > 1) {
+      let type = split[0];
+
+      if (
+        type === 'component' ||
+        type === 'helper' ||
+        type === 'modifier' ||
+        (type === 'template' && split[1].indexOf('components/') === 0)
+      ) {
+        return type + ':' + split[1].replace(/_/g, '-');
+      } else {
+        return type + ':' + dasherize(split[1].replace(/\./g, '/'));
+      }
+    } else {
+      return fullName;
+    }
+  }
+
+  pluralize(type) {
+    return (
+      this.pluralizedTypes[type] || (this.pluralizedTypes[type] = type + 's')
+    );
+  }
+
+  podBasedLookupWithPrefix(podPrefix, parsedName) {
+    let fullNameWithoutType = parsedName.fullNameWithoutType;
+
+    if (parsedName.type === 'template') {
+      fullNameWithoutType = fullNameWithoutType.replace(/^components\//, '');
+    }
+
+    return podPrefix + '/' + fullNameWithoutType + '/' + parsedName.type;
+  }
+
+  podBasedModuleName(parsedName) {
+    let podPrefix =
+      this.namespace.podModulePrefix || this.namespace.modulePrefix;
+
+    return this.podBasedLookupWithPrefix(podPrefix, parsedName);
+  }
+
+  podBasedComponentsInSubdir(parsedName) {
+    let podPrefix =
+      this.namespace.podModulePrefix || this.namespace.modulePrefix;
+    podPrefix = podPrefix + '/components';
+
+    if (
+      parsedName.type === 'component' ||
+      /^components/.test(parsedName.fullNameWithoutType)
+    ) {
+      return this.podBasedLookupWithPrefix(podPrefix, parsedName);
+    }
+  }
+
+  resolveEngine(parsedName) {
+    let engineName = parsedName.fullNameWithoutType;
+    let engineModule = engineName + '/engine';
+
+    if (this._moduleRegistry.has(engineModule)) {
+      return this._extractDefaultExport(engineModule);
+    }
+  }
+
+  resolveRouteMap(parsedName) {
+    let engineName = parsedName.fullNameWithoutType;
+    let engineRoutesModule = engineName + '/routes';
+
+    if (this._moduleRegistry.has(engineRoutesModule)) {
+      let routeMap = this._extractDefaultExport(engineRoutesModule);
+
+      assert(
+        `The route map for ${engineName} should be wrapped by 'buildRoutes' before exporting.`,
+        routeMap.isRouteMap
+      );
+
+      return routeMap;
+    }
+  }
+
+  resolveTemplate(parsedName) {
+    return this.resolveOther(parsedName);
+  }
+
+  mainModuleName(parsedName) {
+    if (parsedName.fullNameWithoutType === 'main') {
+      // if router:main or adapter:main look for a module with just the type first
+      return parsedName.prefix + '/' + parsedName.type;
+    }
+  }
+
+  defaultModuleName(parsedName) {
+    return (
+      parsedName.prefix +
+      '/' +
+      this.pluralize(parsedName.type) +
+      '/' +
+      parsedName.fullNameWithoutType
+    );
+  }
+
+  nestedColocationComponentModuleName(parsedName) {
+    if (parsedName.type === 'component') {
+      return (
+        parsedName.prefix +
+        '/' +
+        this.pluralize(parsedName.type) +
+        '/' +
+        parsedName.fullNameWithoutType +
+        '/index'
+      );
+    }
+  }
+
+  prefix(parsedName) {
+    let tmpPrefix = this.namespace.modulePrefix;
+
+    if (this.namespace[parsedName.type + 'Prefix']) {
+      tmpPrefix = this.namespace[parsedName.type + 'Prefix'];
+    }
+
+    return tmpPrefix;
+  }
+
+  findModuleName(parsedName, loggingDisabled) {
+    let moduleNameLookupPatterns = this.moduleNameLookupPatterns;
+    let moduleName;
+
+    for (
+      let index = 0, length = moduleNameLookupPatterns.length;
+      index < length;
+      index++
+    ) {
+      let item = moduleNameLookupPatterns[index];
+
+      let tmpModuleName = item.call(this, parsedName);
+
+      // allow treat all dashed and all underscored as the same thing
+      // supports components with dashes and other stuff with underscores.
+      if (tmpModuleName) {
+        tmpModuleName = this.chooseModuleName(tmpModuleName, parsedName);
+      }
+
+      if (tmpModuleName && this._moduleRegistry.has(tmpModuleName)) {
+        moduleName = tmpModuleName;
+      }
+
+      if (!loggingDisabled) {
+        this._logLookup(moduleName, parsedName, tmpModuleName);
+      }
+
+      if (moduleName) {
+        return moduleName;
+      }
+    }
+  }
+
+  chooseModuleName(moduleName, parsedName) {
+    let underscoredModuleName = underscore(moduleName);
+
+    if (
+      moduleName !== underscoredModuleName &&
+      this._moduleRegistry.has(moduleName) &&
+      this._moduleRegistry.has(underscoredModuleName)
+    ) {
+      throw new TypeError(
+        `Ambiguous module names: '${moduleName}' and '${underscoredModuleName}'`
+      );
+    }
+
+    if (this._moduleRegistry.has(moduleName)) {
+      return moduleName;
+    } else if (this._moduleRegistry.has(underscoredModuleName)) {
+      return underscoredModuleName;
+    }
+    // workaround for dasherized partials:
+    // something/something/-something => something/something/_something
+    let partializedModuleName = moduleName.replace(/\/-([^/]*)$/, '/_$1');
+
+    if (this._moduleRegistry.has(partializedModuleName)) {
+      deprecate(
+        'Modules should not contain underscores. ' +
+          'Attempted to lookup "' +
+          moduleName +
+          '" which ' +
+          'was not found. Please rename "' +
+          partializedModuleName +
+          '" ' +
+          'to "' +
+          moduleName +
+          '" instead.',
+        false,
+        {
+          id: 'ember-resolver.underscored-modules',
+          until: '3.0.0',
+          for: 'ember-resolver',
+          since: '0.1.0',
+        }
+      );
+
+      return partializedModuleName;
+    }
+
+    if (DEBUG) {
+      let isCamelCaseHelper =
+        parsedName.type === 'helper' && /[a-z]+[A-Z]+/.test(moduleName);
+      if (isCamelCaseHelper) {
+        this._camelCaseHelperWarnedNames =
+          this._camelCaseHelperWarnedNames || [];
+        let alreadyWarned =
+          this._camelCaseHelperWarnedNames.indexOf(parsedName.fullName) > -1;
+        if (!alreadyWarned && this._moduleRegistry.has(dasherize(moduleName))) {
+          this._camelCaseHelperWarnedNames.push(parsedName.fullName);
+          warn(
+            'Attempted to lookup "' +
+              parsedName.fullName +
+              '" which ' +
+              'was not found. In previous versions of ember-resolver, a bug would have ' +
+              'caused the module at "' +
+              dasherize(moduleName) +
+              '" to be ' +
+              'returned for this camel case helper name. This has been fixed. ' +
+              'Use the dasherized name to resolve the module that would have been ' +
+              'returned in previous versions.',
+            false,
+            { id: 'ember-resolver.camelcase-helper-names', until: '3.0.0' }
+          );
+        }
+      }
+    }
+  }
+
+  // used by Ember.DefaultResolver.prototype._logLookup
+  lookupDescription(fullName) {
+    let parsedName = this.parseName(fullName);
+
+    let moduleName = this.findModuleName(parsedName, true);
+
+    return moduleName;
+  }
+
+  // only needed until 1.6.0-beta.2 can be required
+  _logLookup(found, parsedName, description) {
+    let owner = getOwner(this);
+    let env = owner?.resolveRegistration?.('config:environment');
+    if (!env?.LOG_MODULE_RESOLVER && !parsedName.root.LOG_RESOLVER) {
+      return;
+    }
+
+    let padding;
+    let symbol = found ? '[✓]' : '[ ]';
+
+    if (parsedName.fullName.length > 60) {
+      padding = '.';
+    } else {
+      padding = new Array(60 - parsedName.fullName.length).join('.');
+    }
+
+    if (!description) {
+      description = this.lookupDescription(parsedName);
+    }
+
+    /* eslint-disable no-console */
+    if (console && console.info) {
+      console.info(symbol, parsedName.fullName, padding, description);
+    }
+  }
+
+  knownForType(type) {
+    let moduleKeys = this._moduleRegistry.moduleNames();
+
+    let items = Object.create(null);
+    for (let index = 0, length = moduleKeys.length; index < length; index++) {
+      let moduleName = moduleKeys[index];
+      let fullname = this.translateToContainerFullname(type, moduleName);
+
+      if (fullname) {
+        items[fullname] = true;
+      }
+    }
+
+    return items;
+  }
+
+  translateToContainerFullname(type, moduleName) {
+    let prefix = this.prefix({ type });
+
+    // Note: using string manipulation here rather than regexes for better performance.
+    // pod modules
+    // '^' + prefix + '/(.+)/' + type + '$'
+    let podPrefix = prefix + '/';
+    let podSuffix = '/' + type;
+    let start = moduleName.indexOf(podPrefix);
+    let end = moduleName.indexOf(podSuffix);
+
+    if (
+      start === 0 &&
+      end === moduleName.length - podSuffix.length &&
+      moduleName.length > podPrefix.length + podSuffix.length
+    ) {
+      return type + ':' + moduleName.slice(start + podPrefix.length, end);
+    }
+
+    // non-pod modules
+    // '^' + prefix + '/' + pluralizedType + '/(.+)$'
+    let pluralizedType = this.pluralize(type);
+    let nonPodPrefix = prefix + '/' + pluralizedType + '/';
+
+    if (
+      moduleName.indexOf(nonPodPrefix) === 0 &&
+      moduleName.length > nonPodPrefix.length
+    ) {
+      return type + ':' + moduleName.slice(nonPodPrefix.length);
+    }
+  }
+
+  _extractDefaultExport(normalizedModuleName) {
+    let module = this._moduleRegistry.get(
+      normalizedModuleName,
+      null,
+      null,
+      true /* force sync */
+    );
+
+    if (module && module['default']) {
+      module = module['default'];
+    }
+
+    return module;
+  }
+}
+
+export default Resolver;
diff --git a/packages/demo/src/config/router.ts b/packages/demo/src/config/router.ts
new file mode 100644
index 00000000000..fc139b8f6cd
--- /dev/null
+++ b/packages/demo/src/config/router.ts
@@ -0,0 +1,104 @@
+import EmberRouter from '@ember/routing/router';
+import config from './env';
+import type Controller from '@ember/controller';
+import Route from '@ember/routing/route';
+import { PrecompiledTemplate } from '@ember/template-compilation';
+import { getOwner } from '@ember/application';
+
+/*
+  Here we use part of lazy-loading logic from https://github.com/embroider-build/embroider/blob/main/packages/router/src/index.ts
+*/
+
+export type HashReturnType = {
+  route?: typeof Route | Promise<typeof Route>;
+  controller?: typeof Controller | Promise<typeof Controller>;
+  template?: PrecompiledTemplate | Promise<PrecompiledTemplate>;
+};
+
+class Router extends EmberRouter {
+  static lazyRoutes: Record<string, () => HashReturnType> = {};
+  location = config.locationType as 'history';
+  rootURL = config.rootURL;
+  loadedRoutes = new Set();
+
+  // This is necessary in order to prevent the premature loading of lazy routes
+  // when we are merely trying to render a link-to that points at them.
+  // Unfortunately the stock query parameter behavior pulls on routes just to
+  // check what their previous QP values were.
+  _getQPMeta(handlerInfo: { name: string }, ...rest: unknown[]) {
+    if (
+      handlerInfo.name in Router.lazyRoutes &&
+      !this.loadedRoutes.has(handlerInfo.name)
+    ) {
+      return undefined;
+    }
+    // @ts-expect-error extending private method
+    return super._getQPMeta(handlerInfo, ...rest);
+  }
+
+  // This is the framework method that we're overriding to provide our own
+  // handlerResolver.
+  setupRouter(...args: unknown[]) {
+    // @ts-expect-error extending private method
+    const isSetup = super.setupRouter(...args);
+    const microLib = (
+      this as unknown as {
+        // TODO: is there a way don't use the private route?
+        /* eslint-disable ember/no-private-routing-service */
+        _routerMicrolib: { getRoute: (name: string) => unknown };
+      }
+    )._routerMicrolib;
+    microLib.getRoute = this._handlerResolver(microLib.getRoute.bind(microLib));
+    return isSetup;
+  }
+
+  lazyBundle(name: string) {
+    if (this.loadedRoutes.has(name)) {
+      return null;
+    }
+    const routeResolver = Router.lazyRoutes[name];
+    const owner = getOwner(this);
+    if (routeResolver) {
+      return {
+        load: async () => {
+          const hash = routeResolver();
+          const keys = Object.keys(hash);
+          const values = await Promise.all(keys.map((key) => hash[key]));
+          keys.forEach((key, index) => {
+            // owner.unregister(`${key}:${name}`);
+            try {
+              owner.register(`${key}:${name}`, values[index]);
+            } catch (e) {
+              // ignore
+            }
+          });
+          this.loadedRoutes.add(name);
+        },
+        loaded: false,
+      };
+    }
+    return null;
+  }
+
+  private _handlerResolver(original: (name: string) => unknown) {
+    return (name: string) => {
+      const bundle = this.lazyBundle(name);
+
+      if (!bundle || bundle.loaded) {
+        return original(name);
+      }
+
+      return bundle.load().then(
+        () => {
+          bundle.loaded = true;
+          return original(name);
+        },
+        (err: Error) => {
+          throw err;
+        }
+      );
+    };
+  }
+}
+
+export default Router;
diff --git a/packages/demo/src/config/string.ts b/packages/demo/src/config/string.ts
new file mode 100644
index 00000000000..f4b591cbea7
--- /dev/null
+++ b/packages/demo/src/config/string.ts
@@ -0,0 +1,162 @@
+class Cache {
+  constructor(limit, func, store) {
+    this.limit = limit;
+    this.func = func;
+    this.store = store;
+    this.size = 0;
+    this.misses = 0;
+    this.hits = 0;
+    this.store = store || new Map();
+  }
+  get(key) {
+    let value = this.store.get(key);
+    if (this.store.has(key)) {
+      this.hits++;
+      return this.store.get(key);
+    } else {
+      this.misses++;
+      value = this.set(key, this.func(key));
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.limit > this.size) {
+      this.size++;
+      this.store.set(key, value);
+    }
+    return value;
+  }
+  purge() {
+    this.store.clear();
+    this.size = 0;
+    this.hits = 0;
+    this.misses = 0;
+  }
+}
+let STRINGS = {};
+export function setStrings(strings) {
+  STRINGS = strings;
+}
+export function getStrings() {
+  return STRINGS;
+}
+export function getString(name) {
+  return STRINGS[name];
+}
+const STRING_DASHERIZE_REGEXP = /[ _]/g;
+const STRING_DASHERIZE_CACHE = new Cache(1000, (key) =>
+  decamelize(key).replace(STRING_DASHERIZE_REGEXP, '-')
+);
+const STRING_CLASSIFY_REGEXP_1 = /^(\-|_)+(.)?/;
+const STRING_CLASSIFY_REGEXP_2 = /(.)(\-|\_|\.|\s)+(.)?/g;
+const STRING_CLASSIFY_REGEXP_3 = /(^|\/|\.)([a-z])/g;
+const CLASSIFY_CACHE = new Cache(1000, (str) => {
+  const replace1 = (_match, _separator, chr) => (chr ? `_${chr.toUpperCase()}` : '');
+  const replace2 = (_match, initialChar, _separator, chr) =>
+    initialChar + (chr ? chr.toUpperCase() : '');
+  const parts = str.split('/');
+  for (let i = 0; i < parts.length; i++) {
+    parts[i] = parts[i]
+      .replace(STRING_CLASSIFY_REGEXP_1, replace1)
+      .replace(STRING_CLASSIFY_REGEXP_2, replace2);
+  }
+  return parts
+    .join('/')
+    .replace(STRING_CLASSIFY_REGEXP_3, (match /*, separator, chr */) => match.toUpperCase());
+});
+const STRING_UNDERSCORE_REGEXP_1 = /([a-z\d])([A-Z]+)/g;
+const STRING_UNDERSCORE_REGEXP_2 = /\-|\s+/g;
+const UNDERSCORE_CACHE = new Cache(1000, (str) =>
+  str
+    .replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2')
+    .replace(STRING_UNDERSCORE_REGEXP_2, '_')
+    .toLowerCase()
+);
+const STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
+const DECAMELIZE_CACHE = new Cache(1000, (str) =>
+  str.replace(STRING_DECAMELIZE_REGEXP, '$1_$2').toLowerCase()
+);
+/**
+  Converts a camelized string into all lower case separated by underscores.
+
+  ```javascript
+  import { decamelize } from '@ember/string';
+
+  decamelize('innerHTML');          // 'inner_html'
+  decamelize('action_name');        // 'action_name'
+  decamelize('css-class-name');     // 'css-class-name'
+  decamelize('my favorite items');  // 'my favorite items'
+  ```
+
+  @method decamelize
+  @param {String} str The string to decamelize.
+  @return {String} the decamelized string.
+  @public
+*/
+export function decamelize(str) {
+  return DECAMELIZE_CACHE.get(str);
+}
+/**
+  Replaces underscores, spaces, or camelCase with dashes.
+
+  ```javascript
+  import { dasherize } from '@ember/string';
+
+  dasherize('innerHTML');                // 'inner-html'
+  dasherize('action_name');              // 'action-name'
+  dasherize('css-class-name');           // 'css-class-name'
+  dasherize('my favorite items');        // 'my-favorite-items'
+  dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'
+  ```
+
+  @method dasherize
+  @param {String} str The string to dasherize.
+  @return {String} the dasherized string.
+  @public
+*/
+export function dasherize(str) {
+  return STRING_DASHERIZE_CACHE.get(str);
+}
+/**
+  Returns the UpperCamelCase form of a string.
+
+  ```javascript
+  import { classify } from '@ember/string';
+
+  classify('innerHTML');                   // 'InnerHTML'
+  classify('action_name');                 // 'ActionName'
+  classify('css-class-name');              // 'CssClassName'
+  classify('my favorite items');           // 'MyFavoriteItems'
+  classify('private-docs/owner-invoice');  // 'PrivateDocs/OwnerInvoice'
+  ```
+
+  @method classify
+  @param {String} str the string to classify
+  @return {String} the classified string
+  @public
+*/
+export function classify(str) {
+  return CLASSIFY_CACHE.get(str);
+}
+/**
+  More general than decamelize. Returns the lower\_case\_and\_underscored
+  form of a string.
+
+  ```javascript
+  import { underscore } from '@ember/string';
+
+  underscore('innerHTML');                 // 'inner_html'
+  underscore('action_name');               // 'action_name'
+  underscore('css-class-name');            // 'css_class_name'
+  underscore('my favorite items');         // 'my_favorite_items'
+  underscore('privateDocs/ownerInvoice');  // 'private_docs/owner_invoice'
+  ```
+
+  @method underscore
+  @param {String} str The string to underscore.
+  @return {String} the underscored string.
+  @public
+*/
+export function underscore(str) {
+  return UNDERSCORE_CACHE.get(str);
+}
diff --git a/packages/demo/src/config/utils.ts b/packages/demo/src/config/utils.ts
new file mode 100644
index 00000000000..7a7ba0e7aa9
--- /dev/null
+++ b/packages/demo/src/config/utils.ts
@@ -0,0 +1,62 @@
+import type Service from '@ember/service';
+import type Controller from '@ember/controller';
+import type Route from '@ember/routing/route';
+import type GlimmerComponent from '@glimmer/component';
+import type Helper from '@ember/component/helper';
+import type Modifier from 'ember-modifier';
+import type { PrecompiledTemplate } from '@ember/template-compilation';
+import { setComponentTemplate } from '@ember/component';
+import env from '@/config/env';
+export type RegisteredComponent = typeof GlimmerComponent & {
+  template: PrecompiledTemplate;
+};
+export type RegistryType =
+  | 'service'
+  | 'controller'
+  | 'route'
+  | 'template'
+  | 'component'
+  | 'helper'
+  | 'modifier';
+export type RegistryKey = `${RegistryType}:${string}`;
+export interface IRegistry {
+  [key: RegistryKey]:
+    | typeof Service
+    | typeof Controller
+    | typeof Route
+    | typeof Helper
+    | Modifier
+    | RegisteredComponent
+    | PrecompiledTemplate;
+}
+
+export function registerComponent<T>(
+  component: T & { template: PrecompiledTemplate }
+): RegisteredComponent {
+  try {
+    return setComponentTemplate(
+      component.template,
+      component as unknown as object
+    ) as RegisteredComponent;
+  } catch (e) {
+    console.error(e);
+    return component as unknown as RegisteredComponent;
+  }
+}
+
+export function resoleFromRegistry<T>(key: RegistryKey): T {
+  // application.__registry__.resolve
+  return window[env.APP.globalName].resolveRegistration(key) as T;
+}
+
+export function extendRegistry(registry) {
+  Object.keys(registry).forEach((key) => {
+    try {
+      window[env.APP.globalName].register(key, registry[key]);
+    } catch(e) {
+      // hot-reload case
+      window[env.APP.globalName].unregister(key);
+      window[env.APP.globalName].register(key, registry[key]);
+    }
+  });
+}
diff --git a/packages/demo/src/controllers/application.ts b/packages/demo/src/controllers/application.ts
new file mode 100644
index 00000000000..8c0d478dcd2
--- /dev/null
+++ b/packages/demo/src/controllers/application.ts
@@ -0,0 +1,9 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+export class ApplicationController extends Controller {
+  @tracked showModal = true;
+
+  constructor(...args: ConstructorParameters<typeof Controller>) {
+    super(...args);
+  }
+}
diff --git a/packages/demo/src/controllers/login.ts b/packages/demo/src/controllers/login.ts
new file mode 100644
index 00000000000..d53ff60cac8
--- /dev/null
+++ b/packages/demo/src/controllers/login.ts
@@ -0,0 +1,15 @@
+import Controller from '@ember/controller';
+import { service } from '@ember/service';
+import { action } from '@ember/object';
+import RouterService from '@ember/routing/router-service';
+
+export class LoginController extends Controller {
+  @service router!: RouterService;
+
+  @action
+  async authenticate(e: MouseEvent) {
+    e.preventDefault();
+
+    await this.session.authenticate('authenticator:custom');
+  }
+}
diff --git a/packages/demo/src/controllers/profile.ts b/packages/demo/src/controllers/profile.ts
new file mode 100644
index 00000000000..b8b7620edb9
--- /dev/null
+++ b/packages/demo/src/controllers/profile.ts
@@ -0,0 +1,22 @@
+import Controller from '@ember/controller';
+import { tracked } from '@glimmer/tracking';
+import type RouterService from '@ember/routing/router-service';
+import { service } from '@ember/service';
+
+
+export class ProfileController extends Controller {
+  @tracked now = new Date().toISOString();
+  @service router!: RouterService;
+
+  toMain = () => {
+    this.router.transitionTo('main');
+  };
+
+  constructor(...args: ConstructorParameters<typeof Controller>) {
+    super(...args);
+    // cellFor(this, 'now').update(new Date().toISOString());
+    setInterval(() => {
+      this.now = new Date().toISOString();
+    }, 1000);
+  }
+}
diff --git a/packages/demo/src/helpers/__mocks__/@ember/component/helper.js b/packages/demo/src/helpers/__mocks__/@ember/component/helper.js
new file mode 100644
index 00000000000..e245eb6d266
--- /dev/null
+++ b/packages/demo/src/helpers/__mocks__/@ember/component/helper.js
@@ -0,0 +1,8 @@
+export default class Helper {
+  willDestroy() {
+    // EOL
+  }
+  recompute() {
+    // EOL
+  }
+}
diff --git a/packages/demo/src/helpers/is-dev.ts b/packages/demo/src/helpers/is-dev.ts
new file mode 100644
index 00000000000..8265b99c49d
--- /dev/null
+++ b/packages/demo/src/helpers/is-dev.ts
@@ -0,0 +1,5 @@
+import env from '@/config/env';
+
+export default function isDev(): boolean {
+  return env.environment === 'development';
+}
diff --git a/packages/demo/src/helpers/memory-usage.test.ts b/packages/demo/src/helpers/memory-usage.test.ts
new file mode 100644
index 00000000000..f12960745c2
--- /dev/null
+++ b/packages/demo/src/helpers/memory-usage.test.ts
@@ -0,0 +1,30 @@
+// jest test for memory-usage.ts
+import MemoryUsage from './memory-usage';
+
+describe('helpers | memory-usage', () => {
+  it('should retun from computation if no performance property', () => {
+    const memoryUsage = new MemoryUsage();
+    expect(memoryUsage.compute()).toBeNull();
+  });
+  it('should not call recompute if measureMemory called without performance', async () => {
+    const memoryUsage = new MemoryUsage();
+    const recomputeSpy = jest.spyOn(memoryUsage, 'recompute');
+    await memoryUsage.measureMemory();
+    expect(recomputeSpy).not.toHaveBeenCalled();
+  });
+  it('will destroy should clear interval', async () => {
+    const memoryUsage = new MemoryUsage();
+    let a = 1;
+    const interval = setInterval(() => {
+      a++;
+      // NOOP
+    }, 10);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    memoryUsage.interval = interval;
+    expect(memoryUsage.interval).toBe(interval);
+    const lastIntervalValue = a;
+    memoryUsage.willDestroy();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(a).toBe(lastIntervalValue);
+  });
+});
diff --git a/packages/demo/src/helpers/memory-usage.ts b/packages/demo/src/helpers/memory-usage.ts
new file mode 100644
index 00000000000..f806c72e4b3
--- /dev/null
+++ b/packages/demo/src/helpers/memory-usage.ts
@@ -0,0 +1,38 @@
+import Helper from '@ember/component/helper';
+
+export default class MemoryUsage extends Helper {
+  interval: number | undefined;
+  heapSize: number | undefined;
+
+  constructor() {
+    super();
+
+    if (!performance.memory) {
+      return;
+    }
+
+    this.interval = setInterval(this.measureMemory.bind(this), 1000);
+  }
+
+  async measureMemory() {
+    if (!performance.memory) {
+      return;
+    }
+
+    const dirtyValue = performance.memory.usedJSHeapSize / 1048576;
+
+    this.heapSize = Math.round(dirtyValue * 100) / 100;
+
+    this.recompute();
+  }
+
+  compute() {
+    return this.heapSize ? `Memory used ${this.heapSize} MB` : null;
+  }
+
+  willDestroy() {
+    super.willDestroy();
+
+    clearInterval(this.interval);
+  }
+}
diff --git a/packages/demo/src/initializers/ember-data.ts b/packages/demo/src/initializers/ember-data.ts
new file mode 100644
index 00000000000..808a21d1a62
--- /dev/null
+++ b/packages/demo/src/initializers/ember-data.ts
@@ -0,0 +1,18 @@
+import type Application from '@ember/application';
+
+function initializeStore(application: Application) {
+  application.registerOptionsForType('serializer', { singleton: false });
+  application.registerOptionsForType('adapter', { singleton: false });
+}
+
+function setupContainer(application: Application) {
+  initializeStore(application);
+}
+
+/*
+  This code initializes EmberData in an Ember application.
+*/
+export default {
+  name: 'ember-data',
+  initialize: setupContainer,
+};
diff --git a/packages/demo/src/initializers/logger.ts b/packages/demo/src/initializers/logger.ts
new file mode 100644
index 00000000000..9427816d9fb
--- /dev/null
+++ b/packages/demo/src/initializers/logger.ts
@@ -0,0 +1,18 @@
+import type Application from '@ember/application';
+import EmberObject from '@ember/object';
+
+export class Logger extends EmberObject {
+  log(m: unknown) {
+    console.log(m);
+  }
+}
+
+export function initialize(application: Application) {
+  application.register('logger:main', Logger);
+  console.log('logger registered');
+}
+
+export default {
+  name: 'logger',
+  initialize,
+};
diff --git a/packages/demo/src/instance-initializers/logger.test.ts b/packages/demo/src/instance-initializers/logger.test.ts
new file mode 100644
index 00000000000..c7eeb21e852
--- /dev/null
+++ b/packages/demo/src/instance-initializers/logger.test.ts
@@ -0,0 +1,18 @@
+import logger from './logger';
+
+// jest test for instance-initializers/logger.ts
+describe('instance-initializers/logger', () => {
+  it('should log', () => {
+    const mockLogger = {
+      log: jest.fn(),
+    };
+
+    logger.initialize({
+      lookup() {
+        return mockLogger;
+      },
+    } as any);
+
+    expect(mockLogger.log).toHaveBeenCalledWith('Instance initializer init');
+  });
+});
diff --git a/packages/demo/src/instance-initializers/logger.ts b/packages/demo/src/instance-initializers/logger.ts
new file mode 100644
index 00000000000..35889c58555
--- /dev/null
+++ b/packages/demo/src/instance-initializers/logger.ts
@@ -0,0 +1,13 @@
+import type ApplicationInstance from '@ember/application/instance';
+import type { Logger } from '../initializers/logger';
+
+export function initialize(applicationInstance: ApplicationInstance) {
+  const logger = applicationInstance.lookup('logger:main') as Logger;
+
+  logger.log('Instance initializer init');
+}
+
+export default {
+  name: 'logger',
+  initialize,
+};
diff --git a/packages/demo/src/main.ts b/packages/demo/src/main.ts
new file mode 100644
index 00000000000..c439d26ea93
--- /dev/null
+++ b/packages/demo/src/main.ts
@@ -0,0 +1,18 @@
+import './style.css';
+
+import Ember from 'ember';
+import App from '@/config/application';
+import { init } from '@/config/initializer';
+import { setupApplicationGlobals } from '@/config/helpers';
+import { extendRegistry } from '@/config/utils';
+import env from '@/config/env';
+import Router from './router';
+
+import '@/config/inspector';
+
+setupApplicationGlobals(Ember);
+
+const app = init(App, Router);
+
+window[env.APP.globalName] = app; // for debugging and experiments
+app.visit(window.location.pathname);
diff --git a/packages/demo/src/models/person.ts b/packages/demo/src/models/person.ts
new file mode 100644
index 00000000000..f1156f17e3f
--- /dev/null
+++ b/packages/demo/src/models/person.ts
@@ -0,0 +1,7 @@
+import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+
+export default class PersonModel extends Model {
+  @attr name;
+  @belongsTo('pet', { inverse: 'owner', async: false }) dog;
+  @hasMany('person', { inverse: 'friends', async: false }) friends;
+}
diff --git a/packages/demo/src/models/pet.ts b/packages/demo/src/models/pet.ts
new file mode 100644
index 00000000000..ce55c58ff2e
--- /dev/null
+++ b/packages/demo/src/models/pet.ts
@@ -0,0 +1,6 @@
+import Model, { attr, belongsTo } from '@ember-data/model';
+
+export default class PetModel extends Model {
+  @attr name;
+  @belongsTo('person', { inverse: 'dog', async: false }) owner;
+}
diff --git a/packages/demo/src/modifiers/click-tracker.ts b/packages/demo/src/modifiers/click-tracker.ts
new file mode 100644
index 00000000000..ae8e1b37d2f
--- /dev/null
+++ b/packages/demo/src/modifiers/click-tracker.ts
@@ -0,0 +1,26 @@
+import Modifier from 'ember-modifier';
+import { registerDestructor } from '@ember/destroyable';
+
+function cleanup(instance: ClickTracker) {
+  document.body.removeEventListener('click', instance.handler);
+}
+
+export default class ClickTracker extends Modifier {
+  element!: Element;
+
+  modify(element: Element) {
+    this.element = element;
+
+    document.body.addEventListener('click', this.handler);
+
+    registerDestructor(this, cleanup);
+  }
+
+  handler = (e: Event) => {
+    const place = this.element.contains(e.target as Element)
+      ? 'inside'
+      : 'outside';
+
+    console.log(`Click ${place} ${this.element}`);
+  };
+}
diff --git a/packages/demo/src/router.ts b/packages/demo/src/router.ts
new file mode 100644
index 00000000000..de10d70ccb3
--- /dev/null
+++ b/packages/demo/src/router.ts
@@ -0,0 +1,46 @@
+import Router from '@/config/router';
+// import type { HashReturnType } from '@/config/router';
+// import MainTemplate from './templates/main';
+
+export enum Routes {
+  Main = 'main',
+  Profile = 'profile',
+  Login = 'login',
+  Logout = 'logout',
+  About = 'about',
+  NotFound = 'not-found',
+  Bootstrap = 'bootstrap',
+}
+
+// Router.lazyRoutes = {
+//   [Routes.Main]: (): HashReturnType => ({
+//     // sample of lazy-loaded route, and statically resolved template
+//     // have no idea how to fix typings here...
+//     route: import('./routes/main').then((m) => m.MainRoute),
+//     template: MainTemplate,
+//   }),
+//   [Routes.Profile]: (): HashReturnType => ({
+//     route: import('./routes/profile').then((m) => m.default),
+//     template: import('./templates/profile.hbs').then((m) => m.default),
+//   }),
+//   [Routes.NotFound]: (): HashReturnType => ({
+//     // sample of lazy-loaded route, and dynamically resolved template
+//     template: import('./templates/not-found').then((m) => m.default),
+//   }),
+//   [Routes.Bootstrap]: (): HashReturnType => ({
+//     // sample of lazy-loaded route, and dynamically resolved template
+//     template: import('./templates/bootstrap').then((m) => m.default),
+//   }),
+// };
+
+Router.map(function () {
+  this.route(Routes.Main, { path: '/' });
+  this.route(Routes.Profile, { path: '/profile' });
+  this.route(Routes.Login, { path: '/login' });
+  this.route(Routes.Logout, { path: '/logout' });
+  this.route(Routes.About, { path: '/about' });
+  this.route(Routes.Bootstrap, { path: '/bootstrap' });
+  this.route(Routes.NotFound, { path: '*wildcard_path' });
+});
+
+export default Router;
diff --git a/packages/demo/src/routes/application.ts b/packages/demo/src/routes/application.ts
new file mode 100644
index 00000000000..5e511a5dfb5
--- /dev/null
+++ b/packages/demo/src/routes/application.ts
@@ -0,0 +1,13 @@
+import Route from '@ember/routing/route';
+
+export class ApplicationRoute extends Route {
+
+  async beforeModel() {
+    console.log('before model');
+  }
+
+  model() {
+    console.log('model');
+    return ['red', 'yellow', 'blue'];
+  }
+}
diff --git a/packages/demo/src/routes/login.ts b/packages/demo/src/routes/login.ts
new file mode 100644
index 00000000000..37a3ee3a977
--- /dev/null
+++ b/packages/demo/src/routes/login.ts
@@ -0,0 +1,5 @@
+import Route from '@ember/routing/route';
+
+export default class LoginRoute extends Route {
+
+}
diff --git a/packages/demo/src/routes/logout.ts b/packages/demo/src/routes/logout.ts
new file mode 100644
index 00000000000..81960ad7c39
--- /dev/null
+++ b/packages/demo/src/routes/logout.ts
@@ -0,0 +1,13 @@
+import Route from '@ember/routing/route';
+import RouterService from '@ember/routing/router-service';
+import Transition from '@ember/routing/transition';
+import { service } from '@ember/service';
+
+export default class LogoutRoute extends Route {
+  @service router!: RouterService;
+
+  async beforeModel(transition: Transition) {
+
+    this.router.transitionTo('main');
+  }
+}
diff --git a/packages/demo/src/routes/main.ts b/packages/demo/src/routes/main.ts
new file mode 100644
index 00000000000..1a62e7ca7c4
--- /dev/null
+++ b/packages/demo/src/routes/main.ts
@@ -0,0 +1,7 @@
+import Route from '@ember/routing/route';
+
+export class MainRoute extends Route {
+  model() {
+    return ['foo', 'boo', 'blue'];
+  }
+}
diff --git a/packages/demo/src/routes/profile.ts b/packages/demo/src/routes/profile.ts
new file mode 100644
index 00000000000..05a295faf56
--- /dev/null
+++ b/packages/demo/src/routes/profile.ts
@@ -0,0 +1,18 @@
+import Route from '@ember/routing/route';
+import type Transition from '@ember/routing/transition';
+export default class ProfileRoute extends Route {
+  queryParams: Record<string, { refreshModel?: boolean; replace?: boolean; as?: string; }> = {
+    q: {
+      refreshModel: true,
+      replace: true,
+    }
+  }
+
+  beforeModel(transition: Transition) {
+    console.log('beforeModel:profile', transition);
+  }
+
+  model() {
+    return [1, 2, 3];
+  }
+}
diff --git a/packages/demo/src/services/date.ts b/packages/demo/src/services/date.ts
new file mode 100644
index 00000000000..57e6e05992c
--- /dev/null
+++ b/packages/demo/src/services/date.ts
@@ -0,0 +1,29 @@
+import Service from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+import { cached } from 'tracked-toolbox';
+
+export default class DateService extends Service {
+  interval: ReturnType<(typeof window)['setInterval']> | null = null;
+  @tracked _date = new Date();
+
+  constructor(...args: ConstructorParameters<typeof Service>) {
+    super(...args);
+
+    this.interval = setInterval(() => {
+      this._date = new Date();
+    }, 1000);
+  }
+
+  willDestroy(...args: Parameters<Service['willDestroy']>) {
+    super.willDestroy(...args);
+    if (this.interval) {
+      clearInterval(this.interval);
+    }
+  }
+
+  @cached
+  get date() {
+    console.log('ama cached getter, recalculating only on value change')
+    return this._date.toLocaleTimeString();
+  }
+}
diff --git a/packages/demo/src/services/store.ts b/packages/demo/src/services/store.ts
new file mode 100644
index 00000000000..8ed8aa05539
--- /dev/null
+++ b/packages/demo/src/services/store.ts
@@ -0,0 +1,23 @@
+import Cache from '@ember-data/json-api';
+import EDataStore, { CacheHandler } from '@ember-data/store';
+import RequestManager from '@ember-data/request';
+import Fetch from '@ember-data/request/fetch';
+import Adapter from '@ember-data/adapter/json-api';
+
+export default class Store extends EDataStore {
+  #adapter = new Adapter();
+
+  adapterFor() {
+    return this.#adapter;
+  }
+  constructor() {
+    // eslint-disable-next-line prefer-rest-params
+    super(...arguments);
+    this.requestManager = new RequestManager();
+    this.requestManager.use([Fetch]);
+    this.requestManager.useCache(CacheHandler);
+  }
+  createCache(storeWrapper) {
+    return new Cache(storeWrapper);
+  }
+}
diff --git a/packages/demo/src/style.css b/packages/demo/src/style.css
new file mode 100644
index 00000000000..d8693c21ccb
--- /dev/null
+++ b/packages/demo/src/style.css
@@ -0,0 +1,12 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+a.active {
+    text-decoration: underline;
+    text-decoration-color: rgb(218, 118, 118);
+}
+
+code {
+    color: green;
+}
\ No newline at end of file
diff --git a/packages/demo/src/templates/about.hbs b/packages/demo/src/templates/about.hbs
new file mode 100644
index 00000000000..ac4dc94debe
--- /dev/null
+++ b/packages/demo/src/templates/about.hbs
@@ -0,0 +1,14 @@
+{{page-title "Page Title: About"}}
+<h2 class="text-lg font-medium text-gray-900">About</h2>
+
+<div class="bg-gray-50 sm:rounded-lg mt-4">
+  <div class="px-4 py-5 sm:p-6">
+    <h3 class="text-lg font-medium leading-6 text-gray-900">Need more bandwidth?</h3>
+    <div class="mt-2 max-w-xl text-sm text-gray-500">
+      <p>Ember Application, powered by Vite</p>
+    </div>
+    <div class="mt-5">
+      <LinkTo @tagName="button" @route='main' type="button" class="inline-flex items-center rounded-md border border-gray-300 bg-white px-4 py-2 font-medium text-gray-700 shadow-sm hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:ring-offset-2 sm:text-sm">Home</LinkTo>
+    </div>
+  </div>
+</div>
diff --git a/packages/demo/src/templates/application.hbs b/packages/demo/src/templates/application.hbs
new file mode 100644
index 00000000000..2fa0dd57f09
--- /dev/null
+++ b/packages/demo/src/templates/application.hbs
@@ -0,0 +1,60 @@
+<Header @session={{this.session}} />
+<EmberNotify />
+{{#if this.showModal}}
+<ModalDialog>
+  <div data-test-id="modal-dialog-message">
+    Ember Modal Dialog test <Button {{on 'click' (stop-propagation this.closeModal)}} data-test-id="close-modal-dialog">Close</Button>
+  </div>
+</ModalDialog>
+{{/if}}
+
+<div class='mx-auto max-w-7xl px-4 sm:px-6 lg:px-8 mt-8'>
+  <div class='mx-auto max-w-3xl'>
+
+  {{#if (media 'isDesktop')}}
+    looks like you on Desktop
+  {{else if (media 'isTablet')}}
+    looks like you on Tablet
+  {{else if (media 'isMobile')}}
+    looks like you on Mobile
+  {{else}}
+    wow
+  {{/if}}
+
+    {{outlet}}
+
+    <div class='rounded-md bg-blue-50 p-4 mt-8'>
+      <div class='flex'>
+        <div class='flex-shrink-0'>
+          <svg
+            class='h-5 w-5 text-blue-400'
+            xmlns='http://www.w3.org/2000/svg'
+            viewBox='0 0 20 20'
+            fill='currentColor'
+            aria-hidden='true'
+          >
+            <path
+              fill-rule='evenodd'
+              d='M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7-4a1 1 0 11-2 0 1 1 0 012 0zM9 9a.75.75 0 000 1.5h.253a.25.25 0 01.244.304l-.459 2.066A1.75 1.75 0 0010.747 15H11a.75.75 0 000-1.5h-.253a.25.25 0 01-.244-.304l.459-2.066A1.75 1.75 0 009.253 9H9z'
+              clip-rule='evenodd'
+            />
+          </svg>
+        </div>
+        <div class='ml-3 flex-1 md:flex md:justify-between'>
+          <p class='text-sm text-blue-700'>Here is your login status</p>
+          <p class='mt-3 text-sm md:mt-0 md:ml-6' data-login-status>
+            {{#if this.session.isAuthenticated}}
+              You are authenticated as
+              {{this.session.data.authenticated.name}}
+            {{else}}
+              You are not authenticated
+            {{/if}}
+          </p>
+        </div>
+      </div>
+    </div>
+
+  </div>
+</div>
+
+<Footer />
\ No newline at end of file
diff --git a/packages/demo/src/templates/bootstrap.ts b/packages/demo/src/templates/bootstrap.ts
new file mode 100644
index 00000000000..77903494b8a
--- /dev/null
+++ b/packages/demo/src/templates/bootstrap.ts
@@ -0,0 +1,20 @@
+import { template } from '@ember/template-compiler';
+import Bootstrap from '../components/Bootstrap';
+import EmberBootstrapRegistry from './../addons/ember-bootstrap';
+import { extendRegistry, resoleFromRegistry } from '@/config/utils';
+import { LinkTo } from '@ember/routing';
+
+extendRegistry(EmberBootstrapRegistry);
+
+const PageTitle = resoleFromRegistry('helper:page-title');
+
+export default template(
+  `
+  {{title "Bootstrap"}}
+  <LinkTo @route='main'>Home</LinkTo>
+  <Bootstrap />
+`,
+  {
+    scope: () => ({ LinkTo, Bootstrap, title: PageTitle }),
+  }
+);
diff --git a/packages/demo/src/templates/login.hbs b/packages/demo/src/templates/login.hbs
new file mode 100644
index 00000000000..53980a286e7
--- /dev/null
+++ b/packages/demo/src/templates/login.hbs
@@ -0,0 +1,4 @@
+<h1 class="text-3xl font-bold leading-tight tracking-tight text-gray-900">Login Page</h1>
+<div class="m-4">
+    <button class="pointer-events-auto rounded-md bg-indigo-600 py-2 px-3 text-[0.8125rem] font-semibold leading-5 text-white hover:bg-indigo-500" type="button" data-test-login-button {{on "click" this.authenticate}}>Login</button>
+</div>
\ No newline at end of file
diff --git a/packages/demo/src/templates/not-found.ts b/packages/demo/src/templates/not-found.ts
new file mode 100644
index 00000000000..fd040963a51
--- /dev/null
+++ b/packages/demo/src/templates/not-found.ts
@@ -0,0 +1,33 @@
+import { precompileTemplate } from '@ember/template-compilation';
+
+const currentPath = () => window.location.pathname;
+
+export default precompileTemplate(
+  `
+  {{page-title "Not found"}}
+  <div class="flex min-h-full flex-col bg-white pt-16 pb-12">
+  <main class="mx-auto flex w-full max-w-7xl flex-grow flex-col justify-center px-6 lg:px-8">
+    <div class="flex flex-shrink-0 justify-center">
+      <a href="/" class="inline-flex">
+        <span class="sr-only">Ember</span>
+        <img class="h-12 w-auto" src="/vite.svg" alt="">
+      </a>
+    </div>
+    <div class="py-16">
+      <div class="text-center">
+        <p class="text-base font-semibold text-indigo-600">404</p>
+        <h1 class="mt-2 text-4xl font-bold tracking-tight text-gray-900 sm:text-5xl">Page not found.</h1>
+        <p class="mt-2 text-base text-gray-500" data-not-found-text>Sorry, we couldn’t find the page {{currentPath}}</p>
+        <div class="mt-6">
+          <LinkTo @route="main" class="text-base font-medium text-indigo-600 hover:text-indigo-500">
+          Go back home
+            <span aria-hidden="true"> &rarr;</span>
+          </LinkTo>
+        </div>
+      </div>
+    </div>
+  </main>
+</div>
+`,
+  { isStrictMode: true, scope: () => ({ currentPath }) }
+);
diff --git a/packages/demo/src/templates/profile.hbs b/packages/demo/src/templates/profile.hbs
new file mode 100644
index 00000000000..fd6b387f45b
--- /dev/null
+++ b/packages/demo/src/templates/profile.hbs
@@ -0,0 +1,15 @@
+{{page-title 'Profile page'}}
+<h2 class='text-lg font-medium text-gray-900'>Profile</h2>
+
+
+
+<div class="card w-96 mx-auto bg-white  shadow-xl hover:shadow rounded-lg">
+     <img class="w-32 mx-auto rounded-full border-8 border-white" src="/ember.svg" alt="">
+     <div data-test-name class="text-center mt-2 text-3xl font-medium">{{@model.name}}</div>
+     <div class="text-center mt-2 font-light text-sm">#emberjs</div>
+     <div class="px-6 text-center mt-2 font-light text-sm">
+       <p class="pb-2">
+         It seems your id is {{@model.id}}
+       </p>
+     </div>
+  </div>
\ No newline at end of file
diff --git a/packages/demo/src/vite-env.d.ts b/packages/demo/src/vite-env.d.ts
new file mode 100644
index 00000000000..11f02fe2a00
--- /dev/null
+++ b/packages/demo/src/vite-env.d.ts
@@ -0,0 +1 @@
+/// <reference types="vite/client" />
diff --git a/packages/demo/tsconfig.json b/packages/demo/tsconfig.json
new file mode 100644
index 00000000000..1a00f50e367
--- /dev/null
+++ b/packages/demo/tsconfig.json
@@ -0,0 +1,20 @@
+{
+  // "extends": "./../tsconfig.json",
+  "compilerOptions": {
+    "paths": {
+      "@/config/*": ["./src/config/*"],
+      "@/addons/*": ["./src/addons/*"],
+      "@/addons": ["./src/addons"],
+      "@/components/*": ["./src/components/*"],
+      "@/controllers/*": ["./src/controllers/*"],
+      "@/templates/*": ["./src/templates/*"],
+      "@/helpers/*": ["./src/helpers/*"],
+      "@/modifiers/*": ["./src/modifiers/*"],
+      "@/models/*": ["./src/models/*"],
+      "@/services/*": ["./src/services/*"],
+      "@/tests/*": ["./tests/*"],
+      "@/initializers/*": ["./src/initializers/*"],
+      "@/instance-initializers/*": ["./src/instance-initializers/*"],
+    }
+  }
+}
diff --git a/packages/demo/vite.config.mts b/packages/demo/vite.config.mts
new file mode 100644
index 00000000000..484609d7b56
--- /dev/null
+++ b/packages/demo/vite.config.mts
@@ -0,0 +1,36 @@
+import { defineConfig } from 'vite';
+import { compiler } from '@lifeart/gxt/compiler';
+import { fileURLToPath, URL } from 'node:url';
+
+const projectRoot = import.meta.url;
+
+export default defineConfig(({ mode }) => ({
+  plugins: [compiler(mode)],
+  base: '',
+  rollupOptions: {
+    input: {
+      main: 'index.html',
+    },
+  },
+  resolve: {
+    alias: [
+      { find: /^@\/(.+)/, replacement: '/src/$1' },
+      {
+        find: '@ember/template-compilation',
+        replacement: fileURLToPath(new URL(`./compat/compile`, projectRoot)),
+      },
+      {
+        find: '@ember/-internals/deprecations',
+        replacement: fileURLToPath(new URL(`./compat/deprecate`, projectRoot)),
+      },
+      {
+        find: '@glimmer/application',
+        replacement: fileURLToPath(new URL(`./compat/glimmer-application`, projectRoot)),
+      },
+      {
+        find: '@glimmer/utils',
+        replacement: fileURLToPath(new URL(`./compat/glimmer-util`, projectRoot)),
+      },
+    ],
+  },
+}));
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 1816532ee9e..aabc2ac2189 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -418,6 +418,9 @@ importers:
       '@glimmer/vm':
         specifier: 0.92.0
         version: 0.92.0
+      '@lifeart/gxt':
+        specifier: ^0.0.49
+        version: 0.0.49
       '@simple-dom/interface':
         specifier: ^1.4.0
         version: 1.4.0
@@ -1258,6 +1261,138 @@ importers:
         specifier: workspace:*
         version: link:../../@ember/-internals
 
+  packages/demo:
+    dependencies:
+      '@ember/-internals':
+        specifier: workspace:*
+        version: link:../@ember/-internals
+      '@ember/application':
+        specifier: workspace:*
+        version: link:../@ember/application
+      '@ember/array':
+        specifier: workspace:*
+        version: link:../@ember/array
+      '@ember/canary-features':
+        specifier: workspace:*
+        version: link:../@ember/canary-features
+      '@ember/component':
+        specifier: workspace:*
+        version: link:../@ember/component
+      '@ember/controller':
+        specifier: workspace:*
+        version: link:../@ember/controller
+      '@ember/debug':
+        specifier: workspace:*
+        version: link:../@ember/debug
+      '@ember/destroyable':
+        specifier: workspace:*
+        version: link:../@ember/destroyable
+      '@ember/engine':
+        specifier: workspace:*
+        version: link:../@ember/engine
+      '@ember/enumerable':
+        specifier: workspace:*
+        version: link:../@ember/enumerable
+      '@ember/helper':
+        specifier: workspace:*
+        version: link:../@ember/helper
+      '@ember/instrumentation':
+        specifier: workspace:*
+        version: link:../@ember/instrumentation
+      '@ember/modifier':
+        specifier: workspace:*
+        version: link:../@ember/modifier
+      '@ember/object':
+        specifier: workspace:*
+        version: link:../@ember/object
+      '@ember/owner':
+        specifier: workspace:*
+        version: link:../@ember/owner
+      '@ember/routing':
+        specifier: workspace:*
+        version: link:../@ember/routing
+      '@ember/runloop':
+        specifier: workspace:*
+        version: link:../@ember/runloop
+      '@ember/service':
+        specifier: workspace:*
+        version: link:../@ember/service
+      '@ember/template':
+        specifier: workspace:*
+        version: link:../@ember/template
+      '@ember/template-compilation':
+        specifier: workspace:*
+        version: link:../@ember/template-compilation
+      '@ember/template-factory':
+        specifier: workspace:*
+        version: link:../@ember/template-factory
+      '@ember/test':
+        specifier: workspace:*
+        version: link:../@ember/test
+      '@ember/utils':
+        specifier: workspace:*
+        version: link:../@ember/utils
+      '@ember/version':
+        specifier: workspace:*
+        version: link:../@ember/version
+      '@glimmer/destroyable':
+        specifier: 0.92.0
+        version: 0.92.0
+      '@glimmer/env':
+        specifier: ^0.1.7
+        version: 0.1.7
+      '@glimmer/manager':
+        specifier: 0.92.0
+        version: 0.92.0
+      '@glimmer/owner':
+        specifier: 0.92.0
+        version: 0.92.0
+      '@glimmer/runtime':
+        specifier: 0.92.0
+        version: 0.92.0
+      '@glimmer/tracking':
+        specifier: workspace:*
+        version: link:../@glimmer/tracking
+      '@glimmer/util':
+        specifier: 0.92.0
+        version: 0.92.0
+      '@glimmer/validator':
+        specifier: 0.92.0
+        version: 0.92.0
+      '@lifeart/gxt':
+        specifier: ^0.0.49
+        version: 0.0.49
+      backburner.js:
+        specifier: ^2.7.0
+        version: 2.8.0
+      dag-map:
+        specifier: ^2.0.2
+        version: 2.0.2
+      ember:
+        specifier: workspace:*
+        version: link:../ember
+      ember-template-compiler:
+        specifier: workspace:*
+        version: link:../ember-template-compiler
+      ember-testing:
+        specifier: workspace:*
+        version: link:../ember-testing
+      expect-type:
+        specifier: ^0.15.0
+        version: 0.15.0
+      internal-test-helpers:
+        specifier: workspace:*
+        version: link:../internal-test-helpers
+      router_js:
+        specifier: ^8.0.5
+        version: 8.0.5(route-recognizer@0.3.4)(rsvp@4.8.5)
+      rsvp:
+        specifier: ^4.8.5
+        version: 4.8.5
+      vite:
+        specifier: ^5.0.10
+        version: 5.2.10
+
   packages/ember:
     dependencies:
       '@ember/-internals':
@@ -2445,6 +2580,14 @@ packages:
       '@babel/highlight': 7.24.2
       picocolors: 1.0.0
 
+  /@babel/code-frame@7.24.7:
+    resolution: {integrity: sha512-BcYH1CVJBO9tvyIZ2jVeXgSIMvGZ2FDRvDdOIVQyuklNKSsx+eppDEBq/g47Ayw+RqNFE+URvOShmf+f/qwAlA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/highlight': 7.24.7
+      picocolors: 1.0.0
+    dev: false
+
   /@babel/compat-data@7.24.4:
     resolution: {integrity: sha512-vg8Gih2MLK+kOkHJp4gBEIkyaIi00jgWot2D9QOmmfLC8jINSOzmCLta6Bvz/JSBCqnegV0L80jhxkol5GWNfQ==}
     engines: {node: '>=6.9.0'}
@@ -2504,12 +2647,29 @@ packages:
       '@jridgewell/trace-mapping': 0.3.25
       jsesc: 2.5.2
 
+  /@babel/generator@7.24.7:
+    resolution: {integrity: sha512-oipXieGC3i45Y1A41t4tAqpnEZWgB/lC6Ehh6+rOviR5XWpTtMmLN+fGjz9vOiNRt0p6RtO6DtD0pdU3vpqdSA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.24.7
+      '@jridgewell/gen-mapping': 0.3.5
+      '@jridgewell/trace-mapping': 0.3.25
+      jsesc: 2.5.2
+    dev: false
+
   /@babel/helper-annotate-as-pure@7.22.5:
     resolution: {integrity: sha512-LvBTxu8bQSQkcyKOU+a1btnNFQ1dMAd0R6PyW3arXes06F6QLWLIrd681bxRPIXlrMGR3XYnW9JyML7dP3qgxg==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.24.0
 
+  /@babel/helper-annotate-as-pure@7.24.7:
+    resolution: {integrity: sha512-BaDeOonYvhdKw+JoMVkAixAAJzG2jVPIwWoKBPdYuY9b452e2rPuI9QPYh3KpofZ3pW2akOmwZLOiOsHMiqRAg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.24.7
+    dev: false
+
   /@babel/helper-builder-binary-assignment-operator-visitor@7.22.15:
     resolution: {integrity: sha512-QkBXwGgaoC2GtGZRoma6kv7Szfv06khvhFav67ZExau2RaXzy8MpHSMO2PNoP2XtmQphJQRHFfg77Bq731Yizw==}
     engines: {node: '>=6.9.0'}
@@ -2543,6 +2703,26 @@ packages:
       '@babel/helper-split-export-declaration': 7.22.6
       semver: 6.3.1
 
+  /@babel/helper-create-class-features-plugin@7.24.7(@babel/core@7.24.4):
+    resolution: {integrity: sha512-kTkaDl7c9vO80zeX1rJxnuRpEsD5tA81yh11X1gQo+PhSti3JS+7qeZo9U4RHobKRiFPKaGK3svUAeb8D0Q7eg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.24.4(supports-color@8.1.1)
+      '@babel/helper-annotate-as-pure': 7.24.7
+      '@babel/helper-environment-visitor': 7.24.7
+      '@babel/helper-function-name': 7.24.7
+      '@babel/helper-member-expression-to-functions': 7.24.7
+      '@babel/helper-optimise-call-expression': 7.24.7
+      '@babel/helper-replace-supers': 7.24.7(@babel/core@7.24.4)
+      '@babel/helper-skip-transparent-expression-wrappers': 7.24.7
+      '@babel/helper-split-export-declaration': 7.24.7
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@babel/helper-create-regexp-features-plugin@7.22.15(@babel/core@7.24.4):
     resolution: {integrity: sha512-29FkPLFjn4TPEa3RE7GpW+qbE8tlsu3jntNYNfcGsc49LphF1PQIiD+vMZ1z1xVOKt+93khA9tc2JBs3kBjA7w==}
     engines: {node: '>=6.9.0'}
@@ -2572,6 +2752,13 @@ packages:
     resolution: {integrity: sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==}
     engines: {node: '>=6.9.0'}
 
+  /@babel/helper-environment-visitor@7.24.7:
+    resolution: {integrity: sha512-DoiN84+4Gnd0ncbBOM9AZENV4a5ZiL39HYMyZJGZ/AZEykHYdJw0wW3kdcsh9/Kn+BRXHLkkklZ51ecPKmI1CQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.24.7
+    dev: false
+
   /@babel/helper-function-name@7.23.0:
     resolution: {integrity: sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==}
     engines: {node: '>=6.9.0'}
@@ -2579,24 +2766,59 @@ packages:
       '@babel/template': 7.24.0
       '@babel/types': 7.24.0
 
+  /@babel/helper-function-name@7.24.7:
+    resolution: {integrity: sha512-FyoJTsj/PEUWu1/TYRiXTIHc8lbw+TDYkZuoE43opPS5TrI7MyONBE1oNvfguEXAD9yhQRrVBnXdXzSLQl9XnA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/template': 7.24.7
+      '@babel/types': 7.24.7
+    dev: false
+
   /@babel/helper-hoist-variables@7.22.5:
     resolution: {integrity: sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.24.0
 
+  /@babel/helper-hoist-variables@7.24.7:
+    resolution: {integrity: sha512-MJJwhkoGy5c4ehfoRyrJ/owKeMl19U54h27YYftT0o2teQ3FJ3nQUf/I3LlJsX4l3qlw7WRXUmiyajvHXoTubQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.24.7
+    dev: false
+
   /@babel/helper-member-expression-to-functions@7.23.0:
     resolution: {integrity: sha512-6gfrPwh7OuT6gZyJZvd6WbTfrqAo7vm4xCzAXOusKqq/vWdKXphTpj5klHKNmRUU6/QRGlBsyU9mAIPaWHlqJA==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.24.0
 
+  /@babel/helper-member-expression-to-functions@7.24.7:
+    resolution: {integrity: sha512-LGeMaf5JN4hAT471eJdBs/GK1DoYIJ5GCtZN/EsL6KUiiDZOvO/eKE11AMZJa2zP4zk4qe9V2O/hxAmkRc8p6w==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/traverse': 7.24.7
+      '@babel/types': 7.24.7
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@babel/helper-module-imports@7.24.3:
     resolution: {integrity: sha512-viKb0F9f2s0BCS22QSF308z/+1YWKV/76mwt61NBzS5izMzDPwdq1pTrzf+Li3npBWX9KdQbkeCt1jSAM7lZqg==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.24.0
 
+  /@babel/helper-module-imports@7.24.7:
+    resolution: {integrity: sha512-8AyH3C+74cgCVVXow/myrynrAGv+nTVg5vKu2nZph9x7RcRwzmh0VFallJuFTZ9mx6u4eSdXZfcOzSqTUm0HCA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/traverse': 7.24.7
+      '@babel/types': 7.24.7
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@babel/helper-module-transforms@7.23.3(@babel/core@7.24.4):
     resolution: {integrity: sha512-7bBs4ED9OmswdfDzpz4MpWgSrV7FXlc3zIagvLFjS5H+Mk7Snr21vQ6QwrsoCGMfNC4e4LQPdoULEt4ykz0SRQ==}
     engines: {node: '>=6.9.0'}
@@ -2610,16 +2832,44 @@ packages:
       '@babel/helper-split-export-declaration': 7.22.6
       '@babel/helper-validator-identifier': 7.22.20
 
+  /@babel/helper-module-transforms@7.24.7(@babel/core@7.24.4):
+    resolution: {integrity: sha512-1fuJEwIrp+97rM4RWdO+qrRsZlAeL1lQJoPqtCYWv0NL115XM93hIH4CSRln2w52SqvmY5hqdtauB6QFCDiZNQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.24.4(supports-color@8.1.1)
+      '@babel/helper-environment-visitor': 7.24.7
+      '@babel/helper-module-imports': 7.24.7
+      '@babel/helper-simple-access': 7.24.7
+      '@babel/helper-split-export-declaration': 7.24.7
+      '@babel/helper-validator-identifier': 7.24.7
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@babel/helper-optimise-call-expression@7.22.5:
     resolution: {integrity: sha512-HBwaojN0xFRx4yIvpwGqxiV2tUfl7401jlok564NgB9EHS1y6QT17FmKWm4ztqjeVdXLuC4fSvHc5ePpQjoTbw==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.24.0
 
+  /@babel/helper-optimise-call-expression@7.24.7:
+    resolution: {integrity: sha512-jKiTsW2xmWwxT1ixIdfXUZp+P5yURx2suzLZr5Hi64rURpDYdMW0pv+Uf17EYk2Rd428Lx4tLsnjGJzYKDM/6A==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.24.7
+    dev: false
+
   /@babel/helper-plugin-utils@7.24.0:
     resolution: {integrity: sha512-9cUznXMG0+FxRuJfvL82QlTqIzhVW9sL0KjMPHhAOOvpQGL8QtdxnBKILjBqxlHyliz0yCa1G903ZXI/FuHy2w==}
     engines: {node: '>=6.9.0'}
 
+  /@babel/helper-plugin-utils@7.24.7:
+    resolution: {integrity: sha512-Rq76wjt7yz9AAc1KnlRKNAi/dMSVWgDRx43FHoJEbcYU6xOWaE2dVPwcdTukJrjxS65GITyfbvEYHvkirZ6uEg==}
+    engines: {node: '>=6.9.0'}
+    dev: false
+
   /@babel/helper-remap-async-to-generator@7.22.20(@babel/core@7.24.4):
     resolution: {integrity: sha512-pBGyV4uBqOns+0UvhsTO8qgl8hO89PmiDYv+/COyp1aeMcmfrfruz+/nCMFiYyFF/Knn0yfrC85ZzNFjembFTw==}
     engines: {node: '>=6.9.0'}
@@ -2642,36 +2892,92 @@ packages:
       '@babel/helper-member-expression-to-functions': 7.23.0
       '@babel/helper-optimise-call-expression': 7.22.5
 
+  /@babel/helper-replace-supers@7.24.7(@babel/core@7.24.4):
+    resolution: {integrity: sha512-qTAxxBM81VEyoAY0TtLrx1oAEJc09ZK67Q9ljQToqCnA+55eNwCORaxlKyu+rNfX86o8OXRUSNUnrtsAZXM9sg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.24.4(supports-color@8.1.1)
+      '@babel/helper-environment-visitor': 7.24.7
+      '@babel/helper-member-expression-to-functions': 7.24.7
+      '@babel/helper-optimise-call-expression': 7.24.7
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@babel/helper-simple-access@7.22.5:
     resolution: {integrity: sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.24.0
 
+  /@babel/helper-simple-access@7.24.7:
+    resolution: {integrity: sha512-zBAIvbCMh5Ts+b86r/CjU+4XGYIs+R1j951gxI3KmmxBMhCg4oQMsv6ZXQ64XOm/cvzfU1FmoCyt6+owc5QMYg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/traverse': 7.24.7
+      '@babel/types': 7.24.7
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@babel/helper-skip-transparent-expression-wrappers@7.22.5:
     resolution: {integrity: sha512-tK14r66JZKiC43p8Ki33yLBVJKlQDFoA8GYN67lWCDCqoL6EMMSuM9b+Iff2jHaM/RRFYl7K+iiru7hbRqNx8Q==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.24.0
 
+  /@babel/helper-skip-transparent-expression-wrappers@7.24.7:
+    resolution: {integrity: sha512-IO+DLT3LQUElMbpzlatRASEyQtfhSE0+m465v++3jyyXeBTBUjtVZg28/gHeV5mrTJqvEKhKroBGAvhW+qPHiQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/traverse': 7.24.7
+      '@babel/types': 7.24.7
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@babel/helper-split-export-declaration@7.22.6:
     resolution: {integrity: sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.24.0
 
+  /@babel/helper-split-export-declaration@7.24.7:
+    resolution: {integrity: sha512-oy5V7pD+UvfkEATUKvIjvIAH/xCzfsFVw7ygW2SI6NClZzquT+mwdTfgfdbUiceh6iQO0CHtCPsyze/MZ2YbAA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.24.7
+    dev: false
+
   /@babel/helper-string-parser@7.24.1:
     resolution: {integrity: sha512-2ofRCjnnA9y+wk8b9IAREroeUP02KHp431N2mhKniy2yKIDKpbrHv9eXwm8cBeWQYcJmzv5qKCu65P47eCF7CQ==}
     engines: {node: '>=6.9.0'}
 
+  /@babel/helper-string-parser@7.24.7:
+    resolution: {integrity: sha512-7MbVt6xrwFQbunH2DNQsAP5sTGxfqQtErvBIvIMi6EQnbgUOuVYanvREcmFrOPhoXBrTtjhhP+lW+o5UfK+tDg==}
+    engines: {node: '>=6.9.0'}
+    dev: false
+
   /@babel/helper-validator-identifier@7.22.20:
     resolution: {integrity: sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==}
     engines: {node: '>=6.9.0'}
 
+  /@babel/helper-validator-identifier@7.24.7:
+    resolution: {integrity: sha512-rR+PBcQ1SMQDDyF6X0wxtG8QyLCgUB0eRAGguqRLfkCA87l7yAP7ehq8SNj96OOGTO8OBV70KhuFYcIkHXOg0w==}
+    engines: {node: '>=6.9.0'}
+    dev: false
+
   /@babel/helper-validator-option@7.23.5:
     resolution: {integrity: sha512-85ttAOMLsr53VgXkTbkx8oA6YTfT4q7/HzXSLEYmjcSTJPMPQtvq1BD79Byep5xMUYbGRzEpDsjUf3dyp54IKw==}
     engines: {node: '>=6.9.0'}
 
+  /@babel/helper-validator-option@7.24.7:
+    resolution: {integrity: sha512-yy1/KvjhV/ZCL+SM7hBrvnZJ3ZuT9OuZgIJAGpPEToANvc3iM6iDvBnRjtElWibHU6n8/LPR/EjX9EtIEYO3pw==}
+    engines: {node: '>=6.9.0'}
+    dev: false
+
   /@babel/helper-wrap-function@7.22.20:
     resolution: {integrity: sha512-pms/UwkOpnQe/PDAEdV/d7dVCoBbB+R4FvYoHGZz+4VPcg7RtYy2KP7S2lbuWM6FCSgob5wshfGESbC/hzNXZw==}
     engines: {node: '>=6.9.0'}
@@ -2699,6 +3005,16 @@ packages:
       js-tokens: 4.0.0
       picocolors: 1.0.0
 
+  /@babel/highlight@7.24.7:
+    resolution: {integrity: sha512-EStJpq4OuY8xYfhGVXngigBJRWxftKX9ksiGDnmlY3o7B/V7KIAc9X4oiK87uPJSc/vs5L869bem5fhZa8caZw==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-validator-identifier': 7.24.7
+      chalk: 2.4.2
+      js-tokens: 4.0.0
+      picocolors: 1.0.0
+    dev: false
+
   /@babel/parser@7.24.4:
     resolution: {integrity: sha512-zTvEBcghmeBma9QIGunWevvBAp4/Qu9Bdq+2k0Ot4fVMD6v3dsC9WOcRSKk7tRRyBM/53yKMJko9xOatGQAwSg==}
     engines: {node: '>=6.0.0'}
@@ -2706,6 +3022,14 @@ packages:
     dependencies:
       '@babel/types': 7.24.0
 
+  /@babel/parser@7.24.7:
+    resolution: {integrity: sha512-9uUYRm6OqQrCqQdG1iCBwBPZgN8ciDBro2nIOFaiRz1/BCxaI7CNvQbDHvsArAC7Tw9Hda/B3U+6ui9u4HWXPw==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+    dependencies:
+      '@babel/types': 7.24.7
+    dev: false
+
   /@babel/plugin-bugfix-firefox-class-in-computed-class-key@7.24.4(@babel/core@7.24.4):
     resolution: {integrity: sha512-qpl6vOOEEzTLLcsuqYYo8yDtrTocmu2xkGvgNebvPjT9DTtfFYGmgDqY+rBYXNlqL4s9qLDn6xkrJv4RxAPiTA==}
     engines: {node: '>=6.9.0'}
@@ -2884,6 +3208,16 @@ packages:
       '@babel/core': 7.24.4(supports-color@8.1.1)
       '@babel/helper-plugin-utils': 7.24.0
 
+  /@babel/plugin-syntax-jsx@7.24.7(@babel/core@7.24.4):
+    resolution: {integrity: sha512-6ddciUPe/mpMnOKv/U+RSd2vvVy+Yw/JfBB0ZHYjEZt9NLHmCUylNYlsbqCCS1Bffjlb0fCwC9Vqz+sBz6PsiQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.24.4(supports-color@8.1.1)
+      '@babel/helper-plugin-utils': 7.24.7
+    dev: false
+
   /@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.24.4):
     resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==}
     peerDependencies:
@@ -2959,6 +3293,16 @@ packages:
       '@babel/core': 7.24.4(supports-color@8.1.1)
       '@babel/helper-plugin-utils': 7.24.0
 
+  /@babel/plugin-syntax-typescript@7.24.7(@babel/core@7.24.4):
+    resolution: {integrity: sha512-c/+fVeJBB0FeKsFvwytYiUD+LBvhHjGSI0g446PRGdSVGZLRNArBUno2PETbAly3tpiNAQR5XaZ+JslxkotsbA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.24.4(supports-color@8.1.1)
+      '@babel/helper-plugin-utils': 7.24.7
+    dev: false
+
   /@babel/plugin-syntax-unicode-sets-regex@7.18.6(@babel/core@7.24.4):
     resolution: {integrity: sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==}
     engines: {node: '>=6.9.0'}
@@ -3204,6 +3548,20 @@ packages:
       '@babel/helper-plugin-utils': 7.24.0
       '@babel/helper-simple-access': 7.22.5
 
+  /@babel/plugin-transform-modules-commonjs@7.24.7(@babel/core@7.24.4):
+    resolution: {integrity: sha512-iFI8GDxtevHJ/Z22J5xQpVqFLlMNstcLXh994xifFwxxGslr2ZXXLWgtBeLctOD63UFDArdvN6Tg8RFw+aEmjQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.24.4(supports-color@8.1.1)
+      '@babel/helper-module-transforms': 7.24.7(@babel/core@7.24.4)
+      '@babel/helper-plugin-utils': 7.24.7
+      '@babel/helper-simple-access': 7.24.7
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@babel/plugin-transform-modules-systemjs@7.24.1(@babel/core@7.24.4):
     resolution: {integrity: sha512-mqQ3Zh9vFO1Tpmlt8QPnbwGHzNz3lpNEMxQb1kAemn/erstyqw1r9KeOlOfo3y6xAnFEcOv2tSyrXfmMk+/YZA==}
     engines: {node: '>=6.9.0'}
@@ -3441,6 +3799,21 @@ packages:
       '@babel/helper-plugin-utils': 7.24.0
       '@babel/plugin-syntax-typescript': 7.24.1(@babel/core@7.24.4)
 
+  /@babel/plugin-transform-typescript@7.24.7(@babel/core@7.24.4):
+    resolution: {integrity: sha512-iLD3UNkgx2n/HrjBesVbYX6j0yqn/sJktvbtKKgcaLIQ4bTTQ8obAypc1VpyHPD2y4Phh9zHOaAt8e/L14wCpw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.24.4(supports-color@8.1.1)
+      '@babel/helper-annotate-as-pure': 7.24.7
+      '@babel/helper-create-class-features-plugin': 7.24.7(@babel/core@7.24.4)
+      '@babel/helper-plugin-utils': 7.24.7
+      '@babel/plugin-syntax-typescript': 7.24.7(@babel/core@7.24.4)
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@babel/plugin-transform-typescript@7.4.5(@babel/core@7.24.4):
     resolution: {integrity: sha512-RPB/YeGr4ZrFKNwfuQRlMf2lxoCUaU01MTw39/OFE/RiL8HDjtn68BwEPft1P7JN4akyEmjGWAMNldOV7o9V2g==}
     peerDependencies:
@@ -3608,6 +3981,22 @@ packages:
       '@babel/types': 7.24.0
       esutils: 2.0.3
 
+  /@babel/preset-typescript@7.24.7(@babel/core@7.24.4):
+    resolution: {integrity: sha512-SyXRe3OdWwIwalxDg5UtJnJQO+YPcTfwiIY2B0Xlddh9o7jpWLvv8X1RthIeDOxQ+O1ML5BLPCONToObyVQVuQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.24.4(supports-color@8.1.1)
+      '@babel/helper-plugin-utils': 7.24.7
+      '@babel/helper-validator-option': 7.24.7
+      '@babel/plugin-syntax-jsx': 7.24.7(@babel/core@7.24.4)
+      '@babel/plugin-transform-modules-commonjs': 7.24.7(@babel/core@7.24.4)
+      '@babel/plugin-transform-typescript': 7.24.7(@babel/core@7.24.4)
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@babel/regjsgen@0.8.0:
     resolution: {integrity: sha512-x/rqGMdzj+fWZvCOYForTghzbtqPDZ5gPwaoNGHdgDfF2QA/XZbCBp4Moo5scrkAMPhB7z26XM/AaHuIJdgauA==}
 
@@ -3630,6 +4019,15 @@ packages:
       '@babel/parser': 7.24.4
       '@babel/types': 7.24.0
 
+  /@babel/template@7.24.7:
+    resolution: {integrity: sha512-jYqfPrU9JTF0PmPy1tLYHW4Mp4KlgxJD9l2nP9fD6yT/ICi554DmrWBAEYpIelzjHf1msDP3PxJIRt/nFNfBig==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/code-frame': 7.24.7
+      '@babel/parser': 7.24.7
+      '@babel/types': 7.24.7
+    dev: false
+
   /@babel/traverse@7.23.9:
     resolution: {integrity: sha512-I/4UJ9vs90OkBtY6iiiTORVMyIhJ4kAVmsKo9KFc8UOxMeUfi2hvtIBsET5u9GizXE6/GFSuKCTNfgCswuEjRg==}
     engines: {node: '>=6.9.0'}
@@ -3665,6 +4063,24 @@ packages:
     transitivePeerDependencies:
       - supports-color
 
+  /@babel/traverse@7.24.7:
+    resolution: {integrity: sha512-yb65Ed5S/QAcewNPh0nZczy9JdYXkkAbIsEo+P7BE7yO3txAY30Y/oPa3QkQ5It3xVG2kpKMg9MsdxZaO31uKA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/code-frame': 7.24.7
+      '@babel/generator': 7.24.7
+      '@babel/helper-environment-visitor': 7.24.7
+      '@babel/helper-function-name': 7.24.7
+      '@babel/helper-hoist-variables': 7.24.7
+      '@babel/helper-split-export-declaration': 7.24.7
+      '@babel/parser': 7.24.7
+      '@babel/types': 7.24.7
+      debug: 4.3.4(supports-color@8.1.1)
+      globals: 11.12.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@babel/types@7.23.0:
     resolution: {integrity: sha512-0oIyUfKoI3mSqMvsxBdclDwxXKXAUA8v/apZbc+iSyARYou1o8ZGDxbUYyLFoW2arqS2jDGqJuZvv1d/io1axg==}
     engines: {node: '>=6.9.0'}
@@ -3682,6 +4098,15 @@ packages:
       '@babel/helper-validator-identifier': 7.22.20
       to-fast-properties: 2.0.0
 
+  /@babel/types@7.24.7:
+    resolution: {integrity: sha512-XEFXSlxiG5td2EJRe8vOmRbaXVgfcBlszKujvVmWIK/UpywWljQCfzAv3RQCGujWQ1RD4YYWEAqDXfuJiy8f5Q==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-string-parser': 7.24.7
+      '@babel/helper-validator-identifier': 7.24.7
+      to-fast-properties: 2.0.0
+    dev: false
+
   /@cnakazawa/watch@1.0.4:
     resolution: {integrity: sha512-v9kIhKwjeZThiWrLmj0y17CWoyddASLj9O2yvbZkbvw/N3rWOYy9zkV66ursAoVr0mV15bL8g0c4QZUE6cdDoQ==}
     engines: {node: '>=0.1.95'}
@@ -4338,7 +4763,6 @@ packages:
     cpu: [ppc64]
     os: [aix]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/android-arm64@0.20.2:
@@ -4347,7 +4771,6 @@ packages:
     cpu: [arm64]
     os: [android]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/android-arm@0.20.2:
@@ -4356,7 +4779,6 @@ packages:
     cpu: [arm]
     os: [android]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/android-x64@0.20.2:
@@ -4365,7 +4787,6 @@ packages:
     cpu: [x64]
     os: [android]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/darwin-arm64@0.20.2:
@@ -4374,7 +4795,6 @@ packages:
     cpu: [arm64]
     os: [darwin]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/darwin-x64@0.20.2:
@@ -4383,7 +4803,6 @@ packages:
     cpu: [x64]
     os: [darwin]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/freebsd-arm64@0.20.2:
@@ -4392,7 +4811,6 @@ packages:
     cpu: [arm64]
     os: [freebsd]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/freebsd-x64@0.20.2:
@@ -4401,7 +4819,6 @@ packages:
     cpu: [x64]
     os: [freebsd]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/linux-arm64@0.20.2:
@@ -4410,7 +4827,6 @@ packages:
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/linux-arm@0.20.2:
@@ -4419,7 +4835,6 @@ packages:
     cpu: [arm]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/linux-ia32@0.20.2:
@@ -4428,7 +4843,6 @@ packages:
     cpu: [ia32]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/linux-loong64@0.20.2:
@@ -4437,7 +4851,6 @@ packages:
     cpu: [loong64]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/linux-mips64el@0.20.2:
@@ -4446,7 +4859,6 @@ packages:
     cpu: [mips64el]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/linux-ppc64@0.20.2:
@@ -4455,7 +4867,6 @@ packages:
     cpu: [ppc64]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/linux-riscv64@0.20.2:
@@ -4464,7 +4875,6 @@ packages:
     cpu: [riscv64]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/linux-s390x@0.20.2:
@@ -4473,7 +4883,6 @@ packages:
     cpu: [s390x]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/linux-x64@0.20.2:
@@ -4482,7 +4891,6 @@ packages:
     cpu: [x64]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/netbsd-x64@0.20.2:
@@ -4491,7 +4899,6 @@ packages:
     cpu: [x64]
     os: [netbsd]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/openbsd-x64@0.20.2:
@@ -4500,7 +4907,6 @@ packages:
     cpu: [x64]
     os: [openbsd]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/sunos-x64@0.20.2:
@@ -4509,7 +4915,6 @@ packages:
     cpu: [x64]
     os: [sunos]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/win32-arm64@0.20.2:
@@ -4518,7 +4923,6 @@ packages:
     cpu: [arm64]
     os: [win32]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/win32-ia32@0.20.2:
@@ -4527,7 +4931,6 @@ packages:
     cpu: [ia32]
     os: [win32]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@esbuild/win32-x64@0.20.2:
@@ -4536,7 +4939,6 @@ packages:
     cpu: [x64]
     os: [win32]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@eslint-community/eslint-utils@4.4.0(eslint@8.57.0):
@@ -4654,6 +5056,12 @@ packages:
     dependencies:
       '@simple-dom/interface': 1.4.0
 
+  /@glimmer/interfaces@0.87.1:
+    resolution: {integrity: sha512-2lbwLY4Bt9i2SvwT4hhY0TgEYKhOMQBgYvRiraq2BYHwO8iLKh3lC8iO3d+rQ3VgDtQ9i/sP6HG848VNRyVHxA==}
+    dependencies:
+      '@simple-dom/interface': 1.4.0
+    dev: false
+
   /@glimmer/interfaces@0.88.1:
     resolution: {integrity: sha512-BOcN8xFNX/eppGxwS9Rm1+PlQaFX+tK91cuQLHj2sRwB+qVbL/WeutIa3AUQYr0VVEzMm2S6bYCLvG6p0a8v9A==}
     dependencies:
@@ -4768,6 +5176,16 @@ packages:
       '@handlebars/parser': 2.0.0
       simple-html-tokenizer: 0.5.11
 
+  /@glimmer/syntax@0.87.1:
+    resolution: {integrity: sha512-zYzZT6LgpSF0iv5iuxmMV5Pf52aE8dukNC2KfrHC6gXJfM4eLZMZcyk76NW5m+SEetZSOXX6AWv/KwLnoxiMfQ==}
+    dependencies:
+      '@glimmer/interfaces': 0.87.1
+      '@glimmer/util': 0.87.1
+      '@glimmer/wire-format': 0.87.1
+      '@handlebars/parser': 2.0.0
+      simple-html-tokenizer: 0.5.11
+    dev: false
+
   /@glimmer/syntax@0.88.1:
     resolution: {integrity: sha512-tucexG0j5SSbk3d4ayCOnvjg5FldvWyrZbzxukZOBhDgAYhGWUnGFAqdoXjpr3w6FkD4xIVliVD9GFrH4lI8DA==}
     dependencies:
@@ -4805,6 +5223,13 @@ packages:
       '@glimmer/interfaces': 0.84.3
       '@simple-dom/interface': 1.4.0
 
+  /@glimmer/util@0.87.1:
+    resolution: {integrity: sha512-Duxi2JutaIewfIWp8PJl7U5n12yasKWtZFHNLSrg+C8TKeMXdRyJtI7uqtqg0Z/6F9JwdJe/IPhTvdsTTfzAuA==}
+    dependencies:
+      '@glimmer/env': 0.1.7
+      '@glimmer/interfaces': 0.87.1
+    dev: false
+
   /@glimmer/util@0.88.1:
     resolution: {integrity: sha512-PV/24+vBmsReR78UQXJlEHDblU6QBAeIJa8MwKhQoxSD6WgvQHP4KmX23rvlCz11GxApTwyPm/2qyp/SwVvX2A==}
     dependencies:
@@ -4855,6 +5280,13 @@ packages:
       '@glimmer/util': 0.92.0
     dev: false
 
+  /@glimmer/wire-format@0.87.1:
+    resolution: {integrity: sha512-O3W1HDfRGX7wHZqvP8UzI/nWyZ2GIMFolU7l6WcLGU9HIdzqfxsc7ae2Icob/fq2kV9meHti4yDEdTMlBVK9AQ==}
+    dependencies:
+      '@glimmer/interfaces': 0.87.1
+      '@glimmer/util': 0.87.1
+    dev: false
+
   /@glimmer/wire-format@0.88.1:
     resolution: {integrity: sha512-DPM2UiYRNzcWdOUrSa8/IFbWKovH+c2JPnbvtk04DpfQapU7+hteBj34coEN/pW3FJiP3WMvx/EuPfWROkeDsg==}
     dependencies:
@@ -4933,6 +5365,18 @@ packages:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.4.15
 
+  /@lifeart/gxt@0.0.49:
+    resolution: {integrity: sha512-0aE3Qp1tYBeRmESOsVbTd0J07QakUk9rsmHpOifPjSPGOAHy3/MJGzE8TBGPwJkXRj/jpzLqlCo0KaxWzHXo2w==}
+    dependencies:
+      '@babel/core': 7.24.4(supports-color@8.1.1)
+      '@babel/preset-typescript': 7.24.7(@babel/core@7.24.4)
+      '@glimmer/syntax': 0.87.1
+      content-tag: 2.0.1
+      decorator-transforms: 2.0.0(@babel/core@7.24.4)
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /@lint-todo/utils@13.1.1:
     resolution: {integrity: sha512-F5z53uvRIF4dYfFfJP3a2Cqg+4P1dgJchJsFnsZE0eZp0LK8X7g2J0CsJHRgns+skpXOlM7n5vFGwkWCWj8qJg==}
     engines: {node: 12.* || >= 14}
@@ -5835,7 +6279,6 @@ packages:
     cpu: [arm]
     os: [android]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-android-arm64@4.16.4:
@@ -5843,7 +6286,6 @@ packages:
     cpu: [arm64]
     os: [android]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-darwin-arm64@4.16.4:
@@ -5851,7 +6293,6 @@ packages:
     cpu: [arm64]
     os: [darwin]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-darwin-x64@4.16.4:
@@ -5859,7 +6300,6 @@ packages:
     cpu: [x64]
     os: [darwin]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-linux-arm-gnueabihf@4.16.4:
@@ -5867,7 +6307,6 @@ packages:
     cpu: [arm]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-linux-arm-musleabihf@4.16.4:
@@ -5875,7 +6314,6 @@ packages:
     cpu: [arm]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-linux-arm64-gnu@4.16.4:
@@ -5883,7 +6321,6 @@ packages:
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-linux-arm64-musl@4.16.4:
@@ -5891,7 +6328,6 @@ packages:
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-linux-powerpc64le-gnu@4.16.4:
@@ -5899,7 +6335,6 @@ packages:
     cpu: [ppc64]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-linux-riscv64-gnu@4.16.4:
@@ -5907,7 +6342,6 @@ packages:
     cpu: [riscv64]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-linux-s390x-gnu@4.16.4:
@@ -5915,7 +6349,6 @@ packages:
     cpu: [s390x]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-linux-x64-gnu@4.16.4:
@@ -5923,7 +6356,6 @@ packages:
     cpu: [x64]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-linux-x64-musl@4.16.4:
@@ -5931,7 +6363,6 @@ packages:
     cpu: [x64]
     os: [linux]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-win32-arm64-msvc@4.16.4:
@@ -5939,7 +6370,6 @@ packages:
     cpu: [arm64]
     os: [win32]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-win32-ia32-msvc@4.16.4:
@@ -5947,7 +6377,6 @@ packages:
     cpu: [ia32]
     os: [win32]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@rollup/rollup-win32-x64-msvc@4.16.4:
@@ -5955,7 +6384,6 @@ packages:
     cpu: [x64]
     os: [win32]
     requiresBuild: true
-    dev: true
     optional: true
 
   /@simple-dom/document@1.4.0:
@@ -7211,9 +7639,6 @@ packages:
 
   /ajv-formats@2.1.1:
     resolution: {integrity: sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==}
-    peerDependenciesMeta:
-      ajv:
-        optional: true
     dependencies:
       ajv: 8.12.0
 
@@ -7704,7 +8129,6 @@ packages:
   /babel-import-util@3.0.0:
     resolution: {integrity: sha512-4YNPkuVsxAW5lnSTa6cn4Wk49RX6GAB6vX+M6LqEtN0YePqoFczv1/x0EyLK/o+4E1j9jEuYj5Su7IEPab5JHQ==}
     engines: {node: '>= 12.*'}
-    dev: true
 
   /babel-loader@8.3.0(@babel/core@7.24.4)(webpack@5.91.0):
     resolution: {integrity: sha512-H8SvsMF+m9t15HNLMipppzkC+Y2Yq+v3SonZyU70RBL/h1gxPkH08Ot8pEE9Z4Kd+czyWJClmFS8qzIP9OZ04Q==}
@@ -9444,6 +9868,10 @@ packages:
     resolution: {integrity: sha512-9guqKIx2H+78N17otBpl8yLZbQGL5q1vBO/jDb3gF2JjixtcVpC62jDUNxjVMNoaZ09oxRX84ZOD6VX02qkVvg==}
     dev: true
 
+  /content-tag@2.0.1:
+    resolution: {integrity: sha512-jxsETSDs5NbNwyiDuIp672fUMhUyu8Qxc5MOBOJOcgW/fQESI6o5K1LBDrnEE7Bh810a685lWEZHTF4jQYGEEw==}
+    dev: false
+
   /content-type@1.0.5:
     resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
     engines: {node: '>= 0.6'}
@@ -9764,7 +10192,6 @@ packages:
       babel-import-util: 3.0.0
     transitivePeerDependencies:
       - '@babel/core'
-    dev: true
 
   /deep-eql@0.1.3:
     resolution: {integrity: sha512-6sEotTRGBFiNcqVoeHwnfopbSpi5NbH1VWJmYCVkmxMmaVTT0bUTrNaGyBwhgP4MZL012W/mkzIn3Da+iDYweg==}
@@ -11199,7 +11626,6 @@ packages:
       '@esbuild/win32-arm64': 0.20.2
       '@esbuild/win32-ia32': 0.20.2
       '@esbuild/win32-x64': 0.20.2
-    dev: true
 
   /escalade@3.1.2:
     resolution: {integrity: sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==}
@@ -12426,7 +12852,6 @@ packages:
     engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
     os: [darwin]
     requiresBuild: true
-    dev: true
     optional: true
 
   /function-bind@1.1.2:
@@ -12885,7 +13310,7 @@ packages:
       function-bind: 1.1.2
 
   /hawk@1.1.1:
-    resolution: {integrity: sha1-h81JH5tG5OKurKM1QWdmiF0tHtk=}
+    resolution: {integrity: sha512-am8sVA2bCJIw8fuuVcKvmmNnGFUGW8spTkVtj2fXTEZVkfN42bwFZFtDem57eFi+NSxurJB8EQ7Jd3uCHLn8Vw==}
     engines: {node: '>=0.8.0'}
     deprecated: This module moved to @hapi/hawk. Please make sure to switch over as this distribution is no longer supported and may contain bugs and critical security issues.
     requiresBuild: true
@@ -16326,7 +16751,6 @@ packages:
       '@rollup/rollup-win32-ia32-msvc': 4.16.4
       '@rollup/rollup-win32-x64-msvc': 4.16.4
       fsevents: 2.3.3
-    dev: true
 
   /route-recognizer@0.3.4:
     resolution: {integrity: sha512-2+MhsfPhvauN1O8KaXpXAOfR/fwe8dnUXVM+xw7yt40lJRfPVQxV6yryZm0cgRvAj5fMF/mdRZbL2ptwbs5i2g==}
@@ -18195,7 +18619,6 @@ packages:
       rollup: 4.16.4
     optionalDependencies:
       fsevents: 2.3.3
-    dev: true
 
   /vow-fs@0.3.6:
     resolution: {integrity: sha512-oK9rtqJSHy7ZQAhAtVU0HiF/oVhm0A4Qx2l2DyyFBUsXbTXUg258EsQGLLIXYZnE5MYaInZLgA6l/10je/EamA==}