useStepper -> preferStepper, added hard threshold of 100 for the stepper

Author: computing-den

src/extension/codemic.ts

@@ -1,4 +1,4 @@
-import './config.js'; // Init config
+import config from './config.js'; // Init config
 import WebviewProvider from './webview_provider.js';
 import Session from './session/session.js';
 import * as storage from './storage.js';
@@ -577,7 +577,7 @@ class CodeMic {
       }
       case 'recorder/seek': {
         assert(this.session?.isLoaded());
-        await this.session.rr.enqueueSeek(req.clock, req.useStepper);
+        await this.session.rr.enqueueSeek(req.clock, req.preferStepper);
         await this.updateFrontend();
         return ok;
       }
@@ -1351,8 +1351,7 @@ class CodeMic {
         history: this.context.settings.history[s.head.id],
         publication: this.publications.get(s.head.id),
       }));
-      sessions = lib.searchSessions(sessions, this.searchQuery);
-      sessions = lib.limitRecentSessions(sessions, 4);
+      sessions = lib.searchSessions(sessions, this.searchQuery, config.debug ? 100 : 4);
 
       welcome = {
         searchQuery: this.searchQuery,

src/extension/session/session_record_and_replay.ts

@@ -122,8 +122,8 @@ export default class SessionRecordAndReplay {
     await this.pauseOnError(this.queue.enqueue(this.record.bind(this)));
   }
 
-  async enqueueSeek(clock: number, useStepper?: boolean) {
-    await this.pauseOnError(this.queue.enqueue(this.seek.bind(this), clock, useStepper));
+  async enqueueSeek(clock: number, preferStepper?: boolean) {
+    await this.pauseOnError(this.queue.enqueue(this.seek.bind(this), clock, preferStepper));
   }
 
   async enqueueSync(clock?: number) {
@@ -196,16 +196,16 @@ export default class SessionRecordAndReplay {
   }
 
   /**
-   * useStepper is only useful during testing to test the stepper.
+   * preferStepper is only useful during testing to test the stepper.
    */
-  private async seek(clock: number, useStepper?: boolean) {
+  private async seek(clock: number, preferStepper?: boolean) {
     const origClock = this.clock;
     this.clock = Math.max(0, Math.min(this.session.head.duration, clock));
 
     // Must only use stepper during playback. Otherwise, we don't know if the user has changed
     // the files and documents while on pause or not.
-    useStepper ??= this.playing && Math.abs(origClock - this.clock) < SEEK_USING_STEPPER_THRESHOLD_S;
-    await this.workspacePlayer.seek(clock, useStepper);
+    preferStepper ??= this.playing && Math.abs(origClock - this.clock) < SEEK_USING_STEPPER_THRESHOLD_S;
+    await this.workspacePlayer.seek(clock, preferStepper);
     await this.syncMedia({ hard: true });
     this.updateLoop.resetDiff();
     this.session.onProgress?.();

src/extension/session/workspace_player.ts

@@ -8,6 +8,8 @@ import _ from 'lodash';
 import { LoadedSession } from './session.js';
 import VscWorkspace from './vsc_workspace.js';
 
+const STEPPER_HARD_THRESHOLD = 100;
+
 class WorkspacePlayer {
   playing = false;
   // onError?: (error: Error) => any;
@@ -100,14 +102,15 @@ class WorkspacePlayer {
     this.dispose();
   }
 
-  async seek(clock: number, useStepper: boolean) {
-    await this.seekWithData(this.internalWorkspace.getSeekData(clock), useStepper);
+  async seek(clock: number, preferStepper: boolean) {
+    await this.seekWithData(this.internalWorkspace.getSeekData(clock), preferStepper);
   }
 
-  async seekWithData(seekData: SeekData, useStepper: boolean) {
+  async seekWithData(seekData: SeekData, preferStepper: boolean) {
     if (seekData.steps.length === 0) return;
+    const forceSync = seekData.steps.length > STEPPER_HARD_THRESHOLD;
 
-    if (useStepper || config.stepOnly) {
+    if ((!forceSync && preferStepper) || config.stepOnly) {
       if (config.logTrackPlayerUpdateStep) console.log('player seek: stepping');
       // Apply updates one at a time.
       // If stepper fails for any reason, fall back to sync (unless config.stepOnly is set

src/lib/lib.ts

@@ -711,23 +711,33 @@ export function getRecorderSelectionClockRange(
   }
 }
 
-export function searchSessions(sessions: t.SessionUIListing[], searchQuery: string): t.SessionUIListing[] {
+export function searchSessions(
+  sessions: t.SessionUIListing[],
+  searchQuery: string,
+  recentLimit: number,
+): t.SessionUIListing[] {
   const searchQueryNorm = _.toLower(_.trim(searchQuery || ''));
-  if (!searchQueryNorm) return sessions;
-
   const tokens = searchQueryNorm.split(/\s+/);
 
-  let pairs = sessions.map(listing => ({
-    listing,
-    score:
-      ((getTokensMatchScore(getFields(listing.head)) *
-        (listing.publication ? listing.publication.likes * 20 + listing.publication.views : 1)) /
-        10) *
-      (listing.head.isClip ? 1 : 2),
-  }));
-  pairs = _.filter(pairs, 'score');
-  pairs = _.orderBy(pairs, 'score', 'desc');
-  return _.map(pairs, 'listing');
+  let pairs = sessions.map(listing => {
+    const matchScore = searchQueryNorm ? getTokensMatchScore(getFields(listing.head)) : 1;
+    const statsScore = (listing.publication ? listing.publication.likes * 20 + listing.publication.views : 1) / 10;
+    const clipScore = listing.head.isClip ? 1 : 2;
+    const score = matchScore * statsScore * clipScore;
+    return { listing, score };
+  });
+
+  let groupedPairs = _.groupBy(pairs, p => p.listing.group);
+  let recentPairs = groupedPairs.recent ?? [];
+  let currentPairs = groupedPairs.current ?? [];
+  let remotePairs = groupedPairs.remote ?? [];
+
+  remotePairs = _.filter(remotePairs, 'score');
+  remotePairs = _.reject(remotePairs, p => recentPairs.some(recent => recent.listing.head.id === p.listing.head.id));
+  remotePairs = _.orderBy(remotePairs, 'score', 'desc');
+  recentPairs = _.take(_.filter(recentPairs, 'score'), recentLimit);
+
+  return _.map([...recentPairs, ...currentPairs, ...remotePairs], 'listing');
 
   function getFields(head: t.SessionHead): string[] {
     return [
@@ -759,15 +769,15 @@ export function searchSessions(sessions: t.SessionUIListing[], searchQuery: stri
   }
 }
 
-export function limitRecentSessions(sessions: t.SessionUIListing[], limit: number): t.SessionUIListing[] {
-  let res = [];
-  let count = 0;
-  for (const listing of sessions) {
-    if (listing.group === 'recent') {
-      if (count >= limit) continue;
-      count++;
-    }
-    res.push(listing);
-  }
-  return res;
-}
+// export function limitRecentSessions(sessions: t.SessionUIListing[], limit: number): t.SessionUIListing[] {
+//   let res = [];
+//   let count = 0;
+//   for (const listing of sessions) {
+//     if (listing.group === 'recent') {
+//       if (count >= limit) continue;
+//       count++;
+//     }
+//     res.push(listing);
+//   }
+//   return res;
+// }

src/lib/types.ts

@@ -40,7 +40,7 @@ export type FrontendToBackendReqRes =
   | { request: { type: 'recorder/play' }; response: OKResponse }
   | { request: { type: 'recorder/record' }; response: OKResponse }
   | { request: { type: 'recorder/pause' }; response: OKResponse }
-  | { request: { type: 'recorder/seek'; clock: number; useStepper?: boolean }; response: OKResponse }
+  | { request: { type: 'recorder/seek'; clock: number; preferStepper?: boolean }; response: OKResponse }
   | { request: { type: 'recorder/syncWorkspace'; clock?: number }; response: OKResponse }
   | { request: { type: 'recorder/setPlaybackRate'; rate: number }; response: OKResponse }
   // | { request: { type: 'recorder/save' }; response: OKResponse }

src/tests/sessions.test.ts

@@ -84,7 +84,7 @@ async function testSessionSteps(sessionHandle: string, steps: SessionTestStep[])
     console.log(`===== Steps: ${label}`);
 
     // Seek if necessary.
-    await getCodeMic().handleMessage({ type: 'recorder/seek', clock: step.clock, useStepper: step.useStepper });
+    await getCodeMic().handleMessage({ type: 'recorder/seek', clock: step.clock, preferStepper: step.preferStepper });
 
     const testClockPath = path.resolve(sessionTestDataPath, `clock_${step.clockStr}`);
     const meta = deserializeTestMeta(JSON.parse(fs.readFileSync(path.resolve(testClockPath, 'meta.json'), 'utf8')));

src/tests/test-helpers.ts

@@ -12,7 +12,7 @@ import { timeout } from '../lib/lib.js';
 export type SessionTestStep = {
   clock: number;
   clockStr: string;
-  useStepper: boolean;
+  preferStepper: boolean;
 };
 
 export const projectPath = path.resolve(__dirname, '..'); // relative to dist
@@ -116,11 +116,11 @@ export function createRandomSessionTestSteps(clockStrs: string[]): SessionTestSt
     if (candidate && candidate !== resClockStrs.at(-1)) resClockStrs.push(candidate);
   }
 
-  return resClockStrs.map(clockStr => ({ clockStr, clock: Number(clockStr), useStepper: _.sample([true, false]) }));
+  return resClockStrs.map(clockStr => ({ clockStr, clock: Number(clockStr), preferStepper: _.sample([true, false]) }));
 }
 
 export function sessionTestStepToString(step: SessionTestStep): string {
-  return (step.useStepper ? 'step:' : 'sync:') + step.clockStr;
+  return (step.preferStepper ? 'step:' : 'sync:') + step.clockStr;
 }
 
 export async function closeAllTabs() {