ember-learn · mansona · Sep 27, 2025 · May 19, 2025 · May 30, 2025 · Jun 2, 2025
diff --git a/.local.dic b/.local.dic
@@ -252,3 +252,4 @@ websocket
 working-with-html-css-and-javascript
 yay
 ZEIT
+userQuestion
diff --git a/config/environment.js b/config/environment.js
@@ -48,6 +48,8 @@ module.exports = function (environment) {
     guidemaker: {
       title: 'Ember Guides',
       sourceRepo: 'https://github.com/ember-learn/guides-source',
+      gjsVersions: ['v6.7.0'],
+      gjsLink: '/release/components/template-tag-format/',
     },
 
     algolia: {

diff --git a/guides/release/accessibility/page-template-considerations.md b/guides/release/accessibility/page-template-considerations.md
@@ -17,29 +17,32 @@ Consider this format:
 
 Note that the unique page title is first. This is because it is the most important piece of information from a contextual perspective. Since a user with a screen reader can interrupt the screen reader as they wish, it introduces less fatigue when the unique page title is first, but provides the additional guidance if it is desired.
 
-A simple way to add page titles is to use the `page-title` helper which comes from the [ember-page-title](https://github.com/ember-cli/ember-page-title) addon that is installed by default in new apps. We can use this helper to set the page title at any point in any template.
+A simple way to add page titles is to use the `pageTitle` helper which comes from the [ember-page-title](https://github.com/ember-cli/ember-page-title) addon that is installed by default in new apps. We can use this helper to set the page title at any point in any template.
 
 For example, if we have a “posts” route, we can set the page title for it like so:
 
+```gjs {data-filename=app/routes/posts.gjs}
+import { pageTitle } from 'ember-page-title';
 
-```handlebars {data-filename=app/routes/posts.hbs}
-{{page-title "Posts - Site Title"}}
-
-{{outlet}}
+<template>
+  {{pageTitle "Posts"}}
+  {{outlet}}
+</template>
 ```
 
 Extending the example, if we have a “post” route that lives within the “posts” route, we could set its page title like so:
 
-```handlebars {data-filename=app/routes/posts/post.hbs}
-{{page-title (concat @model.title " - Site Title")}}
+```gjs {data-filename=app/routes/posts/post.gjs}
+import { pageTitle } from 'ember-page-title';
 
-<h1>{{@model.title}}</h1>
-```
+<template>
+  {{pageTitle @model.title}} {{! e.g.,  "My Title" }}
 
-When your needs become more complex, the following addons facilitate page titles in a more dynamic and maintainable way.
+  <h1>{{@model.title}}</h1>
+</template>
+```
 
-- [ember-cli-head](https://github.com/ronco/ember-cli-head)
-- [ember-cli-document-title](https://github.com/kimroen/ember-cli-document-title)
+Each call to the `{{pageTitle}}` helper will prepend the title string to the existing title all the way up to the root title in `application.gts`.  So, if your application is titled "My App", then the full title for the above example would be "My Title | Posts | My App".
 
 To evaluate more addons to add/manage content in the `<head>` of a page, view this category on [Ember Observer](https://emberobserver.com/categories/header-content).
 
@@ -48,14 +51,14 @@ You can test that page titles are generated correctly by asserting on the value
 ```javascript {data-filename=tests/acceptance/posts-test.js}
 import { module, test } from 'qunit';
 import { visit, currentURL } from '@ember/test-helpers';
-import { setupApplicationTest } from 'my-app-name/tests/helpers';
+import { setupApplicationTest } from 'my-app/tests/helpers';
 
-module('Acceptance | posts', function(hooks) {
+module('Acceptance | posts', function (hooks) {
   setupApplicationTest(hooks);
 
-  test('visiting /posts', async function(assert) {
+  test('visiting /posts', async function (assert) {
     await visit('/posts');
-    assert.equal(document.title, 'Posts - Site Title');
+    assert.equal(document.title, 'Posts | My App');
   });
 });
 ```

diff --git a/guides/release/applications/run-loop.md b/guides/release/applications/run-loop.md
@@ -1,6 +1,22 @@
-**Note:**
-* _For basic Ember app development scenarios, you don't need to understand the run loop or use it directly. All common paths are paved nicely for you and don't require working with the run loop._
-* _However, the run loop will be helpful to understand the internals of Ember and to assist in customized performance tuning by manually batching costly work._
+<div class="cta">
+  <div class="cta-note">
+    <div class="cta-note-body">
+      <div class="cta-note-heading" data-test-es-note-heading="">Zoey says...</div>
+      <div class="cta-note-message">
+
+        <p>
+          For basic Ember app development scenarios, you don't need to understand the run loop or use it directly. All common paths are paved nicely for you and don't require working with the run loop.
+        </p>
+
+        <p>
+          However, the run loop will be helpful to understand the internals of Ember and to assist in customized performance tuning by manually batching costly work.
+        </p>
+
+      </div>
+    </div>
+    <img src="/images/mascots/zoey.png" role="presentation" alt="">
+  </div>
+</div>
 
 Ember's internals and most of the code you will write in your applications takes place in a run loop.
 The run loop is used to batch, and order (or reorder) work in a way that is most effective and efficient.
@@ -83,9 +99,13 @@ class Image {
 
 and a template to display its attributes:
 
-```handlebars
-{{this.width}}
-{{this.aspectRatio}}
+```gjs
+let profilePhoto = new Image({ width: 250, height: 500 });
+
+<template>
+  {{profilePhoto.width}}
+  {{profilePhoto.aspectRatio}}
+</template>
 ```
 
 If we execute the following code without the run loop:
@@ -169,13 +189,15 @@ which will make you a better Ember developer.
 
 You should begin a run loop when the callback fires.
 
-The `Ember.run` method can be used to create a run loop.
-In this example, `Ember.run` is used to handle an online
+The `run()` method, imported from `@ember/runloop`, can be used to create a run loop.
+In this example, `run()` is used to handle an online
 event (browser gains internet access) and run some Ember code.
 
 ```javascript
+import { run } from '@ember/runloop';
+
 window.addEventListener('online', () => {
-  Ember.run(() => {  // begin loop
+  run(() => {  // begin loop
     // Code that results in jobs being scheduled goes here
   }); // end loop, jobs are flushed and executed
 });
@@ -185,15 +207,17 @@ window.addEventListener('online', () => {
 
 ## What happens if I forget to start a run loop in an async handler?
 
-As mentioned above, you should wrap any non-Ember async callbacks in `Ember.run`.
+As mentioned above, you should wrap any non-Ember async callbacks in `run()`.
 If you don't, Ember will try to approximate a beginning and end for you.
 Consider the following callback:
 
 ```javascript
+import { run } from '@ember/runloop';
+
 window.addEventListener('online', () => {
   console.log('Doing things...');
 
-  Ember.run.schedule('actions', () => {
+  run.schedule('actions', () => {
     // Do more things
   });
 });
@@ -207,40 +231,42 @@ These automatically created run loops we call _autoruns_.
 Here is some pseudocode to describe what happens using the example above:
 
 ```javascript
+import { run } from '@ember/runloop';
+
 window.addEventListener('online', () => {
   // 1. autoruns do not change the execution of arbitrary code in a callback.
   //    This code is still run when this callback is executed and will not be
   //    scheduled on an autorun.
   console.log('Doing things...');
 
-  Ember.run.schedule('actions', () => {
+  run.schedule('actions', () => {
     // 2. schedule notices that there is no currently available run loop so it
     //    creates one. It schedules it to close and flush queues on the next
     //    turn of the JS event loop.
-    if (! Ember.run.hasOpenRunLoop()) {
-      Ember.run.begin();
+    if (! run.hasOpenRunLoop()) {
+      run.begin();
       nextTick(() => {
-        Ember.run.end()
+        run.end()
       }, 0);
     }
 
     // 3. There is now a run loop available so schedule adds its item to the
     //    given queue
-    Ember.run.schedule('actions', () => {
+    run.schedule('actions', () => {
       // Do more things
     });
 
   });
 
   // 4. This schedule sees the autorun created by schedule above as an available
   //    run loop and adds its item to the given queue.
-  Ember.run.schedule('afterRender', () => {
+  run.schedule('afterRender', () => {
     // Do yet more things
   });
 });
 ```
 
 ## Where can I find more information?
 
-Check out the [Ember.run](https://api.emberjs.com/ember/release/classes/@ember%2Frunloop) API documentation,
+Check out the [`@ember/runloop`](https://api.emberjs.com/ember/release/classes/@ember%2Frunloop) API documentation,
 as well as the [Backburner library](https://github.com/ebryn/backburner.js/) that powers the run loop.
-Original file line number
+Diff line change
@@ Expand Up / @@ -252,3 +252,4 @@ websocket @@
     working-with-html-css-and-javascript
     yay
     ZEIT
+    userQuestion