reslop 0.2.5 → 0.2.6

package/lib/session/lifecycle.js

@@ -3,10 +3,12 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
+const utilities = require('../utilities.js');
+const { isAbort } = utilities;
 const sessionLoad = require('./load.js');
-const { isAbortError, tagLoaded, fetchSnapshot, fetchExtras } = sessionLoad;
+const { tagLoaded, fetchSnapshot, fetchExtras } = sessionLoad;
 const watch = require('./watch.js');
-const { createDiskWatcher, DEBOUNCE_MS } = watch;
+const { DiskWatcher, DEBOUNCE_MS } = watch;
 const files = require('../files.js');
 const { itemPath, relativeAge } = files;
 const deps = require('../deps.js');
@@ -16,34 +18,7 @@ const { hasNotes, loadReview } = review;
 const reviewMerge = require('../review-merge.js');
 const { mergeReview } = reviewMerge;
 
-const loadOptions = (api, extra = {}) => {
-  const { loadConfig, ui } = api;
-  return {
-    commit: ui.rev,
-    audit: loadConfig.audit,
-    outdatedMap: loadConfig.outdatedMap,
-    auditMap: loadConfig.auditMap,
-    ...extra,
-  };
-};
-
-const shouldDeferExtras = (api) => {
-  const { loadConfig } = api;
-  const audit = !!loadConfig.audit;
-  const waitingOutdated = loadConfig.outdatedMap === undefined;
-  const waitingAudit = loadConfig.auditMap === undefined;
-  return audit && (waitingOutdated || waitingAudit);
-};
-
-const endReadLoop = (api) => {
-  const finish = api.ui.finishReadLoop;
-  if (finish) finish();
-};
-
-const markLoaded = (api) => {
-  api.loader.didLoad = true;
-  api.updater.maybePrompt();
-};
+const WATCH_IGNORE_MS = 500;
 
 const isWorktree = (ui) => !ui.rev && !ui.change;
 
@@ -53,503 +28,455 @@ const kindFromExtra = (extra = {}) => {
   return 'reload';
 };
 
-const finishIfEmpty = (api, kind) => {
-  const { collection, review: notes, ui, nav } = api;
-  if (collection.items.length) return;
-  if (notes.store && hasNotes(notes.store)) return;
-  if (kind === 'keep') return;
-  if (isWorktree(ui)) {
-    if (nav.pane === 'diff') nav.pane = 'files';
-    return;
-  }
-  ui.done = true;
-  ui.exitCode = 0;
-  ui.status = 'nothing to review';
-  ui.emptyReview = kind === 'open';
-  endReadLoop(api);
-};
-
-const failOpen = (api, error) => {
-  if (isAbortError(error)) return;
-  const { ui, ops } = api;
-  ui.loadError = error;
-  ui.done = true;
-  ui.exitCode = 1;
-  ops.setBusy('');
-  ui.stopProgress();
-  endReadLoop(api);
-};
-
-const restoreAfterLoad = (api, here, wasTodo) => {
-  const { collection, nav, ui } = api;
-  nav.tasksOpen = wasTodo;
-  if (here && !wasTodo) {
-    const idx = collection.findRestoredIndex(here);
-    if (idx >= 0) nav.index = idx;
-  }
-  ui.clampIndex();
-  nav.restoreFileCursor(ui.fileList());
-  ui.syncReviewPath();
-  ui.syncFileCursor();
+const statStamp = (file) => {
+  try {
+    const stat = fs.statSync(file);
+    return `${stat.mtimeMs}:${stat.size}`;
+  } catch {
+    return 'missing';
+  }
 };
 
-const itemRels = (collection) => {
-  const rels = [];
-  for (const item of collection.items) {
+const itemRels = (items) => {
+  const rels = new Set();
+  for (const item of items) {
     const rel = itemPath(item);
-    if (!rel) continue;
-    if (rels.includes(rel)) continue;
-    rels.push(rel);
+    if (rel) rels.add(rel);
   }
-  return rels;
+  return [...rels];
 };
 
-const fileDatesFromDisk = (top, rels) => {
-  const dates = new Map();
-  if (!top) return dates;
+const stampItemDates = (top, items) => {
+  if (!top) return;
   const now = Date.now();
-  for (const rel of rels) {
+  const dates = new Map();
+  for (const rel of itemRels(items)) {
     try {
-      const st = fs.statSync(path.join(top, rel));
-      dates.set(rel, relativeAge(st.mtimeMs, now));
+      const stat = fs.statSync(path.join(top, rel));
+      dates.set(rel, relativeAge(stat.mtimeMs, now));
     } catch {
       continue;
     }
   }
-  return dates;
-};
-
-const stampItemDates = (items, dates) => {
   for (const item of items) {
     const date = dates.get(itemPath(item));
     if (date) item.date = date;
   }
 };
 
-const syncUnitEditor = (api) => {
-  const composer = api.ui.composer;
-  if (!composer || typeof composer.applyDiskText !== 'function') return;
-  if (api.nav.pane !== 'unit') return;
-  const rel = api.nav.reviewPath;
-  if (!rel) return;
-  const repo = api.ui.repo;
-  if (!repo || typeof repo.fileText !== 'function') return;
-  const text = repo.fileText(api.ui.top || api.loadConfig.cwd, rel, api.ui.rev);
-  composer.applyDiskText(text);
+const npmRels = (items) => {
+  const rels = new Set([MANIFEST, LOCKFILE]);
+  for (const item of items) {
+    const rel = itemPath(item);
+    if (depFileMeta(rel)) rels.add(rel);
+  }
+  return [...rels].sort();
 };
 
-const syncItemWatches = (api) => {
-  if (!api.diskWatcher) return;
-  const rels = itemRels(api.collection);
-  if (api.nav.pane === 'unit' && api.nav.reviewPath) {
-    if (!rels.includes(api.nav.reviewPath)) rels.push(api.nav.reviewPath);
+class Lifecycle {
+  constructor(ui) {
+    this.ui = ui;
+    this.diskWatcher = null;
+    this.watchRetry = null;
+    this.reviewStamp = '';
+    this.ignoreWatchUntil = 0;
+    this.cachedExtras = null;
   }
-  api.diskWatcher.watchFiles(rels);
-};
 
-const applyLoaded = (api, loaded) => {
-  const { loader, collection, review: notes, nav, ui } = api;
-  if (loaded.generation !== undefined) {
-    if (!loader.accept(loaded.generation, ui.done)) return false;
-  }
-  const wasTodo = nav.tasksOpen === true;
-  const here = ui.current();
-  ui.top = loaded.top ?? api.loadConfig.cwd;
-  collection.replace(loaded.items);
-  stampItemDates(
-    collection.items,
-    fileDatesFromDisk(ui.top, itemRels(collection)),
-  );
-  if (loaded.rev) ui.rev = loaded.rev;
-  if (loaded.revShort) {
-    ui.revShort = loaded.revShort;
-  } else if (ui.rev && !ui.revShort) {
-    ui.revShort = ui.rev.slice(0, 7);
-  }
-  if (loaded.sourceLabel) ui.sourceLabel = loaded.sourceLabel;
-  if (loaded.change) ui.change = loaded.change;
-  if (loaded.branch !== undefined) ui.branch = loaded.branch || '';
-  const repository = ui.change ? ui.change.repository : '';
-  if (!ui.repoName && repository) ui.repoName = repository;
-  if (!notes.store) ui.initReview();
-  notes.applyImported(loaded.imported);
-  restoreAfterLoad(api, here, wasTodo);
-  markLoaded(api);
-  loader.pendingExtras = loaded.pending === true;
-  syncItemWatches(api);
-  syncUnitEditor(api);
-  return true;
-};
+  get root() {
+    return this.ui.top || this.ui.cwd;
+  }
 
-const load = (api) => {
-  const { loadConfig } = api;
-  const loaded = loadConfig.repo.load(
-    loadConfig.cwd,
-    loadConfig.paths,
-    loadOptions(api),
-  );
-  applyLoaded(api, loaded);
-};
+  loadOptions(extra = {}) {
+    const ui = this.ui;
+    return {
+      commit: ui.rev,
+      audit: ui.audit,
+      outdatedMap: ui.outdatedMap,
+      auditMap: ui.auditMap,
+      ...extra,
+    };
+  }
 
-const fileStamp = (top, rel) => {
-  const full = path.join(top, rel);
-  try {
-    const stat = fs.statSync(full);
-    return `${stat.mtimeMs}:${stat.size}`;
-  } catch {
-    return 'missing';
+  endReadLoop() {
+    const finish = this.ui.finishReadLoop;
+    if (finish) finish();
   }
-};
 
-const npmRels = (items) => {
-  const rels = [MANIFEST, LOCKFILE];
-  for (const item of items) {
-    const rel = itemPath(item);
-    if (!depFileMeta(rel)) continue;
-    if (rels.includes(rel)) continue;
-    rels.push(rel);
+  finishIfEmpty(kind) {
+    const ui = this.ui;
+    if (ui.items.length) return;
+    const store = ui.review.store;
+    if (store && hasNotes(store)) return;
+    if (kind === 'keep') return;
+    if (isWorktree(ui)) {
+      if (ui.nav.pane === 'diff') ui.nav.pane = 'files';
+      return;
+    }
+    ui.done = true;
+    ui.exitCode = 0;
+    ui.status = 'nothing to review';
+    ui.emptyReview = kind === 'open';
+    this.endReadLoop();
   }
-  rels.sort();
-  return rels;
-};
 
-const npmStamp = (api) => {
-  const top = api.ui.top || api.loadConfig.cwd;
-  const rels = npmRels(api.collection.items);
-  const parts = new Array(rels.length);
-  for (let i = 0; i < rels.length; i++) {
-    parts[i] = `${rels[i]}:${fileStamp(top, rels[i])}`;
+  failOpen(error) {
+    if (isAbort(error)) return;
+    const ui = this.ui;
+    ui.loadError = error;
+    ui.done = true;
+    ui.exitCode = 1;
+    ui.ops.setBusy('');
+    ui.stopProgress();
+    this.endReadLoop();
   }
-  return parts.join('|');
-};
 
-const npmExtrasStale = (api) => {
-  const cached = api.npmExtras;
-  if (!cached || !api.loadConfig.audit) return false;
-  return cached.stamp !== npmStamp(api);
-};
+  restoreAfterLoad(here, wasTasks) {
+    const { nav, collection } = this.ui;
+    nav.tasksOpen = wasTasks;
+    if (here && !wasTasks) {
+      const idx = collection.findRestoredIndex(here);
+      if (idx >= 0) nav.index = idx;
+    }
+    this.ui.clampIndex();
+    nav.restoreFileCursor(this.ui.fileList());
+    this.ui.syncReviewPath();
+    this.ui.syncFileCursor();
+  }
 
-const cacheNpmExtras = (api, loaded) => {
-  api.npmExtras = {
-    stamp: npmStamp(api),
-    auditMap: loaded.auditMap ?? null,
-    outdatedMap: loaded.outdatedMap ?? null,
-    usedNames: loaded.usedNames ?? null,
-    exportEntries: loaded.exportEntries,
-  };
-};
+  syncUnitEditor() {
+    const ui = this.ui;
+    const rel = ui.nav.reviewPath;
+    if (ui.nav.pane !== 'unit' || !rel || !ui.repo.fileText) return;
+    ui.composer.applyDiskText(ui.repo.fileText(this.root, rel, ui.rev));
+  }
 
-const clearNpmExtras = (api) => {
-  api.npmExtras = null;
-};
+  syncItemWatches() {
+    if (!this.diskWatcher) return;
+    const nav = this.ui.nav;
+    const rels = itemRels(this.ui.items);
+    if (nav.pane === 'unit' && nav.reviewPath) {
+      if (!rels.includes(nav.reviewPath)) rels.push(nav.reviewPath);
+    }
+    this.diskWatcher.watchFiles(rels);
+  }
 
-const isWanted = (api, gen) => {
-  if (!api.loader.isCurrent(gen)) return false;
-  if (!api.ui.done) return true;
-  api.ops.clearBusy();
-  return false;
-};
+  applyLoaded(loaded) {
+    const ui = this.ui;
+    const { loader, collection, nav } = ui;
+    if (loaded.generation !== undefined) {
+      if (!loader.isCurrent(loaded.generation, ui.done)) return false;
+    }
+    const wasTasks = nav.tasksOpen === true;
+    const here = ui.current();
+    ui.top = loaded.top ?? ui.cwd;
+    collection.replace(loaded.items);
+    stampItemDates(ui.top, collection.items);
+    if (loaded.rev) ui.rev = loaded.rev;
+    if (loaded.revShort) ui.revShort = loaded.revShort;
+    else if (ui.rev && !ui.revShort) ui.revShort = ui.rev.slice(0, 7);
+    if (loaded.sourceLabel) ui.sourceLabel = loaded.sourceLabel;
+    if (loaded.change) ui.change = loaded.change;
+    if (loaded.branch !== undefined) ui.branch = loaded.branch || '';
+    const repository = ui.change ? ui.change.repository : '';
+    if (!ui.repoName && repository) ui.repoName = repository;
+    if (!ui.review.store) ui.initReview();
+    ui.review.applyImported(loaded.imported);
+    this.restoreAfterLoad(here, wasTasks);
+    loader.didLoad = true;
+    ui.updater.maybePrompt();
+    loader.pendingExtras = loaded.pending === true;
+    this.syncItemWatches();
+    this.syncUnitEditor();
+    ui.dashboard.noteLoaded();
+    return true;
+  }
 
-const followExtras = async (api, loaded, gen, kind) => {
-  const extra = loadOptions(api, {
-    paths: api.loadConfig.paths,
-    signal: api.loader.signal,
-  });
-  let next;
-  try {
-    next = await fetchExtras(api.loadConfig.repo, loaded, extra);
-  } catch (error) {
-    if (api.loader.isCurrent(gen)) failOpen(api, error);
-    return;
-  }
-  if (!isWanted(api, gen)) return;
-  if (next) {
-    applyLoaded(api, tagLoaded(next, gen));
-    cacheNpmExtras(api, next);
-  } else {
-    api.loader.pendingExtras = false;
-  }
-  api.ops.clearBusy();
-  api.ui.paint();
-  finishIfEmpty(api, kind);
-};
+  load() {
+    const ui = this.ui;
+    const loaded = ui.repo.load(ui.cwd, ui.paths, this.loadOptions());
+    this.applyLoaded(loaded);
+  }
 
-const npmReuseOpts = (api, extra = {}) => {
-  const opts = {};
-  if (extra.signal) opts.signal = extra.signal;
-  const cached = api.npmExtras;
-  if (!cached) return opts;
-  if (cached.stamp !== npmStamp(api)) return opts;
-  opts.deferExtras = false;
-  opts.collect = false;
-  opts.auditMap = cached.auditMap;
-  opts.outdatedMap = cached.outdatedMap;
-  opts.usedNames = cached.usedNames;
-  opts.exportEntries = cached.exportEntries;
-  return opts;
-};
+  npmStamp() {
+    const root = this.root;
+    const rels = npmRels(this.ui.items);
+    const stamp = (rel) => `${rel}:${statStamp(path.join(root, rel))}`;
+    return rels.map(stamp).join('|');
+  }
 
-const snapshotOpts = (api, extra = {}) =>
-  loadOptions(api, {
-    deferExtras: shouldDeferExtras(api),
-    ...npmReuseOpts(api, extra),
-  });
+  npmExtrasStale() {
+    const cached = this.cachedExtras;
+    if (!cached || !this.ui.audit) return false;
+    return cached.stamp !== this.npmStamp();
+  }
 
-const resetNavAfterLoad = (api, extra = {}) => {
-  api.nav.scroll = 0;
-  api.nav.clearSelection();
-  if (extra.afterLoad) extra.afterLoad();
-};
+  cacheNpmExtras(loaded) {
+    this.cachedExtras = {
+      stamp: this.npmStamp(),
+      auditMap: loaded.auditMap ?? null,
+      outdatedMap: loaded.outdatedMap ?? null,
+      usedNames: loaded.usedNames ?? null,
+      exportEntries: loaded.exportEntries,
+    };
+  }
 
-const refreshListsForPane = (api) => {
-  const pane = api.ui.nav.pane;
-  if (pane === 'commits' && api.ui.commits) api.ui.commits.refresh();
-};
+  clearNpmExtras() {
+    this.cachedExtras = null;
+  }
 
-const afterSnapshot = (api, kind, extra = {}) => {
-  refreshListsForPane(api);
-  if (kind !== 'open' && kind !== 'watch') {
-    return void resetNavAfterLoad(api, extra);
+  npmExtras() {
+    if (this.cachedExtras) return this.cachedExtras;
+    const { auditMap, outdatedMap } = this.ui;
+    if (!auditMap && !outdatedMap) return null;
+    return { auditMap: auditMap ?? null, outdatedMap: outdatedMap ?? null };
   }
-  if (extra.afterLoad) extra.afterLoad();
-};
 
-const beginSnapshot = (api, extra) => {
-  if (extra.quiet === true) return;
-  api.ui.progressFrame = 0;
-  api.ops.setBusy('loading');
-  api.ui.paint();
-};
+  isWanted(gen) {
+    if (!this.ui.loader.isCurrent(gen)) return false;
+    if (!this.ui.done) return true;
+    this.ui.ops.clearBusy();
+    return false;
+  }
 
-const runSnapshot = async (api, gen, kind, extra = {}) => {
-  beginSnapshot(api, extra);
-  let loaded;
-  try {
-    loaded = await fetchSnapshot(
-      api.loadConfig.repo,
-      api.loadConfig.cwd,
-      api.loadConfig.paths,
-      snapshotOpts(api, {
-        signal: api.loader.signal,
-        keepView: extra.keepView,
-      }),
-    );
-  } catch (error) {
-    if (api.loader.isCurrent(gen)) failOpen(api, error);
-    return;
-  }
-  if (!isWanted(api, gen)) return;
-  applyLoaded(api, tagLoaded(loaded, gen));
-  afterSnapshot(api, kind, extra);
-  if (loaded.pending === true || npmExtrasStale(api)) {
-    api.ops.setBusy('checking npm');
-    if (kind === 'open' || extra.quiet === true) api.ui.paint();
-    await followExtras(api, loaded, gen, kind);
-    return;
-  }
-  api.ops.clearBusy();
-  finishIfEmpty(api, kind);
-  if (extra.doneStatus && !api.ui.status && !api.ops.busy) {
-    api.ui.status = extra.doneStatus;
-  }
-  api.ui.paint();
-};
+  async followExtras(loaded, gen, kind) {
+    const ui = this.ui;
+    const extra = this.loadOptions({
+      paths: ui.paths,
+      signal: ui.loader.signal,
+    });
+    let next;
+    try {
+      next = await fetchExtras(ui.repo, loaded, extra);
+    } catch (error) {
+      if (ui.loader.isCurrent(gen)) this.failOpen(error);
+      return;
+    }
+    if (!this.isWanted(gen)) return;
+    if (next) {
+      this.applyLoaded(tagLoaded(next, gen));
+      this.cacheNpmExtras(next);
+    } else {
+      ui.loader.pendingExtras = false;
+    }
+    ui.ops.clearBusy();
+    ui.paint();
+    this.finishIfEmpty(kind);
+  }
 
-const openLoad = (api) => {
-  const { loader } = api;
-  if (loader.promise) return loader.promise;
-  if (loader.didLoad && !loader.pendingExtras) {
-    loader.promise = Promise.resolve();
-    return loader.promise;
+  snapshotOpts(extra = {}) {
+    const ui = this.ui;
+    const waiting = ui.outdatedMap === undefined || ui.auditMap === undefined;
+    const opts = { deferExtras: ui.audit && waiting };
+    if (extra.signal) opts.signal = extra.signal;
+    const cached = this.cachedExtras;
+    if (cached && cached.stamp === this.npmStamp()) {
+      opts.deferExtras = false;
+      opts.collect = false;
+      opts.auditMap = cached.auditMap;
+      opts.outdatedMap = cached.outdatedMap;
+      opts.usedNames = cached.usedNames;
+      opts.exportEntries = cached.exportEntries;
+    }
+    return this.loadOptions(opts);
   }
-  const gen = loader.bump();
-  loader.promise = runSnapshot(api, gen, 'open');
-  return loader.promise;
-};
 
-const loadReady = async (api) => {
-  api.ui.ensureRepo();
-  await openLoad(api);
-  if (api.ui.loadError) throw api.ui.loadError;
-};
+  afterSnapshot(kind, extra = {}) {
+    const nav = this.ui.nav;
+    if (nav.pane === 'commits') this.ui.commits.refresh();
+    if (kind !== 'open' && kind !== 'watch') {
+      nav.scroll = 0;
+      nav.clearSelection();
+    }
+    if (extra.afterLoad) extra.afterLoad();
+  }
 
-const refreshFromRepo = (api, extra = {}) => {
-  api.loader.promise = null;
-  const gen = api.loader.bump();
-  const kind = kindFromExtra(extra);
-  if (api.ui.uiOpen && api.loadConfig.repo.loadAsync) {
-    return void runSnapshot(api, gen, kind, extra);
-  }
-  const loaded = api.loadConfig.repo.load(
-    api.loadConfig.cwd,
-    api.loadConfig.paths,
-    snapshotOpts(api, extra),
-  );
-  applyLoaded(api, tagLoaded(loaded, gen));
-  afterSnapshot(api, kind, extra);
-  if (loaded.pending === true || npmExtrasStale(api)) {
-    api.ops.setBusy('checking npm');
-    return void followExtras(api, loaded, gen, kind);
-  }
-  if (kind === 'keep') return;
-  finishIfEmpty(api, kind);
-  if (extra.doneStatus && !api.ui.done && !api.loader.pendingExtras) {
-    api.ui.status = extra.doneStatus;
-  }
-  if (kind === 'watch') api.ui.paint();
-};
+  async runSnapshot(gen, kind, extra = {}) {
+    const ui = this.ui;
+    if (extra.quiet !== true) {
+      ui.progressFrame = 0;
+      ui.ops.setBusy('loading');
+      ui.paint();
+    }
+    let loaded;
+    try {
+      const opts = this.snapshotOpts({ signal: ui.loader.signal });
+      loaded = await fetchSnapshot(ui.repo, ui.cwd, ui.paths, opts);
+    } catch (error) {
+      if (ui.loader.isCurrent(gen)) this.failOpen(error);
+      return;
+    }
+    if (!this.isWanted(gen)) return;
+    this.applyLoaded(tagLoaded(loaded, gen));
+    this.afterSnapshot(kind, extra);
+    if (loaded.pending === true || this.npmExtrasStale()) {
+      ui.ops.setBusy('checking npm');
+      if (kind === 'open' || extra.quiet === true) ui.paint();
+      await this.followExtras(loaded, gen, kind);
+      return;
+    }
+    ui.ops.clearBusy();
+    this.finishIfEmpty(kind);
+    if (extra.doneStatus && !ui.status && !ui.ops.busy) {
+      ui.status = extra.doneStatus;
+    }
+    ui.paint();
+  }
 
-const reloadAfterChange = (api, afterLoad) => {
-  const hereItem = api.ui.current();
-  const hereIndex = api.nav.index;
-  const restore = () => {
-    const idx = api.collection.findRestoredIndex(hereItem);
-    api.nav.index = idx >= 0 ? idx : hereIndex;
-    api.ui.clampIndex();
-    api.ui.syncReviewPath();
-    api.ui.syncFileCursor();
-    if (afterLoad) afterLoad();
-  };
-  if (api.ui.uiOpen && api.loadConfig.repo.loadAsync) {
-    return void refreshFromRepo(api, { afterLoad: restore });
-  }
-  refreshFromRepo(api);
-  restore();
-};
+  openLoad() {
+    const loader = this.ui.loader;
+    if (loader.promise) return loader.promise;
+    if (loader.didLoad && !loader.pendingExtras) {
+      loader.promise = Promise.resolve();
+    } else {
+      loader.promise = this.runSnapshot(loader.bump(), 'open');
+    }
+    return loader.promise;
+  }
 
-const onReload = (api) => {
-  api.collection.dismissed.clear();
-  api.ui.status = '';
-  refreshFromRepo(api, { doneStatus: 'reloaded' });
-};
+  async loadReady() {
+    this.ui.ensureRepo();
+    await this.openLoad();
+    if (this.ui.loadError) throw this.ui.loadError;
+  }
 
-const clearWatchRetry = (api) => {
-  if (api.watchRetry === null) return;
-  clearTimeout(api.watchRetry);
-  api.watchRetry = null;
-};
+  refreshFromRepo(extra = {}) {
+    const ui = this.ui;
+    ui.loader.promise = null;
+    const gen = ui.loader.bump();
+    const kind = kindFromExtra(extra);
+    if (ui.uiOpen && ui.repo.loadAsync) {
+      return void this.runSnapshot(gen, kind, extra);
+    }
+    const loaded = ui.repo.load(ui.cwd, ui.paths, this.snapshotOpts(extra));
+    this.applyLoaded(tagLoaded(loaded, gen));
+    this.afterSnapshot(kind, extra);
+    if (loaded.pending === true || this.npmExtrasStale()) {
+      ui.ops.setBusy('checking npm');
+      return void this.followExtras(loaded, gen, kind);
+    }
+    if (kind === 'keep') return;
+    this.finishIfEmpty(kind);
+    if (extra.doneStatus && !ui.done && !ui.loader.pendingExtras) {
+      ui.status = extra.doneStatus;
+    }
+    if (kind === 'watch') ui.paint();
+  }
 
-const shouldDeferWatch = (api) => {
-  const { ui, ops } = api;
-  if (ui.done) return true;
-  if (!ui.uiOpen) return true;
-  if (!api.loader.didLoad) return true;
-  if (ops.gitBusy) return true;
-  if (ui.mode === 'compose') {
-    const kind = ui.composer && ui.composer.state.composeKind;
-    if (kind === 'file') return false;
-  }
-  if (ui.mode !== 'review') return true;
-  return false;
-};
+  reloadAfterChange(afterLoad) {
+    const ui = this.ui;
+    const hereItem = ui.current();
+    const hereIndex = ui.nav.index;
+    const restore = () => {
+      const idx = ui.collection.findRestoredIndex(hereItem);
+      ui.nav.index = idx >= 0 ? idx : hereIndex;
+      ui.clampIndex();
+      ui.syncReviewPath();
+      ui.syncFileCursor();
+      if (afterLoad) afterLoad();
+    };
+    if (ui.uiOpen && ui.repo.loadAsync) {
+      return void this.refreshFromRepo({ afterLoad: restore });
+    }
+    this.refreshFromRepo();
+    restore();
+  }
 
-const WATCH_IGNORE_MS = 500;
+  onReload() {
+    this.ui.collection.dismissed.clear();
+    this.ui.status = '';
+    this.refreshFromRepo({ doneStatus: 'reloaded' });
+  }
 
-const ignoreWatch = (api, ms = WATCH_IGNORE_MS) => {
-  api.ignoreWatchUntil = Date.now() + ms;
-};
+  clearWatchRetry() {
+    if (this.watchRetry === null) return;
+    clearTimeout(this.watchRetry);
+    this.watchRetry = null;
+  }
 
-const onDiskChange = (api) => {
-  if (Date.now() < (api.ignoreWatchUntil ?? 0)) return;
-  if (shouldDeferWatch(api)) {
-    if (api.watchRetry !== null) return;
-    api.watchRetry = setTimeout(() => {
-      api.watchRetry = null;
-      onDiskChange(api);
-    }, DEBOUNCE_MS);
-    if (typeof api.watchRetry.unref === 'function') api.watchRetry.unref();
-    return;
+  shouldDeferWatch() {
+    const ui = this.ui;
+    if (ui.done || !ui.uiOpen || !ui.loader.didLoad) return true;
+    if (ui.ops.gitBusy) return true;
+    if (ui.mode === 'compose' && ui.composeKind === 'file') return false;
+    return ui.mode !== 'review';
   }
-  refreshFromRepo(api, { keepView: true, quiet: true });
-};
 
-const catchUpWatch = (api) => {
-  clearWatchRetry(api);
-  if (shouldDeferWatch(api)) return void onDiskChange(api);
-  refreshFromRepo(api, { keepView: true, quiet: true });
-};
+  ignoreWatch(ms = WATCH_IGNORE_MS) {
+    this.ignoreWatchUntil = Date.now() + ms;
+  }
 
-const reviewFileStamp = (api) => {
-  const store = api.review && api.review.store;
-  if (!store || !store.reviewPath) return '';
-  try {
-    const stat = fs.statSync(store.reviewPath);
-    return `${stat.mtimeMs}:${stat.size}`;
-  } catch {
-    return 'missing';
+  onDiskChange() {
+    if (Date.now() < this.ignoreWatchUntil) return;
+    if (!this.shouldDeferWatch()) {
+      return void this.refreshFromRepo({ keepView: true, quiet: true });
+    }
+    if (this.watchRetry !== null) return;
+    this.watchRetry = setTimeout(() => {
+      this.watchRetry = null;
+      this.onDiskChange();
+    }, DEBOUNCE_MS);
+    this.watchRetry.unref();
   }
-};
 
-const noteReviewStamp = (api) => {
-  api.reviewStamp = reviewFileStamp(api);
-};
+  catchUpWatch() {
+    this.clearWatchRetry();
+    if (this.shouldDeferWatch()) return void this.onDiskChange();
+    this.refreshFromRepo({ keepView: true, quiet: true });
+  }
 
-const applyReviewChange = (api) => {
-  if (!api.ui || api.ui.done) return;
-  const stamp = reviewFileStamp(api);
-  if (!stamp || stamp === api.reviewStamp) return;
-  if (stamp === 'missing') {
-    api.reviewStamp = stamp;
-    return;
-  }
-  const store = api.review && api.review.store;
-  if (!store) return;
-  let disk;
-  try {
-    disk = loadReview(store.reviewPath, store.templates);
-  } catch {
-    return;
+  reviewFileStamp() {
+    const store = this.ui.review.store;
+    if (!store || !store.reviewPath) return '';
+    return statStamp(store.reviewPath);
   }
-  mergeReview(store, disk);
-  api.reviewStamp = stamp;
-  api.ui.paint();
-};
 
-const stopWatch = (api) => {
-  clearWatchRetry(api);
-  api.reviewStamp = '';
-  if (!api.diskWatcher) return;
-  api.diskWatcher.close();
-  api.diskWatcher = null;
-};
+  noteReviewStamp() {
+    this.reviewStamp = this.reviewFileStamp();
+  }
 
-const startWatch = (api) => {
-  stopWatch(api);
-  if (!isWorktree(api.ui)) return;
-  const root = api.ui.top || api.loadConfig.cwd;
-  if (!root) return;
-  api.diskWatcher = createDiskWatcher({
-    root,
-    paths: api.loadConfig.paths,
-    onChange: () => onDiskChange(api),
-    onReview: () => applyReviewChange(api),
-  });
-  syncItemWatches(api);
-  noteReviewStamp(api);
-};
+  applyReviewChange() {
+    if (this.ui.done) return;
+    const stamp = this.reviewFileStamp();
+    if (!stamp || stamp === this.reviewStamp) return;
+    if (stamp === 'missing') {
+      this.reviewStamp = stamp;
+      return;
+    }
+    const store = this.ui.review.store;
+    let disk;
+    try {
+      disk = loadReview(store.reviewPath, store.templates);
+    } catch {
+      return;
+    }
+    mergeReview(store, disk);
+    this.reviewStamp = stamp;
+    this.ui.paint();
+  }
 
-const createLifecycle = (api) => {
-  api.diskWatcher = null;
-  api.watchRetry = null;
-  api.reviewStamp = '';
-  api.ignoreWatchUntil = 0;
-  api.npmExtras = null;
-  return {
-    load: () => load(api),
-    openLoad: () => openLoad(api),
-    loadReady: () => loadReady(api),
-    refreshFromRepo: (extra) => refreshFromRepo(api, extra),
-    reloadAfterChange: (afterLoad) => reloadAfterChange(api, afterLoad),
-    onReload: () => onReload(api),
-    onDiskChange: () => onDiskChange(api),
-    applyReviewChange: () => applyReviewChange(api),
-    noteReviewStamp: () => noteReviewStamp(api),
-    catchUpWatch: () => catchUpWatch(api),
-    startWatch: () => startWatch(api),
-    stopWatch: () => stopWatch(api),
-    ignoreWatch: (ms) => ignoreWatch(api, ms),
-    clearNpmExtras: () => clearNpmExtras(api),
-  };
-};
+  stopWatch() {
+    this.clearWatchRetry();
+    this.reviewStamp = '';
+    if (!this.diskWatcher) return;
+    this.diskWatcher.close();
+    this.diskWatcher = null;
+  }
+
+  startWatch() {
+    this.stopWatch();
+    const root = this.root;
+    if (!isWorktree(this.ui) || !root) return;
+    this.diskWatcher = new DiskWatcher({
+      root,
+      paths: this.ui.paths,
+      onChange: () => this.onDiskChange(),
+      onReview: () => this.applyReviewChange(),
+      onPaths: (paths) => this.ui.dashboard.noteDisk(paths),
+    });
+    this.syncItemWatches();
+    this.noteReviewStamp();
+  }
+}
 
-module.exports = { createLifecycle };
+module.exports = { Lifecycle };