osu-play 1.1.0 → 1.2.1

package/dist/cli.cjs

@@ -460,11 +460,9 @@ var init_mod3 = __esm(() => {
 });
 
 // src/core/cli/main.ts
-init_mod();
-var import_node_path2 = __toESM(require("node:path"));
-var import_node_child_process = require("node:child_process");
-var import_node_fs2 = require("node:fs");
-var import_node_util = require("node:util");
+var import_node_path3 = __toESM(require("node:path"));
+var import_node_fs3 = require("node:fs");
+var import_pi_tui2 = require("@mariozechner/pi-tui");
 var import_yargs = __toESM(require("yargs/yargs"));
 var import_helpers = require("yargs/helpers");
 
@@ -506,8 +504,954 @@ function buildPlaylist(beatmapSets, osuDataDir) {
   return playlist;
 }
 
+// src/core/player/mpv.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs2 = require("node:fs");
+var import_node_net = __toESM(require("node:net"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path2 = __toESM(require("node:path"));
+var import_promises = require("node:timers/promises");
+function getErrorCode(error) {
+  if (error && typeof error === "object" && "code" in error) {
+    const { code } = error;
+    return typeof code === "string" ? code : null;
+  }
+  return null;
+}
+function isRetryableSocketError(error) {
+  const code = getErrorCode(error);
+  if (code) {
+    return code === "ENOENT" || code === "ECONNREFUSED" || code === "EPERM" || code === "EACCES";
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("ENOENT") || message.includes("ECONNREFUSED") || message.includes("EPERM") || message.includes("EACCES");
+}
+function createSocketPath() {
+  const id = `osu-play-mpv-${process.pid}-${Date.now()}`;
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\${id}`;
+  }
+  return import_node_path2.default.join(import_node_os.default.tmpdir(), `${id}.sock`);
+}
+function isControlText(value) {
+  return [...value].some((character) => {
+    const code = character.charCodeAt(0);
+    return code < 32 || code === 127 || code >= 128 && code <= 159;
+  });
+}
+
+class MpvPlayerBackend {
+  name = "mpv";
+  connectPromise = null;
+  disposePromise = null;
+  disposing = false;
+  listeners = new Set;
+  pendingCommands = new Map;
+  idleActive = true;
+  process = null;
+  requestId = 0;
+  responseBuffer = "";
+  snapshot = {
+    backendName: "mpv",
+    currentPath: null,
+    durationSeconds: null,
+    errorMessage: null,
+    status: "stopped",
+    timePositionSeconds: null
+  };
+  socket = null;
+  socketPath = createSocketPath();
+  stderrBuffer = "";
+  getSnapshot() {
+    return this.snapshot;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener({
+      snapshot: this.snapshot,
+      type: "state"
+    });
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async start() {
+    if (this.socket && !this.socket.destroyed) {
+      return;
+    }
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.connectPromise = this.startInternal();
+    try {
+      await this.connectPromise;
+    } finally {
+      this.connectPromise = null;
+    }
+  }
+  async play(filePath) {
+    await this.start();
+    const previousSnapshot = this.snapshot;
+    try {
+      await this.sendCommand(["loadfile", filePath, "replace"]);
+      await this.sendCommand(["set_property", "pause", false]);
+    } catch (error) {
+      this.snapshot = previousSnapshot;
+      this.emit({
+        snapshot: this.snapshot,
+        type: "state"
+      });
+      throw error;
+    }
+    this.snapshot = {
+      ...this.snapshot,
+      currentPath: filePath,
+      errorMessage: null,
+      status: this.idleActive ? "stopped" : "playing",
+      timePositionSeconds: this.snapshot.timePositionSeconds ?? 0
+    };
+    this.emit({
+      snapshot: this.snapshot,
+      type: "state"
+    });
+  }
+  async togglePause() {
+    await this.start();
+    await this.sendCommand(["cycle", "pause"]);
+  }
+  async seekBy(seconds) {
+    await this.start();
+    await this.sendCommand(["seek", seconds, "relative"]);
+  }
+  async stop() {
+    if (!this.socket || this.socket.destroyed) {
+      return;
+    }
+    await this.sendCommand(["stop"]);
+    this.idleActive = true;
+    this.snapshot = {
+      ...this.snapshot,
+      status: "stopped",
+      timePositionSeconds: null
+    };
+    this.emit({
+      snapshot: this.snapshot,
+      type: "state"
+    });
+  }
+  async dispose() {
+    if (this.disposePromise) {
+      return this.disposePromise;
+    }
+    this.disposePromise = this.disposeInternal();
+    try {
+      await this.disposePromise;
+    } finally {
+      this.disposePromise = null;
+    }
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  async startInternal() {
+    this.cleanupSocketPath();
+    this.disposing = false;
+    this.stderrBuffer = "";
+    const processHandle = import_node_child_process.spawn("mpv", [
+      "--no-config",
+      "--no-terminal",
+      "--idle=yes",
+      "--force-window=no",
+      "--audio-display=no",
+      "--really-quiet",
+      `--input-ipc-server=${this.socketPath}`
+    ], {
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+    this.process = processHandle;
+    processHandle.stderr.setEncoding("utf8");
+    processHandle.stderr.on("data", (chunk) => {
+      this.stderrBuffer = `${this.stderrBuffer}${chunk}`.slice(-4000);
+    });
+    processHandle.once("error", (error) => {
+      this.handleError(error);
+    });
+    processHandle.once("exit", (code, signal) => {
+      if (this.disposing) {
+        return;
+      }
+      const detail = this.stderrBuffer.trim();
+      const suffix = detail ? `
+${detail}` : "";
+      this.handleError(new Error(`mpv exited unexpectedly with ${signal ? `signal ${signal}` : `code ${code}`}.${suffix}`));
+    });
+    await this.connectSocket();
+    await Promise.all([
+      this.sendCommand(["observe_property", 1, "pause"]),
+      this.sendCommand(["observe_property", 2, "time-pos"]),
+      this.sendCommand(["observe_property", 3, "duration"]),
+      this.sendCommand(["observe_property", 4, "idle-active"])
+    ]);
+  }
+  async connectSocket() {
+    const start = Date.now();
+    const timeoutMs = 5000;
+    while (Date.now() - start < timeoutMs) {
+      if (!this.process || this.process.exitCode !== null) {
+        throw new Error(this.formatStartupError("mpv exited before opening its IPC socket."));
+      }
+      try {
+        await this.attachSocket();
+        return;
+      } catch (error) {
+        if (!isRetryableSocketError(error)) {
+          throw error;
+        }
+      }
+      await import_promises.setTimeout(50);
+    }
+    throw new Error(this.formatStartupError("Timed out waiting for mpv IPC to become ready."));
+  }
+  async attachSocket() {
+    await new Promise((resolve, reject) => {
+      const socket = import_node_net.default.createConnection(this.socketPath);
+      const onError = (error) => {
+        socket.destroy();
+        reject(error);
+      };
+      socket.once("error", onError);
+      socket.once("connect", () => {
+        socket.removeListener("error", onError);
+        socket.setEncoding("utf8");
+        socket.on("data", (chunk) => {
+          this.handleSocketData(chunk);
+        });
+        socket.on("error", (error) => {
+          if (!this.disposing) {
+            this.handleError(error);
+          }
+        });
+        socket.on("close", () => {
+          if (!this.disposing) {
+            this.handleError(new Error("mpv IPC socket closed unexpectedly."));
+          }
+        });
+        this.socket = socket;
+        resolve();
+      });
+    });
+  }
+  async sendCommand(command) {
+    const socket = this.socket;
+    if (!socket || socket.destroyed) {
+      throw new Error("mpv IPC socket is not connected.");
+    }
+    const requestId = ++this.requestId;
+    return new Promise((resolve, reject) => {
+      this.pendingCommands.set(requestId, { reject, resolve });
+      socket.write(`${JSON.stringify({ command, request_id: requestId })}
+`, (error) => {
+        if (!error) {
+          return;
+        }
+        this.pendingCommands.delete(requestId);
+        reject(error);
+      });
+    });
+  }
+  handleSocketData(chunk) {
+    this.responseBuffer += chunk;
+    while (true) {
+      const newlineIndex = this.responseBuffer.indexOf(`
+`);
+      if (newlineIndex === -1) {
+        return;
+      }
+      const line = this.responseBuffer.slice(0, newlineIndex).trim();
+      this.responseBuffer = this.responseBuffer.slice(newlineIndex + 1);
+      if (!line) {
+        continue;
+      }
+      try {
+        const response = JSON.parse(line);
+        this.handleResponse(response);
+      } catch (error) {
+        this.handleError(new Error(`Failed to parse mpv IPC message: ${error instanceof Error ? error.message : String(error)}`));
+      }
+    }
+  }
+  handleResponse(response) {
+    if (typeof response.request_id === "number") {
+      const pending = this.pendingCommands.get(response.request_id);
+      if (pending) {
+        this.pendingCommands.delete(response.request_id);
+        if (response.error && response.error !== "success") {
+          pending.reject(new Error(`mpv command failed: ${response.error}`));
+        } else {
+          pending.resolve(response.data);
+        }
+      }
+      return;
+    }
+    if (response.event === "property-change") {
+      this.applyPropertyChange(response.name, response.data);
+      return;
+    }
+    if (response.event === "end-file") {
+      this.snapshot = {
+        ...this.snapshot,
+        status: "stopped",
+        timePositionSeconds: this.snapshot.durationSeconds
+      };
+      this.emit({
+        snapshot: this.snapshot,
+        type: "state"
+      });
+      this.emit({
+        reason: response.reason ?? "unknown",
+        type: "ended"
+      });
+    }
+  }
+  applyPropertyChange(name, data) {
+    switch (name) {
+      case "pause":
+        this.snapshot = {
+          ...this.snapshot,
+          status: data === true ? "paused" : this.idleActive ? "stopped" : "playing"
+        };
+        break;
+      case "time-pos":
+        this.snapshot = {
+          ...this.snapshot,
+          timePositionSeconds: typeof data === "number" ? data : null
+        };
+        break;
+      case "duration":
+        this.snapshot = {
+          ...this.snapshot,
+          durationSeconds: typeof data === "number" ? data : null
+        };
+        break;
+      case "idle-active":
+        this.idleActive = data === true;
+        this.snapshot = {
+          ...this.snapshot,
+          status: data === true ? "stopped" : this.snapshot.status === "paused" ? "paused" : "playing",
+          timePositionSeconds: data === true ? this.snapshot.durationSeconds : this.snapshot.timePositionSeconds
+        };
+        break;
+      default:
+        return;
+    }
+    this.emit({
+      snapshot: this.snapshot,
+      type: "state"
+    });
+  }
+  handleError(error) {
+    const normalizedError = error instanceof Error ? error : new Error(String(error));
+    this.snapshot = {
+      ...this.snapshot,
+      errorMessage: normalizedError.message,
+      status: "stopped"
+    };
+    this.emit({
+      error: normalizedError,
+      type: "error"
+    });
+    for (const [requestId, pending] of this.pendingCommands) {
+      this.pendingCommands.delete(requestId);
+      pending.reject(normalizedError);
+    }
+  }
+  async disposeInternal() {
+    this.disposing = true;
+    if (this.socket && !this.socket.destroyed) {
+      try {
+        await this.sendCommand(["quit"]);
+      } catch {}
+    }
+    this.socket?.destroy();
+    this.socket = null;
+    const processHandle = this.process;
+    this.process = null;
+    if (processHandle && processHandle.exitCode === null) {
+      processHandle.kill("SIGTERM");
+      await Promise.race([
+        new Promise((resolve) => {
+          processHandle.once("exit", () => resolve());
+        }),
+        import_promises.setTimeout(1000)
+      ]);
+      if (processHandle.exitCode === null) {
+        processHandle.kill("SIGKILL");
+      }
+    }
+    this.cleanupSocketPath();
+  }
+  cleanupSocketPath() {
+    if (process.platform === "win32") {
+      return;
+    }
+    if (import_node_fs2.existsSync(this.socketPath)) {
+      import_node_fs2.rmSync(this.socketPath, { force: true });
+    }
+  }
+  formatStartupError(message) {
+    const stderr = this.stderrBuffer.trim();
+    const cleanStderr = stderr && !isControlText(stderr) ? `
+${stderr}` : "";
+    return [
+      message,
+      "osu-play now expects `mpv` to be installed and available on PATH for TUI playback.",
+      cleanStderr
+    ].filter(Boolean).join(`
+`);
+  }
+}
+// src/core/player/session.ts
+function clampIndex(index, length) {
+  if (length <= 0) {
+    return 0;
+  }
+  return Math.max(0, Math.min(index, length - 1));
+}
+function wrapIndex(index, length) {
+  if (length <= 0) {
+    return 0;
+  }
+  return (index % length + length) % length;
+}
+function normalizeSearchText(text) {
+  return text.trim().toLowerCase();
+}
+function findTrackIndexByQuery(playlist, query) {
+  const normalizedQuery = normalizeSearchText(query);
+  if (!normalizedQuery) {
+    return -1;
+  }
+  return playlist.findIndex((track) => normalizeSearchText(track.title).includes(normalizedQuery));
+}
+
+class PlaylistPlayerSession {
+  backend;
+  listeners = new Set;
+  currentIndex = null;
+  errorMessage = null;
+  loop;
+  playlist;
+  searchQuery = "";
+  selectedIndex = 0;
+  unsubscribeBackend;
+  constructor(playlist, backend, options = {}) {
+    this.backend = backend;
+    this.playlist = playlist;
+    this.loop = options.loop ?? false;
+    this.unsubscribeBackend = backend.subscribe((event) => {
+      this.handleBackendEvent(event);
+    });
+  }
+  getSnapshot() {
+    const backendSnapshot = this.backend.getSnapshot();
+    const currentTrack = this.currentIndex !== null ? this.playlist[this.currentIndex] ?? null : null;
+    return {
+      backendName: backendSnapshot.backendName,
+      currentIndex: this.currentIndex,
+      currentTrack,
+      durationSeconds: backendSnapshot.durationSeconds,
+      errorMessage: this.errorMessage ?? backendSnapshot.errorMessage,
+      loop: this.loop,
+      playlist: this.playlist,
+      searchQuery: this.searchQuery,
+      selectedIndex: this.selectedIndex,
+      status: backendSnapshot.status,
+      timePositionSeconds: backendSnapshot.timePositionSeconds
+    };
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.getSnapshot());
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async start() {
+    await this.backend.start();
+    this.emit();
+  }
+  async dispose() {
+    this.unsubscribeBackend();
+    await this.backend.dispose();
+  }
+  moveSelection(delta) {
+    if (this.playlist.length === 0) {
+      return;
+    }
+    this.selectedIndex = wrapIndex(this.selectedIndex + delta, this.playlist.length);
+    this.emit();
+  }
+  moveSelectionPage(delta, pageSize) {
+    this.moveSelection(delta * Math.max(1, pageSize));
+  }
+  selectHome() {
+    if (this.playlist.length === 0) {
+      return;
+    }
+    this.selectedIndex = 0;
+    this.emit();
+  }
+  selectEnd() {
+    if (this.playlist.length === 0) {
+      return;
+    }
+    this.selectedIndex = this.playlist.length - 1;
+    this.emit();
+  }
+  setSelectionIndex(index) {
+    if (this.playlist.length === 0) {
+      return;
+    }
+    this.selectedIndex = clampIndex(index, this.playlist.length);
+    this.emit();
+  }
+  toggleLoop() {
+    this.loop = !this.loop;
+    this.emit();
+  }
+  appendSearchQuery(text) {
+    if (!text) {
+      return;
+    }
+    this.searchQuery += text;
+    this.syncSelectionToSearch();
+  }
+  deleteSearchCharacter() {
+    if (!this.searchQuery) {
+      return;
+    }
+    this.searchQuery = this.searchQuery.slice(0, -1);
+    this.syncSelectionToSearch();
+  }
+  clearSearch() {
+    if (!this.searchQuery) {
+      return;
+    }
+    this.searchQuery = "";
+    this.emit();
+  }
+  async playSelected() {
+    await this.playIndex(this.selectedIndex);
+  }
+  async playNext() {
+    const nextIndex = this.getAdjacentIndex(1);
+    if (nextIndex === null) {
+      return;
+    }
+    await this.playIndex(nextIndex);
+  }
+  async playPrevious() {
+    const previousIndex = this.getAdjacentIndex(-1);
+    if (previousIndex === null) {
+      return;
+    }
+    await this.playIndex(previousIndex);
+  }
+  async togglePause() {
+    if (this.playlist.length === 0) {
+      return;
+    }
+    const { status } = this.backend.getSnapshot();
+    if (status === "stopped") {
+      const restartIndex = this.currentIndex ?? this.selectedIndex;
+      await this.playIndex(restartIndex);
+      return;
+    }
+    try {
+      this.clearError();
+      await this.backend.togglePause();
+    } catch (error) {
+      this.reportError(error);
+    }
+  }
+  async seekBy(seconds) {
+    if (seconds === 0) {
+      return;
+    }
+    const { status } = this.backend.getSnapshot();
+    if (status === "stopped") {
+      return;
+    }
+    try {
+      this.clearError();
+      await this.backend.seekBy(seconds);
+    } catch (error) {
+      this.reportError(error);
+    }
+  }
+  async stop() {
+    try {
+      this.clearError();
+      await this.backend.stop();
+    } catch (error) {
+      this.reportError(error);
+    }
+  }
+  reportError(error) {
+    this.errorMessage = error instanceof Error ? error.message : String(error);
+    this.emit();
+  }
+  clearError() {
+    if (this.errorMessage === null) {
+      return;
+    }
+    this.errorMessage = null;
+  }
+  emit() {
+    const snapshot = this.getSnapshot();
+    for (const listener of this.listeners) {
+      listener(snapshot);
+    }
+  }
+  async playIndex(index) {
+    const track = this.playlist[index];
+    if (!track) {
+      return;
+    }
+    const previousIndex = this.currentIndex;
+    this.currentIndex = index;
+    try {
+      this.clearError();
+      await this.backend.play(track.path);
+    } catch (error) {
+      this.currentIndex = previousIndex;
+      this.reportError(error);
+      return;
+    }
+    this.emit();
+  }
+  getAdjacentIndex(delta) {
+    if (this.playlist.length === 0) {
+      return null;
+    }
+    const baseIndex = this.currentIndex ?? this.selectedIndex;
+    const nextIndex = baseIndex + delta;
+    if (nextIndex < 0) {
+      return this.loop ? this.playlist.length - 1 : null;
+    }
+    if (nextIndex >= this.playlist.length) {
+      return this.loop ? 0 : null;
+    }
+    return nextIndex;
+  }
+  async handleBackendEvent(event) {
+    switch (event.type) {
+      case "state":
+        this.emit();
+        return;
+      case "error":
+        this.reportError(event.error);
+        return;
+      case "ended":
+        if (event.reason === "eof") {
+          const nextIndex = this.getAdjacentIndex(1);
+          if (nextIndex !== null) {
+            await this.playIndex(nextIndex);
+            return;
+          }
+        }
+        this.emit();
+    }
+  }
+  syncSelectionToSearch() {
+    const matchedIndex = findTrackIndexByQuery(this.playlist, this.searchQuery);
+    if (matchedIndex !== -1) {
+      this.selectedIndex = matchedIndex;
+    }
+    this.emit();
+  }
+}
+// src/core/tui/player-screen.ts
+var import_pi_tui = require("@mariozechner/pi-tui");
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+var RED = "\x1B[31m";
+var CYAN = "\x1B[36m";
+var INVERSE = "\x1B[7m";
+var MIN_LIST_ROWS = 4;
+var RESERVED_ROWS = 6;
+var PAGE_SIZE = 10;
+var PENDING_G_TIMEOUT_MS = 400;
+var SEEK_SECONDS = 5;
+function style(text, code) {
+  return `${code}${text}${RESET}`;
+}
+function padIndex(index, total) {
+  const width = String(Math.max(total, 1)).length;
+  return String(index + 1).padStart(width, " ");
+}
+function formatSeconds(seconds) {
+  if (seconds === null || Number.isNaN(seconds)) {
+    return "--:--";
+  }
+  const rounded = Math.max(0, Math.floor(seconds));
+  const minutes = Math.floor(rounded / 60);
+  const remainingSeconds = rounded % 60;
+  return `${String(minutes).padStart(2, "0")}:${String(remainingSeconds).padStart(2, "0")}`;
+}
+function decodePrintableText(data) {
+  const kittyPrintable = import_pi_tui.decodeKittyPrintable(data);
+  if (kittyPrintable !== undefined) {
+    return kittyPrintable;
+  }
+  const hasControlChars = [...data].some((character) => {
+    const code = character.charCodeAt(0);
+    return code < 32 || code === 127 || code >= 128 && code <= 159;
+  });
+  return hasControlChars ? undefined : data;
+}
+function getVisibleTrackRange(selectedIndex, totalTracks, maxVisible) {
+  if (totalTracks <= 0 || maxVisible <= 0) {
+    return { end: 0, start: 0 };
+  }
+  const clampedSelectedIndex = Math.max(0, Math.min(selectedIndex, totalTracks - 1));
+  const start = Math.max(0, Math.min(clampedSelectedIndex - Math.floor(maxVisible / 2), totalTracks - maxVisible));
+  return {
+    end: Math.min(totalTracks, start + maxVisible),
+    start
+  };
+}
+
+class PlaylistPlayerScreen {
+  session;
+  getViewportHeight;
+  pendingGoToTop = false;
+  pendingGoToTopTimer = null;
+  searchMode = false;
+  snapshot;
+  onQuit;
+  constructor(session, getViewportHeight) {
+    this.session = session;
+    this.getViewportHeight = getViewportHeight;
+    this.snapshot = session.getSnapshot();
+  }
+  setSnapshot(snapshot) {
+    this.snapshot = snapshot;
+  }
+  invalidate() {}
+  handleInput(data) {
+    if (this.searchMode) {
+      this.handleSearchInput(data);
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.slash)) {
+      this.searchMode = true;
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, "g")) {
+      if (this.pendingGoToTop) {
+        this.clearPendingGoToTop();
+        this.session.selectHome();
+      } else {
+        this.armPendingGoToTop();
+      }
+      return;
+    }
+    this.clearPendingGoToTop();
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.ctrl("c")) || import_pi_tui.matchesKey(data, "q")) {
+      this.onQuit?.();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.up) || import_pi_tui.matchesKey(data, "k")) {
+      this.session.moveSelection(-1);
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.down) || import_pi_tui.matchesKey(data, "j")) {
+      this.session.moveSelection(1);
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.left) || import_pi_tui.matchesKey(data, "h")) {
+      this.session.seekBy(-SEEK_SECONDS);
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.right) || import_pi_tui.matchesKey(data, "l")) {
+      this.session.seekBy(SEEK_SECONDS);
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.pageUp) || import_pi_tui.matchesKey(data, import_pi_tui.Key.ctrl("u")) || import_pi_tui.matchesKey(data, import_pi_tui.Key.ctrl("b"))) {
+      this.session.moveSelectionPage(-1, PAGE_SIZE);
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.pageDown) || import_pi_tui.matchesKey(data, import_pi_tui.Key.ctrl("d")) || import_pi_tui.matchesKey(data, import_pi_tui.Key.ctrl("f"))) {
+      this.session.moveSelectionPage(1, PAGE_SIZE);
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.home) || import_pi_tui.matchesKey(data, "0")) {
+      this.session.selectHome();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.end) || import_pi_tui.matchesKey(data, import_pi_tui.Key.shift("g"))) {
+      this.session.selectEnd();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.shift("h"))) {
+      this.moveSelectionToVisibleAnchor("top");
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.shift("m"))) {
+      this.moveSelectionToVisibleAnchor("middle");
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.shift("l"))) {
+      this.moveSelectionToVisibleAnchor("bottom");
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.enter)) {
+      this.session.playSelected();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.space)) {
+      this.session.togglePause();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, "n")) {
+      this.session.playNext();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, "p")) {
+      this.session.playPrevious();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, "s")) {
+      this.session.stop();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, "r")) {
+      this.session.toggleLoop();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.backspace)) {
+      this.session.deleteSearchCharacter();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.escape)) {
+      this.session.clearSearch();
+      return;
+    }
+  }
+  render(width) {
+    const { playlist } = this.snapshot;
+    const viewportHeight = Math.max(this.getViewportHeight(), RESERVED_ROWS);
+    const listHeight = this.getListHeight(viewportHeight);
+    const { start, end } = getVisibleTrackRange(this.snapshot.selectedIndex, playlist.length, listHeight);
+    const lines = [
+      import_pi_tui.truncateToWidth(`osu-play | tracks ${playlist.length} | backend ${this.snapshot.backendName} | loop ${this.snapshot.loop ? "on" : "off"}`, width),
+      import_pi_tui.truncateToWidth(style(`now ${this.snapshot.status}: ${this.snapshot.currentTrack?.title ?? "nothing selected"}`, CYAN), width),
+      import_pi_tui.truncateToWidth(style(`${formatSeconds(this.snapshot.timePositionSeconds)} / ${formatSeconds(this.snapshot.durationSeconds)} | selected ${this.snapshot.selectedIndex + 1}/${Math.max(playlist.length, 1)}${this.snapshot.searchQuery ? ` | search "${this.snapshot.searchQuery}"${this.searchMode ? " [input]" : ""}` : this.searchMode ? " | search [input]" : ""}`, DIM), width)
+    ];
+    if (this.snapshot.errorMessage) {
+      lines.push(import_pi_tui.truncateToWidth(style(`error: ${this.snapshot.errorMessage}`, RED), width));
+    } else {
+      lines.push("");
+    }
+    if (playlist.length === 0) {
+      lines.push(import_pi_tui.truncateToWidth("No tracks were found in your osu!lazer library.", width));
+    } else {
+      for (let index = start;index < end; index += 1) {
+        const track = playlist[index];
+        if (!track) {
+          continue;
+        }
+        const isCurrent = index === this.snapshot.currentIndex;
+        const isSelected = index === this.snapshot.selectedIndex;
+        const prefix = `${isSelected ? ">" : " "} ${isCurrent ? "*" : " "} `;
+        const line = `${prefix}${padIndex(index, playlist.length)}. ${track.title}`;
+        lines.push(import_pi_tui.truncateToWidth(isSelected ? style(line, INVERSE) : line, width));
+      }
+    }
+    while (lines.length < viewportHeight - 1) {
+      lines.push("");
+    }
+    lines.push(import_pi_tui.truncateToWidth(style(this.searchMode ? "/ search | type to jump | backspace edit | enter keep | esc leave" : "h/l seek | j/k wrap | gg/G bounds | C-u/C-d page | H/M/L viewport | n/p track | r loop | / search", DIM), width));
+    return lines;
+  }
+  armPendingGoToTop() {
+    this.pendingGoToTop = true;
+    this.pendingGoToTopTimer = setTimeout(() => {
+      this.pendingGoToTop = false;
+      this.pendingGoToTopTimer = null;
+    }, PENDING_G_TIMEOUT_MS);
+  }
+  clearPendingGoToTop() {
+    if (this.pendingGoToTopTimer) {
+      clearTimeout(this.pendingGoToTopTimer);
+      this.pendingGoToTopTimer = null;
+    }
+    this.pendingGoToTop = false;
+  }
+  handleSearchInput(data) {
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.ctrl("c"))) {
+      this.onQuit?.();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.enter)) {
+      this.searchMode = false;
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.escape)) {
+      this.searchMode = false;
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.backspace)) {
+      this.session.deleteSearchCharacter();
+      return;
+    }
+    if (import_pi_tui.matchesKey(data, import_pi_tui.Key.ctrl("u"))) {
+      this.session.clearSearch();
+      return;
+    }
+    const printable = decodePrintableText(data);
+    if (!printable || printable === " ") {
+      return;
+    }
+    this.session.appendSearchQuery(printable);
+  }
+  getListHeight(viewportHeight) {
+    return Math.max(MIN_LIST_ROWS, viewportHeight - RESERVED_ROWS);
+  }
+  moveSelectionToVisibleAnchor(anchor) {
+    if (this.snapshot.playlist.length === 0) {
+      return;
+    }
+    const { start, end } = getVisibleTrackRange(this.snapshot.selectedIndex, this.snapshot.playlist.length, this.getListHeight(Math.max(this.getViewportHeight(), RESERVED_ROWS)));
+    const lastVisibleIndex = Math.max(start, end - 1);
+    switch (anchor) {
+      case "top":
+        this.session.setSelectionIndex(start);
+        return;
+      case "middle":
+        this.session.setSelectionIndex(start + Math.floor((lastVisibleIndex - start) / 2));
+        return;
+      case "bottom":
+        this.session.setSelectionIndex(lastVisibleIndex);
+    }
+  }
+}
+
 // src/core/cli/main.ts
-var execFilePromise = import_node_util.promisify(import_node_child_process.execFile);
+init_mod();
+function formatRealmLoadError(error) {
+  return [
+    "Realm native bindings could not be loaded.",
+    `Current Node runtime: ${process.version}.`,
+    "To repair Realm bindings in this project, run `bun run repair:realm` (or `bun run setup` to reinstall dependencies).",
+    "If you installed dependencies on Node 22, switch to Node 20 LTS and rerun the repair command.",
+    `Original error: ${error instanceof Error ? error.message : String(error)}`
+  ].join(`
+`);
+}
 async function loadRealmDependencies() {
   try {
     const [{ default: Realm8 }, lazerModule] = await Promise.all([
@@ -519,18 +1463,11 @@ async function loadRealmDependencies() {
       ...lazerModule
     };
   } catch (error) {
-    throw new Error([
-      "Realm native bindings could not be loaded.",
-      `Current Node runtime: ${process.version}.`,
-      "To repair Realm bindings in this project, run `bun run repair:realm` (or `bun run setup` to reinstall dependencies).",
-      "If you installed dependencies on Node 22, switch to Node 20 LTS and rerun the repair command.",
-      `Original error: ${error instanceof Error ? error.message : String(error)}`
-    ].join(`
-`), { cause: error });
+    throw new Error(formatRealmLoadError(error), { cause: error });
   }
 }
 function getArgs() {
-  return import_yargs.default(import_helpers.hideBin(process.argv)).scriptName("osu-play").usage(`Play music from your osu!lazer beatmaps from the terminal
+  return import_yargs.default(import_helpers.hideBin(process.argv)).scriptName("osu-play").usage(`Play music from your osu!lazer beatmaps in a minimal terminal player
 Usage: $0 [options]`).option("reload", {
     type: "boolean",
     default: false,
@@ -538,7 +1475,7 @@ Usage: $0 [options]`).option("reload", {
     describe: "Deprecated: ignored. osu-play now reads the live lazer database directly"
   }).option("exportPlaylist", {
     type: "string",
-    describe: "Export playlist to a file"
+    describe: "Export playlist to a file instead of launching the player"
   }).option("osuDataDir", {
     type: "string",
     default: getDefaultOsuDataDir(),
@@ -552,55 +1489,16 @@ Usage: $0 [options]`).option("reload", {
     type: "boolean",
     default: false,
     alias: "l",
-    describe: "Loop the playlist on end"
+    describe: "Loop the playlist when playback reaches the end"
   }).alias("help", "h").help().parse();
 }
-async function promptForBeatmap(uniqueBeatmaps) {
-  const { default: prompts } = await import("prompts");
-  const response = await prompts({
-    type: "autocomplete",
-    name: "beatmap",
-    message: "Which map do you want to play:",
-    choices: uniqueBeatmaps.map((beatmap, index) => ({
-      title: beatmap.title,
-      value: index
-    }))
-  });
-  return response.beatmap;
-}
-async function openBeatmap(filePath) {
-  switch (process.platform) {
-    case "darwin":
-      await execFilePromise("open", [filePath]);
-      return;
-    case "win32":
-      await execFilePromise("cmd", ["/c", "start", "", filePath]);
-      return;
-    default:
-      await execFilePromise("xdg-open", [filePath]);
-  }
-}
-async function main() {
-  const argv = await getArgs();
-  console.log("[INFO] osu-play");
-  if (argv.reload) {
-    console.log("[INFO] `--reload` is deprecated and ignored because osu-play reads osu!lazer's live Realm DB directly.");
-  }
-  if (argv.configDir) {
-    console.log("[INFO] `--configDir` is deprecated and ignored because osu-play no longer copies the Realm DB.");
-  }
-  if (argv.osuDataDir !== getDefaultOsuDataDir()) {
-    console.log(`[INFO] Using osu!lazer data directory: ${argv.osuDataDir}`);
-  }
-  const realmDBPath = getRealmDBPath({
-    osuDataDir: argv.osuDataDir
-  });
+async function createPlaylist(osuDataDir) {
+  const realmDBPath = getRealmDBPath({ osuDataDir });
   if (!realmDBPath) {
     throw new Error("Realm DB not found");
   }
   const {
     Realm: Realm8,
-    LAST_STATIC_LAZER_SCHEMA_VERSION: LAST_STATIC_LAZER_SCHEMA_VERSION2,
     formatLazerSchemaCompatibilityError: formatLazerSchemaCompatibilityError2,
     getBeatmapSets: getBeatmapSets2,
     getLazerDB: getLazerDB2,
@@ -610,55 +1508,65 @@ async function main() {
   const realm = await getLazerDB2(realmDBPath);
   try {
     const schemaReport = inspectLazerSchema2(realm);
-    console.log(`currentSchema: ${schemaReport.version}`);
     if (!schemaReport.compatible) {
       throw new Error(formatLazerSchemaCompatibilityError2(schemaReport));
     }
-    if (schemaReport.version !== LAST_STATIC_LAZER_SCHEMA_VERSION2) {
-      console.log(`[INFO] Detected osu!lazer schema version ${schemaReport.version}; continuing with reflected compatibility checks.`);
-    }
-    const beatmapSets = getBeatmapSets2(realm);
-    const uniqueBeatmaps = buildPlaylist(beatmapSets, argv.osuDataDir);
-    console.log(`beatmap songs: ${uniqueBeatmaps.length}`);
-    if (argv.exportPlaylist) {
-      console.log(`[INFO] Exporting playlist to ${argv.exportPlaylist}`);
-      const playlist = uniqueBeatmaps.map((beatmap) => beatmap.path).join(`
-`);
-      import_node_fs2.writeFileSync(argv.exportPlaylist, playlist);
-      console.log(`[INFO] Done. Use something like \`mpv --playlist=${import_node_path2.default.resolve(argv.exportPlaylist)}\` to play the playlist`);
-      return;
-    }
-    const selectedBeatmap = await promptForBeatmap(uniqueBeatmaps);
-    if (selectedBeatmap === undefined) {
-      console.log("[INFO] Cancelled");
-      return;
-    }
-    console.log(`Selected: ${selectedBeatmap}`);
-    for (let i = selectedBeatmap;i < uniqueBeatmaps.length; i += 1) {
-      const beatmap = uniqueBeatmaps[i];
-      if (!beatmap) {
-        continue;
-      }
-      console.log(`Map: ${beatmap.title}`);
-      if (beatmap.path && import_node_fs2.existsSync(beatmap.path)) {
-        console.log(`Playing ${beatmap.title}`);
-        await openBeatmap(beatmap.path);
-      } else {
-        console.log(`File does not exist: ${beatmap.path}`);
-      }
-      if (i < uniqueBeatmaps.length - 1) {
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-      } else if (argv.loop) {
-        console.log("[INFO] Looping playlist");
-        i = -1;
-      } else {
-        console.log("[INFO] Done. Use --loop to loop the playlist");
-      }
-    }
+    return buildPlaylist(getBeatmapSets2(realm), osuDataDir);
   } finally {
     realm.close();
   }
 }
+async function runTuiPlayer(playlist, loop) {
+  const backend = new MpvPlayerBackend;
+  const session = new PlaylistPlayerSession(playlist, backend, { loop });
+  const terminal = new import_pi_tui2.ProcessTerminal;
+  const tui = new import_pi_tui2.TUI(terminal);
+  const screen = new PlaylistPlayerScreen(session, () => terminal.rows);
+  let started = false;
+  const exitPromise = new Promise((resolve) => {
+    screen.onQuit = () => resolve();
+  });
+  const unsubscribe = session.subscribe((snapshot) => {
+    screen.setSnapshot(snapshot);
+    if (started) {
+      tui.requestRender();
+    }
+  });
+  try {
+    await session.start();
+    tui.addChild(screen);
+    tui.setFocus(screen);
+    tui.start();
+    started = true;
+    await exitPromise;
+  } finally {
+    unsubscribe();
+    if (started) {
+      await terminal.drainInput().catch(() => {});
+      tui.stop();
+    }
+    await session.dispose();
+  }
+}
+async function main() {
+  const argv = await getArgs();
+  if (argv.reload) {
+    console.log("[INFO] `--reload` is deprecated and ignored because osu-play reads osu!lazer's live Realm DB directly.");
+  }
+  if (argv.configDir) {
+    console.log("[INFO] `--configDir` is deprecated and ignored because osu-play no longer copies the Realm DB.");
+  }
+  const playlist = await createPlaylist(argv.osuDataDir);
+  if (argv.exportPlaylist) {
+    const playlistContents = playlist.map((track) => track.path).join(`
+`);
+    import_node_fs3.writeFileSync(argv.exportPlaylist, playlistContents);
+    console.log(`[INFO] Exported ${playlist.length} tracks to ${argv.exportPlaylist}.`);
+    console.log(`[INFO] Use something like \`mpv --playlist=${import_node_path3.default.resolve(argv.exportPlaylist)}\` to play the playlist.`);
+    return;
+  }
+  await runTuiPlayer(playlist, argv.loop);
+}
 
 // src/cli.ts
 main().then(() => {
@@ -668,4 +1576,4 @@ main().then(() => {
   process.exit(1);
 });
 
-//# debugId=6FDBB7EDEE4CC0EA64756E2164756E21
+//# debugId=092198B3F20C100364756E2164756E21