@babylonjsmarket/cli 1.0.5 → 1.0.6

package/dist/index.js

@@ -176,13 +176,8 @@ 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()) {
@@ -195,39 +190,10 @@ var loginCommand = new Command("login").description("Authenticate with BabylonJS
   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 protocol = "http";
+    const 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");
@@ -463,7 +429,7 @@ import ora2 from "ora";
 import { createWriteStream, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
 import { pipeline } from "stream/promises";
 import fetch3 from "node-fetch";
-import path2 from "path";
+import path 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();
@@ -511,7 +477,7 @@ var downloadCommand = new Command4("download").description("Download assets from
     if (!existsSync2(outputDir)) {
       mkdirSync2(outputDir, { recursive: true });
     }
-    const outputPath = path2.join(outputDir, fileName);
+    const outputPath = path.join(outputDir, fileName);
     const contentLength = fileResponse.headers.get("content-length");
     const total = contentLength ? parseInt(contentLength, 10) : 0;
     let loaded = 0;
@@ -1721,7 +1687,7 @@ var MarkdownTerminalRenderer = class {
 
 // src/utils/course-detail-viewer.ts
 import { EventEmitter as EventEmitter2 } from "events";
-import { execSync as execSync2 } from "child_process";
+import { execSync } from "child_process";
 import open2 from "open";
 
 // src/utils/course-detail/layout.ts
@@ -2906,13 +2872,13 @@ var CourseDetailViewer = class extends EventEmitter2 {
             command = "clip";
           } else {
             try {
-              execSync2("which xclip", { stdio: "ignore" });
+              execSync("which xclip", { stdio: "ignore" });
               command = "xclip -selection clipboard";
             } catch {
               command = "xsel --clipboard --input";
             }
           }
-          execSync2(command, { input: block.code });
+          execSync(command, { input: block.code });
           const nowMs = Date.now();
           this.vs = {
             ...this.vs,
@@ -3028,14 +2994,14 @@ var CourseDetailViewer = class extends EventEmitter2 {
 };
 
 // src/commands/bbs.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { homedir as homedir2 } from "os";
 import process2 from "process";
 
 // src/utils/asset-downloader.ts
 import fetch5 from "node-fetch";
-import fs2 from "fs";
+import fs from "fs";
 import { pipeline as pipeline2 } from "stream/promises";
 var AssetDownloader = class {
   authManager;
@@ -3088,7 +3054,7 @@ var AssetDownloader = class {
         const contentLength = fileResponse.headers.get("content-length");
         const total = parseInt(contentLength || "0", 10);
         let loaded = 0;
-        const writer = fs2.createWriteStream(outputPath);
+        const writer = fs.createWriteStream(outputPath);
         fileResponse.body.on("data", (chunk) => {
           loaded += chunk.length;
           writer.write(chunk);
@@ -3102,7 +3068,7 @@ var AssetDownloader = class {
         });
         await pipeline2(fileResponse.body, writer);
       } else {
-        const fileStream = fs2.createWriteStream(outputPath);
+        const fileStream = fs.createWriteStream(outputPath);
         await pipeline2(fileResponse.body, fileStream);
       }
       return true;
@@ -3130,15 +3096,15 @@ var AssetDownloader = class {
 };
 
 // src/utils/project-scanner.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs2 from "fs";
+import path2 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 fs3.promises.readdir(dir, { withFileTypes: true });
+      const entries = await fs2.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;
@@ -3146,7 +3112,7 @@ async function scanForProjects(baseDir, maxDepth = 2) {
         if (entry.isSymbolicLink()) {
           continue;
         }
-        const fullPath = path3.join(dir, entry.name);
+        const fullPath = path2.join(dir, entry.name);
         if (entry.isDirectory()) {
           const isProject = await isProjectDirectory(fullPath);
           if (isProject) {
@@ -3165,10 +3131,10 @@ async function scanForProjects(baseDir, maxDepth = 2) {
 }
 async function isProjectDirectory(dir) {
   try {
-    const entries = await fs3.promises.readdir(dir);
+    const entries = await fs2.promises.readdir(dir);
     if (entries.includes("package.json")) {
-      const packageJsonPath = path3.join(dir, "package.json");
-      const packageJson = JSON.parse(await fs3.promises.readFile(packageJsonPath, "utf-8"));
+      const packageJsonPath = path2.join(dir, "package.json");
+      const packageJson = JSON.parse(await fs2.promises.readFile(packageJsonPath, "utf-8"));
       const allDeps = {
         ...packageJson.dependencies || {},
         ...packageJson.devDependencies || {}
@@ -3191,10 +3157,10 @@ async function isProjectDirectory(dir) {
 async function detectGenre(dir) {
   const configFiles = ["arcade.json", ".arcade", ".arcade.json"];
   for (const configFile of configFiles) {
-    const configPath = path3.join(dir, configFile);
-    if (fs3.existsSync(configPath)) {
+    const configPath = path2.join(dir, configFile);
+    if (fs2.existsSync(configPath)) {
       try {
-        const config = JSON.parse(await fs3.promises.readFile(configPath, "utf-8"));
+        const config = JSON.parse(await fs2.promises.readFile(configPath, "utf-8"));
         if (config.genre || config.template) {
           return config.genre || config.template;
         }
@@ -3202,20 +3168,20 @@ async function detectGenre(dir) {
       }
     }
   }
-  const packageJsonPath = path3.join(dir, "package.json");
-  if (fs3.existsSync(packageJsonPath)) {
+  const packageJsonPath = path2.join(dir, "package.json");
+  if (fs2.existsSync(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(await fs3.promises.readFile(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(await fs2.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 = path3.join(dir, "src", "Components");
-  if (fs3.existsSync(componentsDir)) {
+  const componentsDir = path2.join(dir, "src", "Components");
+  if (fs2.existsSync(componentsDir)) {
     try {
-      const components = await fs3.promises.readdir(componentsDir);
+      const components = await fs2.promises.readdir(componentsDir);
       const componentNames = components.map((c) => c.toLowerCase());
       if (componentNames.some((c) => c.includes("fps") || c.includes("firstperson"))) {
         return "FPS";
@@ -3235,10 +3201,10 @@ async function detectGenre(dir) {
     } catch {
     }
   }
-  const dataDir = path3.join(dir, "data");
-  if (fs3.existsSync(dataDir)) {
+  const dataDir = path2.join(dir, "data");
+  if (fs2.existsSync(dataDir)) {
     try {
-      const dataDirs = await fs3.promises.readdir(dataDir);
+      const dataDirs = await fs2.promises.readdir(dataDir);
       for (const d of dataDirs) {
         const lowerName = d.toLowerCase();
         if (lowerName === "thirdperson") return "ThirdPerson";
@@ -3253,12 +3219,12 @@ async function detectGenre(dir) {
 }
 async function scanComponents(dir) {
   const components = [];
-  const componentsDir = path3.join(dir, "src", "Components");
-  if (!fs3.existsSync(componentsDir)) {
+  const componentsDir = path2.join(dir, "src", "Components");
+  if (!fs2.existsSync(componentsDir)) {
     return components;
   }
   try {
-    const files = await fs3.promises.readdir(componentsDir);
+    const files = await fs2.promises.readdir(componentsDir);
     for (const file of files) {
       if (file.endsWith(".ts") || file.endsWith(".js")) {
         const componentName = file.replace(/\.(ts|js)$/, "");
@@ -3272,14 +3238,14 @@ async function scanComponents(dir) {
   return components.sort();
 }
 async function analyzeProject(dir, id) {
-  const name = path3.basename(dir);
+  const name = path2.basename(dir);
   let hasPackageJson = false;
   let engine = "Unknown";
   try {
-    const packageJsonPath = path3.join(dir, "package.json");
-    if (fs3.existsSync(packageJsonPath)) {
+    const packageJsonPath = path2.join(dir, "package.json");
+    if (fs2.existsSync(packageJsonPath)) {
       hasPackageJson = true;
-      const packageJson = JSON.parse(await fs3.promises.readFile(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(await fs2.promises.readFile(packageJsonPath, "utf-8"));
       const allDeps = {
         ...packageJson.dependencies || {},
         ...packageJson.devDependencies || {}
@@ -3307,15 +3273,15 @@ async function analyzeProject(dir, id) {
 }
 
 // src/utils/component-catalog.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path3 from "path";
 function getLibraryPath() {
   const auth = new AuthManager();
   return auth.getLibraryPath();
 }
 function isLibraryInitialized() {
   const libraryPath = getLibraryPath();
-  return fs4.existsSync(path4.join(libraryPath, "Components"));
+  return fs3.existsSync(path3.join(libraryPath, "Components"));
 }
 async function initializeLibrary(libraryPath) {
   const targetPath = libraryPath || getLibraryPath();
@@ -3329,13 +3295,13 @@ async function initializeLibrary(libraryPath) {
   ];
   try {
     for (const dir of dirs) {
-      const fullPath = path4.join(targetPath, dir);
-      if (!fs4.existsSync(fullPath)) {
-        fs4.mkdirSync(fullPath, { recursive: true });
+      const fullPath = path3.join(targetPath, dir);
+      if (!fs3.existsSync(fullPath)) {
+        fs3.mkdirSync(fullPath, { recursive: true });
       }
     }
-    const readmePath = path4.join(targetPath, "README.md");
-    if (!fs4.existsSync(readmePath)) {
+    const readmePath = path3.join(targetPath, "README.md");
+    if (!fs3.existsSync(readmePath)) {
       const readme = `# BJS Library
 
 Your personal library of BabylonJS components, systems, and game mode presets.
@@ -3362,7 +3328,7 @@ Your personal library of BabylonJS components, systems, and game mode presets.
 
 Content from babylonjsmarket.com will be downloaded here automatically.
 `;
-      fs4.writeFileSync(readmePath, readme);
+      fs3.writeFileSync(readmePath, readme);
     }
     return { success: true, message: `Library initialized at ${targetPath}` };
   } catch (error) {
@@ -3371,12 +3337,12 @@ Content from babylonjsmarket.com will be downloaded here automatically.
 }
 function getGameModeSchema(modeName) {
   const libraryPath = getLibraryPath();
-  const schemaPath = path4.join(libraryPath, "GameModes", modeName, "gamemode.json");
-  if (!fs4.existsSync(schemaPath)) {
+  const schemaPath = path3.join(libraryPath, "GameModes", modeName, "gamemode.json");
+  if (!fs3.existsSync(schemaPath)) {
     return null;
   }
   try {
-    const content = fs4.readFileSync(schemaPath, "utf-8");
+    const content = fs3.readFileSync(schemaPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -3443,45 +3409,45 @@ var COMPONENT_CATALOG = [
 ];
 async function installComponent(componentName, targetProjectPath) {
   const libraryPath = getLibraryPath();
-  const componentDir = path4.join(libraryPath, "Components", componentName);
-  const componentFile = path4.join(componentDir, `${componentName}.ts`);
+  const componentDir = path3.join(libraryPath, "Components", componentName);
+  const componentFile = path3.join(componentDir, `${componentName}.ts`);
   const files = [];
-  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)) {
+  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)) {
         return { success: false, message: `${componentName}.ts already exists`, files };
       }
-      fs4.copyFileSync(legacyPath, targetComponentPath2);
+      fs3.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 = path4.join(targetProjectPath, "src", "Components");
-  if (!fs4.existsSync(targetComponentDir)) {
-    fs4.mkdirSync(targetComponentDir, { recursive: true });
+  const targetComponentDir = path3.join(targetProjectPath, "src", "Components");
+  if (!fs3.existsSync(targetComponentDir)) {
+    fs3.mkdirSync(targetComponentDir, { recursive: true });
   }
-  const targetComponentPath = path4.join(targetComponentDir, `${componentName}.ts`);
-  if (fs4.existsSync(targetComponentPath)) {
+  const targetComponentPath = path3.join(targetComponentDir, `${componentName}.ts`);
+  if (fs3.existsSync(targetComponentPath)) {
     return { success: false, message: `${componentName}.ts already exists`, files };
   }
-  fs4.copyFileSync(componentFile, targetComponentPath);
+  fs3.copyFileSync(componentFile, targetComponentPath);
   files.push(`src/Components/${componentName}.ts`);
-  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);
+  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);
       files.push(`tests/Components/${componentName}.test.ts`);
     }
   }
@@ -3493,26 +3459,26 @@ async function installComponent(componentName, targetProjectPath) {
 }
 function getAvailableComponents(targetProjectPath) {
   const libraryPath = getLibraryPath();
-  const libraryComponentsDir = path4.join(libraryPath, "Components");
-  const targetComponentDir = path4.join(targetProjectPath, "src", "Components");
+  const libraryComponentsDir = path3.join(libraryPath, "Components");
+  const targetComponentDir = path3.join(targetProjectPath, "src", "Components");
   const installedComponents = /* @__PURE__ */ new Set();
   const availableComponents = [];
-  if (fs4.existsSync(targetComponentDir)) {
-    const files = fs4.readdirSync(targetComponentDir);
+  if (fs3.existsSync(targetComponentDir)) {
+    const files = fs3.readdirSync(targetComponentDir);
     for (const file of files) {
       if (file.endsWith(".ts")) {
         installedComponents.add(file.replace(".ts", ""));
       }
     }
   }
-  if (fs4.existsSync(libraryComponentsDir)) {
-    const entries = fs4.readdirSync(libraryComponentsDir, { withFileTypes: true });
+  if (fs3.existsSync(libraryComponentsDir)) {
+    const entries = fs3.readdirSync(libraryComponentsDir, { withFileTypes: true });
     for (const entry of entries) {
       let name;
       if (entry.isDirectory()) {
         name = entry.name;
-        const mainFile = path4.join(libraryComponentsDir, name, `${name}.ts`);
-        if (!fs4.existsSync(mainFile)) {
+        const mainFile = path3.join(libraryComponentsDir, name, `${name}.ts`);
+        if (!fs3.existsSync(mainFile)) {
           continue;
         }
       } else if (entry.isFile() && entry.name.endsWith(".ts")) {
@@ -3535,13 +3501,13 @@ function getAvailableComponents(targetProjectPath) {
 }
 function getGameModeCatalog() {
   const libraryPath = getLibraryPath();
-  const gameModesDir = path4.join(libraryPath, "GameModes");
+  const gameModesDir = path3.join(libraryPath, "GameModes");
   const modes = [];
-  if (!fs4.existsSync(gameModesDir)) {
+  if (!fs3.existsSync(gameModesDir)) {
     return modes;
   }
   try {
-    const dirs = fs4.readdirSync(gameModesDir, { withFileTypes: true });
+    const dirs = fs3.readdirSync(gameModesDir, { withFileTypes: true });
     for (const dir of dirs) {
       if (!dir.isDirectory()) continue;
       const schema = getGameModeSchema(dir.name);
@@ -3554,13 +3520,13 @@ function getGameModeCatalog() {
           hasShared: schema.includeShared || false
         });
       } else {
-        const modePath = path4.join(gameModesDir, dir.name);
+        const modePath = path3.join(gameModesDir, dir.name);
         modes.push({
           name: dir.name,
           description: `${dir.name} game mode`,
-          hasScenes: fs4.existsSync(path4.join(modePath, "Scenes")),
-          hasScreens: fs4.existsSync(path4.join(modePath, "Screens")),
-          hasShared: fs4.existsSync(path4.join(modePath, "Data"))
+          hasScenes: fs3.existsSync(path3.join(modePath, "Scenes")),
+          hasScreens: fs3.existsSync(path3.join(modePath, "Screens")),
+          hasShared: fs3.existsSync(path3.join(modePath, "Data"))
         });
       }
     }
@@ -3569,12 +3535,12 @@ function getGameModeCatalog() {
   return modes;
 }
 function getAvailableGameModes(targetProjectPath) {
-  const targetDataDir = path4.join(targetProjectPath, "data");
+  const targetDataDir = path3.join(targetProjectPath, "data");
   const installedModes = /* @__PURE__ */ new Set();
-  if (fs4.existsSync(targetDataDir)) {
-    const dirs = fs4.readdirSync(targetDataDir);
+  if (fs3.existsSync(targetDataDir)) {
+    const dirs = fs3.readdirSync(targetDataDir);
     for (const dir of dirs) {
-      const stat = fs4.statSync(path4.join(targetDataDir, dir));
+      const stat = fs3.statSync(path3.join(targetDataDir, dir));
       if (stat.isDirectory()) {
         installedModes.add(dir);
       }
@@ -3583,12 +3549,12 @@ function getAvailableGameModes(targetProjectPath) {
   return getGameModeCatalog().filter((m) => !installedModes.has(m.name));
 }
 function getInstalledGameModes(targetProjectPath) {
-  const targetDataDir = path4.join(targetProjectPath, "data");
+  const targetDataDir = path3.join(targetProjectPath, "data");
   const modes = [];
-  if (fs4.existsSync(targetDataDir)) {
-    const dirs = fs4.readdirSync(targetDataDir);
+  if (fs3.existsSync(targetDataDir)) {
+    const dirs = fs3.readdirSync(targetDataDir);
     for (const dir of dirs) {
-      const stat = fs4.statSync(path4.join(targetDataDir, dir));
+      const stat = fs3.statSync(path3.join(targetDataDir, dir));
       if (stat.isDirectory() && dir !== "Shared") {
         modes.push(dir);
       }
@@ -3597,29 +3563,29 @@ function getInstalledGameModes(targetProjectPath) {
   return modes;
 }
 function copyDir(src, dest, files, baseRelPath) {
-  fs4.mkdirSync(dest, { recursive: true });
-  const entries = fs4.readdirSync(src, { withFileTypes: true });
+  fs3.mkdirSync(dest, { recursive: true });
+  const entries = fs3.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path4.join(src, entry.name);
-    const destPath = path4.join(dest, entry.name);
-    const relPath = path4.join(baseRelPath, entry.name);
+    const srcPath = path3.join(src, entry.name);
+    const destPath = path3.join(dest, entry.name);
+    const relPath = path3.join(baseRelPath, entry.name);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath, files, relPath);
     } else if (entry.name !== "gamemode.json") {
-      fs4.copyFileSync(srcPath, destPath);
+      fs3.copyFileSync(srcPath, destPath);
       files.push(relPath);
     }
   }
 }
 async function installGameMode(modeName, targetProjectPath) {
   const libraryPath = getLibraryPath();
-  const gameModeDir = path4.join(libraryPath, "GameModes", modeName);
+  const gameModeDir = path3.join(libraryPath, "GameModes", modeName);
   const files = [];
-  if (!fs4.existsSync(gameModeDir)) {
+  if (!fs3.existsSync(gameModeDir)) {
     return { success: false, message: `Game mode ${modeName} not found in Library`, files };
   }
-  const targetDataDir = path4.join(targetProjectPath, "data", modeName);
-  if (fs4.existsSync(targetDataDir)) {
+  const targetDataDir = path3.join(targetProjectPath, "data", modeName);
+  if (fs3.existsSync(targetDataDir)) {
     return { success: false, message: `${modeName} already exists`, files };
   }
   const schema = getGameModeSchema(modeName);
@@ -3633,34 +3599,34 @@ async function installGameMode(modeName, targetProjectPath) {
       }
       if (schema.systems) {
         for (const sysName of schema.systems) {
-          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 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 targetSysPath = path4.join(targetSysDir, `${sysName}.ts`);
-            if (!fs4.existsSync(targetSysPath)) {
-              fs4.copyFileSync(sysPath, targetSysPath);
+            const targetSysPath = path3.join(targetSysDir, `${sysName}.ts`);
+            if (!fs3.existsSync(targetSysPath)) {
+              fs3.copyFileSync(sysPath, targetSysPath);
               files.push(`src/Systems/${sysName}.ts`);
             }
           }
         }
       }
-      fs4.mkdirSync(targetDataDir, { recursive: true });
-      const modeDataDir = path4.join(gameModeDir, "Data");
-      if (fs4.existsSync(modeDataDir)) {
-        const targetSharedDir = path4.join(targetDataDir, "Shared");
+      fs3.mkdirSync(targetDataDir, { recursive: true });
+      const modeDataDir = path3.join(gameModeDir, "Data");
+      if (fs3.existsSync(modeDataDir)) {
+        const targetSharedDir = path3.join(targetDataDir, "Shared");
         copyDir(modeDataDir, targetSharedDir, files, `data/${modeName}/Shared`);
       }
-      const modeScenesDir = path4.join(gameModeDir, "Scenes");
-      if (fs4.existsSync(modeScenesDir)) {
-        const targetScenesDir = path4.join(targetDataDir, "Scenes");
+      const modeScenesDir = path3.join(gameModeDir, "Scenes");
+      if (fs3.existsSync(modeScenesDir)) {
+        const targetScenesDir = path3.join(targetDataDir, "Scenes");
         copyDir(modeScenesDir, targetScenesDir, files, `data/${modeName}/Scenes`);
       }
-      const modeScreensDir = path4.join(gameModeDir, "Screens");
-      if (fs4.existsSync(modeScreensDir)) {
-        const targetScreensDir = path4.join(targetDataDir, "Screens");
+      const modeScreensDir = path3.join(gameModeDir, "Screens");
+      if (fs3.existsSync(modeScreensDir)) {
+        const targetScreensDir = path3.join(targetDataDir, "Screens");
         copyDir(modeScreensDir, targetScreensDir, files, `data/${modeName}/Screens`);
       }
     } else {
@@ -3677,18 +3643,18 @@ async function installGameMode(modeName, targetProjectPath) {
 }
 function getProjectScenes(targetProjectPath) {
   const scenes = [];
-  const dataDir = path4.join(targetProjectPath, "data");
-  if (!fs4.existsSync(dataDir)) return scenes;
-  const modes = fs4.readdirSync(dataDir);
+  const dataDir = path3.join(targetProjectPath, "data");
+  if (!fs3.existsSync(dataDir)) return scenes;
+  const modes = fs3.readdirSync(dataDir);
   for (const mode of modes) {
-    const scenesDir = path4.join(dataDir, mode, "Scenes");
-    if (fs4.existsSync(scenesDir)) {
-      const sceneFiles = fs4.readdirSync(scenesDir);
+    const scenesDir = path3.join(dataDir, mode, "Scenes");
+    if (fs3.existsSync(scenesDir)) {
+      const sceneFiles = fs3.readdirSync(scenesDir);
       for (const file of sceneFiles) {
         if (file.endsWith(".ts")) {
           scenes.push({
             name: file.replace(".ts", ""),
-            path: path4.join(scenesDir, file),
+            path: path3.join(scenesDir, file),
             gameMode: mode
           });
         }
@@ -3698,12 +3664,12 @@ function getProjectScenes(targetProjectPath) {
   return scenes;
 }
 async function createScene(targetProjectPath, gameMode, sceneName) {
-  const scenesDir = path4.join(targetProjectPath, "data", gameMode, "Scenes");
-  if (!fs4.existsSync(scenesDir)) {
-    fs4.mkdirSync(scenesDir, { recursive: true });
+  const scenesDir = path3.join(targetProjectPath, "data", gameMode, "Scenes");
+  if (!fs3.existsSync(scenesDir)) {
+    fs3.mkdirSync(scenesDir, { recursive: true });
   }
-  const scenePath = path4.join(scenesDir, `${sceneName}.ts`);
-  if (fs4.existsSync(scenePath)) {
+  const scenePath = path3.join(scenesDir, `${sceneName}.ts`);
+  if (fs3.existsSync(scenePath)) {
     return { success: false, message: `Scene ${sceneName} already exists`, path: "" };
   }
   const template = `import Basics from "../../Shared/Basics";
@@ -3733,7 +3699,7 @@ export default {
 };
 `;
   try {
-    fs4.writeFileSync(scenePath, template);
+    fs3.writeFileSync(scenePath, template);
     return {
       success: true,
       message: `Created scene ${sceneName}`,
@@ -3754,46 +3720,46 @@ async function migrateFromArcadeRef() {
     }
   }
   try {
-    const srcComponents = path4.join(ARCADE_REF_PATH, "src", "Components");
-    if (fs4.existsSync(srcComponents)) {
-      const targetComponents = path4.join(libraryPath, "Components");
-      const componentFiles2 = fs4.readdirSync(srcComponents);
+    const srcComponents = path3.join(ARCADE_REF_PATH, "src", "Components");
+    if (fs3.existsSync(srcComponents)) {
+      const targetComponents = path3.join(libraryPath, "Components");
+      const componentFiles2 = fs3.readdirSync(srcComponents);
       for (const file of componentFiles2) {
         if (file.endsWith(".ts")) {
-          const srcPath = path4.join(srcComponents, file);
-          const destPath = path4.join(targetComponents, file);
-          if (!fs4.existsSync(destPath)) {
-            fs4.copyFileSync(srcPath, destPath);
+          const srcPath = path3.join(srcComponents, file);
+          const destPath = path3.join(targetComponents, file);
+          if (!fs3.existsSync(destPath)) {
+            fs3.copyFileSync(srcPath, destPath);
             files.push(`Components/${file}`);
           }
         }
       }
     }
-    const srcTests = path4.join(ARCADE_REF_PATH, "tests", "Components");
-    if (fs4.existsSync(srcTests)) {
-      const targetTests = path4.join(libraryPath, "Tests");
-      const testFiles = fs4.readdirSync(srcTests);
+    const srcTests = path3.join(ARCADE_REF_PATH, "tests", "Components");
+    if (fs3.existsSync(srcTests)) {
+      const targetTests = path3.join(libraryPath, "Tests");
+      const testFiles = fs3.readdirSync(srcTests);
       for (const file of testFiles) {
         if (file.endsWith(".test.ts")) {
-          const srcPath = path4.join(srcTests, file);
-          const destPath = path4.join(targetTests, file);
-          if (!fs4.existsSync(destPath)) {
-            fs4.copyFileSync(srcPath, destPath);
+          const srcPath = path3.join(srcTests, file);
+          const destPath = path3.join(targetTests, file);
+          if (!fs3.existsSync(destPath)) {
+            fs3.copyFileSync(srcPath, destPath);
             files.push(`Tests/${file}`);
           }
         }
       }
     }
-    const srcData = path4.join(ARCADE_REF_PATH, "data", "Shared");
-    if (fs4.existsSync(srcData)) {
-      const targetData = path4.join(libraryPath, "Data");
-      const dataFiles = fs4.readdirSync(srcData);
+    const srcData = path3.join(ARCADE_REF_PATH, "data", "Shared");
+    if (fs3.existsSync(srcData)) {
+      const targetData = path3.join(libraryPath, "Data");
+      const dataFiles = fs3.readdirSync(srcData);
       for (const file of dataFiles) {
         if (file.endsWith(".ts")) {
-          const srcPath = path4.join(srcData, file);
-          const destPath = path4.join(targetData, file);
-          if (!fs4.existsSync(destPath)) {
-            fs4.copyFileSync(srcPath, destPath);
+          const srcPath = path3.join(srcData, file);
+          const destPath = path3.join(targetData, file);
+          if (!fs3.existsSync(destPath)) {
+            fs3.copyFileSync(srcPath, destPath);
             files.push(`Data/${file}`);
           }
         }
@@ -3801,24 +3767,24 @@ async function migrateFromArcadeRef() {
     }
     const gameModes = ["ThirdPerson", "Arcade"];
     for (const mode of gameModes) {
-      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 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 subdirs = ["Scenes", "Screens", "Shared"];
           for (const subdir of subdirs) {
-            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);
+            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);
               for (const file of subFiles) {
-                const srcPath = path4.join(srcSubdir, file);
-                const destPath = path4.join(targetSubdir, file);
-                const stat = fs4.statSync(srcPath);
+                const srcPath = path3.join(srcSubdir, file);
+                const destPath = path3.join(targetSubdir, file);
+                const stat = fs3.statSync(srcPath);
                 if (stat.isFile()) {
-                  fs4.copyFileSync(srcPath, destPath);
+                  fs3.copyFileSync(srcPath, destPath);
                   files.push(`GameModes/${mode}/${subdir === "Shared" ? "Data" : subdir}/${file}`);
                 }
               }
@@ -3830,11 +3796,11 @@ async function migrateFromArcadeRef() {
             components: mode === "ThirdPerson" ? ["Movement", "FollowCamera", "PlayerInput", "Animation", "Physics", "KeyboardTiming"] : ["Movement", "SimpleCamera", "PlayerInput", "SimplePhysics"],
             data: ["Light", "Basics"],
             includeShared: true,
-            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")) : []
+            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")) : []
           };
-          fs4.writeFileSync(
-            path4.join(targetMode, "gamemode.json"),
+          fs3.writeFileSync(
+            path3.join(targetMode, "gamemode.json"),
             JSON.stringify(schema, null, 2)
           );
           files.push(`GameModes/${mode}/gamemode.json`);
@@ -3984,12 +3950,12 @@ async function syncLibrary(onProgress) {
         componentSuccess = false;
         continue;
       }
-      const fullPath = path4.join(libraryPath, filePath);
-      const dir = path4.dirname(fullPath);
-      if (!fs4.existsSync(dir)) {
-        fs4.mkdirSync(dir, { recursive: true });
+      const fullPath = path3.join(libraryPath, filePath);
+      const dir = path3.dirname(fullPath);
+      if (!fs3.existsSync(dir)) {
+        fs3.mkdirSync(dir, { recursive: true });
       }
-      fs4.writeFileSync(fullPath, result.content);
+      fs3.writeFileSync(fullPath, result.content);
     }
     if (componentSuccess) {
       auth.updateLibraryFile(component.path, component.version);
@@ -5262,7 +5228,7 @@ var bbsCommand = new Command5("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 ? path5.resolve(options.saveTo) : process2.cwd();
+  const downloadDirectory = options.saveTo ? path4.resolve(options.saveTo) : process2.cwd();
   const savedPrefs = authManager.getPreferences();
   if (savedPrefs && savedPrefs.theme && THEMES.includes(savedPrefs.theme)) {
     options.theme = savedPrefs.theme;
@@ -5409,7 +5375,7 @@ var bbsCommand = new Command5("bbs").description("BabylonJS Market BBS - Browse
   }
   const user = authManager.getUser();
   try {
-    fs5.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} BBS starting - animations: ${options.animations}
+    fs4.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);
@@ -5420,12 +5386,12 @@ var bbsCommand = new Command5("bbs").description("BabylonJS Market BBS - Browse
       backBuffer.draw({ dst: screenBuffer });
       screenBuffer.draw({ delta: true });
     }
-    fs5.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} Fetching courses from ${API_URL}
+    fs4.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`);
-      fs5.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} Courses fetched OK
+      fs4.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} Courses fetched OK
 `);
     } catch (fetchError) {
       throw new Error(`Network error: ${fetchError.message}`);
@@ -5448,7 +5414,7 @@ var bbsCommand = new Command5("bbs").description("BabylonJS Market BBS - Browse
     }
     let scannedProjects = [];
     const configuredProjectsDir = authManager.getProjectsDirectory();
-    if (configuredProjectsDir && fs5.existsSync(configuredProjectsDir)) {
+    if (configuredProjectsDir && fs4.existsSync(configuredProjectsDir)) {
       try {
         const scanPromise = scanForProjects(configuredProjectsDir, 2);
         const timeoutPromise = new Promise(
@@ -5490,7 +5456,7 @@ var bbsCommand = new Command5("bbs").description("BabylonJS Market BBS - Browse
       term[color](msg);
     };
     const debugLog = (msg) => {
-      fs5.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+      fs4.appendFileSync("/tmp/bbs-debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
     };
     const buildRenderContext = () => {
@@ -5619,10 +5585,10 @@ var bbsCommand = new Command5("bbs").description("BabylonJS Market BBS - Browse
         assetKey = toy.assetKey || toy.name.toLowerCase().replace(/\s+/g, "-");
         fileName = assetKey + ".glb";
       }
-      const outputPath = path5.join(downloadDirectory, fileName);
+      const outputPath = path4.join(downloadDirectory, fileName);
       try {
-        if (!fs5.existsSync(downloadDirectory)) {
-          fs5.mkdirSync(downloadDirectory, { recursive: true });
+        if (!fs4.existsSync(downloadDirectory)) {
+          fs4.mkdirSync(downloadDirectory, { recursive: true });
         }
         showStatus(`Downloading ${name}...`, "yellow");
         const success = await assetDownloader.downloadAsset(
@@ -5650,19 +5616,19 @@ var bbsCommand = new Command5("bbs").description("BabylonJS Market BBS - Browse
         if (!input || input.trim() === "") {
           return homedir2() + "/";
         }
-        const dir = path5.dirname(input);
-        const base = path5.basename(input);
-        if (dir && fs5.existsSync(dir)) {
-          const entries = fs5.readdirSync(dir);
+        const dir = path4.dirname(input);
+        const base = path4.basename(input);
+        if (dir && fs4.existsSync(dir)) {
+          const entries = fs4.readdirSync(dir);
           const matches = entries.filter((e) => e.toLowerCase().startsWith(base.toLowerCase())).filter((e) => {
             try {
-              return fs5.statSync(path5.join(dir, e)).isDirectory();
+              return fs4.statSync(path4.join(dir, e)).isDirectory();
             } catch {
               return false;
             }
           });
           if (matches.length === 1) {
-            return path5.join(dir, matches[0]) + "/";
+            return path4.join(dir, matches[0]) + "/";
           } else if (matches.length > 1) {
             const commonPrefix = matches.reduce((prefix, match) => {
               let i = 0;
@@ -5672,7 +5638,7 @@ var bbsCommand = new Command5("bbs").description("BabylonJS Market BBS - Browse
               return match.slice(0, i);
             });
             if (commonPrefix.length > base.length) {
-              return path5.join(dir, commonPrefix);
+              return path4.join(dir, commonPrefix);
             }
           }
         } else if (input.startsWith("~")) {
@@ -5686,8 +5652,8 @@ var bbsCommand = new Command5("bbs").description("BabylonJS Market BBS - Browse
       switch (effect.type) {
         case "CommitProjectsDir": {
           if (state.projectsDirInput.trim()) {
-            const resolvedPath = path5.resolve(state.projectsDirInput.trim());
-            if (fs5.existsSync(resolvedPath)) {
+            const resolvedPath = path4.resolve(state.projectsDirInput.trim());
+            if (fs4.existsSync(resolvedPath)) {
               authManager.setProjectsDirectory(resolvedPath);
               dispatch({ type: "SetProjectsDirResult", success: "\u2713 Saved! Scanning..." });
               await render();
@@ -5714,9 +5680,9 @@ var bbsCommand = new Command5("bbs").description("BabylonJS Market BBS - Browse
           break;
         case "CommitLibraryPath": {
           if (state.libraryPathInput.trim()) {
-            const resolvedPath = path5.resolve(state.libraryPathInput.trim());
+            const resolvedPath = path4.resolve(state.libraryPathInput.trim());
             authManager.setLibraryPath(resolvedPath);
-            if (!fs5.existsSync(path5.join(resolvedPath, "Components"))) {
+            if (!fs4.existsSync(path4.join(resolvedPath, "Components"))) {
               const result = await initializeLibrary(resolvedPath);
               state = { ...state, libraryPathSuccess: result.success ? "\u2713 Library initialized!" : result.message };
             } else {
@@ -5983,7 +5949,7 @@ var bbsCommand = new Command5("bbs").description("BabylonJS Market BBS - Browse
           const project = state.projects[state.projectsSelectedIndex];
           if (project) {
             const editor = process2.env.EDITOR || "code";
-            const editorName = path5.basename(editor);
+            const editorName = path4.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" });
@@ -6239,8 +6205,8 @@ function getVersion() {
 }
 
 // src/lib/inject/engine.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import mri from "mri";
 import colors2 from "picocolors";
 
@@ -6297,28 +6263,28 @@ function detectLayer(filePath, source, subjectLayer) {
 }
 
 // src/lib/inject/monorepo-root.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findMonorepoRoot() {
-  const here = path6.dirname(fileURLToPath2(import.meta.url));
+  const here = path5.dirname(fileURLToPath2(import.meta.url));
   let dir = here;
   while (true) {
-    const pkgPath = path6.join(dir, "package.json");
-    if (fs6.existsSync(pkgPath)) {
+    const pkgPath = path5.join(dir, "package.json");
+    if (fs5.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf8"));
+        const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf8"));
         if (pkg.name === "babylonjs-market-monorepo") {
           return {
             root: dir,
-            arcadeProRoot: path6.join(dir, "packages", "arcade-pro"),
-            vizProRoot: path6.join(dir, "packages", "viz-pro")
+            arcadeProRoot: path5.join(dir, "packages", "arcade-pro"),
+            vizProRoot: path5.join(dir, "packages", "viz-pro")
           };
         }
       } catch {
       }
     }
-    const parent = path6.dirname(dir);
+    const parent = path5.dirname(dir);
     if (parent === dir) {
       throw new Error(
         `Could not locate umbrella repo (no ancestor package.json with name "babylonjs-market-monorepo" above ${here}).`
@@ -6333,46 +6299,46 @@ var { cyan: cyan2, green, yellow, dim, bold: bold2 } = colors2;
 function componentFiles(dir) {
   const out = [];
   const walk = (d) => {
-    for (const e of fs7.readdirSync(d, { withFileTypes: true })) {
-      const p = path7.join(d, e.name);
+    for (const e of fs6.readdirSync(d, { withFileTypes: true })) {
+      const p = path6.join(d, e.name);
       if (e.isDirectory()) walk(p);
       else if (/\.(ts|tsx)$/.test(e.name)) out.push(p);
     }
   };
-  if (fs7.existsSync(dir)) walk(dir);
+  if (fs6.existsSync(dir)) walk(dir);
   return out;
 }
 function allComponentFiles(dir) {
   const out = [];
   const walk = (d) => {
-    for (const e of fs7.readdirSync(d, { withFileTypes: true })) {
-      const p = path7.join(d, e.name);
+    for (const e of fs6.readdirSync(d, { withFileTypes: true })) {
+      const p = path6.join(d, e.name);
       if (e.isDirectory()) walk(p);
       else out.push(p);
     }
   };
-  if (fs7.existsSync(dir)) walk(dir);
+  if (fs6.existsSync(dir)) walk(dir);
   return out;
 }
 function projectComponentNames(projectDir) {
-  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);
+  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);
 }
 function directDeps(name, componentsDir, allNames) {
   const deps = /* @__PURE__ */ new Set();
-  const metaPath = path7.join(componentsDir, name, "meta.json");
-  if (fs7.existsSync(metaPath)) {
+  const metaPath = path6.join(componentsDir, name, "meta.json");
+  if (fs6.existsSync(metaPath)) {
     try {
-      const meta = JSON.parse(fs7.readFileSync(metaPath, "utf8"));
+      const meta = JSON.parse(fs6.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(path7.join(componentsDir, name))) {
-    const src = fs7.readFileSync(file, "utf8");
+  for (const file of componentFiles(path6.join(componentsDir, name))) {
+    const src = fs6.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]);
@@ -6442,15 +6408,15 @@ function planArcadeProRegistry(existingRegistry, names, registryRelPath = "src/r
   return { lines, added, warnings, markerFound: true };
 }
 function patchArcadeProRegistry(arcadeProRoot, names, dryRun) {
-  const registryPath = path7.join(arcadeProRoot, "src", "registry.ts");
-  const existing = fs7.existsSync(registryPath) ? fs7.readFileSync(registryPath, "utf8") : void 0;
+  const registryPath = path6.join(arcadeProRoot, "src", "registry.ts");
+  const existing = fs6.existsSync(registryPath) ? fs6.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")}`);
-    fs7.writeFileSync(registryPath, next);
+    fs6.writeFileSync(registryPath, next);
   }
   return plan.added.map((n) => `  patched registry: ${n}`);
 }
@@ -6468,21 +6434,21 @@ function planVizProBarrel(existingBarrel, layer, fileName) {
   return { line: `export * from './${fileName}';`, warnings: [] };
 }
 function patchVizProBarrel(vizProRoot, layer, fileName, dryRun) {
-  const barrelPath = path7.join(vizProRoot, "src", layer, "index.ts");
-  const existing = fs7.existsSync(barrelPath) ? fs7.readFileSync(barrelPath, "utf8") : void 0;
+  const barrelPath = path6.join(vizProRoot, "src", layer, "index.ts");
+  const existing = fs6.existsSync(barrelPath) ? fs6.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";
-    fs7.writeFileSync(barrelPath, next);
+    fs6.writeFileSync(barrelPath, next);
   }
   return [`  patched ${layer}/index.ts: ${fileName}`];
 }
 function stripProjectRegistry(projectDir, names, dryRun) {
-  const registryPath = path7.join(projectDir, "src", "registry.ts");
-  if (!fs7.existsSync(registryPath)) return [];
-  let text = fs7.readFileSync(registryPath, "utf8");
+  const registryPath = path6.join(projectDir, "src", "registry.ts");
+  if (!fs6.existsSync(registryPath)) return [];
+  let text = fs6.readFileSync(registryPath, "utf8");
   const removed = [];
   for (const name of names) {
     const re = new RegExp(
@@ -6494,7 +6460,7 @@ function stripProjectRegistry(projectDir, names, dryRun) {
       removed.push(name);
     }
   }
-  if (removed.length && !dryRun) fs7.writeFileSync(registryPath, text);
+  if (removed.length && !dryRun) fs6.writeFileSync(registryPath, text);
   return removed;
 }
 async function inject(args, opts = {}) {
@@ -6566,12 +6532,12 @@ async function inject(args, opts = {}) {
       return;
     }
   }
-  const componentsDir = path7.join(projectDir, "src", "components");
+  const componentsDir = path6.join(projectDir, "src", "components");
   const allProjectNames = projectComponentNames(projectDir);
   const seeds = [];
   for (const name of names) {
-    const sourceDir = sourceOverride ? path7.resolve(cwd, sourceOverride) : path7.join(componentsDir, name);
-    if (!fs7.existsSync(sourceDir)) {
+    const sourceDir = sourceOverride ? path6.resolve(cwd, sourceOverride) : path6.join(componentsDir, name);
+    if (!fs6.existsSync(sourceDir)) {
       console.error(
         yellow(
           `Could not find source for "${name}". Looked at ${sourceDir}. Use --source <path> to point at the seed explicitly.`
@@ -6586,9 +6552,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 : path7.join(componentsDir, name);
+    const dir = sourceOverride && seedNames.has(name) ? seeds.find((s) => s.name === name).sourceDir : path6.join(componentsDir, name);
     for (const f of componentFiles(dir)) {
-      closureFiles.push({ path: f, source: fs7.readFileSync(f, "utf8") });
+      closureFiles.push({ path: f, source: fs6.readFileSync(f, "utf8") });
     }
   }
   const target = explicitTarget ?? detectTarget(closureFiles);
@@ -6597,7 +6563,7 @@ async function inject(args, opts = {}) {
       const dir = seed.sourceDir;
       const files = componentFiles(dir).map((f) => ({
         path: f,
-        source: fs7.readFileSync(f, "utf8")
+        source: fs6.readFileSync(f, "utf8")
       }));
       const perSeed = detectTarget(files);
       if (perSeed !== target) {
@@ -6615,14 +6581,14 @@ async function inject(args, opts = {}) {
   if (mode === "apply") {
     try {
       if (target === "arcade") {
-        if (!fs7.existsSync(packageRoot)) {
+        if (!fs6.existsSync(packageRoot)) {
           throw new Error(
             `packages/arcade is not checked out at ${packageRoot}. Run \`git submodule update --init packages/arcade\` and retry.`
           );
         }
         chosenRoot = packageRoot;
       } else {
-        if (!fs7.existsSync(vizProRoot)) {
+        if (!fs6.existsSync(vizProRoot)) {
           throw new Error(
             `packages/viz-pro is not checked out at ${vizProRoot}. Run \`git submodule update --init packages/viz-pro\` and retry.`
           );
@@ -6680,9 +6646,9 @@ async function inject(args, opts = {}) {
       );
     }
     for (const seed of seeds) {
-      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)`));
+      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)`));
       }
     }
     const removed = stripProjectRegistry(
@@ -6702,31 +6668,31 @@ Done. Components landed in packages/${target}/.
 }
 async function injectArcadePro(args) {
   const { seeds, closure, componentsDir, sourceOverride, arcadeProRoot, dryRun, force } = args;
-  const destComponents = path7.join(arcadeProRoot, "src", "Components");
-  if (!dryRun) fs7.mkdirSync(destComponents, { recursive: true });
+  const destComponents = path6.join(arcadeProRoot, "src", "Components");
+  if (!dryRun) fs6.mkdirSync(destComponents, { recursive: true });
   const sourceOf = (name) => {
     const seed = seeds.find((s) => s.name === name);
-    return seed && sourceOverride ? seed.sourceDir : path7.join(componentsDir, name);
+    return seed && sourceOverride ? seed.sourceDir : path6.join(componentsDir, name);
   };
   for (const name of [...closure].sort()) {
     const src = sourceOf(name);
-    const dest = path7.join(destComponents, name);
-    if (fs7.existsSync(dest) && !force) {
+    const dest = path6.join(destComponents, name);
+    if (fs6.existsSync(dest) && !force) {
       console.log(
         yellow(`  ! packages/arcade/src/Components/${name}/ already exists \u2014 pass --force to overwrite.`)
       );
       continue;
     }
     if (!dryRun) {
-      if (fs7.existsSync(dest)) fs7.rmSync(dest, { recursive: true, force: true });
-      fs7.cpSync(src, dest, { recursive: true });
+      if (fs6.existsSync(dest)) fs6.rmSync(dest, { recursive: true, force: true });
+      fs6.cpSync(src, dest, { recursive: true });
     }
     console.log(green(`  + packages/arcade/src/Components/${name}/`));
   }
   if (!dryRun) {
     for (const name of closure) {
-      const dest = path7.join(destComponents, name);
-      if (!fs7.existsSync(dest)) continue;
+      const dest = path6.join(destComponents, name);
+      if (!fs6.existsSync(dest)) continue;
       rewriteTree(dest, (text) => rewriteArcadeImports(text, closure));
     }
   }
@@ -6742,21 +6708,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 : path7.join(componentsDir, name);
+    return seed && sourceOverride ? seed.sourceDir : path6.join(componentsDir, name);
   };
   const files = [];
   const warnings = [];
   for (const name of [...closure].sort()) {
     const src = sourceOf(name);
-    if (!fs7.existsSync(src)) {
+    if (!fs6.existsSync(src)) {
       warnings.push(`  ! source for ${name} missing at ${src}`);
       continue;
     }
     for (const abs of allComponentFiles(src)) {
-      const rel = path7.relative(src, abs);
-      const baseRel = path7.posix.join("src", "Components", name, rel.split(path7.sep).join("/"));
+      const rel = path6.relative(src, abs);
+      const baseRel = path6.posix.join("src", "Components", name, rel.split(path6.sep).join("/"));
       const isText = /\.(ts|tsx)$/i.test(abs);
-      const raw = fs7.readFileSync(abs, "utf8");
+      const raw = fs6.readFileSync(abs, "utf8");
       const contents = isText ? rewriteArcadeImports(raw, closure) : raw;
       files.push({ path: baseRel, contents });
     }
@@ -6775,15 +6741,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 : path7.join(componentsDir, name);
+    return seed && sourceOverride ? seed.sourceDir : path6.join(componentsDir, name);
   };
   const files = [];
   for (const name of closure) {
     const dir = sourceOf(name);
     for (const abs of componentFiles(dir)) {
-      const base = path7.basename(abs);
+      const base = path6.basename(abs);
       if (/\.test\.tsx?$/.test(base)) continue;
-      const source = fs7.readFileSync(abs, "utf8");
+      const source = fs6.readFileSync(abs, "utf8");
       const layer = layerOverride ?? detectLayer(abs, source);
       files.push({ src: abs, base, owner: name, source, layer, destBase: base });
     }
@@ -6791,9 +6757,9 @@ function classifyVizFiles(args) {
   for (const name of closure) {
     const dir = sourceOf(name);
     for (const abs of componentFiles(dir)) {
-      const base = path7.basename(abs);
+      const base = path6.basename(abs);
       if (!/\.test\.tsx?$/.test(base)) continue;
-      const source = fs7.readFileSync(abs, "utf8");
+      const source = fs6.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));
@@ -6813,8 +6779,8 @@ async function injectVizPro(args) {
   const { files, primaryLayer } = classifyVizFiles(args);
   const layerOf = (name) => primaryLayer.get(name);
   for (const f of files) {
-    const dest = path7.join(vizProRoot, "src", f.layer, f.destBase);
-    if (fs7.existsSync(dest) && !force) {
+    const dest = path6.join(vizProRoot, "src", f.layer, f.destBase);
+    if (fs6.existsSync(dest) && !force) {
       console.log(
         yellow(
           `  ! packages/viz-pro/src/${f.layer}/${f.destBase} already exists \u2014 pass --force to overwrite.`
@@ -6823,13 +6789,13 @@ async function injectVizPro(args) {
     }
   }
   for (const f of files) {
-    const destDir = path7.join(vizProRoot, "src", f.layer);
-    const dest = path7.join(destDir, f.destBase);
-    if (fs7.existsSync(dest) && !force) continue;
+    const destDir = path6.join(vizProRoot, "src", f.layer);
+    const dest = path6.join(destDir, f.destBase);
+    if (fs6.existsSync(dest) && !force) continue;
     if (!dryRun) {
-      fs7.mkdirSync(destDir, { recursive: true });
+      fs6.mkdirSync(destDir, { recursive: true });
       const rewritten = rewriteVizImports(f.source, closure, layerOf, f.layer);
-      fs7.writeFileSync(dest, rewritten);
+      fs6.writeFileSync(dest, rewritten);
     }
     console.log(green(`  + packages/viz-pro/src/${f.layer}/${f.destBase}`));
   }
@@ -6857,7 +6823,7 @@ function collectVizPro(args) {
   const files = [];
   const warnings = [];
   for (const f of classified) {
-    const rel = path7.posix.join("src", f.layer, f.destBase);
+    const rel = path6.posix.join("src", f.layer, f.destBase);
     const contents = rewriteVizImports(f.source, closure, layerOf, f.layer);
     files.push({ path: rel, contents });
   }
@@ -6878,13 +6844,13 @@ function collectVizPro(args) {
   return { files, patches, warnings };
 }
 function rewriteTree(dir, rewrite) {
-  for (const e of fs7.readdirSync(dir, { withFileTypes: true })) {
-    const p = path7.join(dir, e.name);
+  for (const e of fs6.readdirSync(dir, { withFileTypes: true })) {
+    const p = path6.join(dir, e.name);
     if (e.isDirectory()) rewriteTree(p, rewrite);
     else if (/\.(ts|tsx)$/.test(e.name)) {
-      const before = fs7.readFileSync(p, "utf8");
+      const before = fs6.readFileSync(p, "utf8");
       const after = rewrite(before);
-      if (after !== before) fs7.writeFileSync(p, after);
+      if (after !== before) fs6.writeFileSync(p, after);
     }
   }
 }
@@ -7000,8 +6966,8 @@ function readSeedMeta(projectDir, seedName) {
 // src/commands/submissions.ts
 import { Command as Command7 } from "commander";
 import { createInterface } from "readline";
-async function apiCall(auth, method, path8) {
-  return auth.makeAuthenticatedRequest(`${API_URL}${path8}`, { method });
+async function apiCall(auth, method, path7) {
+  return auth.makeAuthenticatedRequest(`${API_URL}${path7}`, { method });
 }
 function formatDate(s) {
   if (!s) return "";