@nightrunners/nightmaxxing 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 851 Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @nightrunners/nightmaxxing
+
+CLI for [nightmaxxing](https://maxxing.nrght.eu) — the social leaderboard
+for LLM token usage. Parses your local agent usage (Claude Code, Codex,
+OpenCode, Gemini CLI, Copilot CLI, Hermes, Pi) via
+[ccusage](https://github.com/ryoppippi/ccusage) and pushes daily aggregates
+to your public profile.
+
+## Usage
+
+```bash
+npm install -g @nightrunners/nightmaxxing@latest
+nightmaxxing login              # sign in in the browser, approves this device
+nightmaxxing sync               # parse local usage and push it
+nightmaxxing service install    # optional: sync automatically every 5 minutes
+nightmaxxing upgrade            # upgrade the global CLI and refresh the service
+```
+
+You can also install globally with `bun add -g --trust @nightrunners/nightmaxxing@latest`,
+`pnpm add -g @nightrunners/nightmaxxing@latest`, or
+`yarn global add @nightrunners/nightmaxxing@latest`.
+
+The background service uses the global `nightmaxxing` binary and syncs every
+5 minutes. It auto-updates through the package manager that installed the
+global binary (bun, npm, pnpm, or yarn) when that package manager can be
+detected.
+Use `nightmaxxing service status` for the last run and `nightmaxxing service
+doctor` to inspect scheduler files, auth, auto-update, locks, and recent logs.
+
+Run `sync` as often as you like, from as many machines as you like —
+profiles aggregate across devices. Useful flags: `--dry-run`,
+`--since YYYY-MM-DD`, `--sources claude,codex`, `--json`.
+
+### What gets uploaded (privacy)
+
+Daily aggregates only: date, model name, agent name, token counts, and the
+API-equivalent cost — never prompts, file paths, project names, or session
+content. Revoke access anytime with `nightmaxxing logout` or from
+[settings](https://maxxing.nrght.eu/settings).
+
+## License
+
+MIT

package/bin/nightmaxxing.exe

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+
+const childProcess = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { createRequire } = require("node:module");
+
+function detectPlatform(value = os.platform()) {
+  return (
+    {
+      darwin: "darwin",
+      linux: "linux",
+      win32: "windows",
+    }[value] ?? value
+  );
+}
+
+function detectArch(value = os.arch()) {
+  return (
+    {
+      arm64: "arm64",
+      x64: "x64",
+    }[value] ?? value
+  );
+}
+
+function binaryName(platform = detectPlatform()) {
+  platform = detectPlatform(platform);
+  return platform === "windows" ? "nightmaxxing.exe" : "nightmaxxing";
+}
+
+function supportsAvx2(options = {}) {
+  const arch = options.arch ?? detectArch();
+  const platform = options.platform ?? detectPlatform();
+  if (arch !== "x64") return false;
+
+  if (platform === "linux") {
+    try {
+      return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"));
+    } catch {
+      return false;
+    }
+  }
+
+  if (platform === "darwin") {
+    try {
+      const result = childProcess.spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], {
+        encoding: "utf8",
+        timeout: 1500,
+      });
+      return result.status === 0 && (result.stdout || "").trim() === "1";
+    } catch {
+      return false;
+    }
+  }
+
+  if (platform === "windows") {
+    const command =
+      '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)';
+    for (const executable of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
+      try {
+        const result = childProcess.spawnSync(
+          executable,
+          ["-NoProfile", "-NonInteractive", "-Command", command],
+          {
+            encoding: "utf8",
+            timeout: 3000,
+            windowsHide: true,
+          },
+        );
+        if (result.status !== 0) continue;
+        const output = (result.stdout || "").trim().toLowerCase();
+        if (output === "true" || output === "1") return true;
+        if (output === "false" || output === "0") return false;
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return false;
+}
+
+function isMusl(platform = detectPlatform()) {
+  if (platform !== "linux") return false;
+
+  try {
+    if (fs.existsSync("/etc/alpine-release")) return true;
+  } catch {
+    return false;
+  }
+
+  try {
+    const result = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" });
+    return `${result.stdout || ""}${result.stderr || ""}`.toLowerCase().includes("musl");
+  } catch {
+    return false;
+  }
+}
+
+function nativePackageNames(options = {}) {
+  const platform = detectPlatform(options.platform);
+  const arch = options.arch ?? detectArch();
+  const musl = options.musl ?? isMusl(platform);
+  const baseline = arch === "x64" && !(options.avx2 ?? supportsAvx2({ arch, platform }));
+  const base = `@nightrunners/nightmaxxing-${platform}-${arch}`;
+
+  if (platform === "linux") {
+    if (arch === "arm64") {
+      return musl ? [`${base}-musl`, base] : [base, `${base}-musl`];
+    }
+
+    if (arch === "x64" && musl) {
+      return baseline
+        ? [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
+        : [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`];
+    }
+
+    if (arch === "x64") {
+      return baseline
+        ? [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
+        : [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`];
+    }
+  }
+
+  if (arch === "x64") {
+    return baseline ? [`${base}-baseline`, base] : [base, `${base}-baseline`];
+  }
+
+  if (arch === "arm64") {
+    return [base];
+  }
+
+  return [];
+}
+
+function packageJsonPaths(packageDir = __dirname) {
+  return [path.join(packageDir, "package.json"), path.join(packageDir, "..", "package.json")];
+}
+
+function readPackageJson(packageDir = __dirname) {
+  for (const packageJsonPath of packageJsonPaths(packageDir)) {
+    try {
+      return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    } catch {
+      continue;
+    }
+  }
+
+  throw new Error("Unable to read @nightrunners/nightmaxxing package.json");
+}
+
+function packageResolvePaths(packageDir = __dirname) {
+  return [packageDir, path.join(packageDir, "..")];
+}
+
+function resolveBinary(packageName, sourceBinary = binaryName(), options = {}) {
+  const packageDir = options.packageDir ?? __dirname;
+  const resolver = createRequire(path.join(packageDir, "package.json"));
+  const packageJsonPath = resolver.resolve(`${packageName}/package.json`, {
+    paths: packageResolvePaths(packageDir),
+  });
+  const binaryPath = path.join(path.dirname(packageJsonPath), "bin", sourceBinary);
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`Binary not found at ${binaryPath}`);
+  }
+  return binaryPath;
+}
+
+function findNativeBinary(options = {}) {
+  const packages = options.packages ?? nativePackageNames(options);
+  const sourceBinary = options.sourceBinary ?? binaryName(options.platform);
+
+  for (const packageName of packages) {
+    try {
+      return {
+        packageName,
+        path: resolveBinary(packageName, sourceBinary, options),
+      };
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+}
+
+function recoveryMessage(options = {}) {
+  const packages = options.packages ?? nativePackageNames(options);
+  return [
+    "Error: @nightrunners/nightmaxxing could not find a native binary for this platform.",
+    "",
+    "This usually means your package manager skipped postinstall scripts or optional dependencies.",
+    "It can also happen when an older broken global install is earlier in PATH.",
+    "",
+    "Debug:",
+    "  which -a nightmaxxing",
+    "",
+    "Fix:",
+    "  bun remove -g @nightrunners/nightmaxxing && bun add -g --trust @nightrunners/nightmaxxing",
+    "  npm install -g @nightrunners/nightmaxxing@latest",
+    "  npx -y @nightrunners/nightmaxxing@latest bootstrap",
+    "",
+    `Expected one of: ${packages.length === 0 ? "(none)" : packages.join(", ")}`,
+  ].join("\n");
+}
+
+function runBinary(target, argv = process.argv.slice(2)) {
+  const result = childProcess.spawnSync(target, argv, {
+    stdio: "inherit",
+    windowsHide: true,
+  });
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  process.exit(typeof result.status === "number" ? result.status : 1);
+}
+
+function runNativeBinary(options = {}) {
+  const envPath = process.env.NIGHTMAXXING_BIN_PATH;
+  if (envPath) {
+    runBinary(envPath, options.argv);
+    return;
+  }
+
+  const nativeBinary = findNativeBinary(options);
+  if (nativeBinary === null) {
+    console.error(recoveryMessage(options));
+    process.exit(1);
+  }
+  runBinary(nativeBinary.path, options.argv);
+}
+
+if (require.main === module) {
+  runNativeBinary();
+}
+
+module.exports = {
+  binaryName,
+  detectArch,
+  detectPlatform,
+  findNativeBinary,
+  isMusl,
+  nativePackageNames,
+  packageJsonPaths,
+  readPackageJson,
+  recoveryMessage,
+  resolveBinary,
+  runNativeBinary,
+  supportsAvx2,
+};

package/install-native.mjs

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+import childProcess from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const launcher = require("./native-bin-launcher.cjs");
+
+const {
+  binaryName,
+  detectArch,
+  detectPlatform,
+  isMusl,
+  nativePackageNames,
+  readPackageJson: readLauncherPackageJson,
+  resolveBinary,
+  supportsAvx2,
+} = launcher;
+
+const targetBinary = path.join(__dirname, "bin", "nightmaxxing.exe");
+let packageJsonCache;
+
+function copyBinary(source, target = targetBinary) {
+  if (!fs.existsSync(source)) {
+    throw new Error(`Binary not found at ${source}`);
+  }
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  if (fs.existsSync(target)) {
+    fs.unlinkSync(target);
+  }
+  try {
+    fs.linkSync(source, target);
+  } catch {
+    fs.copyFileSync(source, target);
+  }
+  fs.chmodSync(target, 0o755);
+}
+
+function installPackage(packageName, sourceBinary = binaryName()) {
+  const packageJson = readPackageJson();
+  const version = packageJson.optionalDependencies?.[packageName];
+  if (typeof version !== "string" || version.length === 0) {
+    return false;
+  }
+
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "nightmaxxing-install-"));
+  try {
+    const result = childProcess.spawnSync(
+      "npm",
+      [
+        "install",
+        "--ignore-scripts",
+        "--no-save",
+        "--loglevel=error",
+        "--prefix",
+        temp,
+        `${packageName}@${version}`,
+      ],
+      { stdio: "inherit", windowsHide: true },
+    );
+    if (result.status !== 0) {
+      return false;
+    }
+
+    copyBinary(path.join(temp, "node_modules", packageName, "bin", sourceBinary));
+    return true;
+  } finally {
+    fs.rmSync(temp, { recursive: true, force: true });
+  }
+}
+
+function readPackageJson() {
+  if (packageJsonCache !== undefined) {
+    return packageJsonCache;
+  }
+  packageJsonCache = readLauncherPackageJson(__dirname);
+  return packageJsonCache;
+}
+
+function verifyBinary(target = targetBinary) {
+  const result = childProcess.spawnSync(target, ["--version"], {
+    stdio: "ignore",
+    timeout: 5000,
+    windowsHide: true,
+  });
+  return result.status === 0;
+}
+
+function installNativeBinary() {
+  const packages = nativePackageNames();
+  const sourceBinary = binaryName();
+
+  for (const packageName of packages) {
+    try {
+      copyBinary(resolveBinary(packageName, sourceBinary, { packageDir: __dirname }));
+      if (verifyBinary()) return;
+    } catch {
+      if (installPackage(packageName, sourceBinary) && verifyBinary()) return;
+    }
+  }
+
+  throw new Error(
+    `It seems your package manager failed to install the right Nightmaxxing native package. Try manually installing ${packages
+      .map((packageName) => JSON.stringify(packageName))
+      .join(" or ")}.`,
+  );
+}
+
+function isMainModule(metaUrl = import.meta.url, argv1 = process.argv[1]) {
+  return argv1 !== undefined && path.resolve(fileURLToPath(metaUrl)) === path.resolve(argv1);
+}
+
+if (isMainModule()) {
+  try {
+    installNativeBinary();
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+export {
+  binaryName,
+  copyBinary,
+  detectArch,
+  detectPlatform,
+  installNativeBinary,
+  isMainModule,
+  isMusl,
+  nativePackageNames,
+  readPackageJson,
+  supportsAvx2,
+  verifyBinary,
+};

package/native-bin-launcher.cjs

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+
+const childProcess = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { createRequire } = require("node:module");
+
+function detectPlatform(value = os.platform()) {
+  return (
+    {
+      darwin: "darwin",
+      linux: "linux",
+      win32: "windows",
+    }[value] ?? value
+  );
+}
+
+function detectArch(value = os.arch()) {
+  return (
+    {
+      arm64: "arm64",
+      x64: "x64",
+    }[value] ?? value
+  );
+}
+
+function binaryName(platform = detectPlatform()) {
+  platform = detectPlatform(platform);
+  return platform === "windows" ? "nightmaxxing.exe" : "nightmaxxing";
+}
+
+function supportsAvx2(options = {}) {
+  const arch = options.arch ?? detectArch();
+  const platform = options.platform ?? detectPlatform();
+  if (arch !== "x64") return false;
+
+  if (platform === "linux") {
+    try {
+      return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"));
+    } catch {
+      return false;
+    }
+  }
+
+  if (platform === "darwin") {
+    try {
+      const result = childProcess.spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], {
+        encoding: "utf8",
+        timeout: 1500,
+      });
+      return result.status === 0 && (result.stdout || "").trim() === "1";
+    } catch {
+      return false;
+    }
+  }
+
+  if (platform === "windows") {
+    const command =
+      '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)';
+    for (const executable of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
+      try {
+        const result = childProcess.spawnSync(
+          executable,
+          ["-NoProfile", "-NonInteractive", "-Command", command],
+          {
+            encoding: "utf8",
+            timeout: 3000,
+            windowsHide: true,
+          },
+        );
+        if (result.status !== 0) continue;
+        const output = (result.stdout || "").trim().toLowerCase();
+        if (output === "true" || output === "1") return true;
+        if (output === "false" || output === "0") return false;
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return false;
+}
+
+function isMusl(platform = detectPlatform()) {
+  if (platform !== "linux") return false;
+
+  try {
+    if (fs.existsSync("/etc/alpine-release")) return true;
+  } catch {
+    return false;
+  }
+
+  try {
+    const result = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" });
+    return `${result.stdout || ""}${result.stderr || ""}`.toLowerCase().includes("musl");
+  } catch {
+    return false;
+  }
+}
+
+function nativePackageNames(options = {}) {
+  const platform = detectPlatform(options.platform);
+  const arch = options.arch ?? detectArch();
+  const musl = options.musl ?? isMusl(platform);
+  const baseline = arch === "x64" && !(options.avx2 ?? supportsAvx2({ arch, platform }));
+  const base = `@nightrunners/nightmaxxing-${platform}-${arch}`;
+
+  if (platform === "linux") {
+    if (arch === "arm64") {
+      return musl ? [`${base}-musl`, base] : [base, `${base}-musl`];
+    }
+
+    if (arch === "x64" && musl) {
+      return baseline
+        ? [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
+        : [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`];
+    }
+
+    if (arch === "x64") {
+      return baseline
+        ? [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
+        : [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`];
+    }
+  }
+
+  if (arch === "x64") {
+    return baseline ? [`${base}-baseline`, base] : [base, `${base}-baseline`];
+  }
+
+  if (arch === "arm64") {
+    return [base];
+  }
+
+  return [];
+}
+
+function packageJsonPaths(packageDir = __dirname) {
+  return [path.join(packageDir, "package.json"), path.join(packageDir, "..", "package.json")];
+}
+
+function readPackageJson(packageDir = __dirname) {
+  for (const packageJsonPath of packageJsonPaths(packageDir)) {
+    try {
+      return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    } catch {
+      continue;
+    }
+  }
+
+  throw new Error("Unable to read @nightrunners/nightmaxxing package.json");
+}
+
+function packageResolvePaths(packageDir = __dirname) {
+  return [packageDir, path.join(packageDir, "..")];
+}
+
+function resolveBinary(packageName, sourceBinary = binaryName(), options = {}) {
+  const packageDir = options.packageDir ?? __dirname;
+  const resolver = createRequire(path.join(packageDir, "package.json"));
+  const packageJsonPath = resolver.resolve(`${packageName}/package.json`, {
+    paths: packageResolvePaths(packageDir),
+  });
+  const binaryPath = path.join(path.dirname(packageJsonPath), "bin", sourceBinary);
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`Binary not found at ${binaryPath}`);
+  }
+  return binaryPath;
+}
+
+function findNativeBinary(options = {}) {
+  const packages = options.packages ?? nativePackageNames(options);
+  const sourceBinary = options.sourceBinary ?? binaryName(options.platform);
+
+  for (const packageName of packages) {
+    try {
+      return {
+        packageName,
+        path: resolveBinary(packageName, sourceBinary, options),
+      };
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+}
+
+function recoveryMessage(options = {}) {
+  const packages = options.packages ?? nativePackageNames(options);
+  return [
+    "Error: @nightrunners/nightmaxxing could not find a native binary for this platform.",
+    "",
+    "This usually means your package manager skipped postinstall scripts or optional dependencies.",
+    "It can also happen when an older broken global install is earlier in PATH.",
+    "",
+    "Debug:",
+    "  which -a nightmaxxing",
+    "",
+    "Fix:",
+    "  bun remove -g @nightrunners/nightmaxxing && bun add -g --trust @nightrunners/nightmaxxing",
+    "  npm install -g @nightrunners/nightmaxxing@latest",
+    "  npx -y @nightrunners/nightmaxxing@latest bootstrap",
+    "",
+    `Expected one of: ${packages.length === 0 ? "(none)" : packages.join(", ")}`,
+  ].join("\n");
+}
+
+function runBinary(target, argv = process.argv.slice(2)) {
+  const result = childProcess.spawnSync(target, argv, {
+    stdio: "inherit",
+    windowsHide: true,
+  });
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  process.exit(typeof result.status === "number" ? result.status : 1);
+}
+
+function runNativeBinary(options = {}) {
+  const envPath = process.env.NIGHTMAXXING_BIN_PATH;
+  if (envPath) {
+    runBinary(envPath, options.argv);
+    return;
+  }
+
+  const nativeBinary = findNativeBinary(options);
+  if (nativeBinary === null) {
+    console.error(recoveryMessage(options));
+    process.exit(1);
+  }
+  runBinary(nativeBinary.path, options.argv);
+}
+
+if (require.main === module) {
+  runNativeBinary();
+}
+
+module.exports = {
+  binaryName,
+  detectArch,
+  detectPlatform,
+  findNativeBinary,
+  isMusl,
+  nativePackageNames,
+  packageJsonPaths,
+  readPackageJson,
+  recoveryMessage,
+  resolveBinary,
+  runNativeBinary,
+  supportsAvx2,
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@nightrunners/nightmaxxing",
+  "version": "0.1.0",
+  "description": "CLI for Nightmaxxing — sync your LLM token usage to the leaderboard.",
+  "keywords": [
+    "ccusage",
+    "claude-code",
+    "cli",
+    "leaderboard",
+    "llm",
+    "tokens"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NightRunnersEU/nightmaxxing.git",
+    "directory": "apps/cli"
+  },
+  "bin": {
+    "nightmaxxing": "./bin/nightmaxxing.exe"
+  },
+  "scripts": {
+    "preinstall": "bun ./install-native.mjs || node ./install-native.mjs"
+  },
+  "files": [
+    "bin",
+    "native-bin-launcher.cjs",
+    "install-native.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "arm64",
+    "x64"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "optionalDependencies": {
+    "@nightrunners/nightmaxxing-linux-arm64": "0.1.0",
+    "@nightrunners/nightmaxxing-linux-x64": "0.1.0",
+    "@nightrunners/nightmaxxing-linux-x64-baseline": "0.1.0",
+    "@nightrunners/nightmaxxing-linux-arm64-musl": "0.1.0",
+    "@nightrunners/nightmaxxing-linux-x64-musl": "0.1.0",
+    "@nightrunners/nightmaxxing-linux-x64-baseline-musl": "0.1.0",
+    "@nightrunners/nightmaxxing-darwin-arm64": "0.1.0",
+    "@nightrunners/nightmaxxing-darwin-x64": "0.1.0",
+    "@nightrunners/nightmaxxing-darwin-x64-baseline": "0.1.0",
+    "@nightrunners/nightmaxxing-windows-arm64": "0.1.0",
+    "@nightrunners/nightmaxxing-windows-x64": "0.1.0",
+    "@nightrunners/nightmaxxing-windows-x64-baseline": "0.1.0"
+  }
+}