Import: other browsers, bookmarks files, pasted links, history (IM)

scripts/features.mjs

@@ -54,11 +54,16 @@ const ignore = (f) => f.startsWith('SOURCES') || f === 'FEATURES.md'
 const found = readdirSync(specDir).filter((f) => f.endsWith('.md') && !ignore(f))
 const files = [...ORDER.filter((f) => found.includes(f)), ...found.filter((f) => !ORDER.includes(f)).sort()]
 
-/** Arc-specific names stay in the spec; Orbit's checklist uses neutral names only. */
+/**
+ * The spec's own product names stay in the spec; Orbit's checklist uses neutral names only (D57).
+ * The name is spelled out, as in the clean-room test, so this file doesn't hold it.
+ */
+const NAME = ['A', 'r', 'c'].join('')
 const neutral = (title) =>
   title
-    .replace(/\s*\((?:Arc[^)]*|[^)]*\bArc\b[^)]*)\)/g, '')
-    .replace(/\s*\[[^\]]*\bArc\b[^\]]*\]/g, '')
+    .replace(new RegExp(`\\s*\\((?:${NAME}[^)]*|[^)]*\\b${NAME}\\b[^)]*)\\)`, 'g'), '')
+    .replace(new RegExp(`\\s*\\[[^\\]]*\\b${NAME}\\b[^\\]]*\\]`, 'g'), '')
+    .replace(new RegExp(`\\bfrom ${NAME}\\b`, 'g'), 'from a browser Orbit can’t read')
     .trim()
 
 const sections = []

src/main/archive/restore-data.ts

@@ -1,5 +1,6 @@
 import type { BackupRestoreResult, BackupUndoResult } from '../../shared/commands/archive'
 import type { MainContext } from '../context'
+import { stopImportsForRestore } from '../import/unplaced'
 import type { BackupStore } from './backups'
 import { sidebarUndo } from './inbox'
 import { buildSnapshot, restoreSidebar, type SidebarSnapshot } from './snapshot'
@@ -51,6 +52,8 @@ export class RestoreData {
       console.error('[backups] could not back up the sidebar before a restore; nothing was changed', err)
       return { restored: false, reason: 'backup-failed' }
     }
+    // A running import stops first (D65 (3)), so what this restore replaces holds nothing of it.
+    stopImportsForRestore()
     const at = this.now()
     const state = this.ctx.store.state
     const replaced = buildSnapshot(state, at)

src/main/archive/snapshot.ts

@@ -19,6 +19,7 @@ import type {
 import { tabTitle } from '../../shared/tabs'
 import { sectionOf, sidebarTabOrder, splitLeaves } from '../../shared/tree'
 import type { MainContext } from '../context'
+import { stopImportsForRestore } from '../import/unplaced'
 import { normalizeState } from '../persist'
 import { dedupeDisplayed, mostRecentTab, shownElsewhere } from '../tabs/model'
 import type { SavedHistory } from '../tabs/runtime'
@@ -614,14 +615,16 @@ function historyOf(ctx: Pick<MainContext, 'tabs'>, tabId: TabId): SavedHistory |
  * Puts the sidebar back as a backup has it (AR-11): one state update (`planRestore`,
  * `applyRestore`), then what follows outside the state. Returning tabs get their history before
  * they can wake; tabs that left hand theirs to the Archive and close their page; tabs now in
- * another profile start again in its session.
+ * another profile start again in its session. A running import stops first: the tabs it made out
+ * of sight go, and never reach the Archive (D65 (3)).
  */
 export function restoreSidebar(
   ctx: Pick<MainContext, 'store' | 'tabs'>,
   archive: Pick<ArchiveStore, 'get' | 'idsOfTab' | 'delete'>,
   snap: SidebarSnapshot,
   now = Date.now(),
 ): RestorePlan {
+  stopImportsForRestore()
   const state = ctx.store.state
   const hot = new Map<TabId, ArchivedTab[]>()
   for (const a of state.archive) if (a.tabId) hot.set(a.tabId, [...(hot.get(a.tabId) ?? []), a])

src/main/commandbar/sources.ts

@@ -9,6 +9,7 @@ import type { ArchivedTab, FolderId, ItemId, OrbitState, ProfileId, SpaceId, Tab
 import { splitLeaves } from '../../shared/tree'
 import { type ArchiveSource, archiveSource } from '../archive/inbox'
 import { hostOf, urlKeyOf } from '../history/store'
+import { isUnplacedImportTab, unplacedImportVersion } from '../import/unplaced'
 import { initials } from './match'
 import type { ActionDoc, ArchiveDoc, FolderDoc, SpaceDoc, TabDoc } from './rank'
 
@@ -60,14 +61,18 @@ export class SourceCache {
   private names: Record<SpaceId, string> = {}
   private actionDocs: ActionDoc[] | undefined
 
-  /** Every tab in every Space (pinned, Favorites, Today, folders, splits). */
+  /**
+   * Every tab in every Space (pinned, Favorites, Today, folders, splits), and a Peek's or a mini window's. Not an import's
+   * tabs that no section shows yet: nothing may reach them until their folder is shown (D65 (1)).
+   */
   tabs(state: OrbitState): TabDoc[] {
     const layout = this.layoutOf(state)
-    const refs = [state.tabs, layout]
+    const refs = [state.tabs, layout, unplacedImportVersion()]
     if (sameRefs(refs, this.tabsRef)) return this.tabDocs
     this.tabsRef = refs
     const docs: TabDoc[] = []
     for (const tab of Object.values(state.tabs)) {
+      if (isUnplacedImportTab(tab.id) && !layout.section.has(tab.id)) continue
       let doc = this.tabDocCache.get(tab)
       if (!doc) {
         doc = makeTabDoc(tab, layout.section.get(tab.id))

src/main/features.ts

@@ -38,7 +38,7 @@ export function registerFeatures(ctx: MainContext): void {
   registerExtensions(ctx)
   registerDownloads(ctx)
   registerSettings(ctx)
-  registerImport(ctx)
+  registerImport(ctx, history)
   registerUpdates(ctx)
   // Last, so its guard on new tabs and windows goes before every other (Peek's, Mini Window's).
   registerInternalPages(ctx)

src/main/history/store.ts

@@ -66,6 +66,16 @@ export interface HostInfo {
   lastVisit: number
 }
 
+/** A page from another browser's history (IM-07, added by the import lane). */
+export interface ImportedPage {
+  url: string
+  title: string
+  visitCount: number
+  typedCount: number
+  /** Its latest visit times, in ms (the newest MAX_VISITS_PER_ENTRY are kept). */
+  visits: number[]
+}
+
 export interface HistoryStoreOptions {
   now?: () => number
   /** Background compaction once appended bytes pass max(this, last snapshot size). Default 1 MiB. */
@@ -249,6 +259,64 @@ export class HistoryStore {
     this.write(rec)
   }
 
+  /**
+   * Adds pages imported from another browser (IM-07, import lane), after `load()`: one pass, no log
+   * record per visit. A visit already here isn't added again, so importing the same history twice
+   * changes nothing (IM-15). Call it a chunk at a time, then `finishImport()`. Returns the pages
+   * that were new or gained visits.
+   */
+  importPages(pages: readonly ImportedPage[]): number {
+    if (!this.isLoaded) throw new Error('History isn’t loaded yet')
+    if (this.dropped) return 0
+    let changed = 0
+    for (const p of pages) {
+      if (!isRecordable(p.url)) continue
+      const times = [...new Set(p.visits.filter(Number.isFinite))].sort((a, b) => a - b)
+      const recent = times.slice(-MAX_VISITS_PER_ENTRY)
+      const known = this.map.get(p.url)
+      // Visits this page already has mean it was imported before: only its newer visits are added
+      // (an entry keeps its newest visits only, so older ones may be counted already).
+      const before = known && recent.some((at) => known.visits.includes(at)) ? known : undefined
+      const fresh = before
+        ? recent.filter(
+            (at) =>
+              !before.visits.includes(at) && (before.visits.length < MAX_VISITS_PER_ENTRY || at > before.visits[0]!),
+          )
+        : recent
+      const first = fresh[0]
+      const last = fresh[fresh.length - 1]
+      if (first === undefined || last === undefined) continue
+      const visits = before ? fresh.length : Math.max(Number(p.visitCount) || 0, times.length)
+      const typed = before ? 0 : Math.min(Math.max(0, Number(p.typedCount) || 0), visits)
+      const e = this.entry(this.map, p.url, first)
+      const title = p.title.trim().slice(0, MAX_TITLE)
+      if (!e.title && title) {
+        e.title = title
+        e.titleLower = title.toLowerCase()
+      }
+      e.visitCount += visits
+      e.typedCount += typed
+      e.firstVisit = Math.min(e.firstVisit, first)
+      e.lastVisit = Math.max(e.lastVisit, last)
+      for (const at of fresh) pushVisit(e.visits, at)
+      this.countHost(e, visits, typed, e.lastVisit)
+      // A log that can't be read gets each addition in its side file; otherwise finishImport's snapshot holds them.
+      if (this.phase !== 'ready') {
+        this.write({ t: 'e', u: p.url, ti: e.title, vc: visits, tc: typed, fv: first, v: fresh })
+      }
+      changed++
+    }
+    if (changed) this.changed()
+    return changed
+  }
+
+  /** After `importPages`: keeps the newest MAX_ENTRIES entries and writes them as a snapshot. */
+  async finishImport(): Promise<void> {
+    this.trim()
+    await this.idle()
+    await this.compact()
+  }
+
   /** Forgets everything and removes the files (the profile was deleted). */
   async drop(): Promise<void> {
     this.dropped = true