osu-play 1.0.7 → 1.1.0

package/dist/cli.cjs

@@ -0,0 +1,671 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+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);
+
+// src/core/utils/mod.ts
+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 import_node_path.default.join(home, ".local", "share");
+      break;
+    }
+    case "darwin": {
+      const home = process.env.HOME;
+      if (home)
+        return import_node_path.default.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 import_node_path.default.join(home, ".config");
+      break;
+    }
+    case "darwin": {
+      const home = process.env.HOME;
+      if (home)
+        return import_node_path.default.join(home, "Library", "Preferences");
+      break;
+    }
+    case "win32":
+      return process.env.APPDATA ?? undefined;
+  }
+  return;
+}
+function getDefaultOsuDataDir() {
+  return import_node_path.default.join(getDataDir() ?? ".", "osu");
+}
+function getDefaultConfigPath(appName = "osu-play") {
+  return import_node_path.default.join(getConfigDir() ?? ".", appName);
+}
+function hashedFilePath(hash, osuDataDir = getDefaultOsuDataDir()) {
+  return import_node_path.default.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 = import_node_path.default.join(osuDataDir, "client.realm");
+  if (!import_node_fs.existsSync(osuDBPath)) {
+    console.log(`[getRealmDBPath]: ${osuDBPath} not found`);
+    return null;
+  }
+  return osuDBPath;
+}
+var import_node_path, import_node_fs;
+var init_mod = __esm(() => {
+  import_node_path = __toESM(require("node:path"));
+  import_node_fs = require("node:fs");
+});
+
+// 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
+var import_realm, Beatmap;
+var init_beatmap = __esm(() => {
+  import_realm = __toESM(require("realm"));
+  Beatmap = class Beatmap extends import_realm.default.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
+var import_realm2, BeatmapMetadata;
+var init_beatmapMetadata = __esm(() => {
+  import_realm2 = __toESM(require("realm"));
+  BeatmapMetadata = class BeatmapMetadata extends import_realm2.default.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
+var import_realm3, BeatmapSet;
+var init_beatmapSet = __esm(() => {
+  import_realm3 = __toESM(require("realm"));
+  BeatmapSet = class BeatmapSet extends import_realm3.default.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
+var import_realm4, RealmFile;
+var init_realmFile = __esm(() => {
+  import_realm4 = __toESM(require("realm"));
+  RealmFile = class RealmFile extends import_realm4.default.Object {
+    Hash;
+    static schema = {
+      name: "File",
+      primaryKey: "Hash",
+      properties: {
+        Hash: { type: "string", default: "", optional: true }
+      }
+    };
+  };
+});
+
+// src/core/lazer/schema/realmUser.ts
+var import_realm5, RealmUser;
+var init_realmUser = __esm(() => {
+  import_realm5 = __toESM(require("realm"));
+  RealmUser = class RealmUser extends import_realm5.default.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
+var import_realm6, RealmNamedFileUsage;
+var init_realmNamedFileUsage = __esm(() => {
+  import_realm6 = __toESM(require("realm"));
+  RealmNamedFileUsage = class RealmNamedFileUsage extends import_realm6.default.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
+});
+function inspectLazerSchema(realm) {
+  return inspectLazerSchemaEntries(realm.schema, import_realm7.default.schemaVersion(realm.path));
+}
+function getBeatmapSets(realm) {
+  return realm.objects("BeatmapSet");
+}
+var import_realm7, getLazerDB = async (realmDBPath) => {
+  return import_realm7.default.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();
+  import_realm7 = __toESM(require("realm"));
+});
+
+// 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_yargs = __toESM(require("yargs/yargs"));
+var import_helpers = require("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/cli/main.ts
+var execFilePromise = import_node_util.promisify(import_node_child_process.execFile);
+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([
+      "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 });
+  }
+}
+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
+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"
+  }).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 on 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
+  });
+  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,
+    inspectLazerSchema: inspectLazerSchema2
+  } = await loadRealmDependencies();
+  Realm8.flags.ALLOW_CLEAR_TEST_STATE = true;
+  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");
+      }
+    }
+  } finally {
+    realm.close();
+  }
+}
+
+// src/cli.ts
+main().then(() => {
+  process.exit(0);
+}).catch((error) => {
+  console.error("Error:", error);
+  process.exit(1);
+});
+
+//# debugId=6FDBB7EDEE4CC0EA64756E2164756E21