fix visits marking

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/url-suggestions.test.ts

@@ -206,9 +206,43 @@ describe('mergeSuggestionSources with an imported directory', () => {
     expect(merged[0]).toMatchObject({
       tier: SUGGESTION_TIER.ACCOUNT,
       lastSeenAt: Date.parse('2026-01-15T00:00:00.000Z'),
+      visits: 900,
     })
   })
 
+  it('keeps the visit counts of hosts promoted above the imported tier', () => {
+    const merged = mergeSuggestionSources(
+      [session('gitlab.com')],
+      [credential('https://github.com')],
+      [site('github.com', { visits: 900 }), site('gitlab.com', { visits: 40 })]
+    )
+
+    // Both were promoted out of the imported tier by other evidence. Dropping
+    // their counts here is what left byConfidence with nothing but hostnames.
+    expect(merged.map((result) => [result.hostname, result.visits])).toEqual([
+      ['github.com', 900],
+      ['gitlab.com', 40],
+    ])
+  })
+
+  it('orders a password import by usage rather than falling back to the alphabet', () => {
+    // One import stamps every credential with the same instant, so tier and
+    // recency both tie and visits is the only thing left to sort on. These
+    // hosts are deliberately in the opposite order by name and by usage.
+    const hosts: Array<[string, number]> = [
+      ['adobe.com', 10],
+      ['github.com', 500],
+      ['zoom.us', 8495],
+    ]
+    const merged = mergeSuggestionSources(
+      [],
+      hosts.map(([hostname]) => credential(`https://${hostname}`)),
+      hosts.map(([hostname, visits]) => site(hostname, { visits }))
+    )
+
+    expect(hostnames(rankSuggestions(merged, ''))).toEqual(['zoom.us', 'github.com', 'adobe.com'])
+  })
+
   it('reaches an imported host by the name the source browser gave it', () => {
     const merged = mergeSuggestionSources([], [], [site('mail.google.com', { name: 'Gmail' })])
 

apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/url-suggestions.ts

@@ -38,9 +38,11 @@ export interface UrlSuggestion {
   /** @see SUGGESTION_TIER */
   tier: SuggestionTier
   /**
-   * Source-browser visit count, for hosts that came from an import. Orders the
-   * imported tier by how much the user actually uses each site, which is the
-   * only usage signal that exists for a host this browser has never seen.
+   * Source-browser visit count, carried over for every host the import knows —
+   * not only the ones admitted at {@link SUGGESTION_TIER.IMPORTED}. A host with
+   * a saved password is usually in the import too, and its visit count is the
+   * only signal that separates it from the rest of its tier once
+   * {@link byConfidence} runs out of timestamps to compare.
    */
   visits?: number
 }
@@ -106,6 +108,7 @@ export function mergeSuggestionSources(
       icon: icon ?? site?.icon,
       lastSeenAt: seenAt,
       tier,
+      visits: site?.visits,
     })
   }
 
@@ -188,8 +191,19 @@ export function rankSuggestions(
  * Tier has to lead. Every host from one import shares that import's timestamp,
  * which is by definition the newest thing in the corpus, so ordering on recency
  * alone would put a site the user has never signed into above the one they use
- * daily. Within the imported tier those timestamps are all equal and the source
- * browser's own usage is what remains to tell them apart.
+ * daily.
+ *
+ * Visits then has to outrank recency, because one import flattens the
+ * timestamps of every tier it touches, not just the imported one: a password
+ * import stamps all of its credentials with the same instant, so the whole
+ * account tier ties on recency and would fall through to the alphabetical
+ * tiebreak below. That is why {@link mergeSuggestionSources} carries `visits`
+ * onto credentialed hosts as well — without it this comparator has nothing
+ * left, and the omnibox opens on whichever eight hosts sort first by name.
+ *
+ * A credentialed host the import has never heard of counts as zero visits and
+ * so sits below one it has. That is deliberate: keeping every step of the chain
+ * a total order is what stops `sort` from seeing an inconsistent comparator.
  */
 function byConfidence(first: UrlSuggestion, second: UrlSuggestion): number {
   return (