npm - @babylonjsmarket/cli - Versions diffs - 1.0.2 → 1.0.3 - Mend

@babylonjsmarket/cli 1.0.2 → 1.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/index.js +587 -435
package/dist/index.js.map +1 -1
package/dist/lib/inject/detect-target.d.ts +13 -8
package/dist/lib/inject/detect-target.js +3 -3
package/dist/lib/inject/detect-target.js.map +1 -1
package/dist/lib/inject/engine.js +20 -19
package/dist/lib/inject/engine.js.map +1 -1
package/dist/lib/inject/index.js +20 -19
package/dist/lib/inject/index.js.map +1 -1
package/dist/lib/inject/inject-options.js +5 -5
package/dist/lib/inject/inject-options.js.map +1 -1
package/package.json +4 -2

package/dist/index.js CHANGED Viewed

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 // src/index.ts
-import { Command as Command7 } from "commander";
-import chalk5 from "chalk";
+import { Command as Command8 } from "commander";
+import chalk6 from "chalk";
-// src/commands/logout.ts
+// src/commands/login-simple.ts
 import { Command } from "commander";
+import chalk from "chalk";
+import open from "open";
+import ora from "ora";
+import fetch2 from "node-fetch";
 // src/utils/auth.ts
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
@@ -171,78 +175,224 @@ var AuthManager = class {
   }
 };
+// src/commands/login-simple.ts
+import { createServer } from "https";
+import { createServer as createHttpServer } from "http";
+import { URL } from "url";
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+var loginCommand = new Command("login").description("Authenticate with BabylonJS Market").option("--no-browser", "Don't open browser automatically").action(async (options) => {
+  const authManager = new AuthManager();
+  if (authManager.isAuthenticated()) {
+    const user = authManager.getUser();
+    console.log(chalk.yellow("You are already logged in as:"), chalk.cyan(user?.email || "Unknown"));
+    console.log(chalk.gray('Run "bjs-cli logout" to log out first.'));
+    return;
+  }
+  console.log(chalk.blue("Starting authentication flow..."));
+  try {
+    const port = 8765;
+    let token = null;
+    const certDir = path.join(os.homedir(), ".bjs", "certs");
+    const keyPath = path.join(certDir, "localhost-key.pem");
+    const certPath = path.join(certDir, "localhost-cert.pem");
+    if (!fs.existsSync(certDir)) {
+      fs.mkdirSync(certDir, { recursive: true });
+    }
+    if (!fs.existsSync(keyPath) || !fs.existsSync(certPath)) {
+      console.log(chalk.gray("Generating self-signed certificate for HTTPS..."));
+      try {
+        execSync(
+          `openssl req -x509 -newkey rsa:2048 -nodes -sha256 -days 365 -keyout "${keyPath}" -out "${certPath}" -subj "/C=US/ST=State/L=City/O=BJS-CLI/CN=localhost"`,
+          { stdio: "pipe" }
+        );
+      } catch (error) {
+        console.log(chalk.yellow("Could not generate HTTPS certificate, falling back to HTTP"));
+      }
+    }
+    let server;
+    let protocol = "https";
+    if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
+      const serverOptions = {
+        key: fs.readFileSync(keyPath),
+        cert: fs.readFileSync(certPath)
+      };
+      server = createServer(serverOptions, (req, res) => {
+        handleRequest(req, res);
+      });
+    } else {
+      protocol = "http";
+      server = createHttpServer((req, res) => {
+        handleRequest(req, res);
+      });
+    }
+    const handleRequest = (req, res) => {
+      const url = new URL(req.url, `${protocol}://localhost:${port}`);
+      token = url.searchParams.get("token");
+      if (token) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+            <!DOCTYPE html>
+            <html>
+            <head>
+              <title>Authentication Successful</title>
+              <style>
+                body { font-family: system-ui; padding: 40px; text-align: center; }
+                .success { color: green; }
+                .token { background: #f0f0f0; padding: 10px; margin: 20px; font-family: monospace; word-break: break-all; }
+              </style>
+            </head>
+            <body>
+              <h1 class="success">\u2713 Authentication Successful!</h1>
+              <p>You can close this window and return to your terminal.</p>
+              <div class="token">Token received: ${token.substring(0, 8)}...</div>
+              <script>setTimeout(() => window.close(), 3000);</script>
+            </body>
+            </html>
+          `);
+        server.close();
+      } else {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Missing token parameter");
+      }
+    };
+    await new Promise((resolve) => {
+      server.listen(port, () => {
+        console.log(chalk.gray(`Local callback server started on port ${port} (${protocol.toUpperCase()})`));
+        resolve();
+      });
+    });
+    const callbackUrl = `${protocol}://localhost:${port}`;
+    const authUrl = `${API_URL}/auth/cli?callback=${encodeURIComponent(callbackUrl)}`;
+    console.log("\n" + chalk.green("To authenticate, visit:"));
+    console.log(chalk.cyan.bold(authUrl));
+    if (options.browser !== false) {
+      console.log("\n" + chalk.gray("Opening browser..."));
+      await open(authUrl);
+    }
+    console.log("\n" + chalk.blue("Waiting for authentication..."));
+    const spinner = ora("Waiting for browser authentication...").start();
+    const timeout = setTimeout(() => {
+      server.close();
+      spinner.fail(chalk.red("Authentication timed out"));
+      process.exit(1);
+    }, 3e5);
+    await new Promise((resolve) => {
+      server.on("close", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+    if (!token) {
+      spinner.fail(chalk.red("No token received"));
+      process.exit(1);
+    }
+    spinner.text = "Exchanging token...";
+    const exchangeResponse = await fetch2(`${API_URL}/api/auth/cli/exchange`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token })
+    });
+    if (!exchangeResponse.ok) {
+      const error = await exchangeResponse.text();
+      spinner.fail(chalk.red("Failed to exchange token"));
+      console.error(chalk.red("Error:"), error);
+      process.exit(1);
+    }
+    const tokenData = await exchangeResponse.json();
+    authManager.saveTokens(
+      tokenData.access_token,
+      tokenData.refresh_token,
+      tokenData.expires_in
+    );
+    authManager.saveUser(tokenData.user);
+    spinner.succeed(chalk.green("Authentication successful!"));
+    console.log(chalk.blue("\nLogged in as:"), chalk.cyan(tokenData.user.email));
+    console.log(chalk.gray(`
+Authentication data saved to ~/.bjs/config.json`));
+  } catch (error) {
+    console.error(chalk.red("Login failed:"), error.message);
+    process.exit(1);
+  }
+});
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
 // src/utils/theme-colors.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 var themes = {
   classic: {
-    primary: (text) => chalk.cyan(text),
-    secondary: (text) => chalk.yellow(text),
-    accent: (text) => chalk.magenta(text),
-    success: (text) => chalk.green(text),
-    error: (text) => chalk.red(text),
-    warning: (text) => chalk.yellow(text),
-    info: (text) => chalk.blue(text),
-    dim: (text) => chalk.gray(text)
+    primary: (text) => chalk2.cyan(text),
+    secondary: (text) => chalk2.yellow(text),
+    accent: (text) => chalk2.magenta(text),
+    success: (text) => chalk2.green(text),
+    error: (text) => chalk2.red(text),
+    warning: (text) => chalk2.yellow(text),
+    info: (text) => chalk2.blue(text),
+    dim: (text) => chalk2.gray(text)
   },
   desert: {
-    primary: (text) => chalk.yellow(text),
-    secondary: (text) => chalk.red(text),
-    accent: (text) => chalk.green(text),
-    success: (text) => chalk.green(text),
-    error: (text) => chalk.red(text),
-    warning: (text) => chalk.yellow(text),
-    info: (text) => chalk.cyan(text),
-    dim: (text) => chalk.gray(text)
+    primary: (text) => chalk2.yellow(text),
+    secondary: (text) => chalk2.red(text),
+    accent: (text) => chalk2.green(text),
+    success: (text) => chalk2.green(text),
+    error: (text) => chalk2.red(text),
+    warning: (text) => chalk2.yellow(text),
+    info: (text) => chalk2.cyan(text),
+    dim: (text) => chalk2.gray(text)
   },
   matrix: {
-    primary: (text) => chalk.green(text),
-    secondary: (text) => chalk.greenBright(text),
-    accent: (text) => chalk.cyan(text),
-    success: (text) => chalk.greenBright(text),
-    error: (text) => chalk.red(text),
-    warning: (text) => chalk.yellow(text),
-    info: (text) => chalk.green(text),
-    dim: (text) => chalk.gray(text)
+    primary: (text) => chalk2.green(text),
+    secondary: (text) => chalk2.greenBright(text),
+    accent: (text) => chalk2.cyan(text),
+    success: (text) => chalk2.greenBright(text),
+    error: (text) => chalk2.red(text),
+    warning: (text) => chalk2.yellow(text),
+    info: (text) => chalk2.green(text),
+    dim: (text) => chalk2.gray(text)
   },
   commando: {
-    primary: (text) => chalk.rgb(107, 142, 35)(text),
+    primary: (text) => chalk2.rgb(107, 142, 35)(text),
     // Olive green
-    secondary: (text) => chalk.rgb(139, 90, 43)(text),
+    secondary: (text) => chalk2.rgb(139, 90, 43)(text),
     // Brown
-    accent: (text) => chalk.rgb(47, 79, 47)(text),
+    accent: (text) => chalk2.rgb(47, 79, 47)(text),
     // Dark green
-    success: (text) => chalk.green(text),
-    error: (text) => chalk.rgb(139, 0, 0)(text),
+    success: (text) => chalk2.green(text),
+    error: (text) => chalk2.rgb(139, 0, 0)(text),
     // Dark red
-    warning: (text) => chalk.rgb(189, 183, 107)(text),
+    warning: (text) => chalk2.rgb(189, 183, 107)(text),
     // Khaki
-    info: (text) => chalk.rgb(85, 107, 47)(text),
+    info: (text) => chalk2.rgb(85, 107, 47)(text),
     // Dark olive green
-    dim: (text) => chalk.gray(text)
+    dim: (text) => chalk2.gray(text)
   },
   sandiego: {
-    primary: (text) => chalk.red(text),
-    secondary: (text) => chalk.yellow(text),
-    accent: (text) => chalk.white(text),
-    success: (text) => chalk.green(text),
-    error: (text) => chalk.redBright(text),
-    warning: (text) => chalk.yellowBright(text),
-    info: (text) => chalk.blue(text),
-    dim: (text) => chalk.gray(text)
+    primary: (text) => chalk2.red(text),
+    secondary: (text) => chalk2.yellow(text),
+    accent: (text) => chalk2.white(text),
+    success: (text) => chalk2.green(text),
+    error: (text) => chalk2.redBright(text),
+    warning: (text) => chalk2.yellowBright(text),
+    info: (text) => chalk2.blue(text),
+    dim: (text) => chalk2.gray(text)
   },
   ed209: {
-    primary: (text) => chalk.rgb(192, 192, 192)(text),
+    primary: (text) => chalk2.rgb(192, 192, 192)(text),
     // Silver
-    secondary: (text) => chalk.rgb(135, 206, 235)(text),
+    secondary: (text) => chalk2.rgb(135, 206, 235)(text),
     // Sky blue
-    accent: (text) => chalk.rgb(105, 105, 105)(text),
+    accent: (text) => chalk2.rgb(105, 105, 105)(text),
     // Dim gray
-    success: (text) => chalk.greenBright(text),
-    error: (text) => chalk.redBright(text),
-    warning: (text) => chalk.rgb(255, 140, 0)(text),
+    success: (text) => chalk2.greenBright(text),
+    error: (text) => chalk2.redBright(text),
+    warning: (text) => chalk2.rgb(255, 140, 0)(text),
     // Dark orange
-    info: (text) => chalk.cyanBright(text),
-    dim: (text) => chalk.gray(text)
+    info: (text) => chalk2.cyanBright(text),
+    dim: (text) => chalk2.gray(text)
   }
 };
 function getThemeColors(themeName) {
@@ -258,16 +408,16 @@ function applyTheme(themeName) {
   return {
     ...theme,
     // Add some convenience methods
-    header: (text) => theme.primary(chalk.bold(text)),
-    subheader: (text) => theme.secondary(chalk.bold(text)),
-    highlight: (text) => theme.accent(chalk.bold(text)),
+    header: (text) => theme.primary(chalk2.bold(text)),
+    subheader: (text) => theme.secondary(chalk2.bold(text)),
+    highlight: (text) => theme.accent(chalk2.bold(text)),
     code: (text) => theme.dim(`\`${text}\``),
-    link: (text) => theme.info(chalk.underline(text))
+    link: (text) => theme.info(chalk2.underline(text))
   };
 }
 // src/commands/logout.ts
-var logoutCommand = new Command("logout").description("Log out from BabylonJS Market").action(async () => {
+var logoutCommand = new Command2("logout").description("Log out from BabylonJS Market").action(async () => {
   const authManager = new AuthManager();
   const theme = applyTheme();
   if (!authManager.isAuthenticated()) {
@@ -283,8 +433,8 @@ var logoutCommand = new Command("logout").description("Log out from BabylonJS Ma
 });
 // src/commands/whoami.ts
-import { Command as Command2 } from "commander";
-var whoamiCommand = new Command2("whoami").description("Display current authenticated user").action(async () => {
+import { Command as Command3 } from "commander";
+var whoamiCommand = new Command3("whoami").description("Display current authenticated user").action(async () => {
   const authManager = new AuthManager();
   const theme = applyTheme();
   if (!authManager.isAuthenticated()) {
@@ -308,13 +458,13 @@ var whoamiCommand = new Command2("whoami").description("Display current authenti
 });
 // src/commands/download.ts
-import { Command as Command3 } from "commander";
-import ora from "ora";
+import { Command as Command4 } from "commander";
+import ora2 from "ora";
 import { createWriteStream, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
 import { pipeline } from "stream/promises";
-import fetch2 from "node-fetch";
-import path from "path";
-var downloadCommand = new Command3("download").description("Download assets from BabylonJS Market").argument("<asset-key>", "Asset key to download").option("-o, --output <path>", "Output directory (default: current directory)").action(async (assetKey, options) => {
+import fetch3 from "node-fetch";
+import path2 from "path";
+var downloadCommand = new Command4("download").description("Download assets from BabylonJS Market").argument("<asset-key>", "Asset key to download").option("-o, --output <path>", "Output directory (default: current directory)").action(async (assetKey, options) => {
   const authManager = new AuthManager();
   const theme = applyTheme();
   if (!authManager.isAuthenticated()) {
@@ -322,7 +472,7 @@ var downloadCommand = new Command3("download").description("Download assets from
     console.log(theme.dim('Run "bjs login" to authenticate.'));
     process.exit(1);
   }
-  const spinner = ora("Requesting download token...").start();
+  const spinner = ora2("Requesting download token...").start();
   try {
     const tokenResponse = await authManager.makeAuthenticatedRequest(
       `${API_URL}/api/assets/download?key=${encodeURIComponent(assetKey)}`
@@ -353,7 +503,7 @@ var downloadCommand = new Command3("download").description("Download assets from
     } else {
       fullDownloadUrl = `${API_URL}/${downloadUrl}`;
     }
-    const fileResponse = await fetch2(fullDownloadUrl);
+    const fileResponse = await fetch3(fullDownloadUrl);
     if (!fileResponse.ok) {
       throw new Error(`Failed to download file: ${fileResponse.status}`);
     }
@@ -361,7 +511,7 @@ var downloadCommand = new Command3("download").description("Download assets from
     if (!existsSync2(outputDir)) {
       mkdirSync2(outputDir, { recursive: true });
     }
-    const outputPath = path.join(outputDir, fileName);
+    const outputPath = path2.join(outputDir, fileName);
     const contentLength = fileResponse.headers.get("content-length");
     const total = contentLength ? parseInt(contentLength, 10) : 0;
     let loaded = 0;
@@ -384,7 +534,7 @@ var downloadCommand = new Command3("download").description("Download assets from
 });
 // src/commands/bbs.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 import terminalKit3 from "terminal-kit";
 // src/utils/buffered-bbs.ts
@@ -956,14 +1106,14 @@ var BufferedBBS = class extends EventEmitter {
 // src/utils/course-detail-viewer.ts
 import terminalKit2 from "terminal-kit";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 // src/utils/markdown-terminal.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import stripAnsi from "strip-ansi";
 // src/utils/code-highlighter.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import { highlight, supportsLanguage } from "cli-highlight";
 var CodeHighlighter = class {
   static SUPPORTED_LANGUAGES = [
@@ -1063,9 +1213,9 @@ var CodeHighlighter = class {
     return code.split("\n").map((line) => {
       const lang = language.toLowerCase();
       if (lang === "javascript" || lang === "typescript" || lang === "js" || lang === "ts") {
-        return line.replace(/\b(const|let|var|function|class|interface|type|return|if|else|for|while|import|export|from|extends|implements|new|this|super|async|await|try|catch|throw|switch|case|break|continue|default)\b/g, chalk2.blue("$1")).replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, chalk2.green("$&")).replace(/\b(\d+)\b/g, chalk2.cyan("$1")).replace(/(\/\/.*$)/g, chalk2.gray("$1")).replace(/(\w+)(?=\()/g, chalk2.yellow("$1")).replace(/\.(\w+)/g, "." + chalk2.cyan("$1"));
+        return line.replace(/\b(const|let|var|function|class|interface|type|return|if|else|for|while|import|export|from|extends|implements|new|this|super|async|await|try|catch|throw|switch|case|break|continue|default)\b/g, chalk3.blue("$1")).replace(/(["'])(?:(?=(\\?))\2.)*?\1/g, chalk3.green("$&")).replace(/\b(\d+)\b/g, chalk3.cyan("$1")).replace(/(\/\/.*$)/g, chalk3.gray("$1")).replace(/(\w+)(?=\()/g, chalk3.yellow("$1")).replace(/\.(\w+)/g, "." + chalk3.cyan("$1"));
       }
-      return chalk2.white(line);
+      return chalk3.white(line);
     });
   }
   /**
@@ -1075,16 +1225,16 @@ var CodeHighlighter = class {
     const lines = [];
     const maxWidth = width - 4;
     const frameColors = {
-      classic: chalk2.cyan,
-      desert: chalk2.yellow,
-      matrix: chalk2.green,
-      commando: chalk2.rgb(107, 142, 35),
+      classic: chalk3.cyan,
+      desert: chalk3.yellow,
+      matrix: chalk3.green,
+      commando: chalk3.rgb(107, 142, 35),
       // Olive green
-      sandiego: chalk2.red,
-      ed209: chalk2.rgb(192, 192, 192)
+      sandiego: chalk3.red,
+      ed209: chalk3.rgb(192, 192, 192)
       // Silver
     };
-    const frameColor = frameColors[theme] || chalk2.cyan;
+    const frameColor = frameColors[theme] || chalk3.cyan;
     const languageAliases = {
       "ts": "typescript",
       "js": "javascript",
@@ -1111,11 +1261,11 @@ var CodeHighlighter = class {
     const highlightedLines = this.highlightCode(code, displayLang);
     highlightedLines.forEach((line, index) => {
       const lineNum = String(lineNumStart + index).padStart(3, " ");
-      const lineNumFormatted = chalk2.dim.gray(`${lineNum} \u2502`);
+      const lineNumFormatted = chalk3.dim.gray(`${lineNum} \u2502`);
       let codeLine = line;
       const maxLineLength = maxWidth - 8;
       if (codeLine.length > 200) {
-        codeLine = codeLine.substring(0, 197) + chalk2.dim("...");
+        codeLine = codeLine.substring(0, 197) + chalk3.dim("...");
       }
       lines.push(`${frameColor("\u2502")} ${lineNumFormatted} ${codeLine}`);
     });
@@ -1143,14 +1293,14 @@ var CodeHighlighter = class {
    */
   static formatInlineCode(code, theme = "classic") {
     const themeColors = {
-      classic: chalk2.bgGray.white,
-      desert: chalk2.bgYellow.black,
-      matrix: chalk2.bgGreen.black,
-      commando: chalk2.bgRgb(107, 142, 35).white,
-      sandiego: chalk2.bgRed.white,
-      ed209: chalk2.bgRgb(105, 105, 105).white
+      classic: chalk3.bgGray.white,
+      desert: chalk3.bgYellow.black,
+      matrix: chalk3.bgGreen.black,
+      commando: chalk3.bgRgb(107, 142, 35).white,
+      sandiego: chalk3.bgRed.white,
+      ed209: chalk3.bgRgb(105, 105, 105).white
     };
-    const colorFn = themeColors[theme] || chalk2.bgGray.white;
+    const colorFn = themeColors[theme] || chalk3.bgGray.white;
     return ` ${colorFn(code)} `;
   }
   /**
@@ -1180,7 +1330,7 @@ var CodeHighlighter = class {
 // src/utils/markdown-terminal.ts
 import asciify from "asciify-image";
-import fetch3 from "node-fetch";
+import fetch4 from "node-fetch";
 var MarkdownTerminalRenderer = class {
   theme;
   width;
@@ -1358,27 +1508,27 @@ var MarkdownTerminalRenderer = class {
       return `\0LINK${index}\0`;
     });
     result = result.replace(/\*\*\*(.+?)\*\*\*/g, (_, content) => {
-      return chalk3.bold(chalk3.italic(content));
+      return chalk4.bold(chalk4.italic(content));
     });
     result = result.replace(/___(.+?)___/g, (_, content) => {
-      return chalk3.bold(chalk3.italic(content));
+      return chalk4.bold(chalk4.italic(content));
     });
     result = result.replace(/\*\*(.+?)\*\*/g, (_, content) => {
-      const withItalic = content.replace(/\*(.+?)\*/g, (_2, text2) => chalk3.italic(text2));
-      return chalk3.bold(withItalic);
+      const withItalic = content.replace(/\*(.+?)\*/g, (_2, text2) => chalk4.italic(text2));
+      return chalk4.bold(withItalic);
     });
     result = result.replace(/__(.+?)__/g, (_, content) => {
-      const withItalic = content.replace(/_(.+?)_/g, (_2, text2) => chalk3.italic(text2));
-      return chalk3.bold(withItalic);
+      const withItalic = content.replace(/_(.+?)_/g, (_2, text2) => chalk4.italic(text2));
+      return chalk4.bold(withItalic);
     });
     result = result.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, (_, content) => {
-      return chalk3.italic(content);
+      return chalk4.italic(content);
     });
     result = result.replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, (_, content) => {
-      return chalk3.italic(content);
+      return chalk4.italic(content);
     });
     result = result.replace(/~~(.+?)~~/g, (_, content) => {
-      return chalk3.strikethrough(content);
+      return chalk4.strikethrough(content);
     });
     result = result.replace(/\x00CODE(\d+)\x00/g, (_, index) => {
       return codeBlocks[parseInt(index)];
@@ -1386,9 +1536,9 @@ var MarkdownTerminalRenderer = class {
     result = result.replace(/\x00LINK(\d+)\x00/g, (_, index) => {
       const link = links[parseInt(index)];
       let formattedText = link.text;
-      formattedText = formattedText.replace(/\*\*(.+?)\*\*/g, (_2, text2) => chalk3.bold(text2));
-      formattedText = formattedText.replace(/\*(.+?)\*/g, (_2, text2) => chalk3.italic(text2));
-      return chalk3.underline(chalk3.blue(formattedText)) + chalk3.gray(` (${link.url})`);
+      formattedText = formattedText.replace(/\*\*(.+?)\*\*/g, (_2, text2) => chalk4.bold(text2));
+      formattedText = formattedText.replace(/\*(.+?)\*/g, (_2, text2) => chalk4.italic(text2));
+      return chalk4.underline(chalk4.blue(formattedText)) + chalk4.gray(` (${link.url})`);
     });
     return result;
   }
@@ -1402,9 +1552,9 @@ var MarkdownTerminalRenderer = class {
     const imageIndex = this.trackedImages.length;
     const lines = [];
     lines.push("");
-    lines.push(chalk3.gray("\u250C" + border + "\u2510"));
+    lines.push(chalk4.gray("\u250C" + border + "\u2510"));
     try {
-      const response = await fetch3(url);
+      const response = await fetch4(url);
       if (response.ok) {
         const buffer = await response.buffer();
         const asciiArt = await asciify(buffer, {
@@ -1418,31 +1568,31 @@ var MarkdownTerminalRenderer = class {
         for (const line of asciiLines) {
           if (line) {
             const padding2 = Math.max(0, width - line.length);
-            lines.push(chalk3.gray("\u2502 ") + chalk3.cyan(line) + " ".repeat(padding2) + chalk3.gray("\u2502"));
+            lines.push(chalk4.gray("\u2502 ") + chalk4.cyan(line) + " ".repeat(padding2) + chalk4.gray("\u2502"));
           }
         }
       } else {
-        lines.push(chalk3.gray("\u2502") + chalk3.yellow(" \u{1F5BC}  Image could not be loaded ") + " ".repeat(Math.max(0, width - 32)) + chalk3.gray("\u2502"));
+        lines.push(chalk4.gray("\u2502") + chalk4.yellow(" \u{1F5BC}  Image could not be loaded ") + " ".repeat(Math.max(0, width - 32)) + chalk4.gray("\u2502"));
       }
     } catch (error) {
-      lines.push(chalk3.gray("\u2502") + chalk3.yellow(" \u{1F5BC}  Image (local/offline) ") + " ".repeat(Math.max(0, width - 28)) + chalk3.gray("\u2502"));
+      lines.push(chalk4.gray("\u2502") + chalk4.yellow(" \u{1F5BC}  Image (local/offline) ") + " ".repeat(Math.max(0, width - 28)) + chalk4.gray("\u2502"));
     }
     if (lines.length === 2) {
-      lines.push(chalk3.gray("\u2502") + chalk3.dim(" [Image] ") + " ".repeat(Math.max(0, width - 10)) + chalk3.gray("\u2502"));
+      lines.push(chalk4.gray("\u2502") + chalk4.dim(" [Image] ") + " ".repeat(Math.max(0, width - 10)) + chalk4.gray("\u2502"));
     }
-    lines.push(chalk3.gray("\u251C" + border + "\u2524"));
+    lines.push(chalk4.gray("\u251C" + border + "\u2524"));
     if (alt && alt.trim()) {
       const altLines = this.wrapText(alt, width - 2);
       for (const line of altLines) {
         const padding2 = Math.max(0, width - stripAnsi(line).length);
-        lines.push(chalk3.gray("\u2502 ") + chalk3.white(line) + " ".repeat(padding2) + chalk3.gray("\u2502"));
+        lines.push(chalk4.gray("\u2502 ") + chalk4.white(line) + " ".repeat(padding2) + chalk4.gray("\u2502"));
       }
-      lines.push(chalk3.gray("\u251C" + border + "\u2524"));
+      lines.push(chalk4.gray("\u251C" + border + "\u2524"));
     }
     const instruction = `Press [I] to open image ${imageIndex} in browser`;
     const padding = Math.max(0, width - instruction.length);
-    lines.push(chalk3.gray("\u2502 ") + chalk3.yellow(instruction) + " ".repeat(padding) + chalk3.gray("\u2502"));
-    lines.push(chalk3.gray("\u2514" + border + "\u2518"));
+    lines.push(chalk4.gray("\u2502 ") + chalk4.yellow(instruction) + " ".repeat(padding) + chalk4.gray("\u2502"));
+    lines.push(chalk4.gray("\u2514" + border + "\u2518"));
     lines.push("");
     return lines.join("\n");
   }
@@ -1571,8 +1721,8 @@ var MarkdownTerminalRenderer = class {
 // src/utils/course-detail-viewer.ts
 import { EventEmitter as EventEmitter2 } from "events";
-import { execSync } from "child_process";
-import open from "open";
+import { execSync as execSync2 } from "child_process";
+import open2 from "open";
 // src/utils/course-detail/layout.ts
 function computeTocWidth(terminalWidth) {
@@ -2219,8 +2369,8 @@ var CourseDetailViewer = class extends EventEmitter2 {
         }
         const imageStartLine = result.length;
         result.push("");
-        result.push(chalk4.cyan("[IMAGE] ") + chalk4.white(alt || "Image"));
-        result.push(chalk4.yellow("Press [I] to view in browser"));
+        result.push(chalk5.cyan("[IMAGE] ") + chalk5.white(alt || "Image"));
+        result.push(chalk5.yellow("Press [I] to view in browser"));
         const imageEndLine = result.length;
         this.trackedImages.push({ url, alt, lineNumber: imageStartLine, endLine: imageEndLine });
         result.push("");
@@ -2731,7 +2881,7 @@ var CourseDetailViewer = class extends EventEmitter2 {
         image.lineNumber <= viewportStart && image.endLine && image.endLine >= viewportEnd
       );
       if (imageVisible) {
-        open(image.url);
+        open2(image.url);
         return true;
       }
     }
@@ -2757,13 +2907,13 @@ var CourseDetailViewer = class extends EventEmitter2 {
             command = "clip";
           } else {
             try {
-              execSync("which xclip", { stdio: "ignore" });
+              execSync2("which xclip", { stdio: "ignore" });
               command = "xclip -selection clipboard";
             } catch {
               command = "xsel --clipboard --input";
             }
           }
-          execSync(command, { input: block.code });
+          execSync2(command, { input: block.code });
           const nowMs = Date.now();
           this.vs = {
             ...this.vs,
@@ -2879,14 +3029,14 @@ var CourseDetailViewer = class extends EventEmitter2 {
 };
 // src/commands/bbs.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { homedir as homedir2 } from "os";
 import process2 from "process";
 // src/utils/asset-downloader.ts
-import fetch4 from "node-fetch";
-import fs from "fs";
+import fetch5 from "node-fetch";
+import fs2 from "fs";
 import { pipeline as pipeline2 } from "stream/promises";
 var AssetDownloader = class {
   authManager;
@@ -2928,7 +3078,7 @@ var AssetDownloader = class {
       } else {
         downloadUrl = `${this.baseUrl}/${downloadUrl}`;
       }
-      const fileResponse = await fetch4(downloadUrl);
+      const fileResponse = await fetch5(downloadUrl);
       if (!fileResponse.ok) {
         if (fileResponse.status === 401) {
           throw new Error("Download token expired. Please try again.");
@@ -2939,7 +3089,7 @@ var AssetDownloader = class {
         const contentLength = fileResponse.headers.get("content-length");
         const total = parseInt(contentLength || "0", 10);
         let loaded = 0;
-        const writer = fs.createWriteStream(outputPath);
+        const writer = fs2.createWriteStream(outputPath);
         fileResponse.body.on("data", (chunk) => {
           loaded += chunk.length;
           writer.write(chunk);
@@ -2953,7 +3103,7 @@ var AssetDownloader = class {
         });
         await pipeline2(fileResponse.body, writer);
       } else {
-        const fileStream = fs.createWriteStream(outputPath);
+        const fileStream = fs2.createWriteStream(outputPath);
         await pipeline2(fileResponse.body, fileStream);
       }
       return true;
@@ -2981,15 +3131,15 @@ var AssetDownloader = class {
 };
 // src/utils/project-scanner.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 async function scanForProjects(baseDir, maxDepth = 2) {
   const projects = [];
   let projectId = 1;
   async function scanDirectory(dir, depth) {
     if (depth > maxDepth) return;
     try {
-      const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
+      const entries = await fs3.promises.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist" || entry.name === ".next") {
           continue;
@@ -2997,7 +3147,7 @@ async function scanForProjects(baseDir, maxDepth = 2) {
         if (entry.isSymbolicLink()) {
           continue;
         }
-        const fullPath = path2.join(dir, entry.name);
+        const fullPath = path3.join(dir, entry.name);
         if (entry.isDirectory()) {
           const isProject = await isProjectDirectory(fullPath);
           if (isProject) {
@@ -3016,10 +3166,10 @@ async function scanForProjects(baseDir, maxDepth = 2) {
 }
 async function isProjectDirectory(dir) {
   try {
-    const entries = await fs2.promises.readdir(dir);
+    const entries = await fs3.promises.readdir(dir);
     if (entries.includes("package.json")) {
-      const packageJsonPath = path2.join(dir, "package.json");
-      const packageJson = JSON.parse(await fs2.promises.readFile(packageJsonPath, "utf-8"));
+      const packageJsonPath = path3.join(dir, "package.json");
+      const packageJson = JSON.parse(await fs3.promises.readFile(packageJsonPath, "utf-8"));
       const allDeps = {
         ...packageJson.dependencies || {},
         ...packageJson.devDependencies || {}
@@ -3042,10 +3192,10 @@ async function isProjectDirectory(dir) {
 async function detectGenre(dir) {
   const configFiles = ["arcade.json", ".arcade", ".arcade.json"];
   for (const configFile of configFiles) {
-    const configPath = path2.join(dir, configFile);
-    if (fs2.existsSync(configPath)) {
+    const configPath = path3.join(dir, configFile);
+    if (fs3.existsSync(configPath)) {
       try {
-        const config = JSON.parse(await fs2.promises.readFile(configPath, "utf-8"));
+        const config = JSON.parse(await fs3.promises.readFile(configPath, "utf-8"));
         if (config.genre || config.template) {
           return config.genre || config.template;
         }
@@ -3053,20 +3203,20 @@ async function detectGenre(dir) {
       }
     }
   }
-  const packageJsonPath = path2.join(dir, "package.json");
-  if (fs2.existsSync(packageJsonPath)) {
+  const packageJsonPath = path3.join(dir, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(await fs2.promises.readFile(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(await fs3.promises.readFile(packageJsonPath, "utf-8"));
       if (pkg.arcade?.genre) return pkg.arcade.genre;
       if (pkg.arcade?.template) return pkg.arcade.template;
       if (pkg.gameType) return pkg.gameType;
     } catch {
     }
   }
-  const componentsDir = path2.join(dir, "src", "Components");
-  if (fs2.existsSync(componentsDir)) {
+  const componentsDir = path3.join(dir, "src", "Components");
+  if (fs3.existsSync(componentsDir)) {
     try {
-      const components = await fs2.promises.readdir(componentsDir);
+      const components = await fs3.promises.readdir(componentsDir);
       const componentNames = components.map((c) => c.toLowerCase());
       if (componentNames.some((c) => c.includes("fps") || c.includes("firstperson"))) {
         return "FPS";
@@ -3086,10 +3236,10 @@ async function detectGenre(dir) {
     } catch {
     }
   }
-  const dataDir = path2.join(dir, "data");
-  if (fs2.existsSync(dataDir)) {
+  const dataDir = path3.join(dir, "data");
+  if (fs3.existsSync(dataDir)) {
     try {
-      const dataDirs = await fs2.promises.readdir(dataDir);
+      const dataDirs = await fs3.promises.readdir(dataDir);
       for (const d of dataDirs) {
         const lowerName = d.toLowerCase();
         if (lowerName === "thirdperson") return "ThirdPerson";
@@ -3104,12 +3254,12 @@ async function detectGenre(dir) {
 }
 async function scanComponents(dir) {
   const components = [];
-  const componentsDir = path2.join(dir, "src", "Components");
-  if (!fs2.existsSync(componentsDir)) {
+  const componentsDir = path3.join(dir, "src", "Components");
+  if (!fs3.existsSync(componentsDir)) {
     return components;
   }
   try {
-    const files = await fs2.promises.readdir(componentsDir);
+    const files = await fs3.promises.readdir(componentsDir);
     for (const file of files) {
       if (file.endsWith(".ts") || file.endsWith(".js")) {
         const componentName = file.replace(/\.(ts|js)$/, "");
@@ -3123,14 +3273,14 @@ async function scanComponents(dir) {
   return components.sort();
 }
 async function analyzeProject(dir, id) {
-  const name = path2.basename(dir);
+  const name = path3.basename(dir);
   let hasPackageJson = false;
   let engine = "Unknown";
   try {
-    const packageJsonPath = path2.join(dir, "package.json");
-    if (fs2.existsSync(packageJsonPath)) {
+    const packageJsonPath = path3.join(dir, "package.json");
+    if (fs3.existsSync(packageJsonPath)) {
       hasPackageJson = true;
-      const packageJson = JSON.parse(await fs2.promises.readFile(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(await fs3.promises.readFile(packageJsonPath, "utf-8"));
       const allDeps = {
         ...packageJson.dependencies || {},
         ...packageJson.devDependencies || {}
@@ -3158,15 +3308,15 @@ async function analyzeProject(dir, id) {
 }
 // src/utils/component-catalog.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 function getLibraryPath() {
   const auth = new AuthManager();
   return auth.getLibraryPath();
 }
 function isLibraryInitialized() {
   const libraryPath = getLibraryPath();
-  return fs3.existsSync(path3.join(libraryPath, "Components"));
+  return fs4.existsSync(path4.join(libraryPath, "Components"));
 }
 async function initializeLibrary(libraryPath) {
   const targetPath = libraryPath || getLibraryPath();
@@ -3180,13 +3330,13 @@ async function initializeLibrary(libraryPath) {
   ];
   try {
     for (const dir of dirs) {
-      const fullPath = path3.join(targetPath, dir);
-      if (!fs3.existsSync(fullPath)) {
-        fs3.mkdirSync(fullPath, { recursive: true });
+      const fullPath = path4.join(targetPath, dir);
+      if (!fs4.existsSync(fullPath)) {
+        fs4.mkdirSync(fullPath, { recursive: true });
       }
     }
-    const readmePath = path3.join(targetPath, "README.md");
-    if (!fs3.existsSync(readmePath)) {
+    const readmePath = path4.join(targetPath, "README.md");
+    if (!fs4.existsSync(readmePath)) {
       const readme = `# BJS Library
 Your personal library of BabylonJS components, systems, and game mode presets.
@@ -3213,7 +3363,7 @@ Your personal library of BabylonJS components, systems, and game mode presets.
 Content from babylonjsmarket.com will be downloaded here automatically.
 `;
-      fs3.writeFileSync(readmePath, readme);
+      fs4.writeFileSync(readmePath, readme);
     }
     return { success: true, message: `Library initialized at ${targetPath}` };
   } catch (error) {
@@ -3222,12 +3372,12 @@ Content from babylonjsmarket.com will be downloaded here automatically.
 }
 function getGameModeSchema(modeName) {
   const libraryPath = getLibraryPath();
-  const schemaPath = path3.join(libraryPath, "GameModes", modeName, "gamemode.json");
-  if (!fs3.existsSync(schemaPath)) {
+  const schemaPath = path4.join(libraryPath, "GameModes", modeName, "gamemode.json");
+  if (!fs4.existsSync(schemaPath)) {
     return null;
   }
   try {
-    const content = fs3.readFileSync(schemaPath, "utf-8");
+    const content = fs4.readFileSync(schemaPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -3294,45 +3444,45 @@ var COMPONENT_CATALOG = [
 ];
 async function installComponent(componentName, targetProjectPath) {
   const libraryPath = getLibraryPath();
-  const componentDir = path3.join(libraryPath, "Components", componentName);
-  const componentFile = path3.join(componentDir, `${componentName}.ts`);
+  const componentDir = path4.join(libraryPath, "Components", componentName);
+  const componentFile = path4.join(componentDir, `${componentName}.ts`);
   const files = [];
-  if (!fs3.existsSync(componentFile)) {
-    const legacyPath = path3.join(libraryPath, "Components", `${componentName}.ts`);
-    if (fs3.existsSync(legacyPath)) {
-      const targetComponentDir2 = path3.join(targetProjectPath, "src", "Components");
-      if (!fs3.existsSync(targetComponentDir2)) {
-        fs3.mkdirSync(targetComponentDir2, { recursive: true });
-      }
-      const targetComponentPath2 = path3.join(targetComponentDir2, `${componentName}.ts`);
-      if (fs3.existsSync(targetComponentPath2)) {
+  if (!fs4.existsSync(componentFile)) {
+    const legacyPath = path4.join(libraryPath, "Components", `${componentName}.ts`);
+    if (fs4.existsSync(legacyPath)) {
+      const targetComponentDir2 = path4.join(targetProjectPath, "src", "Components");
+      if (!fs4.existsSync(targetComponentDir2)) {
+        fs4.mkdirSync(targetComponentDir2, { recursive: true });
+      }
+      const targetComponentPath2 = path4.join(targetComponentDir2, `${componentName}.ts`);
+      if (fs4.existsSync(targetComponentPath2)) {
         return { success: false, message: `${componentName}.ts already exists`, files };
       }
-      fs3.copyFileSync(legacyPath, targetComponentPath2);
+      fs4.copyFileSync(legacyPath, targetComponentPath2);
       files.push(`src/Components/${componentName}.ts`);
       return { success: true, message: `Installed ${componentName} (${files.length} files)`, files };
     }
     return { success: false, message: `Component ${componentName} not found in Library`, files };
   }
-  const targetComponentDir = path3.join(targetProjectPath, "src", "Components");
-  if (!fs3.existsSync(targetComponentDir)) {
-    fs3.mkdirSync(targetComponentDir, { recursive: true });
+  const targetComponentDir = path4.join(targetProjectPath, "src", "Components");
+  if (!fs4.existsSync(targetComponentDir)) {
+    fs4.mkdirSync(targetComponentDir, { recursive: true });
   }
-  const targetComponentPath = path3.join(targetComponentDir, `${componentName}.ts`);
-  if (fs3.existsSync(targetComponentPath)) {
+  const targetComponentPath = path4.join(targetComponentDir, `${componentName}.ts`);
+  if (fs4.existsSync(targetComponentPath)) {
     return { success: false, message: `${componentName}.ts already exists`, files };
   }
-  fs3.copyFileSync(componentFile, targetComponentPath);
+  fs4.copyFileSync(componentFile, targetComponentPath);
   files.push(`src/Components/${componentName}.ts`);
-  const testPath = path3.join(componentDir, `${componentName}.test.ts`);
-  if (fs3.existsSync(testPath)) {
-    const targetTestDir = path3.join(targetProjectPath, "tests", "Components");
-    if (!fs3.existsSync(targetTestDir)) {
-      fs3.mkdirSync(targetTestDir, { recursive: true });
-    }
-    const targetTestPath = path3.join(targetTestDir, `${componentName}.test.ts`);
-    if (!fs3.existsSync(targetTestPath)) {
-      fs3.copyFileSync(testPath, targetTestPath);
+  const testPath = path4.join(componentDir, `${componentName}.test.ts`);
+  if (fs4.existsSync(testPath)) {
+    const targetTestDir = path4.join(targetProjectPath, "tests", "Components");
+    if (!fs4.existsSync(targetTestDir)) {
+      fs4.mkdirSync(targetTestDir, { recursive: true });
+    }
+    const targetTestPath = path4.join(targetTestDir, `${componentName}.test.ts`);
+    if (!fs4.existsSync(targetTestPath)) {
+      fs4.copyFileSync(testPath, targetTestPath);
       files.push(`tests/Components/${componentName}.test.ts`);
     }
   }
@@ -3344,26 +3494,26 @@ async function installComponent(componentName, targetProjectPath) {
 }
 function getAvailableComponents(targetProjectPath) {
   const libraryPath = getLibraryPath();
-  const libraryComponentsDir = path3.join(libraryPath, "Components");
-  const targetComponentDir = path3.join(targetProjectPath, "src", "Components");
+  const libraryComponentsDir = path4.join(libraryPath, "Components");
+  const targetComponentDir = path4.join(targetProjectPath, "src", "Components");
   const installedComponents = /* @__PURE__ */ new Set();
   const availableComponents = [];
-  if (fs3.existsSync(targetComponentDir)) {
-    const files = fs3.readdirSync(targetComponentDir);
+  if (fs4.existsSync(targetComponentDir)) {
+    const files = fs4.readdirSync(targetComponentDir);
     for (const file of files) {
       if (file.endsWith(".ts")) {
         installedComponents.add(file.replace(".ts", ""));
       }
     }
   }
-  if (fs3.existsSync(libraryComponentsDir)) {
-    const entries = fs3.readdirSync(libraryComponentsDir, { withFileTypes: true });
+  if (fs4.existsSync(libraryComponentsDir)) {
+    const entries = fs4.readdirSync(libraryComponentsDir, { withFileTypes: true });
     for (const entry of entries) {
       let name;
       if (entry.isDirectory()) {
         name = entry.name;
-        const mainFile = path3.join(libraryComponentsDir, name, `${name}.ts`);
-        if (!fs3.existsSync(mainFile)) {
+        const mainFile = path4.join(libraryComponentsDir, name, `${name}.ts`);
+        if (!fs4.existsSync(mainFile)) {
           continue;
         }
       } else if (entry.isFile() && entry.name.endsWith(".ts")) {
@@ -3386,13 +3536,13 @@ function getAvailableComponents(targetProjectPath) {
 }
 function getGameModeCatalog() {
   const libraryPath = getLibraryPath();
-  const gameModesDir = path3.join(libraryPath, "GameModes");
+  const gameModesDir = path4.join(libraryPath, "GameModes");
   const modes = [];
-  if (!fs3.existsSync(gameModesDir)) {
+  if (!fs4.existsSync(gameModesDir)) {
     return modes;
   }
   try {
-    const dirs = fs3.readdirSync(gameModesDir, { withFileTypes: true });
+    const dirs = fs4.readdirSync(gameModesDir, { withFileTypes: true });
     for (const dir of dirs) {
       if (!dir.isDirectory()) continue;
       const schema = getGameModeSchema(dir.name);
@@ -3405,13 +3555,13 @@ function getGameModeCatalog() {
           hasShared: schema.includeShared || false
         });
       } else {
-        const modePath = path3.join(gameModesDir, dir.name);
+        const modePath = path4.join(gameModesDir, dir.name);
         modes.push({
           name: dir.name,
           description: `${dir.name} game mode`,
-          hasScenes: fs3.existsSync(path3.join(modePath, "Scenes")),
-          hasScreens: fs3.existsSync(path3.join(modePath, "Screens")),
-          hasShared: fs3.existsSync(path3.join(modePath, "Data"))
+          hasScenes: fs4.existsSync(path4.join(modePath, "Scenes")),
+          hasScreens: fs4.existsSync(path4.join(modePath, "Screens")),
+          hasShared: fs4.existsSync(path4.join(modePath, "Data"))
         });
       }
     }
@@ -3420,12 +3570,12 @@ function getGameModeCatalog() {
   return modes;
 }
 function getAvailableGameModes(targetProjectPath) {
-  const targetDataDir = path3.join(targetProjectPath, "data");
+  const targetDataDir = path4.join(targetProjectPath, "data");
   const installedModes = /* @__PURE__ */ new Set();
-  if (fs3.existsSync(targetDataDir)) {
-    const dirs = fs3.readdirSync(targetDataDir);
+  if (fs4.existsSync(targetDataDir)) {
+    const dirs = fs4.readdirSync(targetDataDir);
     for (const dir of dirs) {
-      const stat = fs3.statSync(path3.join(targetDataDir, dir));
+      const stat = fs4.statSync(path4.join(targetDataDir, dir));
       if (stat.isDirectory()) {
         installedModes.add(dir);
       }
@@ -3434,12 +3584,12 @@ function getAvailableGameModes(targetProjectPath) {
   return getGameModeCatalog().filter((m) => !installedModes.has(m.name));
 }
 function getInstalledGameModes(targetProjectPath) {
-  const targetDataDir = path3.join(targetProjectPath, "data");
+  const targetDataDir = path4.join(targetProjectPath, "data");
   const modes = [];
-  if (fs3.existsSync(targetDataDir)) {
-    const dirs = fs3.readdirSync(targetDataDir);
+  if (fs4.existsSync(targetDataDir)) {
+    const dirs = fs4.readdirSync(targetDataDir);
     for (const dir of dirs) {
-      const stat = fs3.statSync(path3.join(targetDataDir, dir));
+      const stat = fs4.statSync(path4.join(targetDataDir, dir));
       if (stat.isDirectory() && dir !== "Shared") {
         modes.push(dir);
       }
@@ -3448,29 +3598,29 @@ function getInstalledGameModes(targetProjectPath) {
   return modes;
 }
 function copyDir(src, dest, files, baseRelPath) {
-  fs3.mkdirSync(dest, { recursive: true });
-  const entries = fs3.readdirSync(src, { withFileTypes: true });
+  fs4.mkdirSync(dest, { recursive: true });
+  const entries = fs4.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path3.join(src, entry.name);
-    const destPath = path3.join(dest, entry.name);
-    const relPath = path3.join(baseRelPath, entry.name);
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
+    const relPath = path4.join(baseRelPath, entry.name);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath, files, relPath);
     } else if (entry.name !== "gamemode.json") {
-      fs3.copyFileSync(srcPath, destPath);
+      fs4.copyFileSync(srcPath, destPath);
       files.push(relPath);
     }
   }
 }
 async function installGameMode(modeName, targetProjectPath) {
   const libraryPath = getLibraryPath();
-  const gameModeDir = path3.join(libraryPath, "GameModes", modeName);
+  const gameModeDir = path4.join(libraryPath, "GameModes", modeName);
   const files = [];
-  if (!fs3.existsSync(gameModeDir)) {
+  if (!fs4.existsSync(gameModeDir)) {
     return { success: false, message: `Game mode ${modeName} not found in Library`, files };
   }
-  const targetDataDir = path3.join(targetProjectPath, "data", modeName);
-  if (fs3.existsSync(targetDataDir)) {
+  const targetDataDir = path4.join(targetProjectPath, "data", modeName);
+  if (fs4.existsSync(targetDataDir)) {
     return { success: false, message: `${modeName} already exists`, files };
   }
   const schema = getGameModeSchema(modeName);
@@ -3484,34 +3634,34 @@ async function installGameMode(modeName, targetProjectPath) {
       }
       if (schema.systems) {
         for (const sysName of schema.systems) {
-          const sysPath = path3.join(libraryPath, "Systems", `${sysName}.ts`);
-          if (fs3.existsSync(sysPath)) {
-            const targetSysDir = path3.join(targetProjectPath, "src", "Systems");
-            if (!fs3.existsSync(targetSysDir)) {
-              fs3.mkdirSync(targetSysDir, { recursive: true });
+          const sysPath = path4.join(libraryPath, "Systems", `${sysName}.ts`);
+          if (fs4.existsSync(sysPath)) {
+            const targetSysDir = path4.join(targetProjectPath, "src", "Systems");
+            if (!fs4.existsSync(targetSysDir)) {
+              fs4.mkdirSync(targetSysDir, { recursive: true });
             }
-            const targetSysPath = path3.join(targetSysDir, `${sysName}.ts`);
-            if (!fs3.existsSync(targetSysPath)) {
-              fs3.copyFileSync(sysPath, targetSysPath);
+            const targetSysPath = path4.join(targetSysDir, `${sysName}.ts`);
+            if (!fs4.existsSync(targetSysPath)) {
+              fs4.copyFileSync(sysPath, targetSysPath);
               files.push(`src/Systems/${sysName}.ts`);
             }
           }
         }
       }
-      fs3.mkdirSync(targetDataDir, { recursive: true });
-      const modeDataDir = path3.join(gameModeDir, "Data");
-      if (fs3.existsSync(modeDataDir)) {
-        const targetSharedDir = path3.join(targetDataDir, "Shared");
+      fs4.mkdirSync(targetDataDir, { recursive: true });
+      const modeDataDir = path4.join(gameModeDir, "Data");
+      if (fs4.existsSync(modeDataDir)) {
+        const targetSharedDir = path4.join(targetDataDir, "Shared");
         copyDir(modeDataDir, targetSharedDir, files, `data/${modeName}/Shared`);
       }
-      const modeScenesDir = path3.join(gameModeDir, "Scenes");
-      if (fs3.existsSync(modeScenesDir)) {
-        const targetScenesDir = path3.join(targetDataDir, "Scenes");
+      const modeScenesDir = path4.join(gameModeDir, "Scenes");
+      if (fs4.existsSync(modeScenesDir)) {
+        const targetScenesDir = path4.join(targetDataDir, "Scenes");
         copyDir(modeScenesDir, targetScenesDir, files, `data/${modeName}/Scenes`);
       }
-      const modeScreensDir = path3.join(gameModeDir, "Screens");
-      if (fs3.existsSync(modeScreensDir)) {
-        const targetScreensDir = path3.join(targetDataDir, "Screens");
+      const modeScreensDir = path4.join(gameModeDir, "Screens");
+      if (fs4.existsSync(modeScreensDir)) {
+        const targetScreensDir = path4.join(targetDataDir, "Screens");
         copyDir(modeScreensDir, targetScreensDir, files, `data/${modeName}/Screens`);
       }
     } else {
@@ -3528,18 +3678,18 @@ async function installGameMode(modeName, targetProjectPath) {
 }
 function getProjectScenes(targetProjectPath) {
   const scenes = [];
-  const dataDir = path3.join(targetProjectPath, "data");
-  if (!fs3.existsSync(dataDir)) return scenes;
-  const modes = fs3.readdirSync(dataDir);
+  const dataDir = path4.join(targetProjectPath, "data");
+  if (!fs4.existsSync(dataDir)) return scenes;
+  const modes = fs4.readdirSync(dataDir);
   for (const mode of modes) {
-    const scenesDir = path3.join(dataDir, mode, "Scenes");
-    if (fs3.existsSync(scenesDir)) {
-      const sceneFiles = fs3.readdirSync(scenesDir);
+    const scenesDir = path4.join(dataDir, mode, "Scenes");
+    if (fs4.existsSync(scenesDir)) {
+      const sceneFiles = fs4.readdirSync(scenesDir);
       for (const file of sceneFiles) {
         if (file.endsWith(".ts")) {
           scenes.push({
             name: file.replace(".ts", ""),
-            path: path3.join(scenesDir, file),
+            path: path4.join(scenesDir, file),
             gameMode: mode
           });
         }
@@ -3549,12 +3699,12 @@ function getProjectScenes(targetProjectPath) {
   return scenes;
 }
 async function createScene(targetProjectPath, gameMode, sceneName) {
-  const scenesDir = path3.join(targetProjectPath, "data", gameMode, "Scenes");
-  if (!fs3.existsSync(scenesDir)) {
-    fs3.mkdirSync(scenesDir, { recursive: true });
+  const scenesDir = path4.join(targetProjectPath, "data", gameMode, "Scenes");
+  if (!fs4.existsSync(scenesDir)) {
+    fs4.mkdirSync(scenesDir, { recursive: true });
   }
-  const scenePath = path3.join(scenesDir, `${sceneName}.ts`);
-  if (fs3.existsSync(scenePath)) {
+  const scenePath = path4.join(scenesDir, `${sceneName}.ts`);
+  if (fs4.existsSync(scenePath)) {
     return { success: false, message: `Scene ${sceneName} already exists`, path: "" };
   }
   const template = `import Basics from "../../Shared/Basics";
@@ -3584,7 +3734,7 @@ export default {
 };
 `;
   try {
-    fs3.writeFileSync(scenePath, template);
+    fs4.writeFileSync(scenePath, template);
     return {
       success: true,
       message: `Created scene ${sceneName}`,
@@ -3605,46 +3755,46 @@ async function migrateFromArcadeRef() {
     }
   }
   try {
-    const srcComponents = path3.join(ARCADE_REF_PATH, "src", "Components");
-    if (fs3.existsSync(srcComponents)) {
-      const targetComponents = path3.join(libraryPath, "Components");
-      const componentFiles2 = fs3.readdirSync(srcComponents);
+    const srcComponents = path4.join(ARCADE_REF_PATH, "src", "Components");
+    if (fs4.existsSync(srcComponents)) {
+      const targetComponents = path4.join(libraryPath, "Components");
+      const componentFiles2 = fs4.readdirSync(srcComponents);
       for (const file of componentFiles2) {
         if (file.endsWith(".ts")) {
-          const srcPath = path3.join(srcComponents, file);
-          const destPath = path3.join(targetComponents, file);
-          if (!fs3.existsSync(destPath)) {
-            fs3.copyFileSync(srcPath, destPath);
+          const srcPath = path4.join(srcComponents, file);
+          const destPath = path4.join(targetComponents, file);
+          if (!fs4.existsSync(destPath)) {
+            fs4.copyFileSync(srcPath, destPath);
             files.push(`Components/${file}`);
           }
         }
       }
     }
-    const srcTests = path3.join(ARCADE_REF_PATH, "tests", "Components");
-    if (fs3.existsSync(srcTests)) {
-      const targetTests = path3.join(libraryPath, "Tests");
-      const testFiles = fs3.readdirSync(srcTests);
+    const srcTests = path4.join(ARCADE_REF_PATH, "tests", "Components");
+    if (fs4.existsSync(srcTests)) {
+      const targetTests = path4.join(libraryPath, "Tests");
+      const testFiles = fs4.readdirSync(srcTests);
       for (const file of testFiles) {
         if (file.endsWith(".test.ts")) {
-          const srcPath = path3.join(srcTests, file);
-          const destPath = path3.join(targetTests, file);
-          if (!fs3.existsSync(destPath)) {
-            fs3.copyFileSync(srcPath, destPath);
+          const srcPath = path4.join(srcTests, file);
+          const destPath = path4.join(targetTests, file);
+          if (!fs4.existsSync(destPath)) {
+            fs4.copyFileSync(srcPath, destPath);
             files.push(`Tests/${file}`);
           }
         }
       }
     }
-    const srcData = path3.join(ARCADE_REF_PATH, "data", "Shared");
-    if (fs3.existsSync(srcData)) {
-      const targetData = path3.join(libraryPath, "Data");
-      const dataFiles = fs3.readdirSync(srcData);
+    const srcData = path4.join(ARCADE_REF_PATH, "data", "Shared");
+    if (fs4.existsSync(srcData)) {
+      const targetData = path4.join(libraryPath, "Data");
+      const dataFiles = fs4.readdirSync(srcData);
       for (const file of dataFiles) {
         if (file.endsWith(".ts")) {
-          const srcPath = path3.join(srcData, file);
-          const destPath = path3.join(targetData, file);
-          if (!fs3.existsSync(destPath)) {
-            fs3.copyFileSync(srcPath, destPath);
+          const srcPath = path4.join(srcData, file);
+          const destPath = path4.join(targetData, file);
+          if (!fs4.existsSync(destPath)) {
+            fs4.copyFileSync(srcPath, destPath);
             files.push(`Data/${file}`);
           }
         }
@@ -3652,24 +3802,24 @@ async function migrateFromArcadeRef() {
     }
     const gameModes = ["ThirdPerson", "Arcade"];
     for (const mode of gameModes) {
-      const srcMode = path3.join(ARCADE_REF_PATH, "data", mode);
-      if (fs3.existsSync(srcMode)) {
-        const targetMode = path3.join(libraryPath, "GameModes", mode);
-        if (!fs3.existsSync(targetMode)) {
-          fs3.mkdirSync(targetMode, { recursive: true });
+      const srcMode = path4.join(ARCADE_REF_PATH, "data", mode);
+      if (fs4.existsSync(srcMode)) {
+        const targetMode = path4.join(libraryPath, "GameModes", mode);
+        if (!fs4.existsSync(targetMode)) {
+          fs4.mkdirSync(targetMode, { recursive: true });
           const subdirs = ["Scenes", "Screens", "Shared"];
           for (const subdir of subdirs) {
-            const srcSubdir = path3.join(srcMode, subdir);
-            if (fs3.existsSync(srcSubdir)) {
-              const targetSubdir = subdir === "Shared" ? path3.join(targetMode, "Data") : path3.join(targetMode, subdir);
-              fs3.mkdirSync(targetSubdir, { recursive: true });
-              const subFiles = fs3.readdirSync(srcSubdir);
+            const srcSubdir = path4.join(srcMode, subdir);
+            if (fs4.existsSync(srcSubdir)) {
+              const targetSubdir = subdir === "Shared" ? path4.join(targetMode, "Data") : path4.join(targetMode, subdir);
+              fs4.mkdirSync(targetSubdir, { recursive: true });
+              const subFiles = fs4.readdirSync(srcSubdir);
               for (const file of subFiles) {
-                const srcPath = path3.join(srcSubdir, file);
-                const destPath = path3.join(targetSubdir, file);
-                const stat = fs3.statSync(srcPath);
+                const srcPath = path4.join(srcSubdir, file);
+                const destPath = path4.join(targetSubdir, file);
+                const stat = fs4.statSync(srcPath);
                 if (stat.isFile()) {
-                  fs3.copyFileSync(srcPath, destPath);
+                  fs4.copyFileSync(srcPath, destPath);
                   files.push(`GameModes/${mode}/${subdir === "Shared" ? "Data" : subdir}/${file}`);
                 }
               }
@@ -3681,11 +3831,11 @@ async function migrateFromArcadeRef() {
             components: mode === "ThirdPerson" ? ["Movement", "FollowCamera", "PlayerInput", "Animation", "Physics", "KeyboardTiming"] : ["Movement", "SimpleCamera", "PlayerInput", "SimplePhysics"],
             data: ["Light", "Basics"],
             includeShared: true,
-            scenes: fs3.existsSync(path3.join(srcMode, "Scenes")) ? fs3.readdirSync(path3.join(srcMode, "Scenes")).filter((f) => f.endsWith(".ts")) : [],
-            screens: fs3.existsSync(path3.join(srcMode, "Screens")) ? fs3.readdirSync(path3.join(srcMode, "Screens")).filter((f) => f.endsWith(".ts")) : []
+            scenes: fs4.existsSync(path4.join(srcMode, "Scenes")) ? fs4.readdirSync(path4.join(srcMode, "Scenes")).filter((f) => f.endsWith(".ts")) : [],
+            screens: fs4.existsSync(path4.join(srcMode, "Screens")) ? fs4.readdirSync(path4.join(srcMode, "Screens")).filter((f) => f.endsWith(".ts")) : []
           };
-          fs3.writeFileSync(
-            path3.join(targetMode, "gamemode.json"),
+          fs4.writeFileSync(
+            path4.join(targetMode, "gamemode.json"),
             JSON.stringify(schema, null, 2)
           );
           files.push(`GameModes/${mode}/gamemode.json`);
@@ -3835,12 +3985,12 @@ async function syncLibrary(onProgress) {
         componentSuccess = false;
         continue;
       }
-      const fullPath = path3.join(libraryPath, filePath);
-      const dir = path3.dirname(fullPath);
-      if (!fs3.existsSync(dir)) {
-        fs3.mkdirSync(dir, { recursive: true });
+      const fullPath = path4.join(libraryPath, filePath);
+      const dir = path4.dirname(fullPath);
+      if (!fs4.existsSync(dir)) {
+        fs4.mkdirSync(dir, { recursive: true });
       }
-      fs3.writeFileSync(fullPath, result.content);
+      fs4.writeFileSync(fullPath, result.content);
     }
     if (componentSuccess) {
       auth.updateLibraryFile(component.path, component.version);
@@ -3864,8 +4014,8 @@ async function syncLibrary(onProgress) {
 }
 // src/commands/bbs.ts
-import open2 from "open";
-import fetch5 from "node-fetch";
+import open3 from "open";
+import fetch6 from "node-fetch";
 // src/commands/bbs/state.ts
 var THEMES = [
@@ -5105,7 +5255,7 @@ function fatalError(error, context) {
   }
   process2.exit(1);
 }
-var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse courses and assets in retro style").option("-t, --theme <theme>", "Color theme (classic, desert, matrix, commando, sandiego, ed209)", "classic").option("--no-animations", "Disable animations").option("--no-mouse", "Disable mouse support").option("--no-browser", "Don't open browser automatically during authentication").option("--saveTo <path>", "Directory to save downloaded files (default: current directory)").action(async (options) => {
+var bbsCommand = new Command5("bbs").description("BabylonJS Market BBS - Browse courses and assets in retro style").option("-t, --theme <theme>", "Color theme (classic, desert, matrix, commando, sandiego, ed209)", "classic").option("--no-animations", "Disable animations").option("--no-mouse", "Disable mouse support").option("--no-browser", "Don't open browser automatically during authentication").option("--saveTo <path>", "Directory to save downloaded files (default: current directory)").action(async (options) => {
   process2.on("uncaughtException", (error) => {
     fatalError(error, "Uncaught Exception");
   });
@@ -5113,7 +5263,7 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
     fatalError(reason instanceof Error ? reason : new Error(String(reason)), "Unhandled Promise Rejection");
   });
   const authManager = new AuthManager();
-  const downloadDirectory = options.saveTo ? path4.resolve(options.saveTo) : process2.cwd();
+  const downloadDirectory = options.saveTo ? path5.resolve(options.saveTo) : process2.cwd();
   const savedPrefs = authManager.getPreferences();
   if (savedPrefs && savedPrefs.theme && THEMES.includes(savedPrefs.theme)) {
     options.theme = savedPrefs.theme;
@@ -5162,7 +5312,7 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
       bbs.showPollingStatus("checking", "Requesting authentication code...");
       backBuffer.draw({ dst: screenBuffer });
       screenBuffer.draw({ delta: true });
-      const deviceCodeResponse = await fetch5(AUTH_DEVICE_CODE_URL, {
+      const deviceCodeResponse = await fetch6(AUTH_DEVICE_CODE_URL, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ client_id: CLIENT_ID })
@@ -5179,7 +5329,7 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
       screenBuffer.draw({ delta: true });
       if (options.browser !== false) {
         const urlToOpen = deviceData.verification_uri_complete || deviceData.verification_uri;
-        await open2(urlToOpen);
+        await open3(urlToOpen);
       }
       const startTime = Date.now();
       const pollInterval = (deviceData.interval || 5) * 1e3;
@@ -5189,7 +5339,7 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
         bbs.showPollingStatus("checking", "Checking authentication status...");
         backBuffer.draw({ dst: screenBuffer });
         screenBuffer.draw({ delta: true });
-        const tokenResponse = await fetch5(AUTH_DEVICE_TOKEN_URL, {
+        const tokenResponse = await fetch6(AUTH_DEVICE_TOKEN_URL, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({
@@ -5260,7 +5410,7 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
   }
   const user = authManager.getUser();
   try {
-    fs4.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} BBS starting - animations: ${options.animations}
+    fs5.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} BBS starting - animations: ${options.animations}
 `);
     if (options.animations) {
       await bbs.showLoadingAnimation("Dialing BabylonJS Market BBS...", 1500);
@@ -5271,12 +5421,12 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
       backBuffer.draw({ dst: screenBuffer });
       screenBuffer.draw({ delta: true });
     }
-    fs4.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} Fetching courses from ${API_URL}
+    fs5.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} Fetching courses from ${API_URL}
 `);
     let allCoursesResponse;
     try {
       allCoursesResponse = await authManager.makeAuthenticatedRequest(`${API_URL}/api/auth/courses/all`);
-      fs4.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} Courses fetched OK
+      fs5.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} Courses fetched OK
 `);
     } catch (fetchError) {
       throw new Error(`Network error: ${fetchError.message}`);
@@ -5299,7 +5449,7 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
     }
     let scannedProjects = [];
     const configuredProjectsDir = authManager.getProjectsDirectory();
-    if (configuredProjectsDir && fs4.existsSync(configuredProjectsDir)) {
+    if (configuredProjectsDir && fs5.existsSync(configuredProjectsDir)) {
       try {
         const scanPromise = scanForProjects(configuredProjectsDir, 2);
         const timeoutPromise = new Promise(
@@ -5341,7 +5491,7 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
       term[color](msg);
     };
     const debugLog = (msg) => {
-      fs4.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+      fs5.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
     };
     const buildRenderContext = () => {
@@ -5470,10 +5620,10 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
         assetKey = toy.assetKey || toy.name.toLowerCase().replace(/\s+/g, "-");
         fileName = assetKey + ".glb";
       }
-      const outputPath = path4.join(downloadDirectory, fileName);
+      const outputPath = path5.join(downloadDirectory, fileName);
       try {
-        if (!fs4.existsSync(downloadDirectory)) {
-          fs4.mkdirSync(downloadDirectory, { recursive: true });
+        if (!fs5.existsSync(downloadDirectory)) {
+          fs5.mkdirSync(downloadDirectory, { recursive: true });
         }
         showStatus(`Downloading ${name}...`, "yellow");
         const success = await assetDownloader.downloadAsset(
@@ -5501,19 +5651,19 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
         if (!input || input.trim() === "") {
           return homedir2() + "/";
         }
-        const dir = path4.dirname(input);
-        const base = path4.basename(input);
-        if (dir && fs4.existsSync(dir)) {
-          const entries = fs4.readdirSync(dir);
+        const dir = path5.dirname(input);
+        const base = path5.basename(input);
+        if (dir && fs5.existsSync(dir)) {
+          const entries = fs5.readdirSync(dir);
           const matches = entries.filter((e) => e.toLowerCase().startsWith(base.toLowerCase())).filter((e) => {
             try {
-              return fs4.statSync(path4.join(dir, e)).isDirectory();
+              return fs5.statSync(path5.join(dir, e)).isDirectory();
             } catch {
               return false;
             }
           });
           if (matches.length === 1) {
-            return path4.join(dir, matches[0]) + "/";
+            return path5.join(dir, matches[0]) + "/";
           } else if (matches.length > 1) {
             const commonPrefix = matches.reduce((prefix, match) => {
               let i = 0;
@@ -5523,7 +5673,7 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
               return match.slice(0, i);
             });
             if (commonPrefix.length > base.length) {
-              return path4.join(dir, commonPrefix);
+              return path5.join(dir, commonPrefix);
             }
           }
         } else if (input.startsWith("~")) {
@@ -5537,8 +5687,8 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
       switch (effect.type) {
         case "CommitProjectsDir": {
           if (state.projectsDirInput.trim()) {
-            const resolvedPath = path4.resolve(state.projectsDirInput.trim());
-            if (fs4.existsSync(resolvedPath)) {
+            const resolvedPath = path5.resolve(state.projectsDirInput.trim());
+            if (fs5.existsSync(resolvedPath)) {
               authManager.setProjectsDirectory(resolvedPath);
               dispatch({ type: "SetProjectsDirResult", success: "\u2713 Saved! Scanning..." });
               await render();
@@ -5565,9 +5715,9 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
           break;
         case "CommitLibraryPath": {
           if (state.libraryPathInput.trim()) {
-            const resolvedPath = path4.resolve(state.libraryPathInput.trim());
+            const resolvedPath = path5.resolve(state.libraryPathInput.trim());
             authManager.setLibraryPath(resolvedPath);
-            if (!fs4.existsSync(path4.join(resolvedPath, "Components"))) {
+            if (!fs5.existsSync(path5.join(resolvedPath, "Components"))) {
               const result = await initializeLibrary(resolvedPath);
               state = { ...state, libraryPathSuccess: result.success ? "\u2713 Library initialized!" : result.message };
             } else {
@@ -5801,7 +5951,7 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
               } else {
                 showStatus(`Opening browser to purchase: ${course.title}...`, "yellow");
                 const category = course.category || "foundations";
-                await open2(`https://dev.babylonjsmarket.com/products/${category}/${course.slug}/`);
+                await open3(`https://dev.babylonjsmarket.com/products/${category}/${course.slug}/`);
                 showStatus(`Opened browser for course purchase`, "green");
                 setTimeout(() => {
                   term.moveTo(1, statusY);
@@ -5834,7 +5984,7 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
           const project = state.projects[state.projectsSelectedIndex];
           if (project) {
             const editor = process2.env.EDITOR || "code";
-            const editorName = path4.basename(editor);
+            const editorName = path5.basename(editor);
             showStatus(`Opening ${project.name} in ${editorName}...`, "yellow");
             const { spawn } = await import("child_process");
             const editorProcess = spawn(editor, [project.path], { detached: true, stdio: "ignore" });
@@ -6069,7 +6219,7 @@ var bbsCommand = new Command4("bbs").description("BabylonJS Market BBS - Browse
 });
 // src/commands/inject.ts
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 import { mkdtempSync, existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { join as join4 } from "path";
 import { tmpdir } from "os";
@@ -6090,8 +6240,8 @@ function getVersion() {
 }
 // src/lib/inject/engine.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import mri from "mri";
 import colors2 from "picocolors";
@@ -6105,15 +6255,15 @@ BabylonJS Market for curator review (reverse of ${cyan("arcade eject")}).
 With no ${bold("--target")}, the tool auto-detects per seed:
   * any file extending ${cyan("PanelDebuggerSystem")} / ${cyan("StateStepperSystem")} or
-    importing from ${cyan("@babylonjsmarket/viz-pro")} \u2192 ${cyan("viz-pro")},
-  * otherwise \u2192 ${cyan("arcade-pro")}.
+    importing from ${cyan("@babylonjsmarket/viz")} \u2192 ${cyan("viz")},
+  * otherwise \u2192 ${cyan("arcade")}.
 Multi-seed inputs must all detect to the same target.
 Options:
-  --target <arcade-pro|viz-pro>   skip auto-detection
+  --target <arcade|viz>           skip auto-detection (legacy: arcade-pro, viz-pro)
   --source <path>                 override <cwd>/src/components/<Name>/
-  --layer <core|solid|ecs>        viz-pro only; skip per-file layer detection
+  --layer <core|solid|ecs>        viz only; skip per-file layer detection
   --force                         allow overwriting an existing target
   --dry-run                       print the plan, write nothing, do not submit
   -h, --help                      print this help message
@@ -6121,17 +6271,17 @@ Options:
 Examples:
   bjs inject Foo                              # auto-detect target
   bjs inject Foo Bar --dry-run                # multi-name, preview
-  bjs inject MyPanelDebugger --target viz-pro
+  bjs inject MyPanelDebugger --target viz
   bjs inject Foo --source ./packages/demo/src/components/Foo
 `;
 // src/lib/inject/detect-target.ts
 function detectTarget(seedFiles) {
   for (const { source } of seedFiles) {
-    if (/from\s+['"]@babylonjsmarket\/viz-pro['"]/.test(source)) return "viz-pro";
-    if (/extends\s+(PanelDebuggerSystem|StateStepperSystem)\b/.test(source)) return "viz-pro";
+    if (/from\s+['"]@babylonjsmarket\/viz(?:-pro)?['"]/.test(source)) return "viz";
+    if (/extends\s+(PanelDebuggerSystem|StateStepperSystem)\b/.test(source)) return "viz";
   }
-  return "arcade-pro";
+  return "arcade";
 }
 function detectLayer(filePath, source, subjectLayer) {
   const base = filePath.split(/[\\/]/).pop() ?? filePath;
@@ -6148,28 +6298,28 @@ function detectLayer(filePath, source, subjectLayer) {
 }
 // src/lib/inject/monorepo-root.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findMonorepoRoot() {
-  const here = path5.dirname(fileURLToPath2(import.meta.url));
+  const here = path6.dirname(fileURLToPath2(import.meta.url));
   let dir = here;
   while (true) {
-    const pkgPath = path5.join(dir, "package.json");
-    if (fs5.existsSync(pkgPath)) {
+    const pkgPath = path6.join(dir, "package.json");
+    if (fs6.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf8"));
+        const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf8"));
         if (pkg.name === "babylonjs-market-monorepo") {
           return {
             root: dir,
-            arcadeProRoot: path5.join(dir, "packages", "arcade-pro"),
-            vizProRoot: path5.join(dir, "packages", "viz-pro")
+            arcadeProRoot: path6.join(dir, "packages", "arcade-pro"),
+            vizProRoot: path6.join(dir, "packages", "viz-pro")
           };
         }
       } catch {
       }
     }
-    const parent = path5.dirname(dir);
+    const parent = path6.dirname(dir);
     if (parent === dir) {
       throw new Error(
         `Could not locate umbrella repo (no ancestor package.json with name "babylonjs-market-monorepo" above ${here}).`
@@ -6184,46 +6334,46 @@ var { cyan: cyan2, green, yellow, dim, bold: bold2 } = colors2;
 function componentFiles(dir) {
   const out = [];
   const walk = (d) => {
-    for (const e of fs6.readdirSync(d, { withFileTypes: true })) {
-      const p = path6.join(d, e.name);
+    for (const e of fs7.readdirSync(d, { withFileTypes: true })) {
+      const p = path7.join(d, e.name);
       if (e.isDirectory()) walk(p);
       else if (/\.(ts|tsx)$/.test(e.name)) out.push(p);
     }
   };
-  if (fs6.existsSync(dir)) walk(dir);
+  if (fs7.existsSync(dir)) walk(dir);
   return out;
 }
 function allComponentFiles(dir) {
   const out = [];
   const walk = (d) => {
-    for (const e of fs6.readdirSync(d, { withFileTypes: true })) {
-      const p = path6.join(d, e.name);
+    for (const e of fs7.readdirSync(d, { withFileTypes: true })) {
+      const p = path7.join(d, e.name);
       if (e.isDirectory()) walk(p);
       else out.push(p);
     }
   };
-  if (fs6.existsSync(dir)) walk(dir);
+  if (fs7.existsSync(dir)) walk(dir);
   return out;
 }
 function projectComponentNames(projectDir) {
-  const dir = path6.join(projectDir, "src", "components");
-  if (!fs6.existsSync(dir)) return [];
-  return fs6.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== "_shared").map((e) => e.name);
+  const dir = path7.join(projectDir, "src", "components");
+  if (!fs7.existsSync(dir)) return [];
+  return fs7.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== "_shared").map((e) => e.name);
 }
 function directDeps(name, componentsDir, allNames) {
   const deps = /* @__PURE__ */ new Set();
-  const metaPath = path6.join(componentsDir, name, "meta.json");
-  if (fs6.existsSync(metaPath)) {
+  const metaPath = path7.join(componentsDir, name, "meta.json");
+  if (fs7.existsSync(metaPath)) {
     try {
-      const meta = JSON.parse(fs6.readFileSync(metaPath, "utf8"));
+      const meta = JSON.parse(fs7.readFileSync(metaPath, "utf8"));
       for (const d of meta.dependencies ?? []) if (allNames.has(d)) deps.add(d);
     } catch {
     }
   }
   const relRe = /['"]\.\.\/([A-Z][A-Za-z0-9_]*)\//g;
   const aliasRe = /['"]~\/components\/([A-Z][A-Za-z0-9_]*)\//g;
-  for (const file of componentFiles(path6.join(componentsDir, name))) {
-    const src = fs6.readFileSync(file, "utf8");
+  for (const file of componentFiles(path7.join(componentsDir, name))) {
+    const src = fs7.readFileSync(file, "utf8");
     let m;
     while (m = relRe.exec(src)) if (allNames.has(m[1])) deps.add(m[1]);
     while (m = aliasRe.exec(src)) if (allNames.has(m[1])) deps.add(m[1]);
@@ -6258,7 +6408,7 @@ function rewriteArcadeImports(src, injected) {
 }
 function rewriteVizImports(src, injected, layerOf, fromLayer) {
   return src.replace(
-    /(['"])@babylonjsmarket\/(?:viz-pro|arcade|arcade-pro)\/([A-Z][A-Za-z0-9_]*)\1/g,
+    /(['"])@babylonjsmarket\/(?:viz-pro|viz|arcade|arcade-pro)\/([A-Z][A-Za-z0-9_]*)\1/g,
     (whole, quote, sibling) => {
       if (!injected.has(sibling)) return whole;
       const dest = layerOf(sibling);
@@ -6272,7 +6422,7 @@ function planArcadeProRegistry(existingRegistry, names, registryRelPath = "src/r
   const warnings = [];
   if (existingRegistry === void 0) {
     warnings.push(
-      `! packages/arcade-pro/${registryRelPath} not found \u2014 add resolvers manually for: ${names.join(", ")}`
+      `! packages/arcade/${registryRelPath} not found \u2014 add resolvers manually for: ${names.join(", ")}`
     );
     return { lines: [], added: [], warnings, markerFound: false };
   }
@@ -6293,15 +6443,15 @@ function planArcadeProRegistry(existingRegistry, names, registryRelPath = "src/r
   return { lines, added, warnings, markerFound: true };
 }
 function patchArcadeProRegistry(arcadeProRoot, names, dryRun) {
-  const registryPath = path6.join(arcadeProRoot, "src", "registry.ts");
-  const existing = fs6.existsSync(registryPath) ? fs6.readFileSync(registryPath, "utf8") : void 0;
+  const registryPath = path7.join(arcadeProRoot, "src", "registry.ts");
+  const existing = fs7.existsSync(registryPath) ? fs7.readFileSync(registryPath, "utf8") : void 0;
   const plan = planArcadeProRegistry(existing, names);
   if (plan.warnings.length) return plan.warnings;
   if (plan.added.length && !dryRun) {
     const marker = /ARCADE_PRO_COMPONENT_REGISTRY:\s*Record<string,\s*LazyComponentResolver>\s*=\s*\{/;
     const next = existing.replace(marker, (m) => `${m}
 ${plan.lines.join("\n")}`);
-    fs6.writeFileSync(registryPath, next);
+    fs7.writeFileSync(registryPath, next);
   }
   return plan.added.map((n) => `  patched registry: ${n}`);
 }
@@ -6319,21 +6469,21 @@ function planVizProBarrel(existingBarrel, layer, fileName) {
   return { line: `export * from './${fileName}';`, warnings: [] };
 }
 function patchVizProBarrel(vizProRoot, layer, fileName, dryRun) {
-  const barrelPath = path6.join(vizProRoot, "src", layer, "index.ts");
-  const existing = fs6.existsSync(barrelPath) ? fs6.readFileSync(barrelPath, "utf8") : void 0;
+  const barrelPath = path7.join(vizProRoot, "src", layer, "index.ts");
+  const existing = fs7.existsSync(barrelPath) ? fs7.readFileSync(barrelPath, "utf8") : void 0;
   const plan = planVizProBarrel(existing, layer, fileName);
   if (plan.warnings.length) return plan.warnings;
   if (plan.line === null) return [];
   if (!dryRun) {
     const next = existing.endsWith("\n") ? existing + plan.line + "\n" : existing + "\n" + plan.line + "\n";
-    fs6.writeFileSync(barrelPath, next);
+    fs7.writeFileSync(barrelPath, next);
   }
   return [`  patched ${layer}/index.ts: ${fileName}`];
 }
 function stripProjectRegistry(projectDir, names, dryRun) {
-  const registryPath = path6.join(projectDir, "src", "registry.ts");
-  if (!fs6.existsSync(registryPath)) return [];
-  let text = fs6.readFileSync(registryPath, "utf8");
+  const registryPath = path7.join(projectDir, "src", "registry.ts");
+  if (!fs7.existsSync(registryPath)) return [];
+  let text = fs7.readFileSync(registryPath, "utf8");
   const removed = [];
   for (const name of names) {
     const re = new RegExp(
@@ -6345,7 +6495,7 @@ function stripProjectRegistry(projectDir, names, dryRun) {
       removed.push(name);
     }
   }
-  if (removed.length && !dryRun) fs6.writeFileSync(registryPath, text);
+  if (removed.length && !dryRun) fs7.writeFileSync(registryPath, text);
   return removed;
 }
 async function inject(args, opts = {}) {
@@ -6362,7 +6512,8 @@ async function inject(args, opts = {}) {
   const move = Boolean(argv.move);
   const confirm2 = Boolean(argv.confirm);
   const force = Boolean(argv.force);
-  const explicitTarget = argv.target;
+  const rawTarget = argv.target;
+  const explicitTarget = rawTarget === "arcade-pro" ? "arcade" : rawTarget === "viz-pro" ? "viz" : rawTarget;
   const sourceOverride = argv.source;
   const layerOverride = argv.layer;
   const names = argv._.map(String);
@@ -6388,8 +6539,8 @@ async function inject(args, opts = {}) {
     process.exit(1);
     return;
   }
-  if (explicitTarget && explicitTarget !== "arcade-pro" && explicitTarget !== "viz-pro") {
-    console.error(yellow(`Unknown --target ${explicitTarget}. Use arcade-pro or viz-pro.`));
+  if (explicitTarget && explicitTarget !== "arcade" && explicitTarget !== "viz") {
+    console.error(yellow(`Unknown --target ${rawTarget}. Use arcade or viz.`));
     process.exit(1);
     return;
   }
@@ -6416,12 +6567,12 @@ async function inject(args, opts = {}) {
       return;
     }
   }
-  const componentsDir = path6.join(projectDir, "src", "components");
+  const componentsDir = path7.join(projectDir, "src", "components");
   const allProjectNames = projectComponentNames(projectDir);
   const seeds = [];
   for (const name of names) {
-    const sourceDir = sourceOverride ? path6.resolve(cwd, sourceOverride) : path6.join(componentsDir, name);
-    if (!fs6.existsSync(sourceDir)) {
+    const sourceDir = sourceOverride ? path7.resolve(cwd, sourceOverride) : path7.join(componentsDir, name);
+    if (!fs7.existsSync(sourceDir)) {
       console.error(
         yellow(
           `Could not find source for "${name}". Looked at ${sourceDir}. Use --source <path> to point at the seed explicitly.`
@@ -6436,9 +6587,9 @@ async function inject(args, opts = {}) {
   const closure = sourceOverride ? seedNames : resolveClosure(seedNames, componentsDir, allProjectNames);
   const closureFiles = [];
   for (const name of closure) {
-    const dir = sourceOverride && seedNames.has(name) ? seeds.find((s) => s.name === name).sourceDir : path6.join(componentsDir, name);
+    const dir = sourceOverride && seedNames.has(name) ? seeds.find((s) => s.name === name).sourceDir : path7.join(componentsDir, name);
     for (const f of componentFiles(dir)) {
-      closureFiles.push({ path: f, source: fs6.readFileSync(f, "utf8") });
+      closureFiles.push({ path: f, source: fs7.readFileSync(f, "utf8") });
     }
   }
   const target = explicitTarget ?? detectTarget(closureFiles);
@@ -6447,7 +6598,7 @@ async function inject(args, opts = {}) {
       const dir = seed.sourceDir;
       const files = componentFiles(dir).map((f) => ({
         path: f,
-        source: fs6.readFileSync(f, "utf8")
+        source: fs7.readFileSync(f, "utf8")
       }));
       const perSeed = detectTarget(files);
       if (perSeed !== target) {
@@ -6464,15 +6615,15 @@ async function inject(args, opts = {}) {
   let chosenRoot;
   if (mode === "apply") {
     try {
-      if (target === "arcade-pro") {
-        if (!fs6.existsSync(packageRoot)) {
+      if (target === "arcade") {
+        if (!fs7.existsSync(packageRoot)) {
           throw new Error(
-            `packages/arcade-pro is not checked out at ${packageRoot}. Run \`git submodule update --init packages/arcade-pro\` and retry.`
+            `packages/arcade is not checked out at ${packageRoot}. Run \`git submodule update --init packages/arcade\` and retry.`
           );
         }
         chosenRoot = packageRoot;
       } else {
-        if (!fs6.existsSync(vizProRoot)) {
+        if (!fs7.existsSync(vizProRoot)) {
           throw new Error(
             `packages/viz-pro is not checked out at ${vizProRoot}. Run \`git submodule update --init packages/viz-pro\` and retry.`
           );
@@ -6491,7 +6642,7 @@ async function inject(args, opts = {}) {
   console.log(`  target:     ${cyan2(target)}`);
   console.log(`  components: ${cyan2([...closure].sort().join(", "))}`);
   if (mode === "collect") {
-    const result = target === "arcade-pro" ? collectArcadePro({ seeds, closure, componentsDir, sourceOverride }) : collectVizPro({ seeds, closure, componentsDir, sourceOverride, layerOverride });
+    const result = target === "arcade" ? collectArcadePro({ seeds, closure, componentsDir, sourceOverride }) : collectVizPro({ seeds, closure, componentsDir, sourceOverride, layerOverride });
     for (const f of result.files) console.log(green(`  + packages/${target}/${f.path}`));
     for (const w of result.warnings) console.log(yellow(w));
     console.log(
@@ -6499,7 +6650,7 @@ async function inject(args, opts = {}) {
     );
     return { ...result, target };
   }
-  if (target === "arcade-pro") {
+  if (target === "arcade") {
     await injectArcadePro({
       seeds,
       closure,
@@ -6530,9 +6681,9 @@ async function inject(args, opts = {}) {
       );
     }
     for (const seed of seeds) {
-      if (fs6.existsSync(seed.sourceDir)) {
-        if (!dryRun) fs6.rmSync(seed.sourceDir, { recursive: true, force: true });
-        console.log(dim(`  - ${path6.relative(projectDir, seed.sourceDir)}/ (project copy removed)`));
+      if (fs7.existsSync(seed.sourceDir)) {
+        if (!dryRun) fs7.rmSync(seed.sourceDir, { recursive: true, force: true });
+        console.log(dim(`  - ${path7.relative(projectDir, seed.sourceDir)}/ (project copy removed)`));
       }
     }
     const removed = stripProjectRegistry(
@@ -6552,31 +6703,31 @@ Done. Components landed in packages/${target}/.
 }
 async function injectArcadePro(args) {
   const { seeds, closure, componentsDir, sourceOverride, arcadeProRoot, dryRun, force } = args;
-  const destComponents = path6.join(arcadeProRoot, "src", "Components");
-  if (!dryRun) fs6.mkdirSync(destComponents, { recursive: true });
+  const destComponents = path7.join(arcadeProRoot, "src", "Components");
+  if (!dryRun) fs7.mkdirSync(destComponents, { recursive: true });
   const sourceOf = (name) => {
     const seed = seeds.find((s) => s.name === name);
-    return seed && sourceOverride ? seed.sourceDir : path6.join(componentsDir, name);
+    return seed && sourceOverride ? seed.sourceDir : path7.join(componentsDir, name);
   };
   for (const name of [...closure].sort()) {
     const src = sourceOf(name);
-    const dest = path6.join(destComponents, name);
-    if (fs6.existsSync(dest) && !force) {
+    const dest = path7.join(destComponents, name);
+    if (fs7.existsSync(dest) && !force) {
       console.log(
-        yellow(`  ! packages/arcade-pro/src/Components/${name}/ already exists \u2014 pass --force to overwrite.`)
+        yellow(`  ! packages/arcade/src/Components/${name}/ already exists \u2014 pass --force to overwrite.`)
       );
       continue;
     }
     if (!dryRun) {
-      if (fs6.existsSync(dest)) fs6.rmSync(dest, { recursive: true, force: true });
-      fs6.cpSync(src, dest, { recursive: true });
+      if (fs7.existsSync(dest)) fs7.rmSync(dest, { recursive: true, force: true });
+      fs7.cpSync(src, dest, { recursive: true });
     }
-    console.log(green(`  + packages/arcade-pro/src/Components/${name}/`));
+    console.log(green(`  + packages/arcade/src/Components/${name}/`));
   }
   if (!dryRun) {
     for (const name of closure) {
-      const dest = path6.join(destComponents, name);
-      if (!fs6.existsSync(dest)) continue;
+      const dest = path7.join(destComponents, name);
+      if (!fs7.existsSync(dest)) continue;
       rewriteTree(dest, (text) => rewriteArcadeImports(text, closure));
     }
   }
@@ -6592,21 +6743,21 @@ function collectArcadePro(args) {
   const { seeds, closure, componentsDir, sourceOverride } = args;
   const sourceOf = (name) => {
     const seed = seeds.find((s) => s.name === name);
-    return seed && sourceOverride ? seed.sourceDir : path6.join(componentsDir, name);
+    return seed && sourceOverride ? seed.sourceDir : path7.join(componentsDir, name);
   };
   const files = [];
   const warnings = [];
   for (const name of [...closure].sort()) {
     const src = sourceOf(name);
-    if (!fs6.existsSync(src)) {
+    if (!fs7.existsSync(src)) {
       warnings.push(`  ! source for ${name} missing at ${src}`);
       continue;
     }
     for (const abs of allComponentFiles(src)) {
-      const rel = path6.relative(src, abs);
-      const baseRel = path6.posix.join("src", "Components", name, rel.split(path6.sep).join("/"));
+      const rel = path7.relative(src, abs);
+      const baseRel = path7.posix.join("src", "Components", name, rel.split(path7.sep).join("/"));
       const isText = /\.(ts|tsx)$/i.test(abs);
-      const raw = fs6.readFileSync(abs, "utf8");
+      const raw = fs7.readFileSync(abs, "utf8");
       const contents = isText ? rewriteArcadeImports(raw, closure) : raw;
       files.push({ path: baseRel, contents });
     }
@@ -6625,15 +6776,15 @@ function classifyVizFiles(args) {
   const { seeds, closure, componentsDir, sourceOverride, layerOverride } = args;
   const sourceOf = (name) => {
     const seed = seeds.find((s) => s.name === name);
-    return seed && sourceOverride ? seed.sourceDir : path6.join(componentsDir, name);
+    return seed && sourceOverride ? seed.sourceDir : path7.join(componentsDir, name);
   };
   const files = [];
   for (const name of closure) {
     const dir = sourceOf(name);
     for (const abs of componentFiles(dir)) {
-      const base = path6.basename(abs);
+      const base = path7.basename(abs);
       if (/\.test\.tsx?$/.test(base)) continue;
-      const source = fs6.readFileSync(abs, "utf8");
+      const source = fs7.readFileSync(abs, "utf8");
       const layer = layerOverride ?? detectLayer(abs, source);
       files.push({ src: abs, base, owner: name, source, layer, destBase: base });
     }
@@ -6641,9 +6792,9 @@ function classifyVizFiles(args) {
   for (const name of closure) {
     const dir = sourceOf(name);
     for (const abs of componentFiles(dir)) {
-      const base = path6.basename(abs);
+      const base = path7.basename(abs);
       if (!/\.test\.tsx?$/.test(base)) continue;
-      const source = fs6.readFileSync(abs, "utf8");
+      const source = fs7.readFileSync(abs, "utf8");
       const subjectBase = base.replace(/\.test(\.tsx?)$/, "$1");
       const subjectAlt = base.replace(/\.test\.tsx?$/, ".tsx");
       const subject = files.find((f) => f.owner === name && (f.base === subjectBase || f.base === subjectAlt));
@@ -6663,8 +6814,8 @@ async function injectVizPro(args) {
   const { files, primaryLayer } = classifyVizFiles(args);
   const layerOf = (name) => primaryLayer.get(name);
   for (const f of files) {
-    const dest = path6.join(vizProRoot, "src", f.layer, f.destBase);
-    if (fs6.existsSync(dest) && !force) {
+    const dest = path7.join(vizProRoot, "src", f.layer, f.destBase);
+    if (fs7.existsSync(dest) && !force) {
       console.log(
         yellow(
           `  ! packages/viz-pro/src/${f.layer}/${f.destBase} already exists \u2014 pass --force to overwrite.`
@@ -6673,13 +6824,13 @@ async function injectVizPro(args) {
     }
   }
   for (const f of files) {
-    const destDir = path6.join(vizProRoot, "src", f.layer);
-    const dest = path6.join(destDir, f.destBase);
-    if (fs6.existsSync(dest) && !force) continue;
+    const destDir = path7.join(vizProRoot, "src", f.layer);
+    const dest = path7.join(destDir, f.destBase);
+    if (fs7.existsSync(dest) && !force) continue;
     if (!dryRun) {
-      fs6.mkdirSync(destDir, { recursive: true });
+      fs7.mkdirSync(destDir, { recursive: true });
       const rewritten = rewriteVizImports(f.source, closure, layerOf, f.layer);
-      fs6.writeFileSync(dest, rewritten);
+      fs7.writeFileSync(dest, rewritten);
     }
     console.log(green(`  + packages/viz-pro/src/${f.layer}/${f.destBase}`));
   }
@@ -6707,7 +6858,7 @@ function collectVizPro(args) {
   const files = [];
   const warnings = [];
   for (const f of classified) {
-    const rel = path6.posix.join("src", f.layer, f.destBase);
+    const rel = path7.posix.join("src", f.layer, f.destBase);
     const contents = rewriteVizImports(f.source, closure, layerOf, f.layer);
     files.push({ path: rel, contents });
   }
@@ -6728,19 +6879,19 @@ function collectVizPro(args) {
   return { files, patches, warnings };
 }
 function rewriteTree(dir, rewrite) {
-  for (const e of fs6.readdirSync(dir, { withFileTypes: true })) {
-    const p = path6.join(dir, e.name);
+  for (const e of fs7.readdirSync(dir, { withFileTypes: true })) {
+    const p = path7.join(dir, e.name);
     if (e.isDirectory()) rewriteTree(p, rewrite);
     else if (/\.(ts|tsx)$/.test(e.name)) {
-      const before = fs6.readFileSync(p, "utf8");
+      const before = fs7.readFileSync(p, "utf8");
       const after = rewrite(before);
-      if (after !== before) fs6.writeFileSync(p, after);
+      if (after !== before) fs7.writeFileSync(p, after);
     }
   }
 }
 // src/commands/inject.ts
-var injectCommand = new Command5("inject").description("Submit a component or system to BabylonJS Market for curator review").argument("[names...]", "Component / system name(s) to submit").option("--target <target>", "arcade-pro | viz-pro (skip auto-detection)").option("--source <path>", "override <cwd>/src/components/<Name>/").option("--layer <layer>", "viz-pro only; skip per-file layer detection (core|solid|ecs)").option("--force", "allow overwriting an existing target").option("--dry-run", "print the plan, write nothing, do not submit").allowUnknownOption(false).action(async (names, options) => {
+var injectCommand = new Command6("inject").description("Submit a component or system to BabylonJS Market for curator review").argument("[names...]", "Component / system name(s) to submit").option("--target <target>", "arcade | viz (skip auto-detection; legacy arcade-pro/viz-pro accepted)").option("--source <path>", "override <cwd>/src/components/<Name>/").option("--layer <layer>", "viz only; skip per-file layer detection (core|solid|ecs)").option("--force", "allow overwriting an existing target").option("--dry-run", "print the plan, write nothing, do not submit").allowUnknownOption(false).action(async (names, options) => {
   const auth = new AuthManager();
   const theme = applyTheme();
   if (!auth.isAuthenticated()) {
@@ -6848,10 +6999,10 @@ function readSeedMeta(projectDir, seedName) {
 }
 // src/commands/submissions.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 import { createInterface } from "readline";
-async function apiCall(auth, method, path7) {
-  return auth.makeAuthenticatedRequest(`${API_URL}${path7}`, { method });
+async function apiCall(auth, method, path8) {
+  return auth.makeAuthenticatedRequest(`${API_URL}${path8}`, { method });
 }
 function formatDate(s) {
   if (!s) return "";
@@ -7079,7 +7230,7 @@ async function withdrawSubmissionAction(idArg, opts) {
   }
   console.log(theme.success("Withdrawn."));
 }
-var submissionsCommand = new Command6("submissions").description("List or inspect your marketplace submissions").action(async () => {
+var submissionsCommand = new Command7("submissions").description("List or inspect your marketplace submissions").action(async () => {
   await listSubmissionsAction({});
 });
 submissionsCommand.command("list").description("List your submissions").option("--status <status>", "filter: pending|reviewing|merged|rejected|withdrawn").option("--limit <n>", "max results (default 20, capped at 100 server-side)", (v) => parseInt(v, 10)).option("--json", "machine-readable output").action(async (opts) => {
@@ -7093,8 +7244,9 @@ submissionsCommand.command("withdraw <id>").description("Withdraw a pending subm
 });
 // src/index.ts
-var program = new Command7();
+var program = new Command8();
 program.name("bjs").description("BabylonJS Market CLI - BBS-style interface for courses and assets").version(getVersion());
+program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.addCommand(whoamiCommand);
 program.addCommand(downloadCommand);
@@ -7108,7 +7260,7 @@ try {
   if (error.code === "commander.executeSubCommandAsync") {
     process.exit(error.exitCode);
   }
-  console.error(chalk5.red("Error:"), error.message);
+  console.error(chalk6.red("Error:"), error.message);
   process.exit(1);
 }
 //# sourceMappingURL=index.js.map