@chrrxs/robloxstudio-mcp 3.1.6 → 3.2.0

package/dist/index.js

@@ -3346,6 +3346,7 @@ Read output with get_runtime_logs. Reuse nextCursor as cursor for one Instance,
 - breakpoints clear removes only MCP-created breakpoints unless clear_all is true. clear_all also removes user-created breakpoints.
 - capture_script_profiler ranks Luau functions by CPU time. Use output_path when the raw capture is needed.
 - capture_micro_profiler attributes frame time across engine and game work. Its rows are inclusive or cumulative views, so do not sum them as disjoint totals.
+- MicroProfiler records frames only while Studio renders. Studio stops rendering when the display turns off or Studio is minimized, and the capture then fails with micro_profiler_no_frames.
 - Use baseline_path or baseline for before-and-after MicroProfiler comparisons.
 - Use get_memory_breakdown for memory categories and get_scene_analysis for instance, script, triangle, animation, or audio cost.
 
@@ -3357,6 +3358,16 @@ Studio must allow third-party asset loading for public third-party previews and
 
 generate_model stages generated content under ServerStorage for review. upload_asset sends an explicit local file to the chosen Roblox user or group.
 
+## Monetization
+
+manage_monetization lists, reads, creates, and updates developer products and game passes through Roblox Open Cloud. ROBLOX_OPEN_CLOUD_API_KEY needs developer-product:read and developer-product:write, or game-pass:read and game-pass:write, with the experience added to the key. universe_id defaults to the connected Studio place; an unpublished place has no universe.
+
+- Roblox cannot delete developer products or game passes. To retire one, update it with for_sale=false.
+- create keeps new items off sale unless for_sale=true, which also needs a price.
+- create refuses a name that already exists in the universe and returns the existing item. If a create times out, list the universe before retrying.
+- update changes only the arguments supplied, then reads the item back.
+- image_path uploads a local PNG, JPEG, or BMP icon. Roblox shows icons at 512x512 inside a circle, so keep details away from the corners.
+
 ## RBXM files
 
 - export_rbxm writes selected instances to an explicit local path. It can read the edit DataModel or a live server DataModel.
@@ -3414,11 +3425,11 @@ function registerResourceHandlers(server) {
 }
 
 // ../core/dist/studio-instance-manager.js
-import { execFile, execFileSync as execFileSync2, spawn } from "child_process";
-import { copyFileSync, existsSync as existsSync2, mkdirSync, readdirSync, readFileSync as readFileSync2, realpathSync, rmSync, statSync } from "fs";
-import { randomUUID as randomUUID3 } from "crypto";
+import { execFile, execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync3, realpathSync, rmSync as rmSync2, statSync as statSync2 } from "fs";
+import { randomUUID as randomUUID4 } from "crypto";
 import * as os2 from "os";
-import * as path3 from "path";
+import * as path5 from "path";
 import { promisify } from "util";
 
 // ../core/dist/studio-sign-in.js
@@ -3664,7 +3675,9 @@ var ManagedInstanceRegistry = class {
           const currentOwner = await this.readLockOwner(lockDir, stat2.isDirectory());
           const ownerIsActive = currentOwner?.pid === process.pid ? activeLockTokens.has(currentOwner.token) : currentOwner ? isProcessAlive(currentOwner.pid) : void 0;
           if (ownerIsActive === false || currentOwner === void 0 && !activeLockPaths.has(lockDir) && Date.now() - stat2.mtimeMs > LOCK_STALE_MS) {
-            await fs.rm(lockDir, { recursive: true, force: true });
+            if (await this.isInspectedLock(lockDir, stat2, currentOwner)) {
+              await fs.rm(lockDir, { recursive: true, force: true });
+            }
             continue;
           }
         } catch {
@@ -3701,6 +3714,16 @@ var ManagedInstanceRegistry = class {
       return void 0;
     }
   }
+  // The inspected owner can release, and another holder can take the lock, while this
+  // waiter decides. Reclaim only the instance that was judged abandoned: the same owner
+  // token, or for an unreadable owner the same unchanged directory entry.
+  async isInspectedLock(lockPath, inspected, inspectedOwner) {
+    const current = await fs.stat(lockPath);
+    const currentOwner = await this.readLockOwner(lockPath, current.isDirectory());
+    if (inspectedOwner)
+      return currentOwner?.token === inspectedOwner.token;
+    return currentOwner === void 0 && current.ino === inspected.ino && current.mtimeMs === inspected.mtimeMs;
+  }
   async ensureDir() {
     await fs.mkdir(this.dir, { recursive: true });
   }
@@ -3909,7 +3932,8 @@ var ManagedInstanceRegistry = class {
 
 // ../core/dist/studio-platform.js
 import { execFileSync } from "child_process";
-import { existsSync, readFileSync } from "fs";
+import { accessSync, constants, existsSync, readFileSync, statSync } from "fs";
+import * as path3 from "path";
 var WSL_KERNEL_PATTERN = /microsoft|wsl/i;
 var WINDOWS_INTEROP_PROBE_TOKEN = "ROBLOXSTUDIO_MCP_WINDOWS_INTEROP_OK";
 var WINDOWS_POWERSHELL = "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe";
@@ -3950,7 +3974,20 @@ function detectStudioPlatform(evidence) {
       }
     };
   }
-  const reason = hasWslKernel ? "The Linux kernel has a WSL signature, but the live process cannot execute the Windows launcher." : "The retained Windows Studio launcher is unavailable on native Linux.";
+  if (!hasWslKernel && evidence.wineLauncher && evidence.wineLauncherExecutable === true) {
+    return {
+      hostPlatform: "linux",
+      isWsl: false,
+      windowsInteropAvailable: false,
+      processIdentity: {
+        supported: true,
+        launcher: "wine-retained"
+      },
+      // Wine hosts are always Linux; keep POSIX semantics when tests run elsewhere.
+      wineLauncher: path3.posix.resolve(evidence.wineLauncher)
+    };
+  }
+  const reason = hasWslKernel ? "The Linux kernel has a WSL signature, but the live process cannot execute the Windows launcher." : evidence.wineLauncher ? `The retained Windows Studio launcher is unavailable on native Linux, and ROBLOX_STUDIO_WINE_LAUNCHER (${evidence.wineLauncher}) is not an executable file.` : "The retained Windows Studio launcher is unavailable on native Linux. Set ROBLOX_STUDIO_WINE_LAUNCHER to an executable Wine launcher to run Studio under Wine.";
   return {
     hostPlatform: "linux",
     isWsl: false,
@@ -4000,11 +4037,22 @@ function probeWindowsInterop(kernelVersion) {
   }
   return false;
 }
+function isExecutableFile(file) {
+  try {
+    if (!statSync(file).isFile())
+      return false;
+    accessSync(file, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
 var cachedStudioPlatformCapabilities;
 function getStudioPlatformCapabilities() {
   if (cachedStudioPlatformCapabilities)
     return cachedStudioPlatformCapabilities;
   const kernelVersion = readKernelVersion();
+  const wineLauncher = process.env.ROBLOX_STUDIO_WINE_LAUNCHER || void 0;
   cachedStudioPlatformCapabilities = detectStudioPlatform({
     platform: process.platform,
     kernelVersion,
@@ -4012,13 +4060,435 @@ function getStudioPlatformCapabilities() {
     wslDistroName: process.env.WSL_DISTRO_NAME,
     windowsRootPresent: existsSync("/mnt/c/Windows"),
     wslPathPresent: existsSync("/usr/bin/wslpath") || existsSync("/bin/wslpath"),
-    windowsInteropAvailable: probeWindowsInterop(kernelVersion)
+    windowsInteropAvailable: probeWindowsInterop(kernelVersion),
+    wineLauncher,
+    wineLauncherExecutable: process.platform === "linux" && wineLauncher !== void 0 && isExecutableFile(wineLauncher)
   });
   return cachedStudioPlatformCapabilities;
 }
 
+// ../core/dist/studio-wine.js
+import { spawn } from "child_process";
+import { randomUUID as randomUUID3 } from "crypto";
+import { closeSync, fstatSync, linkSync, mkdirSync, openSync, readdirSync, readFileSync as readFileSync2, readSync, rmSync, unlinkSync, writeFileSync } from "fs";
+import * as path4 from "path";
+var DEFAULT_PROC_ROOT = "/proc";
+var STUDIO_EXECUTABLE_NAME = "robloxstudiobeta.exe";
+var GATE_SCRIPT = 'kill -STOP $$ && exec "$0" "$@"';
+var GATE_TIMEOUT_MS = 5e3;
+var STUDIO_EXEC_TIMEOUT_MS = 6e4;
+var MAX_STUDIO_EXEC_TIMEOUT_MS = 15e4;
+var STUDIO_EXEC_TIMEOUT_ENV = "ROBLOX_STUDIO_WINE_START_TIMEOUT_MS";
+var ABORT_TIMEOUT_MS = 1e4;
+var TERMINATE_GRACE_MS = 5e3;
+var POLL_INTERVAL_MS = 50;
+var LAUNCHER_LOGS_KEPT = 10;
+var LAUNCHER_LOG_TAIL_BYTES = 4096;
+var LAUNCHER_LOG_TAIL_LINES = 20;
+var BOOT_ANCHOR_PREFIX = "wine-boot-time-";
+var FILETIME_UNIX_EPOCH2 = 116444736000000000n;
+var FILETIME_TICKS_PER_SECOND = 10000000n;
+var USER_HZ = 100n;
+var bootTimeByProcRoot = /* @__PURE__ */ new Map();
+function delay3(ms) {
+  const { promise, resolve: resolve6 } = Promise.withResolvers();
+  setTimeout(resolve6, ms);
+  return promise;
+}
+function isMissingProcessError(error) {
+  const code = error?.code;
+  return code === "ENOENT" || code === "ESRCH";
+}
+function procStartTimeToFileTime(bootTimeSeconds2, startTimeTicks) {
+  return (FILETIME_UNIX_EPOCH2 + bootTimeSeconds2 * FILETIME_TICKS_PER_SECOND + startTimeTicks * (FILETIME_TICKS_PER_SECOND / USER_HZ)).toString();
+}
+function toWineWindowsPath(unixPath) {
+  return `Z:${unixPath.replace(/\//g, "\\")}`;
+}
+function isWineStudioCommand(argv0) {
+  return argv0 !== void 0 && argv0.split(/[\\/]/u).pop()?.toLowerCase() === STUDIO_EXECUTABLE_NAME;
+}
+function parseProcStat(content) {
+  const commEnd = content.lastIndexOf(")");
+  const fields = commEnd < 0 ? [] : content.slice(commEnd + 1).trim().split(/\s+/u);
+  const state = fields[0];
+  const startTime = fields[19];
+  if (!state || !startTime || !/^\d+$/u.test(startTime)) {
+    throw new Error("Malformed /proc/<pid>/stat.");
+  }
+  return { state, startTimeTicks: BigInt(startTime) };
+}
+function readProcStat(procRoot, pid) {
+  let content;
+  try {
+    content = readFileSync2(`${procRoot}/${pid}/stat`, "utf8");
+  } catch (error) {
+    if (isMissingProcessError(error))
+      return void 0;
+    throw error;
+  }
+  return parseProcStat(content);
+}
+function readCmdline(procRoot, pid) {
+  let content;
+  try {
+    content = readFileSync2(`${procRoot}/${pid}/cmdline`, "utf8");
+  } catch (error) {
+    if (isMissingProcessError(error))
+      return void 0;
+    throw error;
+  }
+  const args = content.split("\0");
+  if (args[args.length - 1] === "")
+    args.pop();
+  return args;
+}
+function readArgv0(procRoot, pid) {
+  return readCmdline(procRoot, pid)?.[0] || void 0;
+}
+function readRealUid(procRoot, pid) {
+  let content;
+  try {
+    content = readFileSync2(`${procRoot}/${pid}/status`, "utf8");
+  } catch (error) {
+    if (isMissingProcessError(error))
+      return void 0;
+    throw error;
+  }
+  const match = /^Uid:\s+(\d+)/mu.exec(content);
+  if (!match)
+    throw new Error(`Malformed ${procRoot}/${pid}/status.`);
+  return Number(match[1]);
+}
+function readLiveBootTime(procRoot) {
+  const match = /^btime\s+(\d+)\s*$/mu.exec(readFileSync2(`${procRoot}/stat`, "utf8"));
+  if (!match)
+    throw new Error(`${procRoot}/stat has no btime.`);
+  return BigInt(match[1]);
+}
+function readBootId(procRoot) {
+  try {
+    const bootId = readFileSync2(`${procRoot}/sys/kernel/random/boot_id`, "utf8").trim();
+    return /^[0-9a-f-]+$/iu.test(bootId) ? bootId : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readBootAnchor(file) {
+  let content;
+  try {
+    content = readFileSync2(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return void 0;
+    throw error;
+  }
+  const match = /^(\d+)\n?$/u.exec(content);
+  if (!match)
+    throw new Error(`${file} is not a boot time.`);
+  return BigInt(match[1]);
+}
+function removeStaleBootAnchors(anchorDir, currentName) {
+  try {
+    for (const name of readdirSync(anchorDir)) {
+      if (!name.startsWith(BOOT_ANCHOR_PREFIX) || name.startsWith(currentName))
+        continue;
+      rmSync(path4.join(anchorDir, name), { force: true });
+    }
+  } catch {
+  }
+}
+function anchoredBootTime(procRoot, liveBootTime) {
+  const bootId = readBootId(procRoot);
+  if (bootId === void 0)
+    return liveBootTime;
+  const anchorDir = defaultManagedInstanceRegistryDir();
+  const anchorName = `${BOOT_ANCHOR_PREFIX}${bootId}`;
+  const anchorFile = path4.join(anchorDir, anchorName);
+  try {
+    const existing = readBootAnchor(anchorFile);
+    if (existing !== void 0)
+      return existing;
+    mkdirSync(anchorDir, { recursive: true });
+    const tmpFile = `${anchorFile}.${process.pid}.${randomUUID3()}.tmp`;
+    writeFileSync(tmpFile, `${liveBootTime}
+`);
+    try {
+      linkSync(tmpFile, anchorFile);
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    } finally {
+      unlinkSync(tmpFile);
+    }
+    removeStaleBootAnchors(anchorDir, anchorName);
+    return readBootAnchor(anchorFile) ?? liveBootTime;
+  } catch (error) {
+    console.error(`[studio] Could not persist the Wine boot-time anchor at ${anchorFile}: ${error instanceof Error ? error.message : String(error)}. Studio identities may not survive a broker restart after a clock change.`);
+    return liveBootTime;
+  }
+}
+function bootTimeSeconds(procRoot) {
+  const cached = bootTimeByProcRoot.get(procRoot);
+  if (cached !== void 0)
+    return cached;
+  const bootTime = anchoredBootTime(procRoot, readLiveBootTime(procRoot));
+  bootTimeByProcRoot.set(procRoot, bootTime);
+  return bootTime;
+}
+function readWineProcessStartTime(pid, procRoot = DEFAULT_PROC_ROOT) {
+  const stat2 = readProcStat(procRoot, pid);
+  if (!stat2 || stat2.state === "Z" || stat2.state === "X")
+    return void 0;
+  return procStartTimeToFileTime(bootTimeSeconds(procRoot), stat2.startTimeTicks);
+}
+function listWineStudioProcesses(procRoot = DEFAULT_PROC_ROOT, uid = process.getuid?.()) {
+  const processes = [];
+  for (const entry of readdirSync(procRoot)) {
+    if (!/^\d+$/u.test(entry))
+      continue;
+    const pid = Number(entry);
+    let argv0;
+    let startedAt;
+    try {
+      if (uid !== void 0 && readRealUid(procRoot, pid) !== uid)
+        continue;
+      argv0 = readArgv0(procRoot, pid);
+      if (!isWineStudioCommand(argv0))
+        continue;
+      startedAt = readWineProcessStartTime(pid, procRoot);
+    } catch (error) {
+      if (error.code === "EACCES" || isMissingProcessError(error))
+        continue;
+      throw error;
+    }
+    if (startedAt === void 0)
+      continue;
+    processes.push({
+      Id: pid,
+      Name: "RobloxStudioBeta",
+      Path: argv0,
+      MainWindowTitle: "",
+      StartTimeUtcFileTime: startedAt
+    });
+  }
+  return processes;
+}
+function signalProcess(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch (error) {
+    if (!isMissingProcessError(error))
+      throw error;
+  }
+}
+async function stopWineStudio(pid, startedAt, timeoutMs, procRoot = DEFAULT_PROC_ROOT) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    throw new Error("processId must be a positive integer.");
+  if (!/^[1-9]\d*$/u.test(startedAt))
+    throw new Error("startedAt must be a positive FILETIME string.");
+  const isTarget = () => readWineProcessStartTime(pid, procRoot) === startedAt;
+  if (!isTarget())
+    return;
+  signalProcess(pid, "SIGTERM");
+  const graceDeadline = Date.now() + Math.min(TERMINATE_GRACE_MS, timeoutMs / 2);
+  while (Date.now() < graceDeadline) {
+    await delay3(POLL_INTERVAL_MS);
+    if (!isTarget())
+      return;
+  }
+  if (isTarget())
+    signalProcess(pid, "SIGKILL");
+}
+function killOrphanedWineLaunchGate(pid, startedAt, procRoot = DEFAULT_PROC_ROOT) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  const stat2 = readProcStat(procRoot, pid);
+  if (stat2?.state !== "T")
+    return false;
+  if (procStartTimeToFileTime(bootTimeSeconds(procRoot), stat2.startTimeTicks) !== startedAt)
+    return false;
+  const cmdline = readCmdline(procRoot, pid);
+  if (cmdline?.[1] !== "-c" || cmdline[2] !== GATE_SCRIPT)
+    return false;
+  signalProcess(pid, "SIGKILL");
+  return true;
+}
+function studioExecTimeoutMs(explicit) {
+  if (explicit !== void 0)
+    return explicit;
+  const configured = process.env[STUDIO_EXEC_TIMEOUT_ENV];
+  if (configured === void 0 || configured === "")
+    return STUDIO_EXEC_TIMEOUT_MS;
+  const value = /^\d+$/u.test(configured) ? Number(configured) : NaN;
+  if (!Number.isSafeInteger(value) || value < 1 || value > MAX_STUDIO_EXEC_TIMEOUT_MS) {
+    throw new Error(`${STUDIO_EXEC_TIMEOUT_ENV} must be a whole number of milliseconds from 1 to ${MAX_STUDIO_EXEC_TIMEOUT_MS}; got "${configured}".`);
+  }
+  return value;
+}
+function openLauncherLog(logDir) {
+  try {
+    mkdirSync(logDir, { recursive: true });
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/gu, "-");
+    const file = path4.join(logDir, `${stamp}-${randomUUID3().slice(0, 8)}.log`);
+    const fd = openSync(file, "a", 384);
+    const logs = readdirSync(logDir).filter((name) => name.endsWith(".log")).sort();
+    for (const name of logs.slice(0, Math.max(0, logs.length - LAUNCHER_LOGS_KEPT))) {
+      rmSync(path4.join(logDir, name), { force: true });
+    }
+    return { file, fd };
+  } catch (error) {
+    console.error(`[studio] Could not open a Wine launcher log in ${logDir}; launcher output is discarded: ${error instanceof Error ? error.message : String(error)}`);
+    return void 0;
+  }
+}
+function launcherLogTail(file) {
+  if (file === void 0)
+    return "";
+  let tail;
+  try {
+    const fd = openSync(file, "r");
+    try {
+      const size = fstatSync(fd).size;
+      const length = Math.min(size, LAUNCHER_LOG_TAIL_BYTES);
+      const buffer = Buffer.alloc(length);
+      readSync(fd, buffer, 0, length, size - length);
+      tail = buffer.toString("utf8");
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return ` Launcher log: ${file}.`;
+  }
+  const lines = tail.trimEnd().split("\n").slice(-LAUNCHER_LOG_TAIL_LINES).join("\n");
+  return lines ? ` Launcher output (${file}):
+${lines}` : ` The launcher wrote no output (log: ${file}).`;
+}
+async function spawnWineStudio(launcher, exe, args, spawnOptions, options = {}) {
+  const procRoot = options.procRoot ?? DEFAULT_PROC_ROOT;
+  const execTimeoutMs = studioExecTimeoutMs(options.studioExecTimeoutMs);
+  const log = options.logDir === void 0 ? void 0 : openLauncherLog(options.logDir);
+  let child;
+  try {
+    child = spawn("/bin/sh", ["-c", GATE_SCRIPT, launcher, exe, ...args], {
+      cwd: spawnOptions.cwd,
+      env: spawnOptions.env,
+      detached: true,
+      stdio: log ? ["ignore", log.fd, log.fd] : "ignore"
+    });
+  } finally {
+    if (log)
+      closeSync(log.fd);
+  }
+  const logTail = () => launcherLogTail(log?.file);
+  let exitDetail;
+  const { promise: exited, resolve: markExited } = Promise.withResolvers();
+  child.once("exit", (code, signal) => {
+    exitDetail ??= signal ? `signal ${signal}` : `code ${code}`;
+    markExited();
+  });
+  child.once("error", (error) => {
+    exitDetail ??= error.message;
+  });
+  const pid = child.pid;
+  if (pid === void 0) {
+    await delay3(0);
+    throw new Error(`Failed to start the Wine Studio launch gate: ${exitDetail ?? "no PID was assigned"}.`);
+  }
+  const gateDeadline = Date.now() + (options.gateTimeoutMs ?? GATE_TIMEOUT_MS);
+  let gated;
+  try {
+    while (exitDetail === void 0 && Date.now() < gateDeadline) {
+      const stat2 = readProcStat(procRoot, pid);
+      if (stat2?.state === "T") {
+        gated = stat2;
+        break;
+      }
+      await delay3(10);
+    }
+  } catch (error) {
+    child.kill("SIGKILL");
+    throw error;
+  }
+  if (!gated) {
+    child.kill("SIGKILL");
+    throw new Error(exitDetail === void 0 ? "Timed out waiting for the Wine Studio launch gate to stop; the gated process was killed." : `Wine Studio launch gate exited before stopping (${exitDetail}).${logTail()}`);
+  }
+  const nativeStartedAt = procStartTimeToFileTime(bootTimeSeconds(procRoot), gated.startTimeTicks);
+  let controlState = "pending";
+  const authorize = async () => {
+    if (controlState === "resumed")
+      return;
+    if (controlState !== "pending") {
+      throw new Error(`Studio launch cannot be authorized from ${controlState}.`);
+    }
+    controlState = "authorizing";
+    child.kill("SIGCONT");
+    const deadline = Date.now() + execTimeoutMs;
+    try {
+      while (exitDetail === void 0 && Date.now() < deadline) {
+        if (readWineProcessStartTime(pid, procRoot) === nativeStartedAt && isWineStudioCommand(readArgv0(procRoot, pid))) {
+          controlState = "resumed";
+          return;
+        }
+        await delay3(POLL_INTERVAL_MS);
+      }
+    } catch (error) {
+      controlState = "aborted";
+      child.kill("SIGKILL");
+      throw error;
+    }
+    controlState = "aborted";
+    if (exitDetail !== void 0) {
+      throw new Error(`Wine Studio process ${pid} exited (${exitDetail}) before RobloxStudioBeta.exe started.${logTail()}`);
+    }
+    child.kill("SIGKILL");
+    throw new Error(`Wine launcher did not exec RobloxStudioBeta.exe in gated process ${pid} within ${execTimeoutMs} ms; the process was killed. ROBLOX_STUDIO_WINE_LAUNCHER must exec Wine so Studio keeps the launcher PID; if Wine is only slow to start, raise ${STUDIO_EXEC_TIMEOUT_ENV}.${logTail()}`);
+  };
+  const release = async () => {
+    if (controlState === "released")
+      return;
+    if (controlState !== "resumed") {
+      throw new Error(`Studio launch cannot be released from ${controlState}.`);
+    }
+    controlState = "released";
+  };
+  const abort = async () => {
+    if (controlState === "released")
+      return;
+    controlState = "aborted";
+    if (exitDetail !== void 0)
+      return;
+    child.kill("SIGKILL");
+    const { promise: timedOut, resolve: markTimedOut } = Promise.withResolvers();
+    const timer = setTimeout(() => markTimedOut(true), ABORT_TIMEOUT_MS);
+    try {
+      if (await Promise.race([exited.then(() => false), timedOut])) {
+        throw new Error(`Timed out aborting Wine Studio process ${pid}.`);
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  return {
+    pid,
+    nativePid: pid,
+    nativeStartedAt,
+    unref: () => child.unref(),
+    authorize,
+    release,
+    abort,
+    onExit: (listener) => {
+      child.once("exit", listener);
+    },
+    onError: (listener) => {
+      child.once("error", listener);
+    }
+  };
+}
+
 // ../core/dist/studio-instance-manager.js
-var BASEPLATE_TEMP_DIR = path3.join(os2.tmpdir(), "robloxstudio-mcp-baseplates");
+var BASEPLATE_TEMP_DIR = path5.join(os2.tmpdir(), "robloxstudio-mcp-baseplates");
 var BASEPLATE_TEMP_NAME = /^Baseplate-\d+-\d+\.rbxl$/;
 var BASEPLATE_TEMPLATE_NAME = "Baseplate.rbxl";
 var retainedLaunchControls = /* @__PURE__ */ new Map();
@@ -4101,6 +4571,9 @@ async function runAsync(command, args, options = {}) {
 function isWsl() {
   return getStudioPlatformCapabilities().isWsl;
 }
+function isWineHost() {
+  return getStudioPlatformCapabilities().processIdentity.launcher === "wine-retained";
+}
 async function powershellAsync(script, timeoutMs = 15e3) {
   return runAsync("powershell.exe", ["-NoProfile", "-Command", script], {
     cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd(),
@@ -4144,7 +4617,9 @@ async function toWslPathAsync(windowsPath) {
   return runAsync("wslpath", ["-u", windowsPath]);
 }
 async function toStudioLaunchArgAsync(arg) {
-  if (!isWsl() || !path3.isAbsolute(arg) || !existsSync2(arg))
+  if (isWineHost() && path5.isAbsolute(arg) && existsSync2(arg))
+    return toWineWindowsPath(arg);
+  if (!isWsl() || !path5.isAbsolute(arg) || !existsSync2(arg))
     return arg;
   return runAsync("wslpath", ["-w", arg]);
 }
@@ -4464,7 +4939,8 @@ public sealed class McpSuspendedStudio : IDisposable
 
     private static IntPtr OpenTestWorkerJob(string name)
     {
-        if (name == null) return IntPtr.Zero;
+        // PowerShell passes $null to a .NET string parameter as "", so both mean "no worker job".
+        if (String.IsNullOrEmpty(name)) return IntPtr.Zero;
         if (!System.Text.RegularExpressions.Regex.IsMatch(name, @"\\ALocal\\\\RsmcpStudioWorker-[a-f0-9]{32}\\z"))
             throw new ArgumentException("Invalid Studio test worker job name");
         IntPtr handle = OpenJobObjectW(5, false, name);
@@ -4640,7 +5116,7 @@ var studioLogsRoot;
 async function settleWindowsStudioSignIn(startedAt) {
   studioLogsRoot ??= (async () => {
     const localAppData = await windowsLocalAppDataAsync();
-    return localAppData ? path3.join(await toWslPathAsync(localAppData), "Roblox", "logs") : void 0;
+    return localAppData ? path5.join(await toWslPathAsync(localAppData), "Roblox", "logs") : void 0;
   })();
   const logsRoot = await studioLogsRoot;
   if (!logsRoot)
@@ -4657,7 +5133,7 @@ async function spawnWindowsStudio(exe, args, processEnvironment, studioWorkingDi
   const windowsWorkingDirectory = studioWorkingDirectory ? await toStudioLaunchArgAsync(studioWorkingDirectory) : void 0;
   const testWorkerJobName = process.env.RSMCP_STUDIO_TEST_WORKER_JOB;
   const script = buildWindowsStudioStartScriptFromConvertedExe(windowsExe, args, processEnvironment, windowsWorkingDirectory, testWorkerJobName);
-  const launcher = spawn("powershell.exe", ["-NoProfile", "-Command", script], {
+  const launcher = spawn2("powershell.exe", ["-NoProfile", "-Command", script], {
     cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd(),
     stdio: ["pipe", "pipe", "pipe"],
     windowsHide: true
@@ -4877,21 +5353,21 @@ function resolveEntrypointDir() {
   if (!entrypoint)
     return void 0;
   try {
-    return path3.dirname(realpathSync(entrypoint));
+    return path5.dirname(realpathSync(entrypoint));
   } catch {
-    return path3.dirname(path3.resolve(entrypoint));
+    return path5.dirname(path5.resolve(entrypoint));
   }
 }
 function resolveBaseplateTemplatePath() {
   const entrypointDir = resolveEntrypointDir();
   const candidates = [
     ...entrypointDir ? [
-      path3.join(entrypointDir, "assets", BASEPLATE_TEMPLATE_NAME),
-      path3.join(entrypointDir, "..", "assets", BASEPLATE_TEMPLATE_NAME)
+      path5.join(entrypointDir, "assets", BASEPLATE_TEMPLATE_NAME),
+      path5.join(entrypointDir, "..", "assets", BASEPLATE_TEMPLATE_NAME)
     ] : [],
-    path3.join(process.cwd(), "packages", "core", "assets", BASEPLATE_TEMPLATE_NAME),
-    path3.join(process.cwd(), "packages", "robloxstudio-mcp", "dist", "assets", BASEPLATE_TEMPLATE_NAME),
-    path3.join(process.cwd(), "assets", BASEPLATE_TEMPLATE_NAME)
+    path5.join(process.cwd(), "packages", "core", "assets", BASEPLATE_TEMPLATE_NAME),
+    path5.join(process.cwd(), "packages", "robloxstudio-mcp", "dist", "assets", BASEPLATE_TEMPLATE_NAME),
+    path5.join(process.cwd(), "assets", BASEPLATE_TEMPLATE_NAME)
   ];
   for (const candidate of candidates) {
     if (existsSync2(candidate))
@@ -4913,7 +5389,7 @@ function isProcessAlive2(pid) {
 function sweepStaleBaseplateFiles() {
   let entries;
   try {
-    entries = readdirSync(BASEPLATE_TEMP_DIR);
+    entries = readdirSync2(BASEPLATE_TEMP_DIR);
   } catch {
     return;
   }
@@ -4924,24 +5400,24 @@ function sweepStaleBaseplateFiles() {
       continue;
     if (Number(match[1]) !== process.pid && isProcessAlive2(Number(match[1])))
       continue;
-    const file = path3.join(BASEPLATE_TEMP_DIR, entry);
+    const file = path5.join(BASEPLATE_TEMP_DIR, entry);
     try {
-      if (statSync(file).mtimeMs < cutoff)
-        rmSync(file, { force: true });
+      if (statSync2(file).mtimeMs < cutoff)
+        rmSync2(file, { force: true });
     } catch {
     }
   }
 }
 function createBaseplatePlaceFile() {
-  mkdirSync(BASEPLATE_TEMP_DIR, { recursive: true });
+  mkdirSync2(BASEPLATE_TEMP_DIR, { recursive: true });
   sweepStaleBaseplateFiles();
-  const file = path3.join(BASEPLATE_TEMP_DIR, `Baseplate-${process.pid}-${Date.now()}.rbxl`);
+  const file = path5.join(BASEPLATE_TEMP_DIR, `Baseplate-${process.pid}-${Date.now()}.rbxl`);
   copyFileSync(resolveBaseplateTemplatePath(), file);
   return file;
 }
 function isGeneratedBaseplatePlaceFile(file) {
-  const resolvedFile = path3.resolve(file);
-  return path3.dirname(resolvedFile) === path3.resolve(BASEPLATE_TEMP_DIR) && BASEPLATE_TEMP_NAME.test(path3.basename(resolvedFile));
+  const resolvedFile = path5.resolve(file);
+  return path5.dirname(resolvedFile) === path5.resolve(BASEPLATE_TEMP_DIR) && BASEPLATE_TEMP_NAME.test(path5.basename(resolvedFile));
 }
 function cleanupManagedBaseplateFiles(record) {
   if (record.source !== "baseplate" || !record.localPlaceFile)
@@ -4950,7 +5426,7 @@ function cleanupManagedBaseplateFiles(record) {
     return;
   for (const file of [record.localPlaceFile, `${record.localPlaceFile}.lock`]) {
     try {
-      rmSync(file, { force: true });
+      rmSync2(file, { force: true });
     } catch {
     }
   }
@@ -4967,21 +5443,33 @@ function resolveStudioExeFromVersions(root) {
   if (!existsSync2(root)) {
     throw new Error(`Roblox Studio Versions folder not found: ${root}. Set ROBLOX_STUDIO_EXE.`);
   }
-  const candidates = readdirSync(root).filter((name) => name.startsWith("version-")).map((name) => path3.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync2(candidate)).sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
+  const candidates = readdirSync2(root).filter((name) => name.startsWith("version-")).map((name) => path5.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync2(candidate)).sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs);
   if (candidates.length === 0) {
     throw new Error(`RobloxStudioBeta.exe not found under ${root}. Set ROBLOX_STUDIO_EXE.`);
   }
   const exe = candidates[0];
-  const installationDir = path3.dirname(exe);
-  const hasIncompleteDownload = readdirSync(installationDir).some((name) => /\.crdownload$/i.test(name));
-  const settings = statSync(path3.join(installationDir, "AppSettings.xml"), { throwIfNoEntry: false });
+  const installationDir = path5.dirname(exe);
+  const hasIncompleteDownload = readdirSync2(installationDir).some((name) => /\.crdownload$/i.test(name));
+  const settings = statSync2(path5.join(installationDir, "AppSettings.xml"), { throwIfNoEntry: false });
   if (hasIncompleteDownload || !settings?.isFile() || settings.size === 0) {
     const reason = hasIncompleteDownload ? "an unfinished .crdownload download is present" : "AppSettings.xml is missing, empty, or not a regular file";
     throw new Error(`Roblox Studio installation/update is incomplete at ${installationDir}: ${reason}. Complete the installation/update or reinstall Roblox Studio under the owning Windows account before launching.`);
   }
   return exe;
 }
+function resolveNativeLinuxStudioExe() {
+  const exe = process.env.ROBLOX_STUDIO_EXE;
+  if (!exe) {
+    throw new Error("Set ROBLOX_STUDIO_EXE to RobloxStudioBeta.exe inside your Wine prefix to launch Studio on native Linux.");
+  }
+  if (!statSync2(exe, { throwIfNoEntry: false })?.isFile()) {
+    throw new Error(`ROBLOX_STUDIO_EXE does not name an existing file: ${exe}`);
+  }
+  return exe;
+}
 function resolveStudioExe() {
+  if (process.platform === "linux" && isWineHost())
+    return resolveNativeLinuxStudioExe();
   if (process.env.ROBLOX_STUDIO_EXE)
     return process.env.ROBLOX_STUDIO_EXE;
   if (process.platform === "darwin") {
@@ -4991,10 +5479,12 @@ function resolveStudioExe() {
     throw new Error("Roblox Studio executable auto-discovery is only supported on Windows, WSL, and macOS. Set ROBLOX_STUDIO_EXE.");
   }
   const localAppData = windowsLocalAppData();
-  const root = localAppData ? path3.join(toWslPath(localAppData), "Roblox", "Versions") : path3.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
+  const root = localAppData ? path5.join(toWslPath(localAppData), "Roblox", "Versions") : path5.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
   return resolveStudioExeFromVersions(root);
 }
 async function resolveStudioExeAsync() {
+  if (process.platform === "linux" && isWineHost())
+    return resolveNativeLinuxStudioExe();
   if (process.env.ROBLOX_STUDIO_EXE)
     return process.env.ROBLOX_STUDIO_EXE;
   if (process.platform === "darwin") {
@@ -5004,7 +5494,7 @@ async function resolveStudioExeAsync() {
     throw new Error("Roblox Studio executable auto-discovery is only supported on Windows, WSL, and macOS. Set ROBLOX_STUDIO_EXE.");
   }
   const localAppData = await windowsLocalAppDataAsync();
-  const root = localAppData ? path3.join(await toWslPathAsync(localAppData), "Roblox", "Versions") : path3.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
+  const root = localAppData ? path5.join(await toWslPathAsync(localAppData), "Roblox", "Versions") : path5.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
   return resolveStudioExeFromVersions(root);
 }
 var WINDOWS_STUDIO_PROCESS_QUERY = [
@@ -5041,6 +5531,9 @@ async function observeStudioProcesses(timeoutMs = 15e3) {
       }).filter((proc) => Number.isFinite(proc.Id));
       return { status: "ok", observedAt, processes };
     }
+    if (process.platform === "linux" && isWineHost()) {
+      return { status: "ok", observedAt, processes: listWineStudioProcesses() };
+    }
     if (process.platform !== "win32" && !isWsl()) {
       return { status: "ok", observedAt, processes: [] };
     }
@@ -5057,7 +5550,7 @@ async function observeStudioProcesses(timeoutMs = 15e3) {
 async function currentBootIdAsync() {
   if (process.platform === "linux") {
     try {
-      return readFileSync2("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      return readFileSync3("/proc/sys/kernel/random/boot_id", "utf8").trim();
     } catch {
     }
   }
@@ -5108,11 +5601,11 @@ function buildStudioLaunchArgs(options) {
       ];
   }
 }
-function delay3(ms) {
+function delay4(ms) {
   return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function basenameAny(filePath) {
-  return path3.basename(filePath.replace(/\\/g, "/"));
+  return path5.basename(filePath.replace(/\\/g, "/"));
 }
 var StudioInstanceManager = class {
   managedByInstanceId = /* @__PURE__ */ new Map();
@@ -5364,8 +5857,15 @@ var StudioInstanceManager = class {
         proc = await this.processAdapter.spawnStudio(exe, args, spawnOptions);
       } else if (lifecycleCapabilities.processIdentity.launcher === "windows-retained" || lifecycleCapabilities.processIdentity.launcher === "wsl-windows-retained") {
         proc = await this.windowsStudioLauncher(exe, args, processEnvironment, studioWorkingDirectory);
+      } else if (lifecycleCapabilities.processIdentity.launcher === "wine-retained") {
+        const wineLauncher = (this.platformCapabilities ?? getStudioPlatformCapabilities()).wineLauncher;
+        if (!wineLauncher)
+          throw new Error("The Wine Studio launcher path is unavailable.");
+        proc = await spawnWineStudio(wineLauncher, exe, args, spawnOptions, {
+          logDir: path5.join(this.registry.dir, "wine-launches")
+        });
       } else {
-        const child = spawn(exe, args, spawnOptions);
+        const child = spawn2(exe, args, spawnOptions);
         proc = {
           pid: child.pid,
           nativePid: child.pid,
@@ -5415,7 +5915,7 @@ var StudioInstanceManager = class {
     }
     const launchedAt = Date.now();
     const record = {
-      recordId: randomUUID3(),
+      recordId: randomUUID4(),
       source: options.source,
       nativeProcessId: proc.nativePid,
       nativeProcessStartedAt: proc.nativeStartedAt,
@@ -5485,7 +5985,7 @@ var StudioInstanceManager = class {
         await this.persist(record);
         break;
       }
-      await delay3(250);
+      await delay4(250);
     }
     if (record.nativeProcessId === void 0 && process.platform !== "win32" && !isWsl()) {
       record.nativeProcessId = proc.pid;
@@ -5667,6 +6167,11 @@ var StudioInstanceManager = class {
           throw new Error("Cannot stop a Windows Studio process without its creation-time identity.");
         }
         await stopWindowsStudio(processId, startedAt, Math.max(1, deadline - Date.now()));
+      } else if (isWineHost()) {
+        if (startedAt === void 0) {
+          throw new Error("Cannot stop a Wine Studio process without its creation-time identity.");
+        }
+        await stopWineStudio(processId, startedAt, Math.max(1, deadline - Date.now()));
       } else {
         try {
           process.kill(processId, "SIGTERM");
@@ -5687,7 +6192,7 @@ var StudioInstanceManager = class {
       if (remaining <= 0) {
         throw new StudioCloseVerificationError(`Timed out closing Studio process ${processId}: the process is still running. Close can be retried.`, observation);
       }
-      await delay3(Math.min(100, remaining));
+      await delay4(Math.min(100, remaining));
       if (Date.now() >= deadline) {
         throw new StudioCloseVerificationError(`Timed out closing Studio process ${processId}: the process is still running. Close can be retried.`, observation);
       }
@@ -5784,15 +6289,39 @@ var StudioInstanceManager = class {
       confirmedExitGraceMs: this.confirmedExitGraceMs
     };
   }
+  isOrphanedUnreleasedLaunch(registryRecord, currentBootId) {
+    const ownerPid = registryRecord.ownerPid;
+    return !(registryRecord.processAuthorizationState === "released" || this.launchControls.has(registryRecord.recordId) || registryRecord.bootId !== currentBootId || ownerPid === void 0 || ownerPid !== process.pid && isProcessAlive2(ownerPid));
+  }
+  // A broker that dies between spawn and authorization leaves its Wine launch
+  // gate stopped. The gate is /bin/sh, not Studio, so the orphan cleanup below
+  // never sees it in a Studio snapshot.
+  async reapOrphanedWineLaunchGates(currentBootId) {
+    if (this.getLifecycleCapabilities().processIdentity.launcher !== "wine-retained")
+      return;
+    for (const registryRecord of await this.registry.listOpenUnchecked()) {
+      const processId = registryRecord.nativeProcessId;
+      const startedAt = registryRecord.nativeProcessStartedAt;
+      if (registryRecord.processAuthorizationState !== "pending" || !processId || !startedAt || !this.isOrphanedUnreleasedLaunch(registryRecord, currentBootId)) {
+        continue;
+      }
+      try {
+        if (killOrphanedWineLaunchGate(processId, startedAt)) {
+          console.error(`[studio] Killed Wine launch gate ${processId}, left stopped by a broker that exited before authorizing it.`);
+        }
+      } catch (error) {
+        console.error(`[studio] Could not check orphaned Wine launch gate ${processId}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
   async sweepRegistry(snapshot) {
     const sweepOptions = await this.registrySweepOptions(snapshot);
+    await this.reapOrphanedWineLaunchGates(sweepOptions.currentBootId);
     await this.registry.sweep(sweepOptions);
     const persisted = await this.registry.listOpenUnchecked();
     for (const registryRecord of persisted) {
-      const ownerPid = registryRecord.ownerPid;
-      if (registryRecord.processAuthorizationState === "released" || this.launchControls.has(registryRecord.recordId) || registryRecord.bootId !== sweepOptions.currentBootId || ownerPid === void 0 || ownerPid !== process.pid && isProcessAlive2(ownerPid)) {
+      if (!this.isOrphanedUnreleasedLaunch(registryRecord, sweepOptions.currentBootId))
         continue;
-      }
       const record = this.fromRegistryRecord(registryRecord);
       if (this.observeRecord(record, snapshot).status !== "running")
         continue;
@@ -5855,13 +6384,13 @@ var StudioInstanceManager = class {
     const processId = record.nativeProcessId ?? record.spawnPid;
     if (record.spawnPid && record.spawnPid === processId && studioProcess.Id === processId)
       return true;
-    const processPath = studioProcess.Path ? path3.normalize(studioProcess.Path).toLowerCase() : "";
-    const exePath = record.exe ? path3.normalize(record.exe).toLowerCase() : "";
+    const processPath = studioProcess.Path ? path5.normalize(studioProcess.Path).toLowerCase() : "";
+    const exePath = record.exe ? path5.normalize(record.exe).toLowerCase() : "";
     if (processPath && exePath && (processPath === exePath || basenameAny(processPath) === basenameAny(exePath))) {
       return true;
     }
     const commandLine = studioProcess.CommandLine ?? "";
-    if (record.localPlaceFile && commandLine.includes(path3.basename(record.localPlaceFile)))
+    if (record.localPlaceFile && commandLine.includes(path5.basename(record.localPlaceFile)))
       return true;
     if (record.placeId !== void 0 && commandLine.includes(String(record.placeId)))
       return true;
@@ -6180,6 +6709,7 @@ var OPEN_WORLD_TOOLS = /* @__PURE__ */ new Set([
   "get_asset_thumbnail",
   "get_roblox_docs",
   "insert_asset",
+  "manage_monetization",
   "preview_asset",
   "search_assets",
   "upload_asset"
@@ -6392,17 +6922,17 @@ function createToolHttpHandler(options) {
 
 // ../core/dist/auth.js
 import { randomBytes, createHash as createHash2, timingSafeEqual } from "crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync, linkSync, unlinkSync } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2, linkSync as linkSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
 import { homedir as homedir3 } from "os";
 function authTokenFilePath() {
-  return join4(homedir3(), ".robloxstudio-mcp", "auth-token");
+  return join5(homedir3(), ".robloxstudio-mcp", "auth-token");
 }
 var EMPTY_TOKEN_RETRY_MS = 25;
 var EMPTY_TOKEN_RETRIES = 20;
 function readTokenFile(filePath) {
   for (let attempt = 0; ; attempt++) {
-    const token = readFileSync3(filePath, "utf8").trim();
+    const token = readFileSync4(filePath, "utf8").trim();
     if (token || attempt >= EMPTY_TOKEN_RETRIES)
       return token;
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, EMPTY_TOKEN_RETRY_MS);
@@ -6429,12 +6959,12 @@ function resolveAuthToken() {
         throw error;
     }
     const fresh = randomBytes(32).toString("hex");
-    mkdirSync2(dirname2(filePath), { recursive: true, mode: 448 });
+    mkdirSync3(dirname2(filePath), { recursive: true, mode: 448 });
     const stagingPath = `${filePath}.${process.pid}.${randomBytes(16).toString("hex")}.tmp`;
-    writeFileSync(stagingPath, fresh + "\n", { encoding: "utf8", mode: 384, flag: "wx" });
+    writeFileSync2(stagingPath, fresh + "\n", { encoding: "utf8", mode: 384, flag: "wx" });
     try {
       try {
-        linkSync(stagingPath, filePath);
+        linkSync2(stagingPath, filePath);
       } catch (error) {
         if (error.code !== "EEXIST")
           throw error;
@@ -6445,7 +6975,7 @@ function resolveAuthToken() {
       return { token, source: "file", filePath };
     } finally {
       try {
-        unlinkSync(stagingPath);
+        unlinkSync2(stagingPath);
       } catch {
       }
     }
@@ -6800,7 +7330,8 @@ var TOOL_PROXY_ENDPOINTS = {
   get_scene_analysis: ["/api/get-scene-analysis"],
   export_rbxm: ["/api/export-rbxm"],
   import_rbxm: ["/api/import-rbxm"],
-  find_and_replace_in_scripts: ["/api/find-and-replace-in-scripts"]
+  find_and_replace_in_scripts: ["/api/find-and-replace-in-scripts"],
+  manage_monetization: ["/api/place-info"]
 };
 function toPassivePeer(peer) {
   return {
@@ -6918,6 +7449,7 @@ var TOOL_HANDLERS = {
   set_device_simulator: (tools, body) => tools.setDeviceSimulator(body.target, body.deviceId, body.orientation, body.resolution, body.pixelDensity, body.scalingMode, body.stopSimulation, body.instance_id),
   capture_device_matrix: (tools, body) => tools.captureDeviceMatrix(body.entries, body.target, body.format, body.quality, body.settleSeconds, body.restoreAfter, body.instance_id),
   manage_instance: (tools, body) => tools.manageInstance(body),
+  manage_monetization: (tools, body) => tools.manageMonetization(body, body.instance_id),
   solo_playtest: (tools, body) => tools.soloPlaytest(body.action, body.mode, body.timeout, body.instance_id),
   multiplayer_playtest: (tools, body) => tools.multiplayerPlaytest(body.action, body.numPlayers, body.target, body.testArgs, body.value, body.timeout, body.instance_id),
   get_runtime_logs: (tools, body, context) => tools.getRuntimeLogs(body.instance_id, body.multiplayer_group_id, body.cursor, body.cursor_by_instance, body.tail, body.filter, context?.signal),
@@ -7135,8 +7667,8 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   });
   const authToken = security?.authToken;
   const authRequired = (requestPath) => {
-    const path9 = requestPath.toLowerCase().replace(/\/+$/, "");
-    return path9 === "/mcp" || path9.startsWith("/mcp/") || path9 === "/proxy" || path9 === "/topology" || path9 === "/request-status" || path9 === "/unregister-instance-id" || path9 === "/create-multiplayer-group" || path9 === "/remove-multiplayer-group";
+    const path11 = requestPath.toLowerCase().replace(/\/+$/, "");
+    return path11 === "/mcp" || path11.startsWith("/mcp/") || path11 === "/proxy" || path11 === "/topology" || path11 === "/request-status" || path11 === "/unregister-instance-id" || path11 === "/create-multiplayer-group" || path11 === "/remove-multiplayer-group";
   };
   app.use((req, res, next) => {
     if (!authToken || !authRequired(req.path)) {
@@ -7737,6 +8269,56 @@ var StudioHttpClient = class {
 };
 
 // ../core/dist/opencloud-client.js
+var MONETIZATION_APIS = {
+  developer_product: {
+    label: "developer product",
+    collectionPath: (universeId) => `/developer-products/v2/universes/${universeId}/developer-products`,
+    listField: "developerProducts",
+    idField: "productId",
+    iconField: "iconImageAssetId"
+  },
+  game_pass: {
+    label: "game pass",
+    collectionPath: (universeId) => `/game-passes/v1/universes/${universeId}/game-passes`,
+    listField: "gamePasses",
+    idField: "gamePassId",
+    iconField: "iconAssetId"
+  }
+};
+function readField(source, key) {
+  return typeof source === "object" && source !== null ? Reflect.get(source, key) : void 0;
+}
+function positiveSafeInteger(value) {
+  const parsed = typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
+  return typeof parsed === "number" && Number.isSafeInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+function normalizeMonetizationItem(kind, universeId, value) {
+  const api = MONETIZATION_APIS[kind];
+  const id = positiveSafeInteger(readField(value, api.idField));
+  if (id === void 0) {
+    throw new Error(`Open Cloud returned a ${api.label} without a valid ${api.idField}.`);
+  }
+  const name = readField(value, "name");
+  const description = readField(value, "description");
+  const price = readField(readField(value, "priceInformation"), "defaultPriceInRobux");
+  const createdAt = readField(value, "createdTimestamp");
+  const updatedAt = readField(value, "updatedTimestamp");
+  const immutable = readField(value, "isImmutable");
+  return {
+    kind,
+    id,
+    universeId: positiveSafeInteger(readField(value, "universeId")) ?? universeId,
+    name: typeof name === "string" ? name : "",
+    description: typeof description === "string" ? description : "",
+    forSale: readField(value, "isForSale") === true,
+    price: typeof price === "number" && Number.isSafeInteger(price) && price >= 0 ? price : null,
+    managedPricing: readField(value, "isManagedPricingEnabled") === true,
+    iconAssetId: positiveSafeInteger(readField(value, api.iconField)) ?? null,
+    ...typeof createdAt === "string" ? { createdAt } : {},
+    ...typeof updatedAt === "string" ? { updatedAt } : {},
+    ...kind === "developer_product" && typeof immutable === "boolean" ? { immutable } : {}
+  };
+}
 function detectAudioMimeType(data) {
   if (data.length >= 4 && data.subarray(0, 4).toString("ascii") === "OggS") {
     return "audio/ogg";
@@ -7752,6 +8334,68 @@ function detectAudioMimeType(data) {
   }
   return void 0;
 }
+var OpenCloudRequestError = class extends Error {
+  status;
+  details;
+  constructor(message, status, details = {}) {
+    super(message);
+    this.status = status;
+    this.details = details;
+    this.name = "OpenCloudRequestError";
+  }
+};
+async function openCloudResponseError(response) {
+  const errorBody = await response.text();
+  let parsed;
+  try {
+    parsed = JSON.parse(errorBody);
+  } catch {
+    parsed = void 0;
+  }
+  const text = (key) => {
+    const value = readField(parsed, key);
+    return typeof value === "string" && value ? value : void 0;
+  };
+  const errorMessage2 = text("detail") ?? text("message") ?? text("errorMessage") ?? errorBody;
+  const errorCode3 = readField(parsed, "errorCode");
+  const field = text("field");
+  const hint = text("hint");
+  const details = {
+    ...typeof errorCode3 === "string" || typeof errorCode3 === "number" ? { errorCode: errorCode3 } : {},
+    ...field ? { field } : {},
+    ...hint ? { hint } : {}
+  };
+  const { status } = response;
+  let message;
+  if (status === 401) {
+    message = "Invalid or expired API key";
+  } else if (status === 403) {
+    message = `API key lacks required permissions: ${errorMessage2}`;
+  } else if (status === 429) {
+    message = "Rate limit exceeded. Please try again later.";
+  } else {
+    message = `Open Cloud API error (${status}): ${errorMessage2}`;
+  }
+  return new OpenCloudRequestError(message, status, details);
+}
+function monetizationForm(changes) {
+  const form = new FormData();
+  if (changes.name !== void 0)
+    form.append("name", changes.name);
+  if (changes.description !== void 0)
+    form.append("description", changes.description);
+  if (changes.price !== void 0)
+    form.append("price", String(changes.price));
+  if (changes.forSale !== void 0)
+    form.append("isForSale", String(changes.forSale));
+  if (changes.managedPricing !== void 0) {
+    form.append("isManagedPricingEnabled", String(changes.managedPricing));
+  }
+  if (changes.icon) {
+    form.append("imageFile", new Blob([new Uint8Array(changes.icon.data)], { type: changes.icon.mimeType }), changes.icon.fileName);
+  }
+  return form;
+}
 var OpenCloudClient = class {
   apiKey;
   baseUrl;
@@ -7792,25 +8436,8 @@ var OpenCloudClient = class {
         body: body ? JSON.stringify(body) : void 0,
         signal: controller.signal
       });
-      if (!response.ok) {
-        const errorBody = await response.text();
-        let errorMessage2;
-        try {
-          const errorJson = JSON.parse(errorBody);
-          errorMessage2 = errorJson.detail || errorJson.message || errorBody;
-        } catch {
-          errorMessage2 = errorBody;
-        }
-        if (response.status === 401) {
-          throw new Error("Invalid or expired API key");
-        } else if (response.status === 403) {
-          throw new Error(`API key lacks required permissions: ${errorMessage2}`);
-        } else if (response.status === 429) {
-          throw new Error("Rate limit exceeded. Please try again later.");
-        } else {
-          throw new Error(`Open Cloud API error (${response.status}): ${errorMessage2}`);
-        }
-      }
+      if (!response.ok)
+        throw await openCloudResponseError(response);
       return await response.json();
     } catch (error) {
       if (controller.signal.aborted)
@@ -7855,6 +8482,36 @@ var OpenCloudClient = class {
       }
     });
   }
+  async listMonetizationItems(kind, universeId, pageToken) {
+    const api = MONETIZATION_APIS[kind];
+    const response = await this.request(`${api.collectionPath(universeId)}/creator`, {
+      params: { pageToken }
+    });
+    const rows = readField(response, api.listField);
+    if (!Array.isArray(rows)) {
+      throw new Error(`Open Cloud returned a ${api.label} list without ${api.listField}.`);
+    }
+    const nextPageToken = readField(response, "nextPageToken");
+    return {
+      items: rows.map((row) => normalizeMonetizationItem(kind, universeId, row)),
+      ...typeof nextPageToken === "string" && nextPageToken ? { nextPageToken } : {}
+    };
+  }
+  async getMonetizationItem(kind, universeId, id) {
+    const path11 = `${MONETIZATION_APIS[kind].collectionPath(universeId)}/${id}/creator`;
+    return normalizeMonetizationItem(kind, universeId, await this.request(path11));
+  }
+  async createMonetizationItem(kind, universeId, item) {
+    const response = await this.requestMultipart(MONETIZATION_APIS[kind].collectionPath(universeId), monetizationForm(item));
+    return normalizeMonetizationItem(kind, universeId, response);
+  }
+  /** Changes only the given fields. Roblox answers with an empty 204. */
+  async updateMonetizationItem(kind, universeId, id, changes) {
+    const path11 = `${MONETIZATION_APIS[kind].collectionPath(universeId)}/${id}`;
+    await this.sendMultipart(path11, monetizationForm(changes), "PATCH", async (response) => {
+      await response.arrayBuffer();
+    });
+  }
   async getAssetThumbnail(assetId, size = "420x420") {
     const url = `https://thumbnails.roblox.com/v1/assets?assetIds=${assetId}&size=${size}&format=Png`;
     try {
@@ -7904,7 +8561,7 @@ var OpenCloudClient = class {
   }
   async downloadAudioAssetContent(assetId, maxBytes) {
     if (!this.apiKey) {
-      throw new Error("Open Cloud API key not configured. Set ROBLOX_OPEN_CLOUD_API_KEY with asset:read permission to download audio previews.");
+      throw new Error("Open Cloud API key not configured. Set ROBLOX_OPEN_CLOUD_API_KEY with the legacy-asset:manage scope to download audio previews.");
     }
     if (!Number.isSafeInteger(assetId) || assetId <= 0) {
       throw new Error("Audio asset ID must be a positive integer.");
@@ -7922,7 +8579,8 @@ var OpenCloudClient = class {
         signal: controller.signal
       });
       if (!deliveryResponse.ok) {
-        throw new Error(`Roblox asset delivery request failed (${deliveryResponse.status}).`);
+        const scopeHint = deliveryResponse.status === 403 ? " The Open Cloud API key lacks the legacy-asset:manage scope required to download audio." : "";
+        throw new Error(`Roblox asset delivery request failed (${deliveryResponse.status}).${scopeHint}`);
       }
       const delivery = await deliveryResponse.json();
       if (!delivery.location) {
@@ -8016,7 +8674,11 @@ var OpenCloudClient = class {
     }
     return mimeTypes[ext];
   }
-  async requestMultipart(endpoint, formData) {
+  requestMultipart(endpoint, formData) {
+    return this.sendMultipart(endpoint, formData, "POST", async (response) => await response.json());
+  }
+  // readResponse runs inside the deadline, so a stalled body still times out.
+  async sendMultipart(endpoint, formData, method, readResponse) {
     if (!this.apiKey) {
       throw new Error("Open Cloud API key not configured. Set ROBLOX_OPEN_CLOUD_API_KEY environment variable.");
     }
@@ -8025,31 +8687,14 @@ var OpenCloudClient = class {
     const timeoutId = setTimeout(() => controller.abort(), this.timeout);
     try {
       const response = await fetch(url, {
-        method: "POST",
+        method,
         headers: { "x-api-key": this.apiKey },
         body: formData,
         signal: controller.signal
       });
-      if (!response.ok) {
-        const errorBody = await response.text();
-        let errorMessage2;
-        try {
-          const errorJson = JSON.parse(errorBody);
-          errorMessage2 = errorJson.detail || errorJson.message || errorBody;
-        } catch {
-          errorMessage2 = errorBody;
-        }
-        if (response.status === 401) {
-          throw new Error("Invalid or expired API key");
-        } else if (response.status === 403) {
-          throw new Error(`API key lacks required permissions: ${errorMessage2}`);
-        } else if (response.status === 429) {
-          throw new Error("Rate limit exceeded. Please try again later.");
-        } else {
-          throw new Error(`Open Cloud API error (${response.status}): ${errorMessage2}`);
-        }
-      }
-      return await response.json();
+      if (!response.ok)
+        throw await openCloudResponseError(response);
+      return await readResponse(response);
     } catch (error) {
       if (controller.signal.aborted)
         throw new Error("Request timed out");
@@ -8247,9 +8892,54 @@ var RobloxCookieClient = class {
 };
 
 // ../core/dist/image-decode.js
-import * as fs2 from "fs";
-import * as path4 from "path";
 import { inflateSync } from "zlib";
+
+// ../core/dist/local-file.js
+import * as fs2 from "fs";
+import * as path6 from "path";
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+}
+function readRegularFileWithinLimit(filePath, argumentName, validateSize) {
+  let descriptor;
+  try {
+    const flags = fs2.constants.O_RDONLY | (fs2.constants.O_NONBLOCK ?? 0);
+    descriptor = fs2.openSync(path6.resolve(filePath), flags);
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ENOENT") {
+      throw new Error(`${argumentName} not found: ${filePath}`);
+    }
+    if (code === "EISDIR") {
+      throw new Error(`${argumentName} must reference a regular file: ${filePath}`);
+    }
+    throw error;
+  }
+  try {
+    const stats = fs2.fstatSync(descriptor);
+    if (!stats.isFile()) {
+      throw new Error(`${argumentName} must reference a regular file: ${filePath}`);
+    }
+    validateSize(stats.size);
+    const data = Buffer.allocUnsafe(stats.size + 1);
+    let offset = 0;
+    while (offset < data.length) {
+      const bytesRead = fs2.readSync(descriptor, data, offset, data.length - offset, offset);
+      if (bytesRead === 0)
+        break;
+      offset += bytesRead;
+    }
+    if (offset !== stats.size) {
+      validateSize(offset);
+      throw new Error(`${argumentName} size changed while reading: ${filePath}`);
+    }
+    return data.subarray(0, offset);
+  } finally {
+    fs2.closeSync(descriptor);
+  }
+}
+
+// ../core/dist/image-decode.js
 var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
 var MAX_EDITABLE_IMAGE_DIMENSION = 1024;
 var MAX_PNG_DIMENSION = 16 * 1024;
@@ -8313,40 +9003,6 @@ function getBase64DecodedLength(encoded) {
   }
   return decodedLength;
 }
-function readPngFileWithinLimit(resolved, imagePath) {
-  let descriptor;
-  try {
-    const flags = fs2.constants.O_RDONLY | (fs2.constants.O_NONBLOCK ?? 0);
-    descriptor = fs2.openSync(resolved, flags);
-  } catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
-      throw new Error(`image_path not found: ${imagePath}`);
-    }
-    throw error;
-  }
-  try {
-    const stats = fs2.fstatSync(descriptor);
-    if (!stats.isFile()) {
-      throw new Error(`image_path must reference a regular file: ${imagePath}`);
-    }
-    validatePngInputSize(stats.size);
-    const data = Buffer.allocUnsafe(stats.size + 1);
-    let offset = 0;
-    while (offset < data.length) {
-      const bytesRead = fs2.readSync(descriptor, data, offset, data.length - offset, offset);
-      if (bytesRead === 0)
-        break;
-      offset += bytesRead;
-    }
-    if (offset !== stats.size) {
-      validatePngInputSize(offset);
-      throw new Error(`image_path size changed while reading: ${imagePath}`);
-    }
-    return data.subarray(0, offset);
-  } finally {
-    fs2.closeSync(descriptor);
-  }
-}
 function validateSourceDimensions(width, height, maxPixels) {
   if (width <= 0 || height <= 0) {
     throw new Error("PNG IHDR dimensions must be positive.");
@@ -8580,14 +9236,13 @@ function decodePngBase64ToRgba(encoded) {
   return decodePngToRgba(data);
 }
 function decodeImagePathToRgba(imagePath) {
-  const resolved = path4.resolve(imagePath);
-  return decodePngToRgba(readPngFileWithinLimit(resolved, imagePath));
+  return decodePngToRgba(readRegularFileWithinLimit(imagePath, "image_path", validatePngInputSize));
 }
 
 // ../core/dist/studio-skills.js
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import * as path5 from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import * as path7 from "path";
 
 // ../../node_modules/fzstd/esm/index.mjs
 var ab = ArrayBuffer;
@@ -9480,12 +10135,12 @@ function discoverNamedFile(root, fileName, depth = 0) {
   const matches = [];
   let entries;
   try {
-    entries = readdirSync2(root, { withFileTypes: true });
+    entries = readdirSync3(root, { withFileTypes: true });
   } catch {
     return matches;
   }
   for (const entry of entries) {
-    const entryPath = path5.join(root, entry.name);
+    const entryPath = path7.join(root, entry.name);
     if (entry.isFile() && entry.name.toLowerCase() === fileName.toLowerCase()) {
       matches.push(entryPath);
     } else if (entry.isDirectory()) {
@@ -9502,13 +10157,13 @@ function resolveAssistantBundlePath(studioExe) {
     }
     return override;
   }
-  const exeDirectory = path5.dirname(studioExe ?? resolveStudioExe());
+  const exeDirectory = path7.dirname(studioExe ?? resolveStudioExe());
   const roots = [
-    path5.join(exeDirectory, "BuiltInStandalonePlugins"),
-    path5.resolve(exeDirectory, "..", "Resources", "BuiltInStandalonePlugins"),
-    path5.resolve(exeDirectory, "..", "..", "OTAPlugins")
+    path7.join(exeDirectory, "BuiltInStandalonePlugins"),
+    path7.resolve(exeDirectory, "..", "Resources", "BuiltInStandalonePlugins"),
+    path7.resolve(exeDirectory, "..", "..", "OTAPlugins")
   ];
-  const direct = path5.join(exeDirectory, "BuiltInStandalonePlugins", "Optimized_Embedded_Signature", "Assistant.rbxm");
+  const direct = path7.join(exeDirectory, "BuiltInStandalonePlugins", "Optimized_Embedded_Signature", "Assistant.rbxm");
   const candidates = /* @__PURE__ */ new Set();
   if (existsSync3(direct))
     candidates.add(direct);
@@ -9516,7 +10171,7 @@ function resolveAssistantBundlePath(studioExe) {
     for (const candidate of discoverNamedFile(root, "Assistant.rbxm"))
       candidates.add(candidate);
   }
-  const newest = [...candidates].map((candidate) => ({ candidate, modifiedAt: statSync2(candidate).mtimeMs })).sort((left, right) => right.modifiedAt - left.modifiedAt)[0]?.candidate;
+  const newest = [...candidates].map((candidate) => ({ candidate, modifiedAt: statSync3(candidate).mtimeMs })).sort((left, right) => right.modifiedAt - left.modifiedAt)[0]?.candidate;
   if (!newest) {
     throw new Error(`Studio Assistant bundle not found for ${studioExe}. Set ROBLOX_STUDIO_ASSISTANT_BUNDLE to the installed Assistant.rbxm path.`);
   }
@@ -9524,16 +10179,16 @@ function resolveAssistantBundlePath(studioExe) {
 }
 var cachedBundle;
 function loadBuiltInStudioSkills(bundlePath = resolveAssistantBundlePath()) {
-  const stats = statSync2(bundlePath);
+  const stats = statSync3(bundlePath);
   if (cachedBundle?.path === bundlePath && cachedBundle.modifiedAt === stats.mtimeMs && cachedBundle.size === stats.size) {
     return cachedBundle.value;
   }
-  const buffer = readFileSync4(bundlePath);
+  const buffer = readFileSync5(bundlePath);
   const skills = parseBuiltInStudioSkills(buffer);
   if (skills.length === 0) {
     throw new Error(`No built-in skill documents found in ${bundlePath}`);
   }
-  const studioVersion = bundlePath.split(path5.sep).find((segment) => /^version-[a-z0-9]+$/i.test(segment));
+  const studioVersion = bundlePath.split(path7.sep).find((segment) => /^version-[a-z0-9]+$/i.test(segment));
   const value = {
     bundlePath,
     bundleModifiedAt: stats.mtime.toISOString(),
@@ -9549,6 +10204,314 @@ function findBuiltInStudioSkill(bundle, requestedName) {
   return bundle.skills.find((skill) => skill.name.toLowerCase() === wanted || skill.sourceName.toLowerCase() === wanted);
 }
 
+// ../core/dist/tools/monetization.js
+var MAX_PRICE_ROBUX = 1e9;
+var MAX_NAME_SCAN_PAGES = 200;
+var MAX_ICON_BYTES = 10 * 1024 * 1024;
+var PNG_SIGNATURE2 = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var SCOPE_PREFIX = {
+  developer_product: "developer-product",
+  game_pass: "game-pass"
+};
+var ACTION_FIELDS = {
+  list: ["page_token"],
+  get: ["id"],
+  create: ["name", "description", "price", "for_sale", "managed_pricing", "image_path"],
+  update: ["id", "name", "description", "price", "for_sale", "managed_pricing", "image_path"]
+};
+var ACTION_SCOPED_FIELDS = [
+  "id",
+  "page_token",
+  "name",
+  "description",
+  "price",
+  "for_sale",
+  "managed_pricing",
+  "image_path"
+];
+var MonetizationError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "MonetizationError";
+  }
+};
+function invalidArgument(message) {
+  return new MonetizationError("invalid_argument", message);
+}
+function isAction(value) {
+  return value === "list" || value === "get" || value === "create" || value === "update";
+}
+function isKind(value) {
+  return value === "developer_product" || value === "game_pass";
+}
+function isPresent(value) {
+  return value !== void 0 && value !== null;
+}
+function optionalId(value, name) {
+  if (!isPresent(value))
+    return void 0;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    throw invalidArgument(`${name} must be a positive whole number.`);
+  }
+  return value;
+}
+function optionalPrice(value) {
+  if (!isPresent(value))
+    return void 0;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > MAX_PRICE_ROBUX) {
+    throw invalidArgument(`price must be a whole number of Robux from 1 to ${MAX_PRICE_ROBUX}.`);
+  }
+  return value;
+}
+function optionalString(value, name) {
+  if (!isPresent(value))
+    return void 0;
+  if (typeof value !== "string")
+    throw invalidArgument(`${name} must be a string.`);
+  return value;
+}
+function optionalNonBlankString(value, name) {
+  const text = optionalString(value, name);
+  if (text !== void 0 && text.trim() === "")
+    throw invalidArgument(`${name} must not be empty.`);
+  return text;
+}
+function optionalBoolean(value, name) {
+  if (!isPresent(value))
+    return void 0;
+  if (typeof value !== "boolean")
+    throw invalidArgument(`${name} must be true or false.`);
+  return value;
+}
+function parseRequest(request) {
+  const { action, kind } = request;
+  if (!isAction(action))
+    throw invalidArgument("action must be list, get, create, or update.");
+  if (!isKind(kind))
+    throw invalidArgument("kind must be developer_product or game_pass.");
+  for (const field of ACTION_SCOPED_FIELDS) {
+    if (isPresent(request[field]) && !ACTION_FIELDS[action].includes(field)) {
+      throw invalidArgument(`${field} is not used by action=${action}.`);
+    }
+  }
+  const parsed = {
+    action,
+    kind,
+    universeId: optionalId(request.universe_id, "universe_id"),
+    id: optionalId(request.id, "id"),
+    pageToken: optionalNonBlankString(request.page_token, "page_token"),
+    name: optionalNonBlankString(request.name, "name")?.trim(),
+    description: optionalString(request.description, "description"),
+    price: optionalPrice(request.price),
+    forSale: optionalBoolean(request.for_sale, "for_sale"),
+    managedPricing: optionalBoolean(request.managed_pricing, "managed_pricing"),
+    imagePath: optionalNonBlankString(request.image_path, "image_path")
+  };
+  if (action === "get" || action === "update")
+    requiredId(parsed);
+  if (action === "create") {
+    requiredName(parsed);
+    if (parsed.forSale === true && parsed.price === void 0) {
+      throw invalidArgument("price is required to create an item with for_sale=true.");
+    }
+  }
+  if (action === "update" && Object.keys(itemChanges(parsed)).length === 0 && parsed.imagePath === void 0) {
+    throw invalidArgument("update needs at least one of name, description, price, for_sale, managed_pricing, or image_path.");
+  }
+  return parsed;
+}
+function requiredId(request) {
+  if (request.id === void 0)
+    throw invalidArgument(`id is required for action=${request.action}.`);
+  return request.id;
+}
+function requiredName(request) {
+  if (request.name === void 0)
+    throw invalidArgument(`name is required for action=${request.action}.`);
+  return request.name;
+}
+function itemChanges(request) {
+  return {
+    ...request.name !== void 0 ? { name: request.name } : {},
+    ...request.description !== void 0 ? { description: request.description } : {},
+    ...request.price !== void 0 ? { price: request.price } : {},
+    ...request.forSale !== void 0 ? { forSale: request.forSale } : {},
+    ...request.managedPricing !== void 0 ? { managedPricing: request.managedPricing } : {}
+  };
+}
+function itemLabel(kind) {
+  return kind === "developer_product" ? "developer product" : "game pass";
+}
+function comparableName(name) {
+  return name.trim().toLowerCase();
+}
+async function findItemNamed(client, kind, universeId, name) {
+  const wanted = comparableName(name);
+  let pageToken;
+  for (let page = 0; page < MAX_NAME_SCAN_PAGES; page++) {
+    const result = await client.listMonetizationItems(kind, universeId, pageToken);
+    const match = result.items.find((candidate) => comparableName(candidate.name) === wanted);
+    if (match)
+      return match;
+    if (!result.nextPageToken)
+      return void 0;
+    pageToken = result.nextPageToken;
+  }
+  throw new MonetizationError("duplicate_check_incomplete", `Stopped looking for an existing ${itemLabel(kind)} named "${name}" after ${MAX_NAME_SCAN_PAGES} pages, so nothing was created.`);
+}
+function requiredScopes(request) {
+  const prefix = SCOPE_PREFIX[request.kind];
+  return request.action === "list" || request.action === "get" ? [`${prefix}:read`] : [`${prefix}:read`, `${prefix}:write`];
+}
+function publicItem(item) {
+  return {
+    kind: item.kind,
+    id: item.id,
+    universe_id: item.universeId,
+    name: item.name,
+    description: item.description,
+    for_sale: item.forSale,
+    price: item.price,
+    managed_pricing: item.managedPricing,
+    icon_asset_id: item.iconAssetId,
+    ...item.createdAt !== void 0 ? { created_at: item.createdAt } : {},
+    ...item.updatedAt !== void 0 ? { updated_at: item.updatedAt } : {},
+    ...item.immutable !== void 0 ? { immutable: item.immutable } : {}
+  };
+}
+async function resolveUniverse(request, context) {
+  if (request.universeId !== void 0)
+    return request.universeId;
+  const universeId = await context.connectedUniverseId();
+  if (!Number.isSafeInteger(universeId) || universeId <= 0) {
+    throw new MonetizationError("unpublished_place", "The connected Studio place is not published, so it has no universe. Publish it or pass universe_id.");
+  }
+  return universeId;
+}
+function iconType(data) {
+  if (data.length >= PNG_SIGNATURE2.length && data.subarray(0, PNG_SIGNATURE2.length).equals(PNG_SIGNATURE2)) {
+    return { mimeType: "image/png", extension: "png" };
+  }
+  if (data.length >= 3 && data[0] === 255 && data[1] === 216 && data[2] === 255) {
+    return { mimeType: "image/jpeg", extension: "jpg" };
+  }
+  if (data.length >= 2 && data[0] === 66 && data[1] === 77) {
+    return { mimeType: "image/bmp", extension: "bmp" };
+  }
+  return void 0;
+}
+function readIcon(imagePath) {
+  let data;
+  try {
+    data = readRegularFileWithinLimit(imagePath, "image_path", (byteLength) => {
+      if (byteLength > MAX_ICON_BYTES) {
+        throw new Error(`image_path is ${byteLength} bytes; icons are limited to ${MAX_ICON_BYTES} bytes.`);
+      }
+    });
+  } catch (error) {
+    throw invalidArgument(error instanceof Error ? error.message : String(error));
+  }
+  const type = iconType(data);
+  if (!type)
+    throw invalidArgument("image_path must be a PNG, JPEG, or BMP file.");
+  return { data, fileName: `icon.${type.extension}`, mimeType: type.mimeType };
+}
+async function runAction(request, universeId, client, icon) {
+  const { kind } = request;
+  const changes = { ...itemChanges(request), ...icon ? { icon } : {} };
+  switch (request.action) {
+    case "list": {
+      const page = await client.listMonetizationItems(kind, universeId, request.pageToken);
+      return {
+        kind,
+        universe_id: universeId,
+        items: page.items.map(publicItem),
+        ...page.nextPageToken ? { next_page_token: page.nextPageToken } : {}
+      };
+    }
+    case "get":
+      return { item: publicItem(await client.getMonetizationItem(kind, universeId, requiredId(request))) };
+    case "create": {
+      const name = requiredName(request);
+      const existing = await findItemNamed(client, kind, universeId, name);
+      if (existing) {
+        throw new MonetizationError("duplicate_name", `A ${itemLabel(kind)} named "${existing.name}" already exists in universe ${universeId}. Update it or choose another name.`, { existing: publicItem(existing) });
+      }
+      const created = await client.createMonetizationItem(kind, universeId, {
+        ...changes,
+        name,
+        forSale: request.forSale ?? false
+      });
+      return { created: true, item: publicItem(created) };
+    }
+    case "update": {
+      const id = requiredId(request);
+      await client.updateMonetizationItem(kind, universeId, id, changes);
+      try {
+        return { updated: true, item: publicItem(await client.getMonetizationItem(kind, universeId, id)) };
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return {
+          updated: true,
+          item: null,
+          warnings: [`The update succeeded, but reading the item back failed: ${reason}`]
+        };
+      }
+    }
+  }
+}
+function openCloudFailure(error, request) {
+  const { message, status } = error;
+  switch (status) {
+    case 401:
+      return { error: "unauthorized", message, hint: "Check ROBLOX_OPEN_CLOUD_API_KEY." };
+    case 403:
+      return {
+        error: "forbidden",
+        message,
+        required_scopes: requiredScopes(request),
+        hint: "Grant these scopes to the API key and add this experience to it."
+      };
+    case 404:
+      return { error: "not_found", message, hint: "Check id, kind, and universe_id." };
+    case 409:
+      return { error: "conflict", message };
+    case 429:
+      return { error: "rate_limited", message, hint: "Wait before retrying." };
+    default: {
+      if (status >= 400 && status < 500) {
+        const { field, hint } = error.details;
+        return { error: "invalid_request", message, ...field ? { field } : {}, ...hint ? { hint } : {} };
+      }
+      return { error: "open_cloud_error", message, status };
+    }
+  }
+}
+async function runManageMonetization(request, context) {
+  let parsed;
+  try {
+    parsed = parseRequest(request);
+    if (!context.client.hasApiKey()) {
+      const scopes = requiredScopes(parsed);
+      throw new MonetizationError("missing_api_key", `ROBLOX_OPEN_CLOUD_API_KEY is not set. Create an Open Cloud API key with ${scopes.join(" and ")} for this experience.`, { required_scopes: scopes });
+    }
+    const icon = parsed.imagePath === void 0 ? void 0 : readIcon(parsed.imagePath);
+    const universeId = await resolveUniverse(parsed, context);
+    return await runAction(parsed, universeId, context.client, icon);
+  } catch (error) {
+    if (error instanceof MonetizationError) {
+      return { error: error.code, message: error.message, ...error.details };
+    }
+    if (error instanceof OpenCloudRequestError && parsed)
+      return openCloudFailure(error, parsed);
+    throw error;
+  }
+}
+
 // ../core/dist/jpeg-encoder.js
 var ZIGZAG = [
   0,
@@ -10502,7 +11465,7 @@ function rgbaToJpeg(rgba, width, height, quality = 80) {
 
 // ../core/dist/png-encoder.js
 import { deflateSync } from "zlib";
-var PNG_SIGNATURE2 = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var PNG_SIGNATURE3 = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
 var CRC_TABLE = new Uint32Array(256);
 for (let n = 0; n < 256; n++) {
   let c = n;
@@ -10546,7 +11509,7 @@ function rgbaToPng(rgba, width, height) {
   ihdr[11] = 0;
   ihdr[12] = 0;
   return Buffer.concat([
-    PNG_SIGNATURE2,
+    PNG_SIGNATURE3,
     writeChunk("IHDR", ihdr),
     writeChunk("IDAT", deflateSync(filtered)),
     writeChunk("IEND", Buffer.alloc(0))
@@ -10554,16 +11517,16 @@ function rgbaToPng(rgba, width, height) {
 }
 
 // ../core/dist/host-capture.js
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import * as fs4 from "fs";
 import * as os4 from "os";
-import * as path7 from "path";
+import * as path9 from "path";
 
 // ../core/dist/host-capture-macos.js
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import * as fs3 from "fs";
 import * as os3 from "os";
-import * as path6 from "path";
+import * as path8 from "path";
 var MAX_IMAGE_BYTES = 128 * 1024 * 1024;
 var MAX_OUTPUT_BYTES = 64 * 1024;
 var STUDIO_BUNDLE_ID = "com.Roblox.RobloxStudio";
@@ -10672,7 +11635,7 @@ func capture() async throws {
 function runBoundedCaptureProcess(executable, args, timeoutMs, env = process.env) {
   return new Promise((resolve6, reject) => {
     const processGroup = process.platform !== "win32";
-    const child = spawn2(executable, args, { env, stdio: ["ignore", "pipe", "pipe"], detached: processGroup });
+    const child = spawn3(executable, args, { env, stdio: ["ignore", "pipe", "pipe"], detached: processGroup });
     let stdout = "";
     let stderr = "";
     let outputBytes = 0;
@@ -10729,10 +11692,10 @@ async function assertSwiftToolchain(env = process.env, selectedDeveloperDir = ()
     }
   }
   const compilers = [
-    path6.join(developerDir, "usr", "bin", "swiftc"),
-    path6.join(developerDir, "Toolchains", "XcodeDefault.xctoolchain", "usr", "bin", "swiftc")
+    path8.join(developerDir, "usr", "bin", "swiftc"),
+    path8.join(developerDir, "Toolchains", "XcodeDefault.xctoolchain", "usr", "bin", "swiftc")
   ];
-  if (!path6.isAbsolute(developerDir) || !compilers.some((compiler) => exists(compiler))) {
+  if (!path8.isAbsolute(developerDir) || !compilers.some((compiler) => exists(compiler))) {
     throw new Error(MISSING_SWIFT_TOOLCHAIN);
   }
 }
@@ -10741,11 +11704,11 @@ async function getHelper() {
   if (!compiledHelper) {
     compiledHelper = (async () => {
       await assertSwiftToolchain();
-      const directory = fs3.mkdtempSync(path6.join(os3.tmpdir(), "robloxstudio-mcp-macos-helper-"));
+      const directory = fs3.mkdtempSync(path8.join(os3.tmpdir(), "robloxstudio-mcp-macos-helper-"));
       const cleanup = () => fs3.rmSync(directory, { recursive: true, force: true });
       try {
-        const source = path6.join(directory, "capture.swift");
-        const executable = path6.join(directory, "capture");
+        const source = path8.join(directory, "capture.swift");
+        const executable = path8.join(directory, "capture");
         fs3.writeFileSync(source, MACOS_CAPTURE_SOURCE, { mode: 384 });
         await runBoundedCaptureProcess("/usr/bin/xcrun", [
           "swiftc",
@@ -10754,7 +11717,7 @@ async function getHelper() {
           "-o",
           executable,
           "-module-cache-path",
-          path6.join(directory, "modules")
+          path8.join(directory, "modules")
         ], 6e4);
         process.once("exit", cleanup);
         return executable;
@@ -10805,9 +11768,9 @@ async function runMacCapture(output, titleHint, expectedIdentity) {
   });
 }
 async function captureMacStudioWindow(titleHint, expectedIdentity, runCapture = runMacCapture) {
-  const directory = fs3.mkdtempSync(path6.join(os3.tmpdir(), "robloxstudio-mcp-macos-capture-"));
+  const directory = fs3.mkdtempSync(path8.join(os3.tmpdir(), "robloxstudio-mcp-macos-capture-"));
   try {
-    const output = path6.join(directory, "capture.rgba");
+    const output = path8.join(directory, "capture.rgba");
     const stdout = await runCapture(output, titleHint, expectedIdentity);
     const report = parseMacCaptureReport(stdout, expectedIdentity);
     if (!report.ok)
@@ -11073,7 +12036,7 @@ function parseWindowsCaptureReport(value, expectedIdentity) {
 function powershellPath() {
   const systemRoot = process.env.SystemRoot ?? process.env.windir;
   if (systemRoot) {
-    const candidate = path7.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    const candidate = path9.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
     if (fs4.existsSync(candidate))
       return candidate;
   }
@@ -11082,7 +12045,7 @@ function powershellPath() {
 function runWindowsCapture(titleHint, outFile, expectedIdentity) {
   const { promise, resolve: resolve6, reject } = Promise.withResolvers();
   const encoded = Buffer.from(WINDOWS_CAPTURE_SCRIPT, "utf16le").toString("base64");
-  const child = spawn3(powershellPath(), ["-NoProfile", "-NonInteractive", "-NoLogo", "-ExecutionPolicy", "Bypass", "-EncodedCommand", encoded], {
+  const child = spawn4(powershellPath(), ["-NoProfile", "-NonInteractive", "-NoLogo", "-ExecutionPolicy", "Bypass", "-EncodedCommand", encoded], {
     env: {
       ...process.env,
       MCP_CAPTURE_TITLE_HINT: titleHint ?? "",
@@ -11145,7 +12108,7 @@ async function captureStudioWindow(titleHint, expectedIdentity) {
   }
   if (process.platform === "darwin")
     return captureMacStudioWindow(titleHint, expectedIdentity);
-  const outFile = path7.join(os4.tmpdir(), `robloxstudio-mcp-capture-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.bgra`);
+  const outFile = path9.join(os4.tmpdir(), `robloxstudio-mcp-capture-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.bgra`);
   try {
     const report = parseWindowsCaptureReport(await runWindowsCapture(titleHint, outFile, expectedIdentity), expectedIdentity);
     if (!report.ok)
@@ -11177,7 +12140,7 @@ async function captureStudioWindow(titleHint, expectedIdentity) {
 
 // ../core/dist/tools/index.js
 import * as fs5 from "fs";
-import * as path8 from "path";
+import * as path10 from "path";
 function sameHostWindowIdentity(actual, expected) {
   return actual?.windowId === expected.windowId && actual.processId === expected.processId && actual.bundleIdentifier === expected.bundleIdentifier;
 }
@@ -11360,9 +12323,9 @@ function compactSoundReference(sound) {
     name: stringField(sound, "name"),
     className: stringField(sound, "className")
   };
-  const path9 = stringField(sound, "path");
-  if (path9)
-    compact.path = path9;
+  const path11 = stringField(sound, "path");
+  if (path11)
+    compact.path = path11;
   const assetId = robloxAssetIdFromContentId(sound.assetId ?? sound.soundId ?? sound.asset);
   if (assetId !== void 0)
     compact.assetId = assetId;
@@ -11425,7 +12388,7 @@ function loadMicroProfilerBaseline(source, sourcePath) {
     if (typeof sourcePath !== "string" || sourcePath === "") {
       throw new Error("baseline_path must be a non-empty string when provided");
     }
-    const resolved = path8.resolve(sourcePath);
+    const resolved = path10.resolve(sourcePath);
     const parsed = JSON.parse(fs5.readFileSync(resolved, "utf8"));
     const record = asRecord(parsed);
     if (!record)
@@ -12377,8 +13340,8 @@ var RobloxStudioTools = class {
       timedOut: true
     };
   }
-  async getFileTree(path9 = "", instance_id) {
-    const response = await this._callSingle("/api/file-tree", { path: path9 }, void 0, instance_id);
+  async getFileTree(path11 = "", instance_id) {
+    const response = await this._callSingle("/api/file-tree", { path: path11 }, void 0, instance_id);
     return {
       content: [
         {
@@ -12410,6 +13373,28 @@ var RobloxStudioTools = class {
       ]
     };
   }
+  async manageMonetization(request, instance_id) {
+    return this._textResult(await runManageMonetization(request, {
+      client: this.openCloudClient,
+      connectedUniverseId: () => this._connectedUniverseId(instance_id)
+    }));
+  }
+  // Monetization APIs address a universe, which Studio reports as game.GameId.
+  async _connectedUniverseId(instance_id) {
+    let info;
+    try {
+      info = await this._callSingle("/api/place-info", {}, void 0, instance_id);
+    } catch (error) {
+      if (error instanceof RoutingFailure) {
+        throw new RoutingFailure({
+          ...error.routingError,
+          message: `${error.routingError.message} Pass universe_id to skip Studio.`
+        });
+      }
+      throw error;
+    }
+    return typeof info.gameId === "number" ? info.gameId : 0;
+  }
   async searchObjects(query, searchType = "name", propertyName, instance_id) {
     const response = await this._callSingle("/api/search-objects", {
       query,
@@ -12470,9 +13455,9 @@ var RobloxStudioTools = class {
       ]
     };
   }
-  async getProjectStructure(path9, maxDepth, scriptsOnly, instance_id) {
+  async getProjectStructure(path11, maxDepth, scriptsOnly, instance_id) {
     const response = await this._callSingle("/api/project-structure", {
-      path: path9,
+      path: path11,
       maxDepth,
       scriptsOnly
     }, void 0, instance_id);
@@ -12633,7 +13618,7 @@ var RobloxStudioTools = class {
     };
   }
   async setSelection(paths, mode, instance_id) {
-    if (!Array.isArray(paths) || paths.some((path9) => typeof path9 !== "string" || path9.length === 0)) {
+    if (!Array.isArray(paths) || paths.some((path11) => typeof path11 !== "string" || path11.length === 0)) {
       throw new Error("selection paths must contain only non-empty instance paths");
     }
     const selectionMode = mode ?? "set";
@@ -13370,8 +14355,8 @@ var RobloxStudioTools = class {
       const rawJson = mutable.raw_json;
       if (typeof rawJson === "string") {
         if (typeof outputPath === "string" && outputPath !== "") {
-          const resolvedOutputPath = path8.resolve(outputPath);
-          fs5.mkdirSync(path8.dirname(resolvedOutputPath), { recursive: true });
+          const resolvedOutputPath = path10.resolve(outputPath);
+          fs5.mkdirSync(path10.dirname(resolvedOutputPath), { recursive: true });
           fs5.writeFileSync(resolvedOutputPath, rawJson, "utf8");
           mutable.output_path = resolvedOutputPath;
         }
@@ -13433,8 +14418,8 @@ var RobloxStudioTools = class {
       const rawSnapshotBase64 = mutable.raw_snapshot_base64;
       if (typeof rawSnapshotBase64 === "string") {
         if (typeof outputPath === "string" && outputPath !== "") {
-          const resolvedOutputPath = path8.resolve(outputPath);
-          fs5.mkdirSync(path8.dirname(resolvedOutputPath), { recursive: true });
+          const resolvedOutputPath = path10.resolve(outputPath);
+          fs5.mkdirSync(path10.dirname(resolvedOutputPath), { recursive: true });
           fs5.writeFileSync(resolvedOutputPath, Buffer.from(rawSnapshotBase64, "base64"));
           mutable.output_path = resolvedOutputPath;
         }
@@ -13449,8 +14434,8 @@ var RobloxStudioTools = class {
         });
       }
       if (typeof summaryOutputPath === "string" && summaryOutputPath !== "") {
-        const resolvedSummaryPath = path8.resolve(summaryOutputPath);
-        fs5.mkdirSync(path8.dirname(resolvedSummaryPath), { recursive: true });
+        const resolvedSummaryPath = path10.resolve(summaryOutputPath);
+        fs5.mkdirSync(path10.dirname(resolvedSummaryPath), { recursive: true });
         fs5.writeFileSync(resolvedSummaryPath, JSON.stringify(mutable, null, 2), "utf8");
         mutable.summary_output_path = resolvedSummaryPath;
       }
@@ -13513,7 +14498,7 @@ var RobloxStudioTools = class {
       return record.placeId !== void 0 && instance.placeId === record.placeId;
     }
     if ((record.source === "baseplate" || record.source === "local_file") && record.localPlaceFile) {
-      const expectedName = path8.basename(record.localPlaceFile);
+      const expectedName = path10.basename(record.localPlaceFile);
       return instance.placeName === expectedName || instance.dataModelName === expectedName;
     }
     return true;
@@ -14848,7 +15833,7 @@ var RobloxStudioTools = class {
       throw new Error(`File not found: ${filePath}`);
     }
     const fileContent = fs5.readFileSync(filePath);
-    const fileName = path8.basename(filePath);
+    const fileName = path10.basename(filePath);
     const resolvedGroupId = groupId || process.env.ROBLOX_CREATOR_GROUP_ID;
     const resolvedUserId = userId || process.env.ROBLOX_CREATOR_USER_ID;
     if (assetType === "Decal" && this.cookieClient.hasCookie()) {
@@ -15064,9 +16049,9 @@ var RobloxStudioTools = class {
       return { content: [{ type: "text", text: JSON.stringify({ error: "plugin returned no base64 payload" }) }] };
     }
     const bytes = Buffer.from(response.base64, "base64");
-    const resolved = path8.resolve(outputPath);
+    const resolved = path10.resolve(outputPath);
     try {
-      fs5.mkdirSync(path8.dirname(resolved), { recursive: true });
+      fs5.mkdirSync(path10.dirname(resolved), { recursive: true });
       fs5.writeFileSync(resolved, bytes);
     } catch (err2) {
       return { content: [{ type: "text", text: JSON.stringify({ error: `failed to write ${resolved}: ${err2.message}` }) }] };
@@ -15427,7 +16412,7 @@ var RobloxStudioTools = class {
 };
 
 // ../core/dist/proxy-bridge-service.js
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 var PROXY_RESPONSE_GRACE_MS = 5e3;
 function parseRequestStatus(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -15486,7 +16471,7 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
     super();
     this.primaryBaseUrl = primaryBaseUrl;
     this.authToken = authToken;
-    this.proxyInstanceId = randomUUID4();
+    this.proxyInstanceId = randomUUID5();
     this.initialRefresh = this.refreshTopology();
     this.refreshTimer = setInterval(() => this.refreshTopology(), _ProxyBridgeService.REFRESH_INTERVAL_MS);
   }
@@ -15672,7 +16657,7 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
     return status;
   }
   async sendRequest(endpoint, data, targetPeerId, timeoutMs = this.proxyRequestTimeout, signal, operationId) {
-    const requestId = operationId ?? randomUUID4();
+    const requestId = operationId ?? randomUUID5();
     const details = { requestId, targetPeerId, stage: "queued", outcome: "not_executed", executionOutcome: "not_executed" };
     if (typeof requestId !== "string" || requestId.trim().length === 0 || requestId.length > 128) {
       throw new RequestFailure("operationId must be a nonempty string of at most 128 characters", "invalid_operation_id", details);
@@ -17570,7 +18555,7 @@ var TOOL_DEFINITIONS = [
         includeAudio: {
           type: "boolean",
           default: true,
-          description: "Return inline audio; needs asset:read and never writes files."
+          description: "Return inline audio; needs legacy-asset:manage and never writes files."
         },
         maxAudioPreviews: {
           type: "number",
@@ -17646,6 +18631,72 @@ var TOOL_DEFINITIONS = [
       }
     }
   },
+  // === Monetization ===
+  {
+    name: "manage_monetization",
+    category: "write",
+    description: "Use to list, inspect, create, or update developer products and game passes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "get", "create", "update"],
+          description: "Operation; create and update change live Roblox items."
+        },
+        kind: {
+          type: "string",
+          enum: ["developer_product", "game_pass"],
+          description: "Item type."
+        },
+        universe_id: {
+          type: "integer",
+          minimum: 1,
+          description: "Universe ID; defaults to the connected Studio place."
+        },
+        id: {
+          type: "integer",
+          minimum: 1,
+          description: "Product or pass ID; required for get and update."
+        },
+        name: {
+          type: "string",
+          description: "Item name; required for create."
+        },
+        description: {
+          type: "string",
+          description: "Item description shown to buyers."
+        },
+        price: {
+          type: "integer",
+          minimum: 1,
+          maximum: 1e9,
+          description: "Default price in Robux."
+        },
+        for_sale: {
+          type: "boolean",
+          description: "Purchasable; create defaults to false."
+        },
+        managed_pricing: {
+          type: "boolean",
+          description: "Let Roblox price optimization set the price."
+        },
+        image_path: {
+          type: "string",
+          description: "Local PNG, JPEG, or BMP icon file."
+        },
+        page_token: {
+          type: "string",
+          description: "Prior list page token."
+        },
+        instance_id: {
+          type: "string",
+          description: "Studio process ID when ambiguous."
+        }
+      },
+      required: ["action", "kind"]
+    }
+  },
   // === Input Simulation ===
   {
     name: "simulate_mouse_input",
@@ -17944,10 +18995,10 @@ var getAllTools = () => [...TOOL_DEFINITIONS];
 
 // ../core/dist/install-plugin-helpers.js
 var import_saxes = __toESM(require_saxes(), 1);
-import { existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync, rmSync as rmSync4, rmdirSync, statSync as statSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync9, renameSync, rmSync as rmSync5, rmdirSync, statSync as statSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "fs";
 import { execSync } from "child_process";
-import { randomUUID as randomUUID5 } from "crypto";
-import { basename as basename3, join as join8 } from "path";
+import { randomUUID as randomUUID6 } from "crypto";
+import { basename as basename3, join as join9 } from "path";
 import { homedir as homedir4 } from "os";
 import { isUtf8 } from "buffer";
 var DEFAULT_PLUGIN_PORT = 58741;
@@ -17999,15 +19050,15 @@ function getPluginsFolder() {
   if (process.env.MCP_PLUGINS_DIR)
     return process.env.MCP_PLUGINS_DIR;
   if (process.platform === "win32") {
-    return join8(process.env.LOCALAPPDATA || join8(homedir4(), "AppData", "Local"), "Roblox", "Plugins");
+    return join9(process.env.LOCALAPPDATA || join9(homedir4(), "AppData", "Local"), "Roblox", "Plugins");
   }
   if (isWSL()) {
     const localAppData = getWindowsUserLocalAppData();
     if (localAppData)
-      return join8(localAppData.linuxPath, "Roblox", "Plugins");
+      return join9(localAppData.linuxPath, "Roblox", "Plugins");
     console.warn("[install-plugin] WSL detected but could not resolve Windows %LOCALAPPDATA%. Falling back to ~/Documents/Roblox/Plugins/ - you will likely need to copy the rbxmx to /mnt/c/Users/<you>/AppData/Local/Roblox/Plugins/ manually. Set MCP_PLUGINS_DIR to skip detection.");
   }
-  return join8(homedir4(), "Documents", "Roblox", "Plugins");
+  return join9(homedir4(), "Documents", "Roblox", "Plugins");
 }
 var STALE_TEST_PLUGINS_DIRECTORY = "RsmcpIsolatedPlugins";
 function pluginDirectorySettingPattern() {
@@ -18022,7 +19073,7 @@ function repairStaleStudioPluginDirectorySetting({ settingsPath, studioPluginsDi
   if (studioPluginsDirectory === "") {
     throw new Error("studioPluginsDirectory must be a non-empty path.");
   }
-  const contents = readFileSync8(settingsPath, "utf8");
+  const contents = readFileSync9(settingsPath, "utf8");
   const matches = [...contents.matchAll(pluginDirectorySettingPattern())];
   if (matches.length !== 1) {
     throw new Error(`Expected exactly one Studio.PluginsDir QDir in ${settingsPath}; found ${matches.length}.`);
@@ -18031,15 +19082,15 @@ function repairStaleStudioPluginDirectorySetting({ settingsPath, studioPluginsDi
     return false;
   const studioPath = escapeXmlText(studioPluginsDirectory);
   const updated = contents.replace(pluginDirectorySettingPattern(), (_match, open4, _value, close) => `${open4}${studioPath}${close}`);
-  const temporaryPath = `${settingsPath}.rsmcp-install-${process.pid}-${randomUUID5()}.tmp`;
+  const temporaryPath = `${settingsPath}.rsmcp-install-${process.pid}-${randomUUID6()}.tmp`;
   try {
-    writeFileSync4(temporaryPath, updated, {
+    writeFileSync5(temporaryPath, updated, {
       encoding: "utf8",
-      mode: statSync3(settingsPath).mode
+      mode: statSync4(settingsPath).mode
     });
     renameSync(temporaryPath, settingsPath);
   } finally {
-    rmSync4(temporaryPath, { force: true });
+    rmSync5(temporaryPath, { force: true });
   }
   return true;
 }
@@ -18050,16 +19101,16 @@ function repairDefaultStudioPluginDirectorySetting(pluginsFolder, log) {
   let defaultPluginsFolder;
   let studioPluginsDirectory;
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || join8(homedir4(), "AppData", "Local");
-    defaultPluginsFolder = join8(localAppData, "Roblox", "Plugins");
-    settingsPath = join8(localAppData, "Roblox", "GlobalSettings_13.xml");
+    const localAppData = process.env.LOCALAPPDATA || join9(homedir4(), "AppData", "Local");
+    defaultPluginsFolder = join9(localAppData, "Roblox", "Plugins");
+    settingsPath = join9(localAppData, "Roblox", "GlobalSettings_13.xml");
     studioPluginsDirectory = defaultPluginsFolder.replaceAll("\\", "/");
   } else if (isWSL()) {
     const localAppData = getWindowsUserLocalAppData();
     if (!localAppData)
       return;
-    defaultPluginsFolder = join8(localAppData.linuxPath, "Roblox", "Plugins");
-    settingsPath = join8(localAppData.linuxPath, "Roblox", "GlobalSettings_13.xml");
+    defaultPluginsFolder = join9(localAppData.linuxPath, "Roblox", "Plugins");
+    settingsPath = join9(localAppData.linuxPath, "Roblox", "GlobalSettings_13.xml");
     studioPluginsDirectory = [
       localAppData.windowsPath.replace(/[\\/]+$/u, ""),
       "Roblox",
@@ -18075,12 +19126,12 @@ function repairDefaultStudioPluginDirectorySetting(pluginsFolder, log) {
   }
 }
 function handleVariantConflict({ pluginsFolder, otherAssetName, replace, log = console.log, warn = console.warn }) {
-  const otherDest = join8(pluginsFolder, otherAssetName);
+  const otherDest = join9(pluginsFolder, otherAssetName);
   if (!existsSync7(otherDest))
     return;
   if (replace) {
     try {
-      unlinkSync2(otherDest);
+      unlinkSync3(otherDest);
       log(`Removed conflicting ${otherAssetName}.`);
     } catch (err2) {
       warn(`[install-plugin] Could not remove ${otherDest}: ${err2}. Continuing.`);
@@ -18094,18 +19145,18 @@ Delete ${otherAssetName} manually or use the default CLI installer behavior to r
 `);
 }
 var PLUGIN_INSTALL_LOCK_NAME = ".robloxstudio-mcp-plugin-install.lock";
-function errorCode(error) {
+function errorCode2(error) {
   return error !== null && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : void 0;
 }
 function pluginInstallLockError(lockPath, reason) {
   return new Error(`${reason}: ${lockPath}. If no installer or lock recovery is running, remove that lock directory and retry.`);
 }
 function readPluginInstallLockOwner(lockPath) {
-  const ownerPath = join8(lockPath, "owner.json");
+  const ownerPath = join9(lockPath, "owner.json");
   if (!lstatSync2(lockPath).isDirectory() || !lstatSync2(ownerPath).isFile()) {
     throw new Error("Lock and owner metadata must be a directory and regular file");
   }
-  const owner = JSON.parse(readFileSync8(ownerPath, "utf8"));
+  const owner = JSON.parse(readFileSync9(ownerPath, "utf8"));
   if (owner === null || typeof owner !== "object" || !("pid" in owner) || typeof owner.pid !== "number" || !Number.isSafeInteger(owner.pid) || owner.pid <= 0 || owner.pid > 2147483647 || !("token" in owner) || typeof owner.token !== "string" || !/^[a-zA-Z0-9-]{1,128}$/.test(owner.token) || !("createdAt" in owner) || typeof owner.createdAt !== "number" || !Number.isFinite(owner.createdAt) || owner.createdAt < 0) {
     throw new Error("Invalid lock owner metadata");
   }
@@ -18116,9 +19167,9 @@ function assertPluginInstallOwnerExited(lockPath, owner) {
     try {
       process.kill(owner.pid, 0);
     } catch (error) {
-      if (errorCode(error) === "ESRCH")
+      if (errorCode2(error) === "ESRCH")
         return;
-      throw pluginInstallLockError(lockPath, `Cannot confirm that plugin installation owner PID ${owner.pid} has exited (${errorCode(error) ?? error})`);
+      throw pluginInstallLockError(lockPath, `Cannot confirm that plugin installation owner PID ${owner.pid} has exited (${errorCode2(error) ?? error})`);
     }
   }
   throw pluginInstallLockError(lockPath, `Another Studio plugin installation is already in progress (owner PID ${owner.pid})`);
@@ -18131,13 +19182,13 @@ function recoverPluginInstallLock(lockPath, warn) {
     throw pluginInstallLockError(lockPath, `Cannot safely read plugin installation lock owner (${error})`);
   }
   assertPluginInstallOwnerExited(lockPath, owner);
-  const claimPath = join8(lockPath, `recovery-${owner.token}`);
+  const claimPath = join9(lockPath, `recovery-${owner.token}`);
   try {
-    mkdirSync4(claimPath);
+    mkdirSync5(claimPath);
   } catch (error) {
-    throw pluginInstallLockError(lockPath, errorCode(error) === "EEXIST" ? "Plugin installation lock recovery is already in progress or was interrupted" : `Could not claim plugin installation lock recovery (${error})`);
+    throw pluginInstallLockError(lockPath, errorCode2(error) === "EEXIST" ? "Plugin installation lock recovery is already in progress or was interrupted" : `Could not claim plugin installation lock recovery (${error})`);
   }
-  const abandonedPath = `${lockPath}.${randomUUID5()}.abandoned`;
+  const abandonedPath = `${lockPath}.${randomUUID6()}.abandoned`;
   let moved = false;
   try {
     let currentOwner;
@@ -18157,49 +19208,49 @@ function recoverPluginInstallLock(lockPath, warn) {
       try {
         rmdirSync(claimPath);
       } catch (error) {
-        if (errorCode(error) !== "ENOENT") {
+        if (errorCode2(error) !== "ENOENT") {
           warn(`[install-plugin] Could not release lock recovery claim ${claimPath}: ${error}`);
         }
       }
     }
   }
   try {
-    rmSync4(abandonedPath, { recursive: true, force: true });
+    rmSync5(abandonedPath, { recursive: true, force: true });
   } catch (error) {
     warn(`[install-plugin] Could not clean abandoned install lock ${abandonedPath}: ${error}`);
   }
 }
 function acquirePluginInstallLock(pluginsFolder, warn) {
-  const lockPath = join8(pluginsFolder, PLUGIN_INSTALL_LOCK_NAME);
-  const ownerPath = join8(lockPath, "owner.json");
+  const lockPath = join9(pluginsFolder, PLUGIN_INSTALL_LOCK_NAME);
+  const ownerPath = join9(lockPath, "owner.json");
   const owner = {
     pid: process.pid,
-    token: randomUUID5(),
+    token: randomUUID6(),
     createdAt: Date.now()
   };
   try {
-    mkdirSync4(lockPath);
+    mkdirSync5(lockPath);
   } catch (error) {
-    if (errorCode(error) !== "EEXIST")
+    if (errorCode2(error) !== "EEXIST")
       throw error;
     recoverPluginInstallLock(lockPath, warn);
     try {
-      mkdirSync4(lockPath);
+      mkdirSync5(lockPath);
     } catch (retryError) {
-      if (errorCode(retryError) !== "EEXIST")
+      if (errorCode2(retryError) !== "EEXIST")
         throw retryError;
       throw pluginInstallLockError(lockPath, "Another Studio plugin installation is already in progress");
     }
   }
   try {
-    writeFileSync4(ownerPath, `${JSON.stringify(owner)}
+    writeFileSync5(ownerPath, `${JSON.stringify(owner)}
 `, {
       encoding: "utf8",
       flag: "wx"
     });
   } catch (error) {
     try {
-      rmSync4(lockPath, { recursive: true, force: true });
+      rmSync5(lockPath, { recursive: true, force: true });
     } catch (cleanupError) {
       warn(`[install-plugin] Could not clean failed install lock ${lockPath}: ${cleanupError}`);
     }
@@ -18209,10 +19260,10 @@ function acquirePluginInstallLock(pluginsFolder, warn) {
     try {
       const currentOwner = readPluginInstallLockOwner(lockPath);
       if (currentOwner.pid === owner.pid && currentOwner.token === owner.token) {
-        rmSync4(lockPath, { recursive: true, force: true });
+        rmSync5(lockPath, { recursive: true, force: true });
       }
     } catch (error) {
-      if (errorCode(error) !== "ENOENT") {
+      if (errorCode2(error) !== "ENOENT") {
         warn(`[install-plugin] Could not release install lock ${lockPath}: ${error}`);
       }
     }
@@ -18305,7 +19356,7 @@ function installedFileMatches(source, destination) {
     return false;
   if (!lstatSync2(destination).isFile())
     return false;
-  const installed = readFileSync8(destination);
+  const installed = readFileSync9(destination);
   return installed.length === source.length && installed.equals(source);
 }
 function installPluginAsset({ pluginsFolder, assetName, otherAssetName, source, expectedVersion, expectedVariant, rawPort, replaceVariant = true, log = console.log, warn = console.warn }) {
@@ -18316,22 +19367,22 @@ function installPluginAsset({ pluginsFolder, assetName, otherAssetName, source,
   }
   const configured = configurePluginAssetForPort(source, rawPort);
   assertPluginAssetIdentity(configured, assetName, expectedVersion, expectedVariant);
-  mkdirSync4(pluginsFolder, { recursive: true });
-  const destination = join8(pluginsFolder, assetName);
+  mkdirSync5(pluginsFolder, { recursive: true });
+  const destination = join9(pluginsFolder, assetName);
   const releaseLock = acquirePluginInstallLock(pluginsFolder, warn);
   try {
     let installed = false;
     if (!installedFileMatches(configured, destination)) {
-      const staged = join8(pluginsFolder, `.${assetName}.${process.pid}.${randomUUID5()}.tmp`);
+      const staged = join9(pluginsFolder, `.${assetName}.${process.pid}.${randomUUID6()}.tmp`);
       try {
-        writeFileSync4(staged, configured, { flag: "wx" });
+        writeFileSync5(staged, configured, { flag: "wx" });
         renameSync(staged, destination);
         installed = true;
       } finally {
         try {
-          unlinkSync2(staged);
+          unlinkSync3(staged);
         } catch (error) {
-          if (errorCode(error) !== "ENOENT") {
+          if (errorCode2(error) !== "ENOENT") {
             warn(`[install-plugin] Could not remove staging file ${staged}: ${error}`);
           }
         }
@@ -18352,8 +19403,8 @@ function installPluginAsset({ pluginsFolder, assetName, otherAssetName, source,
 }
 
 // ../core/dist/plugin-installer.js
-import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname5, join as join9 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname5, join as join10 } from "path";
 import { fileURLToPath } from "url";
 import { get } from "https";
 var REPO = "chrrxs/robloxstudio-mcp";
@@ -18417,8 +19468,8 @@ function createPluginInstaller(moduleUrl, variant) {
   }
   function bundledAssetPath() {
     const candidates = [
-      join9(currentDir, "..", "studio-plugin", ASSET_NAME),
-      join9(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
+      join10(currentDir, "..", "studio-plugin", ASSET_NAME),
+      join10(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
     ];
     return candidates.find((candidate) => existsSync8(candidate)) ?? null;
   }
@@ -18428,7 +19479,7 @@ function createPluginInstaller(moduleUrl, variant) {
     return existsSync8(sourcePath) ? sourcePath : null;
   }
   function packageVersion() {
-    const pkg = JSON.parse(readFileSync9(join9(currentDir, "..", "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync10(join10(currentDir, "..", "package.json"), "utf8"));
     if (!pkg.version) {
       throw new Error("Package version not found");
     }
@@ -18453,7 +19504,7 @@ function createPluginInstaller(moduleUrl, variant) {
     if (!sourcePath) {
       throw new Error(`Bundled ${ASSET_NAME} not found. Run npm run ${buildCommand} in this worktree first.`);
     }
-    const result = installSource(readFileSync9(sourcePath), options);
+    const result = installSource(readFileSync10(sourcePath), options);
     if (result.installed) {
       log(`Installed ${ASSET_NAME} to ${result.destination}`);
     }
@@ -18465,7 +19516,7 @@ function createPluginInstaller(moduleUrl, variant) {
       throw new Error(`Plugin asset not found at explicit path ${options.sourcePath}.`);
     }
     if (bundled) {
-      const result2 = installSource(readFileSync9(bundled), options);
+      const result2 = installSource(readFileSync10(bundled), options);
       if (result2.installed) {
         log(`Installed bundled ${ASSET_NAME} to ${result2.destination}`);
       } else {