(function (root, factory) {
  const createSearchPreview = factory();
  if (typeof module === 'object' && module.exports) module.exports = createSearchPreview;
  if (root) {
    root.createSearchPreview = createSearchPreview;
    root.safeSearchUrl = value => {
      try {
        const url = new URL(value);
        return ['http:', 'https:'].includes(url.protocol) ? url.href : '';
      } catch (_) { return ''; }
    };
    root.searchPreviewUrl = (state, defaultScope, location) => {
      const { query, preview, scope = defaultScope } = state;
      const params = new URLSearchParams({
        search:query || '', preview:preview.kind + ':' + preview.repository + ':' + preview.number,
        search_kind:scope.kind, search_state:scope.state,
      });
      if (scope.repository) params.set('search_repository', scope.repository);
      return new URL('?' + params, location.origin + location.pathname).href;
    };
    root.searchPreviewPath = item => {
      const repository = String(item.repository || '').split('/').map(encodeURIComponent).join('/');
      return 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(item.number) +
        '/preview?kind=' + encodeURIComponent(item.kind);
    };
    root.searchPreviewConversationPath = (item, page) => {
      const repository = String(item.repository || '').split('/').map(encodeURIComponent).join('/');
      const query = new URLSearchParams({ kind:item.kind, limit:'20' });
      if (page) query.set('page', String(page));
      return 'api/v1/repos/' + repository + '/issues/' + encodeURIComponent(item.number) +
        '/preview/conversation?' + query.toString();
    };
    root.followingPullReviewPath = item => {
      const repository = String(item.repository || '').split('/').map(encodeURIComponent).join('/');
      return 'api/v1/following/' + repository + '/pulls/' + encodeURIComponent(item.number) + '/review-data';
    };
    root.searchPreviewReplyPath = item => root.searchPreviewPath(item).replace(/\?.*$/, '') +
      '/comments?kind=' + encodeURIComponent(item.kind);
    root.searchPreviewMutation = fetchJson => (detail, action) => {
      if (action === 'reopen-pull') {
        const path = root.searchPreviewPath(detail).replace('/issues/', '/pulls/').replace(/\/preview.*$/, '/reopen');
        return fetchJson(path, {
          method:'PATCH', headers:{'Content-Type':'application/json'},
          body:JSON.stringify({expected_head_sha:detail.head_sha}),
        });
      }
      return fetchJson(root.searchPreviewPath(detail).replace(/\?.*$/, '') + '/' + action, {method:'PATCH'});
    };
    root.searchPreviewSubscriptionPath = item => root.searchPreviewPath(item).replace(/\?.*$/, '') +
      '/subscription?kind=' + encodeURIComponent(item.kind);
    root.searchPreviewSubscriptionOptions = fetchJson => {
      const options = {
      load:async detail => {
        if (['issue', 'pull'].includes(detail.kind) && detail.state === 'closed' && detail.following === true) {
          return {...detail, watching:true};
        }
        if (!(['issue', 'pull'].includes(detail.kind) && detail.state === 'open')) return detail;
        const result = await fetchJson(root.searchPreviewSubscriptionPath(detail), {headers:{Accept:'application/json'}});
        return {...detail, watching:result.watching === true};
      },
      watch:(detail,watching) => fetchJson(root.searchPreviewSubscriptionPath(detail), {
        method:watching ? 'PUT' : 'DELETE', headers:{Accept:'application/json'},
      }),
      review:item => fetchJson(root.followingPullReviewPath(item)),
      };
      options.preview = async item => options.load({...item, ...await fetchJson(root.searchPreviewPath(item), {
        headers:{Accept:'application/json'},
      })});
      return options;
    };
    root.createDetailWatch = ({fetchJson,refreshFollowing,onState}) => {
      const api=root.searchPreviewSubscriptionOptions(fetchJson);
      let item,watching=false,mutation;
      return {
        async open(next) {
          item=next; onState('loading',watching);
          const result=await api.load(next).catch(error=>{
            if(item===next)onState('error',watching,error);throw error;
          });
          if (item !== next) return;
          watching=result.watching === true; onState('ready',watching);
        },
        toggle() {
          if (mutation) return mutation;
          const next=!watching;
          onState(next?'watching':'unwatching',watching);
          mutation=api.watch(item,next).then(async result => {
            if (result?.watching !== next || result?.following_synced !== true)
              throw new Error(result?.error || 'Unconfirmed.');
            watching=next; await refreshFollowing();
            onState(watching?'watched':'unwatched',watching);
          }).catch(error => {onState('error',watching,error);throw error;})
            .finally(()=>{mutation=null;});
          return mutation;
        },
      };
    };
    root.searchPreviewWatchStatus = state => ({
      watching:'Starting watch…', unwatching:'Stopping watch…',
      watched:'Watching · available in Following. Future activity will appear in Updates.',
      unwatched:'Stopped watching · removed from Following. Assignment and planning are unchanged.',
      'watch-partial':'Watching in Gitea, but Following could not sync. Tap Stop watching, then Watch ' +
        (state.detail?.kind === 'pull' ? 'pull request' : 'issue') + ' to repair.',
      'watch-error':(state.error?.message || 'Watch status was not changed.') + ' Retry.',
    })[state.status] || '';
    root.renderSearchPreviewWatch = (detail, state, button) => {
      const watchableKind = ['issue', 'pull'].includes(detail.kind);
      const retiring = watchableKind && detail.state === 'closed' &&
        detail.following === true && detail.watching === true;
      button.hidden = !(watchableKind && detail.state === 'open') && !retiring;
      button.textContent = retiring ? 'Stop watching & next' :
        (detail.watching ? 'Stop watching' : 'Watch ' + (detail.kind === 'pull' ? 'pull request' : 'issue'));
      button.disabled = state.status === 'watching' || state.status === 'unwatching';
    };
    root.renderSearchPreviewStart = (detail, state, button) => {
      const pull = detail.kind === 'pull' && detail.state === 'closed' &&
        detail.authored_pull_reopenable === true;
      const issue = detail.kind === 'issue' &&
        (detail.reopenable || (detail.state === 'open' && (detail.claimable || detail.assigned_to_me)));
      button.hidden = !(detail.reviewable || pull || issue);
      button.textContent = detail.reviewable ? 'Review now' : pull ? 'Reopen in My Work' :
        detail.reopenable ? 'Reopen & resume' :
          (detail.assigned_to_me ? 'Start in Today' : 'Assign & start');
      button.disabled = state.status === 'claiming' || state.status === 'reopening';
    };
    root.createSearchAuthoredPullRecovery = o =>
      async d => {
        if (!o.confirm('Reopen ' + d.repository + ' #' + d.number + '?')) return 'canceled';
        await o.reopen(d);
        await o.refresh();
        const item = o.find(d);
        if (!item) {
          o.unavailable('Reopened. Refresh My Work.');
          return 'unavailable';
        }
        o.open(item);
        return 'opened';
      };
    root.wireSearchPreviewWatch = (button, preview, getDetail) => button.addEventListener('click', () => {
      const detail = getDetail();
      if (detail) preview.setWatching(detail.watching !== true).catch(() => {});
    });
    root.searchPreviewReplyOptions = (fetchJson, storage, crypto) => ({
      storage,
      createOperationId:() => crypto?.randomUUID?.() || String(Date.now()) + '-' + Math.random(),
      postReply:(item,body,operationId) => fetchJson(root.searchPreviewReplyPath(item), {
        method:'POST', headers:{Accept:'application/json','Content-Type':'application/json','Idempotency-Key':operationId},
        body:JSON.stringify({body}),
      }),
    });
    root.renderSearchPreviewConversation = (conversation, document, escapeHtml, formatTime, renderMarkdown, actions) => {
      const comments = document.querySelector('#search-preview-comments');
      const status = document.querySelector('#search-preview-conversation-status');
      const retry = document.querySelector('#retry-search-preview-conversation');
      const older = document.querySelector('#load-older-search-preview-comments');
      if (!conversation) {
        comments.textContent = status.textContent = '';
        retry.hidden = older.hidden = true;
        return;
      }
      const isNew = comment => Boolean(conversation.reviewedAt && comment.created_at &&
        new Date(comment.created_at).getTime() > new Date(conversation.reviewedAt).getTime());
      const newCount = (conversation.comments || []).filter(isNew).length;
      comments.innerHTML = (conversation.comments || []).map(comment =>
        '<article class="search-preview-comment issue-comment' + (isNew(comment) ? ' new-since-review' : '') +
        '" data-comment-id="' + Number(comment.id || 0) + '">' +
        '<div class="small">' + escapeHtml(comment.author || 'Unknown author') +
        (comment.created_at ? ' · ' + escapeHtml(formatTime(comment.created_at)) : '') +
        (isNew(comment) ? ' · <strong>New since last review</strong>' : '') + '</div>' +
        (actions?.actionHtml?.(comment) || '') +
        '<div class="markdown-content">' + renderMarkdown(comment.body || '') + '</div></article>'
      ).join('');
      retry.hidden = conversation.status !== 'error';
      older.hidden = conversation.status !== 'ready' || !conversation.olderPage;
      older.disabled = conversation.status === 'loading';
      if (conversation.status === 'loading') status.textContent = conversation.comments?.length
        ? 'Loading older messages…' : 'Loading current conversation…';
      else if (conversation.status === 'error') status.textContent =
        'Conversation unavailable. Preview and planning actions still work.';
      else if (!conversation.comments?.length) status.textContent = 'No conversation yet.';
      else status.textContent = conversation.comments.length +
        (conversation.comments.length === 1 ? ' message' : ' messages') +
        (newCount ? ' · ' + newCount + ' new since last review' : '') + '.';
    };
    root.createSearchPreviewConversationActions = ({hydrator,rootNode,retry,paint,wire}) => {
      let latest = null;
      const show = conversation => {
        latest = conversation;
        if (!conversation) {
          paint(null, null);
          return Promise.resolve(false);
        }
        return hydrator.show({root:rootNode,state:conversation,paint,retry,wire});
      };
      retry.addEventListener('click', () => { if (latest) void show(latest); });
      return show;
    };
    root.renderSearchPreviewReply = (state, detail, preview, document) => {
      const section = document.querySelector('.search-preview-reply');
      const input = document.querySelector('#search-preview-reply');
      const status = document.querySelector('#search-preview-reply-status');
      const buttons = ['#send-search-preview-reply', '#send-search-preview-reply-next']
        .map(selector => document.querySelector(selector));
      section.hidden = detail?.commentable !== true;
      status.textContent = '';
      if (section.hidden) {
        buttons.forEach(button => { button.disabled = true; });
        return;
      }
      input.value = preview.replyDraft();
      const replying = state.status === 'replying';
      buttons.forEach(button => {
        button.disabled = replying || (!input.value.trim() && !preview.hasReplyAttachments?.());
      });
      if (replying) status.textContent = 'Saving reply for delivery…';
      else if (state.status === 'queued') status.textContent = 'Reply queued. It will send when connected.';
      else if (state.status === 'replied') status.textContent = 'Reply posted.';
      else if (state.status === 'reply-error') status.textContent =
        state.error?.message || 'Reply failed. Your draft is safe; retry when ready.';
    };
    root.renderSearchPreviewReview = (review, document, escapeHtml) => {
      const section = document.querySelector('#search-preview-review');
      const status = document.querySelector('#search-preview-review-status');
      const files = document.querySelector('#search-preview-files');
      const retry = document.querySelector('#retry-search-preview-review');
      section.hidden = !review;
      retry.hidden = review?.status !== 'error';
      files.innerHTML = '';
      if (!review) {
        status.textContent = '';
        return;
      }
      if (review.status === 'loading') {
        status.textContent = 'Loading CI and changed files…';
        return;
      }
      if (review.status === 'error') {
        status.textContent = 'Changes unavailable. This revision has not been marked reviewed.';
        return;
      }
      const data = review.data || {};
      const changed = Array.isArray(data.files) ? data.files : [];
      const ci = ({success:'CI passed', failure:'CI failed', error:'CI failed', pending:'CI pending'})[
        data.ci_state
      ] || 'CI status unavailable';
      status.textContent = ci + ' · ' + changed.length + ' changed ' +
        (changed.length === 1 ? 'file.' : 'files.');
      files.innerHTML = changed.map(file => {
        const lines = (Array.isArray(file.diff_lines) ? file.diff_lines : []).map(raw => {
          const line = String(raw);
          const kind = line.startsWith('@@') ? 'hunk' : line.startsWith('+') ? 'added' :
            line.startsWith('-') ? 'removed' : 'context';
          return '<span class="pull-diff-line ' + kind + '">' + escapeHtml(line) + '</span>';
        }).join('');
        const diff = file.diff_available
          ? '<pre class="pull-diff">' + lines +
            (file.diff_truncated ? '<span class="pull-diff-note">Preview truncated · open in Gitea for the full diff.</span>' : '') + '</pre>'
          : '<div class="pull-diff-empty">' +
            (file.diff_binary ? 'Binary file · preview unavailable.' : 'Diff preview unavailable.') + '</div>';
        return '<article class="search-preview-file"><strong>' + escapeHtml(file.filename || 'Unknown file') +
          '</strong><span class="small">' + escapeHtml(file.status || 'changed') + ' · +' +
          Number(file.additions || 0) + ' / −' + Number(file.deletions || 0) + '</span>' + diff + '</article>';
      }).join('');
    };
    root.renderSearchPreviewWorkspaces = (state, detail, preview, document, escapeHtml) => {
      root.renderSearchPreviewReply(state, detail, preview, document);
      root.renderSearchPreviewReview(state.review, document, escapeHtml);
      document.querySelector('[data-search-preview-section="changes"]').hidden = !state.review;
    };
  }
})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
  return function createSearchPreview({ fetchJson, fetchConversation, fetchReview, mutate, watch, share, postReply, queueReply, prepareReply, afterReply, afterUnwatch, hasAttachments, clearAttachments, storage, createOperationId, session, getSession, loadMore, onNavigate, onOpened, navigationRoot, onState }) {
    if (Array.isArray(session)) {
      getSession = session[0];
      loadMore = () => session[1].loadMore();
      onNavigate = session[2];
      navigationRoot = document;
    }
    let generation = 0;
    let current = null;
    let mutationRequest = null;
    let shareRequest = null;
    let moveRequest = null;
    let replyRequest = null;
    let watchRequest = null;
    let conversation = null;
    let review = null;
    let openedRevision = null;

    function sameItem(left, right) {
      return left && right && left.kind === right.kind && left.repository === right.repository &&
        Number(left.number) === Number(right.number);
    }

    async function notifyOpened(item, requestGeneration) {
      const revision = [item?.kind, item?.repository, item?.number, item?.updated_at].join(':');
      if (requestGeneration !== generation || openedRevision === revision) return false;
      await onOpened?.({...item});
      if (requestGeneration === generation) openedRevision = revision;
      return true;
    }

    function replyKey(item, suffix) {
      return 'stackchain.search-reply.' + [item?.kind, item?.repository, item?.number]
        .map(value => encodeURIComponent(String(value || ''))).join('.') + '.' + suffix;
    }

    function stored(key) {
      try { return storage?.getItem(key) || ''; }
      catch (_) { return ''; }
    }

    function save(key, value) {
      try {
        if (value) storage?.setItem(key, value);
        else storage?.removeItem(key);
      } catch (_) { /* Volatile drafts still remain in the textarea. */ }
    }

    function navigation(item) {
      const session = typeof getSession === 'function' ? getSession() : null;
      const items = Array.isArray(session?.items) ? session.items : [];
      const index = items.findIndex(candidate => sameItem(candidate, item));
      if (index < 0) return null;
      return {
        position:index + 1,
        total:items.length,
        hasPrevious:index > 0,
        hasNext:index < items.length - 1 || session.more === true,
      };
    }

    function publish(state) {
      if (conversation && !Object.prototype.hasOwnProperty.call(state, 'conversation')) {
        state = {...state, conversation};
      }
      if (review && !Object.prototype.hasOwnProperty.call(state, 'review')) state = {...state, review};
      const position = navigation(state.item || current);
      if (navigationRoot) {
        const bar = navigationRoot.querySelector('.search-preview-navigation');
        bar.hidden = !position;
        if (position) {
          navigationRoot.querySelector('#search-preview-position').textContent = position.position + ' of ' + position.total;
          navigationRoot.querySelector('#previous-search-result').disabled = !position.hasPrevious;
          navigationRoot.querySelector('#next-search-result').disabled = !position.hasNext;
        }
      }
      onState(position ? { ...state, navigation:position } : state);
      if (state.complete && navigationRoot) {
        navigationRoot.querySelector('#search-preview-status').textContent = 'Search pass complete.';
      }
    }

    function run(action, pending, success, detail) {
      if (mutationRequest) return mutationRequest;
      publish({ status: pending, item: current, detail });
      mutationRequest = mutate(detail, action).then(result => {
        publish({ status: success, item: current, detail, result });
        return result;
      }).catch(error => {
        publish({ status: 'ready', item: current, detail, error });
        throw error;
      }).finally(() => { mutationRequest = null; });
      return mutationRequest;
    }

    function loadConversation(detail, requestGeneration, page) {
      if (typeof fetchConversation !== 'function') return Promise.resolve(null);
      const previousComments = page && Array.isArray(conversation?.comments)
        ? conversation.comments : [];
      conversation = {
        status:'loading', comments:previousComments, olderPage:page ?? null,
        reviewedAt:detail?.following === true ? detail.reviewed_at : null,
      };
      publish({ status:'ready', item:current, detail, conversation });
      return fetchConversation(detail, page).then(result => {
        if (requestGeneration !== generation) return result;
        const incoming = Array.isArray(result?.comments) ? result.comments : [];
        const liveComments = Array.isArray(conversation?.comments) ? conversation.comments : previousComments;
        const comments = [...incoming, ...liveComments].filter((comment, index, all) =>
          all.findIndex(candidate => candidate?.id === comment?.id) === index);
        conversation = {
          status:'ready',
          comments,
          olderPage:result?.older_page ?? null,
          reviewedAt:detail?.following === true ? detail.reviewed_at : null,
        };
        publish({ status:'ready', item:current, detail:current, conversation });
        return result;
      }).catch(error => {
        if (requestGeneration === generation) {
          conversation = {
            status:'error', comments:previousComments,
            olderPage:page ?? conversation?.olderPage ?? null, error,
            reviewedAt:detail?.following === true ? detail.reviewed_at : null,
          };
          publish({ status:'ready', item:current, detail:current, conversation });
        }
        return null;
      });
    }

    function loadReview(detail, requestGeneration) {
      if (!(detail?.following === true && detail?.kind === 'pull' && typeof fetchReview === 'function')) {
        review = null;
        return Promise.resolve(null);
      }
      review = {status:'loading', data:null};
      publish({status:'ready', item:current, detail:current, conversation, review});
      return fetchReview(detail).then(data => {
        if (requestGeneration === generation) {
          review = {status:'ready', data};
          publish({status:'ready', item:current, detail:current, conversation, review});
        }
        return data;
      }).catch(error => {
        if (requestGeneration === generation) {
          review = {status:'error', data:null, error};
          publish({status:'ready', item:current, detail:current, conversation, review});
        }
        return null;
      });
    }

    async function acknowledgeWhenContextReady(requestGeneration) {
      const conversationReady = typeof fetchConversation !== 'function' || conversation?.status === 'ready';
      const reviewRequired = current?.following === true && current?.kind === 'pull' &&
        typeof fetchReview === 'function';
      if (conversationReady && (!reviewRequired || review?.status === 'ready')) {
        await notifyOpened(current, requestGeneration);
      }
    }

    const conversationPager = {
      snapshot() {
        return {...(conversation || {}), comments:(conversation?.comments || []).map(comment => ({...comment}))};
      },
      replace(comment) {
        if (!comment || !Number.isInteger(comment.id) || !conversation) return conversationPager.snapshot();
        conversation = {...conversation, comments:(conversation.comments || []).map(existing =>
          existing.id === comment.id ? {...comment} : existing)};
        publish({status:'ready', item:current, detail:current, conversation});
        return conversationPager.snapshot();
      },
      remove(commentId) {
        if (!conversation) return conversationPager.snapshot();
        conversation = {...conversation, comments:(conversation.comments || []).filter(comment => comment.id !== commentId)};
        publish({status:'ready', item:current, detail:current, conversation});
        return conversationPager.snapshot();
      },
    };

    const api = {
      commentPager() { return conversationPager; },
      hasReplyAttachments() {
        return Boolean(hasAttachments?.());
      },
      open(item) {
        if (current && !sameItem(current, item) && hasAttachments?.()) clearAttachments?.();
        generation += 1;
        const requestGeneration = generation;
        current = { ...item };
        conversation = null;
        review = null;
        openedRevision = null;
        publish({ status: 'loading', item: current });
        return fetchJson(current).then(async detail => {
          if (requestGeneration === generation) {
            current = { ...current, ...detail };
            if (typeof fetchConversation === 'function') {
              const context = loadConversation(current, requestGeneration);
              if (current.following === true) {
                const reviewContext = loadReview(current, requestGeneration);
                await Promise.all([context, reviewContext]);
                await acknowledgeWhenContextReady(requestGeneration);
              } else {
                await notifyOpened(current, requestGeneration);
              }
            } else {
              publish({ status: 'ready', item: current, detail });
              await notifyOpened(current, requestGeneration);
            }
          }
          return detail;
        }).catch(error => {
          if (requestGeneration === generation) {
            publish({ status: 'error', item: current, error });
          }
          throw error;
        });
      },
      close() {
        clearAttachments?.();
        generation += 1;
        current = null;
        onState({ status: 'closed' });
      },
      previous() {
        const session = typeof getSession === 'function' ? getSession() : null;
        const items = Array.isArray(session?.items) ? session.items : [];
        const index = items.findIndex(item => sameItem(item, current));
        if (index <= 0) return Promise.resolve(current);
        const item = items[index - 1];
        if (typeof onNavigate === 'function') onNavigate(item);
        return api.open(item);
      },
      next() {
        if (moveRequest) return moveRequest;
        moveRequest = (async () => {
          let session = typeof getSession === 'function' ? getSession() : null;
          let items = Array.isArray(session?.items) ? session.items : [];
          let index = items.findIndex(item => sameItem(item, current));
          if (index < 0) return current;
          if (index === items.length - 1 && session?.more === true && typeof loadMore === 'function') {
            await loadMore();
            session = getSession();
            items = Array.isArray(session?.items) ? session.items : [];
            index = items.findIndex(item => sameItem(item, current));
          }
          if (index >= 0 && index < items.length - 1) {
            const item = items[index + 1];
            if (typeof onNavigate === 'function') onNavigate(item);
            return api.open(item);
          }
          publish({ status:'ready', item:current, detail:current, complete:true });
          return current;
        })().finally(() => { moveRequest = null; });
        return moveRequest;
      },
      async retryConversation() {
        if (!current) return null;
        const requestGeneration = generation;
        const result = await loadConversation(current, requestGeneration);
        if (current?.following === true) await acknowledgeWhenContextReady(requestGeneration);
        return result;
      },
      async retryReview() {
        if (!current) return null;
        const requestGeneration = generation;
        const result = await loadReview(current, requestGeneration);
        await acknowledgeWhenContextReady(requestGeneration);
        return result;
      },
      loadOlderConversation() {
        if (!current || !conversation?.olderPage) return Promise.resolve(null);
        return loadConversation(current, generation, conversation.olderPage);
      },
      saveReplyDraft(body) {
        if (!current) return '';
        const key = replyKey(current, 'draft');
        const next = String(body || '');
        if (stored(key) !== next) save(replyKey(current, 'operation'), '');
        save(key, next);
        return next;
      },
      replyDraft() {
        return current ? stored(replyKey(current, 'draft')) : '';
      },
      reply({ advance = false } = {}) {
        if (replyRequest) return replyRequest;
        if (!current || (typeof postReply !== 'function' && typeof queueReply !== 'function')) {
          return Promise.reject(new Error('Replying is unavailable.'));
        }
        const body = api.replyDraft().trim();
        if (!body && !hasAttachments?.()) return Promise.reject(new Error('Write a reply or add a photo first.'));
        const item = { ...current };
        const operationKey = replyKey(item, 'operation');
        let operationId = stored(operationKey);
        if (!operationId) {
          operationId = String(createOperationId?.() || Date.now()).slice(0, 128);
          save(operationKey, operationId);
        }
        publish({ status:'replying', item:current, detail:current, conversation });
        replyRequest = (typeof queueReply === 'function' ?
          Promise.resolve(queueReply(item, body, operationId)) :
          Promise.resolve(typeof prepareReply === 'function' ? prepareReply(item, body) : body)
            .then(preparedBody => {
              if (!String(preparedBody || '').trim()) throw new Error('Write a reply or add a photo first.');
              return postReply(item, preparedBody, operationId);
            })
        ).then(async comment => {
          await afterReply?.(item);
          if (!comment?.queued) {
            const comments = [...(conversation?.comments || [])];
            if (!comments.some(candidate => candidate?.id === comment?.id)) comments.push(comment);
            conversation = { status:'ready', comments, olderPage:conversation?.olderPage ?? null };
          }
          save(replyKey(item, 'draft'), '');
          save(operationKey, '');
          clearAttachments?.();
          publish({ status:comment?.queued ? 'queued' : 'replied', item:current, detail:current, conversation, result:comment });
          return advance ? api.next().then(() => comment) : comment;
        }).catch(error => {
          publish({ status:'reply-error', item:current, detail:current, conversation, error });
          throw error;
        }).finally(() => { replyRequest = null; });
        return replyRequest;
      },
      share(url) {
        if (shareRequest) return shareRequest;
        if (!current || typeof share !== 'function') return Promise.reject(new Error('Sharing is unavailable.'));
        const detail = current;
        publish({ status:'sharing', item:current, detail });
        shareRequest = share(url).then(result => {
          publish({ status:result, item:current, detail });
          return result;
        }).catch(error => {
          publish({ status:error?.name === 'AbortError' ? 'share-canceled' : 'share-error', item:current, detail, error });
          throw error;
        }).finally(() => { shareRequest = null; });
        return shareRequest;
      },
      claim(detail) {
        return run('claim', 'claiming', 'claimed', detail);
      },
      reopen(detail) {
        return run('reopen', 'reopening', 'reopened', detail);
      },
      reopenPull(detail) {
        return run('reopen-pull', 'reopening', 'reopened', detail);
      },
      setWatching(watching) {
        if (watchRequest) return watchRequest;
        if (!current || typeof watch !== 'function') {
          return Promise.reject(new Error('Watching is unavailable.'));
        }
        const detail = current;
        publish({ status:watching ? 'watching' : 'unwatching', item:current, detail });
        watchRequest = watch(detail, watching).then(async result => {
          current = { ...current, watching:result?.watching === true };
          const status = result?.following_synced === false
            ? 'watch-partial' : (watching ? 'watched' : 'unwatched');
          publish({ status, item:current, detail:current, result });
          if (!watching && result?.watching === false && typeof afterUnwatch === 'function') {
            const next = await afterUnwatch({...current});
            if (next) {
              onNavigate?.(next);
              await api.open(next);
            }
          }
          return result;
        }).catch(error => {
          publish({ status:'watch-error', item:current, detail, error });
          throw error;
        }).finally(() => { watchRequest = null; });
        return watchRequest;
      },
    };
    if (navigationRoot) {
      navigationRoot.querySelector('#previous-search-result').addEventListener('click', () => api.previous().catch(() => {}));
      navigationRoot.querySelector('#next-search-result').addEventListener('click', () => api.next().catch(() => {}));
      navigationRoot.querySelector('#retry-search-preview-conversation').addEventListener('click', () => api.retryConversation());
      navigationRoot.querySelector('#retry-search-preview-review').addEventListener('click', () => api.retryReview());
      navigationRoot.querySelector('#load-older-search-preview-comments').addEventListener('click', () => api.loadOlderConversation());
      const reply = navigationRoot.querySelector('#search-preview-reply');
      reply?.addEventListener('input', event => {
        api.saveReplyDraft(event.target.value);
        const disabled = !event.target.value.trim();
        navigationRoot.querySelector('#send-search-preview-reply').disabled = disabled;
        navigationRoot.querySelector('#send-search-preview-reply-next').disabled = disabled;
      });
      reply?.addEventListener('focus', event => event.target.scrollIntoView({ block:'center', behavior:'smooth' }));
      navigationRoot.querySelector('#send-search-preview-reply')?.addEventListener('click', () => api.reply().catch(() => {}));
      navigationRoot.querySelector('#send-search-preview-reply-next')?.addEventListener('click', () =>
        api.reply({ advance:true }).catch(() => {}));
    }
    return api;
  };
});