Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

29.2 KB
Raw Blame
'use client'
import dynamic from 'next/dynamic'
import Link from 'next/link'
import { useCallback, useEffect, useRef, useState, type ComponentType } from 'react'
import type { NoteCompanionProps } from './note-companion-props'
import { useRouter } from 'next/navigation'
import { useTranslation } from 'react-i18next'
import {
  getNote,
  saveNote,
  listNotes,
  createNote,
  getSuggestions,
  reviewSuggestion,
  noteRequest,
  type NoteBlock,
  type NotePage,
  type NoteSummary,
  type NoteSuggestion,
} from '@/lib/notes-api'
import { exportCoWriterDocx } from '@/lib/co-writer-api'
import { notifyCoWriterChanged } from '@/lib/co-writer-events'
import { browserStorage } from '@/shared/storage'
import { useAuthStatus } from '@/hooks/useAuthStatus'
import { researchOutline } from '../model/research'
import type { NoteAsk, NoteEditorHandle } from './NoteEditor'
import NotePageTree from './NotePageTree'
import './note-workspace.css'
import NotePageHead from './NotePageHead'
import NoteTopBar, { type NoteSaveStatus } from './NoteTopBar'
import NoteOutline from './NoteOutline'
import { blockLineCenter } from './NoteThreadMarkers'
import { foldIntoOrb } from '../model/fold-motion'
import { useNoteThreads } from './useNoteThreads'
import { pageDescendants } from '../model/page-tree'
import { inlineText } from '../model/threads'
import { learningKind } from '../model/learning-kinds'
const Editor = dynamic(() => import('./NoteEditor'), {
  ssr: false,
  loading: () => <div className="dt-note-editor-loading" aria-hidden />,
})
const SourcePicker = dynamic(() => import('./NoteSourcePicker'), { ssr: false })
const FavoritesPicker = dynamic(() => import('./NoteFavoritesPicker'), { ssr: false })

export default function NoteWorkspace({
  docId,
  embedded = false,
  companion: Companion,
}: {
  docId: string
  embedded?: boolean
  companion?: ComponentType<NoteCompanionProps>
}) {
  const { t } = useTranslation()
  const router = useRouter()
  const auth = useAuthStatus()
  const owner =
    auth.statusAvailable && !auth.loading ? (auth.enabled ? auth.userId : 'local') : null
  const [mutating, setMutating] = useState(false)
  const [page, setPage] = useState<NotePage | null>(null)
  const [pages, setPages] = useState<NoteSummary[]>([])
  const [error, setError] = useState('')
  const [reviewErrors, setReviewErrors] = useState<Record<string, string>>({})
  const [status, setStatus] = useState<NoteSaveStatus>('Saved')
  const [tree, setTreeOpen] = useState(false)
  const [outlineOpen, setOutlineOpenState] = useState(true)
  const setOutlineOpen = (open: boolean) => {
    setOutlineOpenState(open)
    if (owner) browserStorage.writeRaw('local', `deeptutor.notes.outline:${owner}`, String(open))
  }
  const [mainEl, setMainEl] = useState<HTMLElement | null>(null)
  // How much margin the page column leaves: room for the open outline, for
  // its folded rail, or for neither.
  const [margin, setMargin] = useState<'wide' | 'rail' | 'none'>('none')
  const slot = useRef<HTMLDivElement>(null)
  const setTree = (open: boolean) => {
    setTreeOpen(open)
    if (owner) browserStorage.writeRaw('local', `deeptutor.notes.tree:${owner}`, String(open))
  }
  const [sources, setSources] = useState(false)
  const [favorites, setFavorites] = useState(false)
  const [suggestions, setSuggestions] = useState<NoteSuggestion[]>([])
  const [backlinks, setBacklinks] = useState<NoteSummary[]>([])
  const [recovery, setRecovery] = useState<{ title: string; blocks: NoteBlock[] } | null>(null)
  const editor = useRef<NoteEditorHandle | null>(null)
  const latest = useRef<NotePage | null>(null)
  const version = useRef(0)
  const savedVersion = useRef(0)
  const inflight = useRef<Promise<void> | null>(null)
  const timer = useRef<ReturnType<typeof setTimeout> | null>(null)
  const root = useRef<HTMLDivElement>(null)
  const draftKey = owner ? `deeptutor.notes.draft:${owner}:${docId}` : null
  const refreshSuggestions = useCallback(() => {
    void getSuggestions(docId)
      .then(r => {
        const pending = r.suggestions.filter(s => s.status === 'pending')
        setSuggestions(previous =>
          JSON.stringify(previous) === JSON.stringify(pending) ? previous : pending
        )
      })
      .catch(e => setError(String(e)))
  }, [docId])
  const refreshPages = useCallback(() => {
    void listNotes()
      .then(r => setPages(r.documents))
      .catch(e => setError(String(e)))
  }, [])
  const persistDraft = useCallback(() => {
    if (draftKey && latest.current)
      browserStorage.writeRaw(
        'local',
        draftKey,
        JSON.stringify({
          title: latest.current.title,
          blocks: latest.current.blocks,
          revision: latest.current.revision,
        })
      )
  }, [draftKey])
  const flush = useCallback(async () => {
    if (inflight.current) await inflight.current
    if (savedVersion.current === version.current || !latest.current) return
    const save = async () => {
      while (savedVersion.current !== version.current && latest.current) {
        const snapshot = latest.current
        const at = version.current
        setStatus('Saving…')
        const result = await saveNote(docId, {
          title: snapshot.title,
          blocks: snapshot.blocks,
          expected_revision: snapshot.revision,
        })
        latest.current = { ...latest.current, revision: result.revision, content: result.content }
        savedVersion.current = at
        if (version.current === at) {
          if (draftKey) browserStorage.removeRaw('local', draftKey)
          setStatus('Saved')
        } else persistDraft()
        setPage(current =>
          current ? { ...current, revision: result.revision, content: result.content } : current
        )
        setPages(current =>
          current.map(p =>
            p.id === docId ? { ...p, title: snapshot.title, revision: result.revision } : p
          )
        )
        notifyCoWriterChanged()
      }
    }
    inflight.current = save()
    try {
      await inflight.current
      setError('')
    } catch (err) {
      persistDraft()
      setStatus('Save failed')
      setError(err instanceof Error ? err.message : String(err))
      throw err
    } finally {
      inflight.current = null
    }
  }, [docId, draftKey, persistDraft])
  const changed = useCallback(
    (patch: Partial<NotePage>) => {
      if (!latest.current) return
      if (patch.blocks && JSON.stringify(patch.blocks) === JSON.stringify(latest.current.blocks))
        return
      latest.current = { ...latest.current, ...patch }
      // Keep the editor's remount snapshot current too. Updating only the ref
      // leaves initialContent stale after a lazy component reload/remount.
      setPage(current => (current ? { ...current, ...patch } : current))
      version.current++
      persistDraft()
      setStatus('Unsaved changes')
      if (timer.current) clearTimeout(timer.current)
      timer.current = setTimeout(() => {
        void flush().catch(() => {})
      }, 900)
    },
    [flush, persistDraft]
  )
  useEffect(() => {
    if (!draftKey) return
    let cancelled = false
    void getNote(docId)
      .then(doc => {
        if (cancelled) return
        const raw = browserStorage.readRaw('local', draftKey)
        if (raw) {
          try {
            const draft = JSON.parse(raw)
            if (Array.isArray(draft.blocks)) {
              if (draft.revision === doc.revision) {
                doc = { ...doc, title: draft.title, blocks: draft.blocks }
                version.current++
              } else setRecovery(draft)
            }
          } catch {
            /* Ignore invalid recovery data, never overwrite the server page. */
          }
        }
        latest.current = doc
        setPage(doc)
        setTreeOpen(browserStorage.readRaw('local', `deeptutor.notes.tree:${owner}`) === 'true')
        setOutlineOpenState(
          browserStorage.readRaw('local', `deeptutor.notes.outline:${owner}`) !== 'false'
        )
        refreshPages()
        refreshSuggestions()
        void noteRequest<{ pages: NoteSummary[] }>(`/${docId}/backlinks`).then(r => {
          if (!cancelled) setBacklinks(r.pages)
        })
      })
      .catch(err => setError(String(err)))
    return () => {
      cancelled = true
      if (timer.current) clearTimeout(timer.current)
    }
  }, [docId, draftKey, owner, refreshPages, refreshSuggestions])
  useEffect(() => {
    const onUnload = (e: BeforeUnloadEvent) => {
      if (version.current !== savedVersion.current) {
        e.preventDefault()
        e.returnValue = ''
      }
    }
    window.addEventListener('beforeunload', onUnload)
    return () => window.removeEventListener('beforeunload', onUnload)
  }, [])
  useEffect(() => {
    const el = root.current
    const showSources = () => setSources(true)
    const showFavorites = () => setFavorites(true)
    el?.addEventListener('note-sources', showSources)
    el?.addEventListener('note-favorites', showFavorites)
    const saveBeforeSwitch = (e: Event) => {
      ;(e as CustomEvent<Promise<void>[]>).detail.push(flush())
    }
    window.addEventListener('deeptutor:before-workspace-switch', saveBeforeSwitch)
    return () => {
      el?.removeEventListener('note-sources', showSources)
      el?.removeEventListener('note-favorites', showFavorites)
      window.removeEventListener('deeptutor:before-workspace-switch', saveBeforeSwitch)
    }
  }, [flush])
  const threads = useNoteThreads({
    pageId: docId,
    owner,
    embedded,
    flush,
    onSuggestions: refreshSuggestions,
    onError: message => setError(message),
  })
  const findBlock = useCallback((blockId: string) => {
    const walk = (blocks: NoteBlock[]): NoteBlock | undefined => {
      for (const block of blocks) {
        if (block.id === blockId) return block
        const nested = walk(block.children || [])
        if (nested) return nested
      }
    }
    return walk(latest.current?.blocks || [])
  }, [])
  /** What kind of block it is: a learning block's kind, or the block type. */
  const blockKind = useCallback(
    (blockId: string): string | null => {
      const block = findBlock(blockId)
      if (!block) return null
      return block.type === 'learning' ? `learning:${String(block.props.kind || '')}` : block.type
    },
    [findBlock]
  )
  /** Plain text of a block on the page, or null once it is gone. */
  const blockText = useCallback(
    (blockId: string): string | null => {
      const block = findBlock(blockId)
      if (!block) return null
      if (block.type === 'learning') {
        const kind = String(block.props.kind || '')
        const prompt = String(block.props.prompt || '').trim()
        return `${t(learningKind(kind).label)}${prompt ? ` · ${prompt}` : ''}`
      }
      return inlineText(block.content).trim()
    },
    [findBlock, t]
  )
  const scrollToBlock = useCallback((blockId: string, flash = true) => {
    const el = root.current?.querySelector<HTMLElement>(
      `.dt-note-editor .bn-block-outer[data-id="${CSS.escape(blockId)}"]`
    )
    if (!el) return
    el.scrollIntoView({ block: 'center', behavior: 'smooth' })
    if (flash)
      el.querySelector('.bn-block-content')?.animate(
        [{ backgroundColor: 'var(--dt-note-anchor-flash)' }, { backgroundColor: 'transparent' }],
        { duration: 1400, easing: 'ease-out' }
      )
  }, [])
  const notebookLink = useCallback(
    (sessionId?: string) =>
      router.push(
        `/co-writer/${docId}${sessionId ? `?chat=${encodeURIComponent(sessionId)}` : ''}`
      ),
    [docId, router]
  )
  const ask = useCallback(
    (request: NoteAsk) => {
      if (embedded) return notebookLink()
      threads.startThread(request)
    },
    [embedded, notebookLink, threads]
  )
  const openThread = useCallback(
    (sessionId: string) => {
      if (embedded) return notebookLink(sessionId)
      const thread = threads.threads.find(item => item.session_id === sessionId)
      void threads.openThread(sessionId)
      if (thread) scrollToBlock(thread.block_id)
    },
    [embedded, notebookLink, scrollToBlock, threads]
  )
  // A block clicked while a conversation is open: a conversation not begun
  // yet moves to it; one under way offers to ask about it in its own thread.
  const [focus, setFocus] = useState<{ key: string; blockId: string } | null>(null)
  const focusBlock = useCallback(
    (blockId: string) => {
      const open = threads.open
      if (!open) return
      if (blockId === open.blockId || threads.retarget(blockId)) setFocus(null)
      else
        setFocus(current =>
          current?.blockId === blockId && current.key === open.key
            ? current
            : { key: open.key, blockId }
        )
    },
    [threads]
  )
  const focused = focus && threads.open && focus.key === threads.open.key ? focus.blockId : null
  const askAtCursor = useCallback(
    (prompt?: string) => {
      const blockId = editor.current?.cursorBlockId() || latest.current?.blocks?.[0]?.id
      if (blockId) ask({ blockId, prompt })
    },
    [ask]
  )
  /* Closing the panel folds the conversation into its orb on the line: a
     ghost of the panel shrinks into the orb, which then takes a breath. */
  const foldPanel = useCallback(() => {
    const open = threads.open
    const panel = slot.current
    const host = root.current
    const keep = Boolean(open && (open.sessionId || threads.hasMessages))
    const still = window.matchMedia('(prefers-reduced-motion: reduce)').matches
    if (!open || !panel || !host || !keep || still) {
      threads.close()
      return
    }
    // The clone is taken before the panel unmounts; it unmounts once the
    // collapse is under way.
    foldIntoOrb(
      panel,
      host,
      () => {
        const orb = open.sessionId
          ? host.querySelector<HTMLElement>(`[data-thread-orb="${CSS.escape(open.sessionId)}"]`)
          : null
        if (orb) return { rect: orb.getBoundingClientRect(), orb }
        const editorEl = host.querySelector<HTMLElement>('.dt-note-editor')
        const center = editorEl ? blockLineCenter(editorEl, open.blockId) : null
        if (!editorEl || center === null) return null
        const box = editorEl.getBoundingClientRect()
        return {
          rect: new DOMRect(box.right - 31, box.top + center - 4, 8, 8),
          orb: host.querySelector<HTMLElement>('.dt-note-orbs'),
        }
      },
      threads.close
    )
  }, [threads])
  useEffect(() => {
    const el = root.current
    const generate = (event: Event) => {
      if (embedded) return notebookLink()
      threads.generateBlock((event as CustomEvent).detail)
    }
    const openFromBlock = (event: Event) => openThread((event as CustomEvent).detail.sessionId)
    const regenerate = (event: Event) => {
      if (embedded) return notebookLink()
      threads.regenerateBlock((event as CustomEvent).detail)
    }
    el?.addEventListener('note-generate', generate)
    el?.addEventListener('note-open-thread', openFromBlock)
    el?.addEventListener('note-regenerate', regenerate)
    return () => {
      el?.removeEventListener('note-generate', generate)
      el?.removeEventListener('note-open-thread', openFromBlock)
      el?.removeEventListener('note-regenerate', regenerate)
    }
  }, [embedded, notebookLink, openThread, threads])
  // The page column's spare margin decides whether the outline can stay open.
  useEffect(() => {
    if (!mainEl) return
    const observer = new ResizeObserver(([entry]) => {
      const spare = (entry.contentRect.width - 820) / 2
      setMargin(spare >= 212 ? 'wide' : spare >= 52 ? 'rail' : 'none')
    })
    observer.observe(mainEl)
    return () => observer.disconnect()
  }, [mainEl])
  const applySuggestion = async (suggestion: NoteSuggestion, accept: boolean) => {
    setMutating(true)
    setReviewErrors(previous => ({ ...previous, [suggestion.id]: '' }))
    editor.current?.setEditable(false)
    try {
      await flush()
      const replacement =
        accept && suggestion.operation !== 'comment' && suggestion.operation !== 'delete'
          ? suggestion.blocks || editor.current?.parse(suggestion.markdown)
          : undefined
      const result = await reviewSuggestion(docId, suggestion.id, accept, replacement)
      latest.current = result
      setPage(result)
      if (accept && suggestion.operation !== 'comment' && result.blocks)
        editor.current?.replace(result.blocks)
      refreshSuggestions()
      setError('')
    } catch (err) {
      const message = String(err instanceof Error ? err.message : err)
      setReviewErrors(previous => ({
        ...previous,
        [suggestion.id]: message.includes('The suggested block changed')
          ? t(
              'This block has changed. Your edits are safe. Discuss a new suggestion or dismiss this one.'
            )
          : message,
      }))
    } finally {
      setMutating(false)
      editor.current?.setEditable(true)
    }
  }
  const continueResearch = async (suggestion: NoteSuggestion) => {
    const outline = researchOutline(suggestion)
    if (!outline) return
    try {
      await flush()
      await reviewSuggestion(docId, suggestion.id, false)
      refreshSuggestions()
      root.current?.dispatchEvent(
        new CustomEvent('note-generate', {
          bubbles: true,
          detail: {
            kind: 'research',
            blockId: suggestion.block_id,
            prompt: outline.topic,
            config: { ...outline.research_config, confirmed_outline: outline.sub_topics },
          },
        })
      )
    } catch (err) {
      setError(String(err))
    }
  }
  const metadata = async (patch: Partial<NotePage>) => {
    setMutating(true)
    editor.current?.setEditable(false)
    try {
      await flush()
      const result = await saveNote(docId, {
        ...patch,
        expected_revision: latest.current!.revision,
      })
      latest.current = result
      setPage(result)
      refreshPages()
      notifyCoWriterChanged()
    } catch (err) {
      setError(String(err))
    } finally {
      setMutating(false)
      editor.current?.setEditable(true)
    }
  }
  const exportFile = async (format: 'md' | 'docx') => {
    try {
      await flush()
      const doc = latest.current!
      const blob =
        format === 'docx'
          ? await exportCoWriterDocx({ title: doc.title, content: doc.content })
          : new Blob([doc.content], { type: 'text/markdown' })
      const url = URL.createObjectURL(blob)
      const link = document.createElement('a')
      link.href = url
      link.download = `${doc.title || 'Note'}.${format}`
      link.click()
      setTimeout(() => URL.revokeObjectURL(url), 1000)
    } catch (err) {
      setError(String(err))
    }
  }
  const invalidParents = pageDescendants(pages, docId)
  const createPage = async (parentId: string | null = null) => {
    setMutating(true)
    try {
      await flush()
      const doc = await createNote('', parentId)
      refreshPages()
      router.push(`/co-writer/${doc.id}`)
    } catch (err) {
      setError(String(err))
    } finally {
      setMutating(false)
    }
  }
  const openPage = async (id: string) => {
    if (id === docId) return
    try {
      await flush()
      router.push(`/co-writer/${id}`)
    } catch {
      /* Keep the unsaved page visible. */
    }
  }
  const navigate = async (event: React.MouseEvent<HTMLAnchorElement>, id: string) => {
    if (event.metaKey || event.ctrlKey || event.shiftKey || event.button !== 0) return
    if (id === docId || version.current !== savedVersion.current) {
      event.preventDefault()
      if (id === docId) return
      try {
        await flush()
        router.push(`/co-writer/${id}`)
      } catch {
        /* Keep the unsaved page visible. */
      }
    }
  }
  return (
    <div
      ref={root}
      className="dt-note-workspace"
      onClickCapture={event => {
        const link = (event.target as HTMLElement).closest<HTMLAnchorElement>('a[data-note-source]')
        if (
          !link ||
          event.button !== 0 ||
          event.metaKey ||
          event.ctrlKey ||
          event.shiftKey ||
          event.altKey
        )
          return
        // Editor link handling otherwise consumes the click as a selection.
        // Flush pending text/title changes before leaving the page.
        event.preventDefault()
        event.stopPropagation()
        const url = new URL(link.href, window.location.href)
        void flush()
          .then(() => {
            if (url.origin === window.location.origin)
              router.push(`${url.pathname}${url.search}${url.hash}`)
            else window.location.assign(url.href)
          })
          .catch(() => {
            /* Save error stays visible; keep the current page. */
          })
      }}
    >
      <NoteTopBar
        page={page}
        pages={pages}
        invalidParents={invalidParents}
        status={status}
        busy={mutating}
        embedded={embedded}
        treeOpen={tree}
        companionOpen={Boolean(threads.open)}
        onToggleTree={() => setTree(!tree)}
        onToggleCompanion={() => (threads.open ? foldPanel() : askAtCursor())}
        onNavigate={navigate}
        onOpenPage={id => void openPage(id)}
        onCreatePage={() => void createPage()}
        onMetadata={patch => void metadata(patch)}
        onInsertFavorite={() => setFavorites(true)}
        onExport={format => void exportFile(format)}
      />
      {error && (
        <div role="alert" className="dt-note-banner is-error">
          <span className="flex-1">{error}</span>
          <button className="dt-note-button" onClick={() => void flush().catch(() => {})}>
            {t('Retry')}
          </button>
          <button
            className="dt-note-button"
            onClick={() => {
              if (latest.current?.blocks)
                setRecovery({ title: latest.current.title, blocks: latest.current.blocks })
              void getNote(docId).then(result => {
                latest.current = result
                setPage(result)
                editor.current?.replace(result.blocks || editor.current.parse(result.content))
                savedVersion.current = version.current
                setError('')
              })
            }}
          >
            {t('Reload page')}
          </button>
        </div>
      )}
      {recovery && (
        <div className="dt-note-banner">
          <span className="flex-1">{t('A local draft differs from this page.')}</span>
          <button
            className="dt-note-button"
            onClick={async () => {
              const doc = await createNote(`${recovery.title} (${t('Recovered draft')})`)
              await saveNote(doc.id, { blocks: recovery.blocks, expected_revision: doc.revision })
              if (draftKey) browserStorage.removeRaw('local', draftKey)
              setRecovery(null)
              refreshPages()
              router.push(`/co-writer/${doc.id}`)
            }}
          >
            {t('Save draft as a new page')}
          </button>
        </div>
      )}
      <div className="dt-note-body">
        {tree && (
          <NotePageTree
            pages={pages}
            currentId={docId}
            busy={mutating}
            embedded={embedded}
            onNavigate={navigate}
            onCreate={createPage}
          />
        )}
        <main className="dt-note-main" ref={setMainEl}>
          {page && margin !== 'none' && (
            <NoteOutline
              blocks={page.blocks}
              scroller={mainEl}
              open={outlineOpen}
              roomy={margin === 'wide'}
              onToggle={() => setOutlineOpen(!outlineOpen)}
              onJump={id => scrollToBlock(id, false)}
            />
          )}
          {page && (
            <div className="dt-note-document">
              <NotePageHead
                page={page}
                disabled={mutating}
                onTitle={title => {
                  setPage({ ...page, title })
                  changed({ title })
                }}
                onMetadata={patch => void metadata(patch)}
              />
              <Editor
                key={docId}
                page={page}
                suggestions={suggestions}
                reviewBusy={mutating}
                reviewErrors={reviewErrors}
                onContinueResearch={suggestion => void continueResearch(suggestion)}
                onReview={(suggestion, accept) => void applySuggestion(suggestion, accept)}
                onDiscuss={suggestion =>
                  suggestion.block_id
                    ? ask({
                        blockId: suggestion.block_id,
                        prompt: `${t('Discuss this feedback')}: ${suggestion.explanation}`,
                      })
                    : askAtCursor(`${t('Discuss this feedback')}: ${suggestion.explanation}`)
                }
                onChange={blocks => changed({ blocks })}
                onReady={handle => {
                  editor.current = handle
                  if (version.current !== savedVersion.current) void flush().catch(() => {})
                }}
                onAI={ask}
                threads={threads.threads}
                activeThread={threads.open}
                threadsInteractive={!embedded}
                onOpenThread={openThread}
                onDeleteThread={threads.removeThread}
                onFocusBlock={threads.open && !embedded ? focusBlock : undefined}
              />
              {!!backlinks.length && (
                <section className="dt-note-backlinks" aria-label={t('Linked from')}>
                  <h2>{t('Linked from')}</h2>
                  {backlinks.map(p => (
                    <Link key={p.id} href={`/co-writer/${p.id}`} onClick={e => navigate(e, p.id)}>
                      <span aria-hidden>{p.icon || '↗'}</span>
                      {p.title || t('Untitled')}
                    </Link>
                  ))}
                </section>
              )}
            </div>
          )}
        </main>
        {threads.open && owner && Companion && (
          <div ref={slot} className="dt-note-companion-slot">
            <Companion
              key={threads.open.key}
              pageId={docId}
              pageTitle={page?.title || ''}
              thread={threads.open}
              bound={threads.bound}
              threads={threads.threads}
              blockText={blockText}
              blockKind={blockKind}
              focus={focused}
              onAskFocus={draft => {
                if (!focused) return
                setFocus(null)
                ask({ blockId: focused, prompt: draft || undefined })
                scrollToBlock(focused, false)
              }}
              onDismissFocus={() => setFocus(null)}
              prefill={threads.prefill}
              onSend={threads.send}
              onMake={(kind, prompt, again) => {
                const anchor = threads.open?.blockId
                const redo = threads.open?.regenerate
                if (again && anchor && redo) {
                  // Another version of the block itself, filed for review.
                  if (!editor.current?.hasBlock(anchor)) {
                    setError(t('The line this conversation was about has been deleted.'))
                    return
                  }
                  editor.current.updateLearningPrompt(anchor, prompt)
                  threads.send(
                    `${t('Regenerate')} · ${t(learningKind(redo.kind).label)} · ${prompt || t('Generate this learning block from the page')}`,
                    { generate: { blockId: anchor, kind: redo.kind, config: redo.config } }
                  )
                  return
                }
                const blockId =
                  anchor && editor.current?.hasBlock(anchor)
                    ? editor.current.insertLearningAfter(anchor, kind, prompt)
                    : null
                if (!blockId) {
                  setError(t('The line this conversation was about has been deleted.'))
                  return
                }
                threads.send(
                  `${t(learningKind(kind).label)} · ${prompt || t('Generate this learning block from the page')}`,
                  { generate: { blockId, kind } }
                )
              }}
              onRegenerate={threads.regenerate}
              onSelect={openThread}
              onNewHere={() =>
                threads.open && ask({ blockId: threads.open.blockId, quote: threads.open.quote })
              }
              onJump={() => threads.open && scrollToBlock(threads.open.blockId)}
              onSuggestions={refreshSuggestions}
              onClose={foldPanel}
            />
          </div>
        )}
      </div>
      {sources && (
        <SourcePicker
          onClose={() => setSources(false)}
          onInsert={(title, markdown, url, id) =>
            editor.current?.insertClip(title, markdown, url, id)
          }
          onKnowledge={name => {
            const blockId = editor.current?.cursorBlockId() || latest.current?.blocks?.[0]?.id
            if (blockId)
              ask({
                blockId,
                knowledgeRef: name,
                prompt: `${t('Find source passages in this knowledge base and suggest cited notes')}: ${name}`,
              })
          }}
        />
      )}
      {favorites && (
        <FavoritesPicker
          onSynthesize={sources =>
            askAtCursor(
              `${t('Organize these favorites into a coherent note. Cite the source of each section.')}\n\n${sources}`
            )
          }
          onClose={() => setFavorites(false)}
          onInsert={clips => {
            editor.current?.insertClips(clips)
            setFavorites(false)
          }}
        />
      )}
    </div>
  )
}