osu-play 1.0.7 → 1.2.0

package/dist/cli.js

@@ -0,0 +1,1569 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/core/utils/mod.ts
+import path from "node:path";
+import { existsSync } from "node:fs";
+function getDataDir() {
+  switch (process.platform) {
+    case "linux":
+    case "openbsd":
+    case "freebsd": {
+      const xdg = process.env.XDG_DATA_HOME;
+      if (xdg)
+        return xdg;
+      const home = process.env.HOME;
+      if (home)
+        return path.join(home, ".local", "share");
+      break;
+    }
+    case "darwin": {
+      const home = process.env.HOME;
+      if (home)
+        return path.join(home, "Library", "Application Support");
+      break;
+    }
+    case "win32":
+      return process.env.LOCALAPPDATA ?? undefined;
+  }
+  return;
+}
+function getConfigDir() {
+  switch (process.platform) {
+    case "openbsd":
+    case "freebsd":
+    case "linux": {
+      const xdg = process.env.XDG_CONFIG_HOME;
+      if (xdg)
+        return xdg;
+      const home = process.env.HOME;
+      if (home)
+        return path.join(home, ".config");
+      break;
+    }
+    case "darwin": {
+      const home = process.env.HOME;
+      if (home)
+        return path.join(home, "Library", "Preferences");
+      break;
+    }
+    case "win32":
+      return process.env.APPDATA ?? undefined;
+  }
+  return;
+}
+function getDefaultOsuDataDir() {
+  return path.join(getDataDir() ?? ".", "osu");
+}
+function getDefaultConfigPath(appName = "osu-play") {
+  return path.join(getConfigDir() ?? ".", appName);
+}
+function hashedFilePath(hash, osuDataDir = getDefaultOsuDataDir()) {
+  return path.join(osuDataDir, "files", hash.slice(0, 1), hash.slice(0, 2), hash);
+}
+function getRealmDBPath(legacyAppConfigDirOrOptions = {}, maybeOptions = {}) {
+  const options = typeof legacyAppConfigDirOrOptions === "string" ? maybeOptions : legacyAppConfigDirOrOptions;
+  const osuDataDir = options.osuDataDir ?? getDefaultOsuDataDir();
+  const osuDBPath = path.join(osuDataDir, "client.realm");
+  if (!existsSync(osuDBPath)) {
+    console.log(`[getRealmDBPath]: ${osuDBPath} not found`);
+    return null;
+  }
+  return osuDBPath;
+}
+var init_mod = () => {};
+
+// src/core/lazer/compat.ts
+function describeRequirement(requirement) {
+  if (requirement.type === "object" || requirement.type === "list") {
+    return `${requirement.type}:${requirement.objectType ?? "unknown"}`;
+  }
+  return requirement.type ?? "unknown";
+}
+function describeProperty(property) {
+  if (!property?.type) {
+    return "missing";
+  }
+  if (property.type === "object" || property.type === "list") {
+    return `${property.type}:${property.objectType ?? "unknown"}`;
+  }
+  return property.type;
+}
+function inspectLazerSchemaEntries(schemaEntries, version) {
+  const schemaByName = new Map(schemaEntries.map((entry) => [entry.name, entry]));
+  const missingObjects = [];
+  const issues = [];
+  for (const [objectName, requirements] of Object.entries(REQUIRED_PLAYLIST_SCHEMA)) {
+    const schemaEntry = schemaByName.get(objectName);
+    if (!schemaEntry) {
+      missingObjects.push(objectName);
+      continue;
+    }
+    for (const [propertyName, requirement] of Object.entries(requirements)) {
+      const property = schemaEntry.properties[propertyName];
+      const typeMatches = !requirement.type || property?.type === requirement.type;
+      const objectTypeMatches = !requirement.objectType || property?.objectType === requirement.objectType;
+      if (!typeMatches || !objectTypeMatches) {
+        issues.push({
+          objectName,
+          propertyName,
+          expected: describeRequirement(requirement),
+          actual: describeProperty(property)
+        });
+      }
+    }
+  }
+  return {
+    compatible: missingObjects.length === 0 && issues.length === 0,
+    version,
+    missingObjects,
+    issues
+  };
+}
+function formatLazerSchemaCompatibilityError(report) {
+  const details = [
+    `Detected osu!lazer schema version ${report.version}, but the playlist reader is missing fields it needs.`
+  ];
+  if (report.missingObjects.length > 0) {
+    details.push(`Missing objects: ${report.missingObjects.join(", ")}`);
+  }
+  if (report.issues.length > 0) {
+    details.push(`Mismatched properties: ${report.issues.map((issue) => `${issue.objectName}.${issue.propertyName} expected ${issue.expected}, got ${issue.actual}`).join("; ")}`);
+  }
+  details.push("This app now reflects the live lazer schema and only depends on a small playlist-safe subset, so version bumps are fine until those required fields change.");
+  return details.join(`
+`);
+}
+var LAST_STATIC_LAZER_SCHEMA_VERSION = 46, REQUIRED_PLAYLIST_SCHEMA;
+var init_compat = __esm(() => {
+  REQUIRED_PLAYLIST_SCHEMA = {
+    BeatmapSet: {
+      Beatmaps: { type: "list", objectType: "Beatmap" },
+      Files: { type: "list", objectType: "RealmNamedFileUsage" }
+    },
+    Beatmap: {
+      Metadata: { type: "object", objectType: "BeatmapMetadata" }
+    },
+    BeatmapMetadata: {
+      AudioFile: { type: "string" },
+      Title: { type: "string" },
+      Artist: { type: "string" },
+      TitleUnicode: { type: "string" },
+      ArtistUnicode: { type: "string" }
+    },
+    RealmNamedFileUsage: {
+      File: { type: "object", objectType: "File" },
+      Filename: { type: "string" }
+    },
+    File: {
+      Hash: { type: "string" }
+    }
+  };
+});
+
+// src/core/lazer/schema/beatmap.ts
+import Realm from "realm";
+var Beatmap;
+var init_beatmap = __esm(() => {
+  Beatmap = class Beatmap extends Realm.Object {
+    ID;
+    DifficultyName;
+    Metadata;
+    BeatmapSet;
+    Status;
+    OnlineID;
+    Length;
+    BPM;
+    Hash;
+    StarRating;
+    MD5Hash;
+    OnlineMD5Hash;
+    LastLocalUpdate;
+    LastOnlineUpdate;
+    Hidden;
+    AudioLeadIn;
+    StackLeniency;
+    SpecialStyle;
+    LetterboxInBreaks;
+    WidescreenStoryboard;
+    EpilepsyWarning;
+    SamplesMatchPlaybackRate;
+    LastPlayed;
+    DistanceSpacing;
+    BeatDivisor;
+    GridSize;
+    TimelineZoom;
+    EditorTimestamp;
+    CountdownOffset;
+    static schema = {
+      name: "Beatmap",
+      primaryKey: "ID",
+      properties: {
+        ID: { type: "uuid", default: "" },
+        DifficultyName: { type: "string", default: "", optional: true },
+        Metadata: {
+          type: "object",
+          objectType: "BeatmapMetadata",
+          default: null
+        },
+        BeatmapSet: { type: "object", objectType: "BeatmapSet", default: null },
+        Status: { type: "int", default: -3 },
+        OnlineID: { type: "int", default: -1 },
+        Length: { type: "double", default: 0 },
+        BPM: { type: "double", default: 0 },
+        Hash: { type: "string", default: "", optional: true },
+        StarRating: { type: "double", default: -1 },
+        MD5Hash: { type: "string", default: "", optional: true },
+        OnlineMD5Hash: { type: "string", default: "", optional: true },
+        LastLocalUpdate: { type: "date", optional: true },
+        LastOnlineUpdate: { type: "date", optional: true },
+        Hidden: { type: "bool", default: false },
+        AudioLeadIn: { type: "double", default: 0 },
+        StackLeniency: { type: "float", default: 0.7 },
+        SpecialStyle: { type: "bool", default: false },
+        LetterboxInBreaks: { type: "bool", default: false },
+        WidescreenStoryboard: { type: "bool", default: false },
+        EpilepsyWarning: { type: "bool", default: false },
+        SamplesMatchPlaybackRate: { type: "bool", default: false },
+        LastPlayed: { type: "date", optional: true },
+        DistanceSpacing: { type: "double", default: 0 },
+        BeatDivisor: { type: "int", default: 0 },
+        GridSize: { type: "int", default: 0 },
+        TimelineZoom: { type: "double", default: 0 },
+        EditorTimestamp: { type: "double", optional: true },
+        CountdownOffset: { type: "int", default: 0 }
+      }
+    };
+  };
+});
+
+// src/core/lazer/schema/beatmapMetadata.ts
+import Realm2 from "realm";
+var BeatmapMetadata;
+var init_beatmapMetadata = __esm(() => {
+  BeatmapMetadata = class BeatmapMetadata extends Realm2.Object {
+    Title;
+    TitleUnicode;
+    Artist;
+    ArtistUnicode;
+    Author;
+    Source;
+    Tags;
+    PreviewTime;
+    AudioFile;
+    BackgroundFile;
+    static schema = {
+      name: "BeatmapMetadata",
+      properties: {
+        Title: { type: "string", default: "", optional: true },
+        TitleUnicode: { type: "string", default: "", optional: true },
+        Artist: { type: "string", default: "", optional: true },
+        ArtistUnicode: { type: "string", default: "", optional: true },
+        Author: { type: "object", objectType: "RealmUser", default: null },
+        Source: { type: "string", default: "", optional: true },
+        Tags: { type: "string", default: "", optional: true },
+        PreviewTime: { type: "int", default: 0 },
+        AudioFile: { type: "string", default: "", optional: true },
+        BackgroundFile: { type: "string", default: "", optional: true }
+      }
+    };
+  };
+});
+
+// src/core/lazer/schema/beatmapSet.ts
+import Realm3 from "realm";
+var BeatmapSet;
+var init_beatmapSet = __esm(() => {
+  BeatmapSet = class BeatmapSet extends Realm3.Object {
+    ID;
+    OnlineID;
+    DateAdded;
+    DateSubmitted;
+    DateRanked;
+    Beatmaps;
+    Files;
+    Status;
+    DeletePending;
+    Hash;
+    Protected;
+    static schema = {
+      name: "BeatmapSet",
+      primaryKey: "ID",
+      properties: {
+        ID: { type: "uuid", default: "" },
+        OnlineID: { type: "int", default: -1 },
+        DateAdded: { type: "date" },
+        DateSubmitted: { type: "date", optional: true },
+        DateRanked: { type: "date", optional: true },
+        Beatmaps: { type: "list", objectType: "Beatmap", default: [] },
+        Files: { type: "list", objectType: "RealmNamedFileUsage", default: [] },
+        Status: { type: "int", default: -3 },
+        DeletePending: { type: "bool", default: false },
+        Hash: { type: "string", default: "", optional: true },
+        Protected: { type: "bool", default: false }
+      }
+    };
+  };
+});
+
+// src/core/lazer/schema/realmFile.ts
+import Realm4 from "realm";
+var RealmFile;
+var init_realmFile = __esm(() => {
+  RealmFile = class RealmFile extends Realm4.Object {
+    Hash;
+    static schema = {
+      name: "File",
+      primaryKey: "Hash",
+      properties: {
+        Hash: { type: "string", default: "", optional: true }
+      }
+    };
+  };
+});
+
+// src/core/lazer/schema/realmUser.ts
+import Realm5 from "realm";
+var RealmUser;
+var init_realmUser = __esm(() => {
+  RealmUser = class RealmUser extends Realm5.Object {
+    OnlineID;
+    Username;
+    CountryCode;
+    static embedded = true;
+    static schema = {
+      name: "RealmUser",
+      embedded: true,
+      properties: {
+        OnlineID: { type: "int", default: 1 },
+        Username: { type: "string", default: "", optional: true },
+        CountryCode: { type: "string", optional: true }
+      }
+    };
+  };
+});
+
+// src/core/lazer/schema/realmNamedFileUsage.ts
+import Realm6 from "realm";
+var RealmNamedFileUsage;
+var init_realmNamedFileUsage = __esm(() => {
+  RealmNamedFileUsage = class RealmNamedFileUsage extends Realm6.Object {
+    File;
+    Filename;
+    static embedded = true;
+    static schema = {
+      name: "RealmNamedFileUsage",
+      embedded: true,
+      properties: {
+        File: "File",
+        Filename: { type: "string", optional: true }
+      }
+    };
+  };
+});
+
+// src/core/lazer/schema/mod.ts
+var init_mod2 = __esm(() => {
+  init_beatmap();
+  init_beatmapMetadata();
+  init_beatmapSet();
+  init_realmFile();
+  init_realmUser();
+  init_realmNamedFileUsage();
+});
+
+// src/core/lazer/mod.ts
+var exports_mod = {};
+__export(exports_mod, {
+  inspectLazerSchemaEntries: () => inspectLazerSchemaEntries,
+  inspectLazerSchema: () => inspectLazerSchema,
+  hashedFilePath: () => hashedFilePath,
+  getNamedFileHash: () => getNamedFileHash2,
+  getLazerDB: () => getLazerDB,
+  getBeatmapSets: () => getBeatmapSets,
+  formatLazerSchemaCompatibilityError: () => formatLazerSchemaCompatibilityError,
+  RealmUser: () => RealmUser,
+  RealmNamedFileUsage: () => RealmNamedFileUsage,
+  RealmFile: () => RealmFile,
+  LAST_STATIC_LAZER_SCHEMA_VERSION: () => LAST_STATIC_LAZER_SCHEMA_VERSION,
+  BeatmapSet: () => BeatmapSet,
+  BeatmapMetadata: () => BeatmapMetadata,
+  Beatmap: () => Beatmap
+});
+import Realm7 from "realm";
+function inspectLazerSchema(realm) {
+  return inspectLazerSchemaEntries(realm.schema, Realm7.schemaVersion(realm.path));
+}
+function getBeatmapSets(realm) {
+  return realm.objects("BeatmapSet");
+}
+var getLazerDB = async (realmDBPath) => {
+  return Realm7.open({
+    path: realmDBPath,
+    readOnly: true
+  });
+}, getNamedFileHash2 = (fileName, beatmapSet) => {
+  const files = beatmapSet.Files;
+  for (const file of files) {
+    if (file.Filename == fileName)
+      return file.File.Hash;
+  }
+  return;
+};
+var init_mod3 = __esm(() => {
+  init_compat();
+  init_mod2();
+  init_compat();
+  init_mod();
+});
+
+// src/core/cli/main.ts
+import path3 from "node:path";
+import { writeFileSync } from "node:fs";
+import { ProcessTerminal, TUI } from "@mariozechner/pi-tui";
+import yargs from "yargs/yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/core/playlist/mod.ts
+init_mod();
+function uniqueParts(parts) {
+  return [...new Set(parts.map((part) => part?.trim()).filter(Boolean))];
+}
+function formatTrackTitle(metadata) {
+  const title = uniqueParts([metadata.Title, metadata.TitleUnicode]).join(" / ");
+  const artist = uniqueParts([metadata.Artist, metadata.ArtistUnicode]).join(" / ");
+  return `${title || "Unknown Title"} - ${artist || "Unknown Artist"}`;
+}
+function getNamedFileHash(fileName, beatmapSet) {
+  for (const file of beatmapSet.Files) {
+    if (file.Filename === fileName && file.File?.Hash) {
+      return file.File.Hash;
+    }
+  }
+  return;
+}
+function buildPlaylist(beatmapSets, osuDataDir) {
+  const seenHashes = new Set;
+  const playlist = [];
+  for (const beatmapSet of beatmapSets) {
+    for (const beatmap of beatmapSet.Beatmaps) {
+      const hash = getNamedFileHash(beatmap.Metadata.AudioFile ?? "", beatmapSet);
+      if (!hash || seenHashes.has(hash)) {
+        continue;
+      }
+      seenHashes.add(hash);
+      playlist.push({
+        hash,
+        path: hashedFilePath(hash, osuDataDir),
+        title: formatTrackTitle(beatmap.Metadata)
+      });
+    }
+  }
+  return playlist;
+}
+
+// src/core/player/mpv.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync2, rmSync } from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import path2 from "node:path";
+import { setTimeout as delay } from "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 path2.join(os.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 = 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 delay(50);
+    }
+    throw new Error(this.formatStartupError("Timed out waiting for mpv IPC to become ready."));
+  }
+  async attachSocket() {
+    await new Promise((resolve, reject) => {
+      const socket = net.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());
+        }),
+        delay(1000)
+      ]);
+      if (processHandle.exitCode === null) {
+        processHandle.kill("SIGKILL");
+      }
+    }
+    this.cleanupSocketPath();
+  }
+  cleanupSocketPath() {
+    if (process.platform === "win32") {
+      return;
+    }
+    if (existsSync2(this.socketPath)) {
+      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
+import {
+  decodeKittyPrintable,
+  Key,
+  matchesKey,
+  truncateToWidth
+} from "@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 = 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 (matchesKey(data, Key.slash)) {
+      this.searchMode = true;
+      return;
+    }
+    if (matchesKey(data, "g")) {
+      if (this.pendingGoToTop) {
+        this.clearPendingGoToTop();
+        this.session.selectHome();
+      } else {
+        this.armPendingGoToTop();
+      }
+      return;
+    }
+    this.clearPendingGoToTop();
+    if (matchesKey(data, Key.ctrl("c")) || matchesKey(data, "q")) {
+      this.onQuit?.();
+      return;
+    }
+    if (matchesKey(data, Key.up) || matchesKey(data, "k")) {
+      this.session.moveSelection(-1);
+      return;
+    }
+    if (matchesKey(data, Key.down) || matchesKey(data, "j")) {
+      this.session.moveSelection(1);
+      return;
+    }
+    if (matchesKey(data, Key.left) || matchesKey(data, "h")) {
+      this.session.seekBy(-SEEK_SECONDS);
+      return;
+    }
+    if (matchesKey(data, Key.right) || matchesKey(data, "l")) {
+      this.session.seekBy(SEEK_SECONDS);
+      return;
+    }
+    if (matchesKey(data, Key.pageUp) || matchesKey(data, Key.ctrl("u")) || matchesKey(data, Key.ctrl("b"))) {
+      this.session.moveSelectionPage(-1, PAGE_SIZE);
+      return;
+    }
+    if (matchesKey(data, Key.pageDown) || matchesKey(data, Key.ctrl("d")) || matchesKey(data, Key.ctrl("f"))) {
+      this.session.moveSelectionPage(1, PAGE_SIZE);
+      return;
+    }
+    if (matchesKey(data, Key.home) || matchesKey(data, "0")) {
+      this.session.selectHome();
+      return;
+    }
+    if (matchesKey(data, Key.end) || matchesKey(data, Key.shift("g"))) {
+      this.session.selectEnd();
+      return;
+    }
+    if (matchesKey(data, Key.shift("h"))) {
+      this.moveSelectionToVisibleAnchor("top");
+      return;
+    }
+    if (matchesKey(data, Key.shift("m"))) {
+      this.moveSelectionToVisibleAnchor("middle");
+      return;
+    }
+    if (matchesKey(data, Key.shift("l"))) {
+      this.moveSelectionToVisibleAnchor("bottom");
+      return;
+    }
+    if (matchesKey(data, Key.enter)) {
+      this.session.playSelected();
+      return;
+    }
+    if (matchesKey(data, Key.space)) {
+      this.session.togglePause();
+      return;
+    }
+    if (matchesKey(data, "n")) {
+      this.session.playNext();
+      return;
+    }
+    if (matchesKey(data, "p")) {
+      this.session.playPrevious();
+      return;
+    }
+    if (matchesKey(data, "s")) {
+      this.session.stop();
+      return;
+    }
+    if (matchesKey(data, "r")) {
+      this.session.toggleLoop();
+      return;
+    }
+    if (matchesKey(data, Key.backspace)) {
+      this.session.deleteSearchCharacter();
+      return;
+    }
+    if (matchesKey(data, 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 = [
+      truncateToWidth(`osu-play | tracks ${playlist.length} | backend ${this.snapshot.backendName} | loop ${this.snapshot.loop ? "on" : "off"}`, width),
+      truncateToWidth(style(`now ${this.snapshot.status}: ${this.snapshot.currentTrack?.title ?? "nothing selected"}`, CYAN), width),
+      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(truncateToWidth(style(`error: ${this.snapshot.errorMessage}`, RED), width));
+    } else {
+      lines.push("");
+    }
+    if (playlist.length === 0) {
+      lines.push(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(truncateToWidth(isSelected ? style(line, INVERSE) : line, width));
+      }
+    }
+    while (lines.length < viewportHeight - 1) {
+      lines.push("");
+    }
+    lines.push(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 (matchesKey(data, Key.ctrl("c"))) {
+      this.onQuit?.();
+      return;
+    }
+    if (matchesKey(data, Key.enter)) {
+      this.searchMode = false;
+      return;
+    }
+    if (matchesKey(data, Key.escape)) {
+      this.searchMode = false;
+      return;
+    }
+    if (matchesKey(data, Key.backspace)) {
+      this.session.deleteSearchCharacter();
+      return;
+    }
+    if (matchesKey(data, 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
+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([
+      import("realm"),
+      Promise.resolve().then(() => (init_mod3(), exports_mod))
+    ]);
+    return {
+      Realm: Realm8,
+      ...lazerModule
+    };
+  } catch (error) {
+    throw new Error(formatRealmLoadError(error), { cause: error });
+  }
+}
+function getArgs() {
+  return yargs(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,
+    alias: "r",
+    describe: "Deprecated: ignored. osu-play now reads the live lazer database directly"
+  }).option("exportPlaylist", {
+    type: "string",
+    describe: "Export playlist to a file instead of launching the player"
+  }).option("osuDataDir", {
+    type: "string",
+    default: getDefaultOsuDataDir(),
+    alias: "d",
+    describe: "Osu!lazer data directory"
+  }).option("configDir", {
+    type: "string",
+    alias: "c",
+    describe: "Deprecated: ignored. osu-play no longer copies the lazer database"
+  }).option("loop", {
+    type: "boolean",
+    default: false,
+    alias: "l",
+    describe: "Loop the playlist when playback reaches the end"
+  }).alias("help", "h").help().parse();
+}
+async function createPlaylist(osuDataDir) {
+  const realmDBPath = getRealmDBPath({ osuDataDir });
+  if (!realmDBPath) {
+    throw new Error("Realm DB not found");
+  }
+  const {
+    Realm: Realm8,
+    formatLazerSchemaCompatibilityError: formatLazerSchemaCompatibilityError2,
+    getBeatmapSets: getBeatmapSets2,
+    getLazerDB: getLazerDB2,
+    inspectLazerSchema: inspectLazerSchema2
+  } = await loadRealmDependencies();
+  Realm8.flags.ALLOW_CLEAR_TEST_STATE = true;
+  const realm = await getLazerDB2(realmDBPath);
+  try {
+    const schemaReport = inspectLazerSchema2(realm);
+    if (!schemaReport.compatible) {
+      throw new Error(formatLazerSchemaCompatibilityError2(schemaReport));
+    }
+    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 ProcessTerminal;
+  const tui = new 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(`
+`);
+    writeFileSync(argv.exportPlaylist, playlistContents);
+    console.log(`[INFO] Exported ${playlist.length} tracks to ${argv.exportPlaylist}.`);
+    console.log(`[INFO] Use something like \`mpv --playlist=${path3.resolve(argv.exportPlaylist)}\` to play the playlist.`);
+    return;
+  }
+  await runTuiPlayer(playlist, argv.loop);
+}
+
+// src/cli.ts
+main().then(() => {
+  process.exit(0);
+}).catch((error) => {
+  console.error("Error:", error);
+  process.exit(1);
+});
+
+//# debugId=FF1120811E982FF064756E2164756E21