diff --git a/packages/host/app/components/card-catalog/modal.gts b/packages/host/app/components/card-catalog/modal.gts
index 5280796085..93a988b97a 100644
--- a/packages/host/app/components/card-catalog/modal.gts
+++ b/packages/host/app/components/card-catalog/modal.gts
@@ -24,6 +24,7 @@ import {
   type CreateNewCard,
   Deferred,
   type RealmInfo,
+  Loader,
 } from '@cardstack/runtime-common';
 
 import type { Query, Filter } from '@cardstack/runtime-common/query';
@@ -327,7 +328,11 @@ export default class CardCatalogModal extends Component<Signature> {
       } = {},
     ) => {
       this.stateId++;
-      let title = chooseCardTitle(query.filter, opts?.multiSelect);
+      let title = await chooseCardTitle(
+        query.filter,
+        this.loaderService.loader,
+        opts?.multiSelect,
+      );
       let request = new TrackedObject<Request>({
         search: getSearchResults(this, () => query),
         deferred: new Deferred(),
@@ -527,14 +532,18 @@ export default class CardCatalogModal extends Component<Signature> {
   );
 }
 
-function chooseCardTitle(
+async function chooseCardTitle(
   filter: Filter | undefined,
+  loader: Loader,
   multiSelect?: boolean,
-): string {
+): Promise<string> {
   if (!filter) {
     return DEFAULT_CHOOOSE_CARD_TITLE;
   }
-  let suggestions = suggestCardChooserTitle(filter, 0, { multiSelect });
+  let suggestions = await suggestCardChooserTitle(filter, 0, {
+    loader,
+    multiSelect,
+  });
   return (
     getSuggestionWithLowestDepth(suggestions) ?? DEFAULT_CHOOOSE_CARD_TITLE
   );
diff --git a/packages/host/app/utils/text-suggestion.ts b/packages/host/app/utils/text-suggestion.ts
index 3f1970e0dd..80081f5ed2 100644
--- a/packages/host/app/utils/text-suggestion.ts
+++ b/packages/host/app/utils/text-suggestion.ts
@@ -1,6 +1,11 @@
 import a from 'indefinite';
 
-import { getPlural } from '@cardstack/runtime-common';
+import {
+  CodeRef,
+  getPlural,
+  loadCard,
+  Loader,
+} from '@cardstack/runtime-common';
 import {
   isCardTypeFilter,
   isEveryFilter,
@@ -12,14 +17,15 @@ interface ChooseCardSuggestion {
   depth: number;
 }
 
-interface TextOpts {
+interface Opts {
+  loader: Loader;
   multiSelect?: boolean;
 }
-export function suggestCardChooserTitle(
+export async function suggestCardChooserTitle(
   filter: Filter,
   depth = 0, //lower the depth, higher the priority
-  textOpts?: TextOpts,
-): ChooseCardSuggestion[] {
+  opts: Opts,
+): Promise<ChooseCardSuggestion[]> {
   let MAX_RECURSION_DEPTH = 2;
   if (filter === undefined || depth + 1 > MAX_RECURSION_DEPTH) {
     return [];
@@ -27,28 +33,30 @@ export function suggestCardChooserTitle(
   let suggestions: ChooseCardSuggestion[] = [];
   //--base case--
   if ('on' in filter && filter.on !== undefined) {
-    let cardRefName = (filter.on as { module: string; name: string }).name;
-    return [{ suggestion: titleText(cardRefName, 'card', textOpts), depth }];
+    let cardDisplayName = await getCardDisplayName(opts.loader, filter.on);
+    return [{ suggestion: titleText(cardDisplayName, 'card', opts), depth }];
   }
   if (isCardTypeFilter(filter)) {
-    let cardRefName = (filter.type as { module: string; name: string }).name;
-    if (cardRefName == 'CardDef') {
+    let cardDisplayName = await getCardDisplayName(opts.loader, filter.type);
+    if (cardDisplayName == 'Card') {
       suggestions.push({
-        suggestion: titleText('Card', 'instance', textOpts),
+        suggestion: titleText('Card', 'instance', opts),
         depth,
       });
     } else {
       suggestions.push({
-        suggestion: titleText(cardRefName, 'card', textOpts),
+        suggestion: titleText(cardDisplayName, 'card', opts),
         depth,
       });
     }
   }
   //--inductive case--
   if (isEveryFilter(filter)) {
-    let nestedSuggestions = filter.every.flatMap((f) =>
-      suggestCardChooserTitle(f, depth + 1, textOpts),
-    );
+    let nestedSuggestions = await Promise.all(
+      filter.every.map(
+        async (f) => await suggestCardChooserTitle(f, depth + 1, opts),
+      ),
+    ).then((arrays) => arrays.flat());
     suggestions = [...suggestions, ...nestedSuggestions];
   }
   return suggestions;
@@ -56,19 +64,20 @@ export function suggestCardChooserTitle(
 
 type CardNoun = 'instance' | 'type' | 'card';
 
-function titleText(
-  cardRefName: string,
-  cardNoun: CardNoun,
-  textOpts?: TextOpts,
-) {
-  let object = `${cardRefName} ${cardNoun}`;
-  if (textOpts?.multiSelect) {
+function titleText(cardDisplayName: string, cardNoun: CardNoun, opts?: Opts) {
+  let object = `${cardDisplayName} ${cardNoun}`;
+  if (opts?.multiSelect) {
     return `Select 1 or more ${getPlural(object)}`;
   } else {
     return `Choose ${a(object)}`;
   }
 }
 
+async function getCardDisplayName(loader: Loader, codeRef: CodeRef) {
+  let card = await loadCard(codeRef, { loader });
+  return card.displayName;
+}
+
 export function getSuggestionWithLowestDepth(
   items: ChooseCardSuggestion[],
 ): string | undefined {
diff --git a/packages/host/tests/integration/components/card-editor-test.gts b/packages/host/tests/integration/components/card-editor-test.gts
index a93b01adfc..d2bca5676d 100644
--- a/packages/host/tests/integration/components/card-editor-test.gts
+++ b/packages/host/tests/integration/components/card-editor-test.gts
@@ -84,6 +84,7 @@ module('Integration | card-editor', function (hooks) {
     let { default: StringField } = string;
 
     class Pet extends CardDef {
+      static displayName = 'Pet';
       @field name = contains(StringField);
       static embedded = class Embedded extends Component<typeof this> {
         <template>
@@ -94,6 +95,7 @@ module('Integration | card-editor', function (hooks) {
       };
     }
     class FancyPet extends Pet {
+      static displayName = 'FancyPet';
       @field favoriteToy = contains(StringField);
       static embedded = class Embedded extends Component<typeof this> {
         <template>
@@ -106,6 +108,7 @@ module('Integration | card-editor', function (hooks) {
       };
     }
     class Person extends CardDef {
+      static displayName = 'Person';
       @field firstName = contains(StringField);
       @field pet = linksTo(Pet);
       static isolated = class Embedded extends Component<typeof this> {
diff --git a/packages/host/tests/integration/components/operator-mode-test.gts b/packages/host/tests/integration/components/operator-mode-test.gts
index 3d91019dee..254071932d 100644
--- a/packages/host/tests/integration/components/operator-mode-test.gts
+++ b/packages/host/tests/integration/components/operator-mode-test.gts
@@ -1202,7 +1202,7 @@ module('Integration | operator-mode', function (hooks) {
     await click('[data-test-create-new-card-button]');
     assert
       .dom('[data-test-card-catalog-modal] [data-test-boxel-header-title]')
-      .containsText('Choose a CatalogEntry card');
+      .containsText('Choose a Catalog Entry card');
     await waitFor(
       `[data-test-card-catalog-item="${testRealmURL}CatalogEntry/publishing-packet"]`,
     );
@@ -1279,7 +1279,7 @@ module('Integration | operator-mode', function (hooks) {
     );
     assert
       .dom('[data-test-card-catalog-modal] [data-test-boxel-header-title]')
-      .containsText('Choose a CatalogEntry card');
+      .containsText('Choose a Catalog Entry card');
     assert.dom('[data-test-card-catalog-item]').exists({ count: 4 });
 
     await click(
@@ -2788,7 +2788,7 @@ module('Integration | operator-mode', function (hooks) {
     await click('[data-test-create-new-card-button]');
     assert
       .dom('[data-test-card-catalog-modal] [data-test-boxel-header-title]')
-      .containsText('Choose a CatalogEntry card');
+      .containsText('Choose a Catalog Entry card');
     await waitFor(
       `[data-test-card-catalog-item="${testRealmURL}CatalogEntry/publishing-packet"]`,
     );
diff --git a/packages/host/tests/integration/components/text-suggestion-test.gts b/packages/host/tests/integration/components/text-suggestion-test.gts
new file mode 100644
index 0000000000..04b4ac013d
--- /dev/null
+++ b/packages/host/tests/integration/components/text-suggestion-test.gts
@@ -0,0 +1,356 @@
+import { RenderingTestContext } from '@ember/test-helpers';
+
+import { setupRenderingTest } from 'ember-qunit';
+import { module, test } from 'qunit';
+
+import { baseRealm, Loader } from '@cardstack/runtime-common';
+
+import type LoaderService from '@cardstack/host/services/loader-service';
+
+import {
+  suggestCardChooserTitle,
+  getSuggestionWithLowestDepth,
+} from '@cardstack/host/utils/text-suggestion';
+
+import {
+  testRealmURL,
+  setupIntegrationTestRealm,
+  setupLocalIndexing,
+} from '../../helpers';
+
+let cardApi: typeof import('https://cardstack.com/base/card-api');
+let string: typeof import('https://cardstack.com/base/string');
+let loader: Loader;
+
+module('Integration | text-suggestion | card-chooser-title', function (hooks) {
+  setupRenderingTest(hooks);
+  setupLocalIndexing(hooks);
+
+  hooks.beforeEach(function (this: RenderingTestContext) {
+    loader = (this.owner.lookup('service:loader-service') as LoaderService)
+      .loader;
+  });
+
+  hooks.beforeEach(async function () {
+    cardApi = await loader.import(`${baseRealm.url}card-api`);
+    string = await loader.import(`${baseRealm.url}string`);
+
+    let { contains, field, CardDef, linksTo } = cardApi;
+    let { default: StringField } = string;
+
+    class Article extends CardDef {
+      static displayName = 'Article';
+      @field author = contains(StringField);
+    }
+
+    class Post extends CardDef {
+      static displayName = 'Post';
+      @field article = linksTo(Article);
+      @field title = contains(StringField);
+    }
+
+    class BlogPost extends Post {
+      static displayName = 'BlogPost';
+      @field article = linksTo(Article);
+    }
+
+    class Book extends CardDef {
+      static displayName = 'Book';
+      @field author = contains(StringField);
+    }
+
+    class Booking extends CardDef {
+      static displayName = 'Booking';
+      @field booker = contains(StringField);
+    }
+
+    await setupIntegrationTestRealm({
+      loader,
+      contents: {
+        'article.gts': { Article },
+        'blog-post.gts': { BlogPost },
+        'book.gts': { Book },
+        'booking.gts': { Booking },
+        'post.gts': { Post },
+      },
+    });
+  });
+
+  test('filter on', async function (assert) {
+    let filter = {
+      on: { module: `${testRealmURL}booking`, name: 'Booking' },
+      eq: { booker: 'Arthur' },
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 0,
+        suggestion: 'Choose a Booking card',
+      },
+    ]);
+  });
+
+  test('filter by type', async function (assert) {
+    let filter = {
+      type: { module: `${testRealmURL}booking`, name: 'Booking' },
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 0,
+        suggestion: 'Choose a Booking card',
+      },
+    ]);
+  });
+
+  test('filter by every', async function (assert) {
+    let filter = {
+      every: [
+        {
+          on: { module: `${testRealmURL}article`, name: 'Article' },
+          eq: { author: 'Kafka' },
+        },
+        {
+          on: { module: `${testRealmURL}book`, name: 'Book' },
+          eq: { author: 'Kafka' },
+        },
+      ],
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 1,
+        suggestion: 'Choose an Article card',
+      },
+      {
+        depth: 1,
+        suggestion: 'Choose a Book card',
+      },
+    ]);
+  });
+
+  test('filter by any', async function (assert) {
+    let filter = {
+      any: [
+        {
+          on: { module: `${testRealmURL}article`, name: 'Article' },
+          eq: { author: 'Kafka' },
+        },
+        {
+          on: { module: `${testRealmURL}book`, name: 'Book' },
+          eq: { author: 'Kafka' },
+        },
+      ],
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, []);
+  });
+
+  test('filter with every with type and on', async function (assert) {
+    let filter = {
+      every: [
+        { type: { module: `${testRealmURL}booking`, name: 'Booking' } },
+        {
+          on: { module: `${testRealmURL}article`, name: 'Article' },
+          eq: { author: 'Kafka' },
+        },
+        {
+          on: { module: `${testRealmURL}book`, name: 'Book' },
+          eq: { author: 'Kafka' },
+        },
+      ],
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 1,
+        suggestion: 'Choose a Booking card',
+      },
+      {
+        depth: 1,
+        suggestion: 'Choose an Article card',
+      },
+      {
+        depth: 1,
+        suggestion: 'Choose a Book card',
+      },
+    ]);
+  });
+
+  test('filter by not', async function (assert) {
+    let filter = {
+      on: { module: `${testRealmURL}article`, name: 'Article' },
+      not: { eq: { author: 'Carl' } },
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 0,
+        suggestion: 'Choose an Article card',
+      },
+    ]);
+  });
+
+  test('filter by range', async function (assert) {
+    let filter = {
+      on: { module: `${testRealmURL}post`, name: 'Post' },
+      range: { views: { lte: 10, gt: 5 }, 'author.posts': { gte: 1 } },
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 0,
+        suggestion: 'Choose a Post card',
+      },
+    ]);
+  });
+
+  test('filter by card instance', async function (assert) {
+    let filter = {
+      type: { module: `${baseRealm.url}card-api`, name: 'CardDef' },
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 0,
+        suggestion: 'Choose a Card instance',
+      },
+    ]);
+  });
+
+  test('filter -- a complex one', async function (assert) {
+    let filter = {
+      every: [
+        {
+          on: {
+            module: `${testRealmURL}post`,
+            name: 'Post',
+          },
+        },
+        { eq: { title: 'Card 1' } },
+        { not: { eq: { 'author.firstName': 'Cardy' } } },
+      ],
+      type: { module: `${baseRealm.url}card-api`, name: 'CardDef' },
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 0,
+        suggestion: 'Choose a Card instance',
+      },
+      {
+        depth: 1,
+        suggestion: 'Choose a Post card',
+      },
+    ]);
+    assert.strictEqual(
+      getSuggestionWithLowestDepth(suggestions),
+      'Choose a Card instance',
+    );
+  });
+
+  test('filter -- nested one that exceeds recursion depth', async function (assert) {
+    let filter = {
+      every: [
+        {
+          type: { module: `${baseRealm.url}card-api`, name: 'CardDef' },
+        },
+        {
+          on: {
+            module: `${testRealmURL}post`,
+            name: 'Post',
+          },
+          every: [
+            {
+              type: {
+                module: `${testRealmURL}article`,
+                name: 'Article',
+              },
+            },
+          ],
+        },
+      ],
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 1,
+        suggestion: 'Choose a Card instance',
+      },
+      {
+        depth: 1,
+        suggestion: 'Choose a Post card',
+      },
+    ]);
+    assert.strictEqual(
+      getSuggestionWithLowestDepth(suggestions),
+      'Choose a Card instance',
+    );
+  });
+
+  test('filter with on specifying multiSelect option', async function (assert) {
+    let filter = {
+      on: { module: `${testRealmURL}booking`, name: 'Booking' },
+      eq: { booker: 'Arthur' },
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, {
+      loader,
+      multiSelect: true,
+    });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 0,
+        suggestion: 'Select 1 or more Booking cards',
+      },
+    ]);
+  });
+
+  test('filter with on but checking for "an"', async function (assert) {
+    let filter = {
+      on: { module: `${testRealmURL}article`, name: 'Article' },
+      eq: { author: 'Kafka' },
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 0,
+        suggestion: 'Choose an Article card',
+      },
+    ]);
+  });
+
+  test(`displays the right title even CodeRef is 'fieldOf' codeRef`, async function (assert) {
+    let filter = {
+      type: {
+        card: { module: `${testRealmURL}post`, name: 'Post' },
+        type: 'fieldOf',
+        field: 'article',
+      },
+      eq: { 'post.title': 'Kafka' },
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 0,
+        suggestion: 'Choose an Article card',
+      },
+    ]);
+  });
+
+  test(`displays the right title even CodeRef is 'ancestorOf' codeRef`, async function (assert) {
+    let filter = {
+      type: {
+        card: { module: `${testRealmURL}blog-post`, name: 'BlogPost' },
+        type: 'ancestorOf',
+      },
+      eq: { 'post.title': 'Kafka' },
+    };
+    let suggestions = await suggestCardChooserTitle(filter, 0, { loader });
+    assert.deepEqual(suggestions, [
+      {
+        depth: 0,
+        suggestion: 'Choose a Post card',
+      },
+    ]);
+  });
+});
diff --git a/packages/host/tests/unit/text-suggestion-test.ts b/packages/host/tests/unit/text-suggestion-test.ts
deleted file mode 100644
index 9016b72065..0000000000
--- a/packages/host/tests/unit/text-suggestion-test.ts
+++ /dev/null
@@ -1,239 +0,0 @@
-import { module, test } from 'qunit';
-
-import {
-  suggestCardChooserTitle,
-  getSuggestionWithLowestDepth,
-} from '@cardstack/host/utils/text-suggestion';
-
-module('Unit | text-suggestion | card-chooser-title', function () {
-  test('filter on', function (assert) {
-    let filter = {
-      on: { module: `https://my.realm/booking`, name: 'Booking' },
-      eq: { 'hosts.firstName': 'Arthur' },
-    };
-    let suggestions = suggestCardChooserTitle(filter);
-    assert.deepEqual(suggestions, [
-      {
-        depth: 0,
-        suggestion: 'Choose a Booking card',
-      },
-    ]);
-  });
-  test('filter by type', function (assert) {
-    let filter = {
-      type: { module: `https://my.realm/booking`, name: 'Booking' },
-    };
-    let suggestions = suggestCardChooserTitle(filter);
-    assert.deepEqual(suggestions, [
-      {
-        depth: 0,
-        suggestion: 'Choose a Booking card',
-      },
-    ]);
-  });
-  test('filter by every', function (assert) {
-    let filter = {
-      every: [
-        {
-          on: { module: `https://my.realm/article`, name: 'Article' },
-          eq: { 'author.firstName': 'Kafka' },
-        },
-        {
-          on: { module: `https://my.realm/book`, name: 'Book' },
-          eq: { 'author.firstName': 'Kafka' },
-        },
-      ],
-    };
-    let suggestions = suggestCardChooserTitle(filter);
-    assert.deepEqual(suggestions, [
-      {
-        depth: 1,
-        suggestion: 'Choose an Article card',
-      },
-      {
-        depth: 1,
-        suggestion: 'Choose a Book card',
-      },
-    ]);
-  });
-
-  test('filter by any', function (assert) {
-    let filter = {
-      any: [
-        {
-          on: { module: `https://my.realm/article`, name: 'Article' },
-          eq: { 'author.firstName': 'Kafka' },
-        },
-        {
-          on: { module: `https://my.realm/book`, name: 'Book' },
-          eq: { 'author.firstName': 'Kafka' },
-        },
-      ],
-    };
-    let suggestions = suggestCardChooserTitle(filter);
-    assert.deepEqual(suggestions, []);
-  });
-  test('filter with every with type and on', function (assert) {
-    let filter = {
-      every: [
-        { type: { module: `https://my.realm/booking`, name: 'Booking' } },
-        {
-          on: { module: `https://my.realm/article`, name: 'Article' },
-          eq: { 'author.firstName': 'Kafka' },
-        },
-        {
-          on: { module: `https://my.realm/book`, name: 'Book' },
-          eq: { 'author.firstName': 'Kafka' },
-        },
-      ],
-    };
-    let suggestions = suggestCardChooserTitle(filter);
-    assert.deepEqual(suggestions, [
-      {
-        depth: 1,
-        suggestion: 'Choose a Booking card',
-      },
-      {
-        depth: 1,
-        suggestion: 'Choose an Article card',
-      },
-      {
-        depth: 1,
-        suggestion: 'Choose a Book card',
-      },
-    ]);
-  });
-
-  test('filter by not', function (assert) {
-    let filter = {
-      on: { module: `https://my.realm/article`, name: 'Article' },
-      not: { eq: { 'author.firstName': 'Carl' } },
-    };
-    let suggestions = suggestCardChooserTitle(filter);
-    assert.deepEqual(suggestions, [
-      {
-        depth: 0,
-        suggestion: 'Choose an Article card',
-      },
-    ]);
-  });
-  test('filter by range', function (assert) {
-    let filter = {
-      on: { module: `https://my.realm/post`, name: 'Post' },
-      range: { views: { lte: 10, gt: 5 }, 'author.posts': { gte: 1 } },
-    };
-    let suggestions = suggestCardChooserTitle(filter);
-    assert.deepEqual(suggestions, [
-      {
-        depth: 0,
-        suggestion: 'Choose a Post card',
-      },
-    ]);
-  });
-  test('filter by card instance', function (assert) {
-    let filter = {
-      type: { module: `https://my.realm/cards-api`, name: 'CardDef' },
-    };
-    let suggestions = suggestCardChooserTitle(filter);
-    assert.deepEqual(suggestions, [
-      {
-        depth: 0,
-        suggestion: 'Choose a Card instance',
-      },
-    ]);
-  });
-  test('filter -- a complex one', function (assert) {
-    let filter = {
-      every: [
-        {
-          on: {
-            module: `https://my.realm/post`,
-            name: 'Post',
-          },
-        },
-        { eq: { title: 'Card 1' } },
-        { not: { eq: { 'author.firstName': 'Cardy' } } },
-      ],
-      type: { module: `https://my.realm/cards-api`, name: 'CardDef' },
-    };
-    let suggestions = suggestCardChooserTitle(filter);
-    assert.deepEqual(suggestions, [
-      {
-        depth: 0,
-        suggestion: 'Choose a Card instance',
-      },
-      {
-        depth: 1,
-        suggestion: 'Choose a Post card',
-      },
-    ]);
-    assert.strictEqual(
-      getSuggestionWithLowestDepth(suggestions),
-      'Choose a Card instance',
-    );
-  });
-  test('filter -- nested one that exceeds recursion depth', function (assert) {
-    let filter = {
-      every: [
-        {
-          type: { module: `https://my.realm/cards-api`, name: 'CardDef' },
-        },
-        {
-          on: {
-            module: `https://my.realm/post`,
-            name: 'Post',
-          },
-          every: [
-            {
-              type: {
-                module: `https://my.realm/some-type`,
-                name: 'SomeCardType',
-              },
-            },
-          ],
-        },
-      ],
-    };
-    let suggestions = suggestCardChooserTitle(filter);
-    assert.deepEqual(suggestions, [
-      {
-        depth: 1,
-        suggestion: 'Choose a Card instance',
-      },
-      {
-        depth: 1,
-        suggestion: 'Choose a Post card',
-      },
-    ]);
-    assert.strictEqual(
-      getSuggestionWithLowestDepth(suggestions),
-      'Choose a Card instance',
-    );
-  });
-  test('filter with on specifying multiSelect option', function (assert) {
-    let filter = {
-      on: { module: `https://my.realm/booking`, name: 'Booking' },
-      eq: { 'hosts.firstName': 'Arthur' },
-    };
-    let suggestions = suggestCardChooserTitle(filter, 0, { multiSelect: true });
-    assert.deepEqual(suggestions, [
-      {
-        depth: 0,
-        suggestion: 'Select 1 or more Booking cards',
-      },
-    ]);
-  });
-  test('filter with on but checking for "an"', function (assert) {
-    let filter = {
-      on: { module: `https://my.realm/article`, name: 'Article' },
-      eq: { 'author.firstName': 'Kafka' },
-    };
-    let suggestions = suggestCardChooserTitle(filter, 0);
-    assert.deepEqual(suggestions, [
-      {
-        depth: 0,
-        suggestion: 'Choose an Article card',
-      },
-    ]);
-  });
-});