In-app release notes

import { check, type Update } from '@tauri-apps/plugin-updater'
import { relaunch } from '@tauri-apps/plugin-process'
import type { AppUpdater } from '@feedbackloop/react/tauri'

/** Creates an app-owned updater; the SDK receives callbacks, never its native handle.
 * @param flushAppState - Consumer persistence step before installation/restart.
 * @returns The updater and its host-unmount cleanup operation.
 */
export function createAppUpdater(flushAppState: () => Promise<void>): {
  updater: AppUpdater
  dispose: () => Promise<void>
} {
  let candidate: Update | null = null
  let disposed = false
  let installing = false
  let generation = 0
  let pendingRelaunch: string | null = null
  const updater: AppUpdater = {
    async check() {
      if (disposed || installing)
        throw new Error('The app updater is busy or closed.')
      const request = ++generation
      const next = await check()
      if (disposed || request !== generation) {
        await next?.close()
        return null
      }
      const previous = candidate
      candidate = next
      await previous?.close()
      return next
        ? { version: next.version, ...(next.body ? { notes: next.body } : {}) }
        : null
    },
    async install(version, reportProgress) {
      if (pendingRelaunch === version && !disposed && !installing) {
        installing = true
        try {
          await flushAppState()
          reportProgress({ phase: 'restarting' })
          await relaunch()
        } finally {
          installing = false
        }
        return
      }
      const selected = candidate
      if (disposed || installing || !selected || selected.version !== version)
        throw new Error('The selected app update is stale. Check again.')
      installing = true
      generation++
      try {
        // A real app flushes its database/documents here before any installer can quit it.
        await flushAppState()
        let downloadedBytes = 0
        let totalBytes: number | undefined
        await selected.downloadAndInstall((event) => {
          if (event.event === 'Started') {
            totalBytes = event.data.contentLength
            reportProgress({
              phase: 'downloading',
              downloadedBytes: 0,
              totalBytes,
            })
          } else if (event.event === 'Progress') {
            downloadedBytes += event.data.chunkLength
            reportProgress({
              phase: 'downloading',
              downloadedBytes,
              totalBytes,
            })
          } else reportProgress({ phase: 'installing' })
        })
        await selected.close().catch(() => undefined)
        candidate = null
        pendingRelaunch = version
        reportProgress({ phase: 'restarting' })
        await relaunch()
      } finally {
        installing = false
      }
    },
    // Official downloadAndInstall has no cancellation contract. The SDK hides Cancel.
  }
  return {
    updater,
    async dispose() {
      disposed = true
      generation++
      // Closing an in-use resource would interfere with a consumer-owned installation.
      if (!installing) {
        await candidate?.close()
        candidate = null
      }
    },
  }
}