@bf6mods/cli 1.1.1 → 1.2.0

package/dist/cli/index.js

@@ -1,853 +1,737 @@
 #!/usr/bin/env node
-
-// src/cli/index.ts
 import { Command } from "commander";
-
-// package.json
-var package_default = {
-  name: "@bf6mods/cli",
-  version: "1.0.2",
-  description: "CLI and library for bundling BF6 mods",
-  license: "MIT",
-  type: "module",
-  bin: {
-    bf6mods: "./dist/cli/index.js"
-  },
-  main: "./dist/index.js",
-  types: "./dist/index.d.ts",
-  scripts: {
-    build: "tsup",
-    start: "cross-env EXIT_CODE=none tsx ./src/cli/index.ts"
-  },
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.js"
-    }
-  },
-  files: [
-    "dist/"
-  ],
-  repository: {
-    type: "git",
-    url: "git+https://github.com/bf6mods/bf6mods.git"
-  },
-  dependencies: {
-    "@bf6mods/sdk": "1.0.3",
-    "@clack/prompts": "^0.11.0",
-    chokidar: "^4.0.3",
-    colors: "^1.4.0",
-    commander: "^14.0.1",
-    jiti: "^2.6.1",
-    knitwork: "^1.2.0",
-    rolldown: "^1.0.0-beta.43",
-    "stringify-object": "^6.0.0"
-  },
-  publishConfig: {
-    access: "public"
-  },
-  devDependencies: {
-    "@oxc-project/types": "^0.95.0",
-    "@types/stringify-object": "^4.0.5",
-    "cross-env": "^10.1.0",
-    tsx: "^4.20.6"
-  }
-};
-
-// src/cli/build/index.ts
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import {
-  AttachmentType
-} from "@bf6mods/sdk";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { AttachmentType } from "@bf6mods/sdk";
+import colors from "colors";
 import { createJiti } from "jiti";
 import { rolldown } from "rolldown";
+import stripAnsi from "strip-ansi";
+import { glob } from "node:fs/promises";
+import chokidar from "chokidar";
+import stringifyObject from "stringify-object";
+import child_process from "node:child_process";
+import * as prompts from "@clack/prompts";
+import { genExport, genInlineTypeImport } from "knitwork";
 
-// src/resources/prepare/types/config.ts
-var MapId = /* @__PURE__ */ ((MapId2) => {
-  MapId2["FireStorm"] = "MP_FireStorm-ModBuilderCustom0";
-  MapId2["SiegeOfCairo"] = "MP_Abbasid-ModBuilderCustom0";
-  MapId2["EmpireState"] = "MP_Aftermath-ModBuilderCustom0";
-  MapId2["IberianOffensive"] = "MP_Battery-ModBuilderCustom0";
-  MapId2["LiberationPeak"] = "MP_Capstone-ModBuilderCustom0";
-  MapId2["ManhattanBridge"] = "MP_Dumbo-ModBuilderCustom0";
-  MapId2["SaintsQuarter"] = "MP_Limestone-ModBuilderCustom0";
-  MapId2["NewSobekCity"] = "MP_Outskirts-ModBuilderCustom0";
-  MapId2["MirakValley"] = "MP_Tungsten-ModBuilderCustom0";
-  return MapId2;
-})(MapId || {});
-
-// src/cli/build/generated-strings.ts
-function extractBf6Strings(bf6Strings, generateFromLiterals) {
-  return {
-    name: "extract-bf6-strings",
-    generateBundle(_options, bundle) {
-      if (!generateFromLiterals) return;
-      let id = 0;
-      const existingStrings = new Set(Object.values(bf6Strings));
-      for (const [_file, output] of Object.entries(bundle)) {
-        let walk2 = function(node) {
-          if (node.type === "Literal") {
-            if (typeof node.value !== "string" || node.value === "" || node.value === "----uniquename----")
-              return;
-            if (!(node.value in bf6Strings) && !existingStrings.has(node.value)) {
-              existingStrings.add(node.value);
-              bf6Strings[`__auto__${id++}`] = node.value;
-            }
-          }
-          for (const value of Object.values(node)) {
-            if (!value) continue;
-            if (Array.isArray(value)) {
-              for (const v of value) {
-                if (v && typeof v === "object" && "type" in v) walk2(v);
-              }
-            } else if (typeof value === "object" && "type" in value) {
-              walk2(value);
-            }
-          }
-        };
-        var walk = walk2;
-        if (output.type !== "chunk") continue;
-        const code = output.code;
-        const program2 = this.parse(code, {
-          lang: "ts",
-          astType: "js",
-          range: true
-        });
-        for (const item of program2.body) {
-          walk2(item);
-        }
-      }
-    },
-    moduleParsed(moduleInfo) {
-      if (moduleInfo.code && moduleInfo.exports.includes("bf6Strings")) {
-        const code = moduleInfo.code;
-        const getSnippet = (start, end, linesBefore = 2, linesAfter = 2) => {
-          const lines = code.split(/\r?\n/);
-          const startLine = Math.max(
-            0,
-            code.slice(0, start).split(/\r?\n/).length - 1 - linesBefore
-          );
-          const endLine = Math.min(
-            lines.length,
-            code.slice(0, end).split(/\r?\n/).length - 1 + linesAfter
-          );
-          return lines.slice(startLine, endLine).map((line, i) => {
-            const actualLine = startLine + i + 1;
-            return `${actualLine.toString().padStart(3)} | ${line}`;
-          }).join("\n");
-        };
-        const program2 = this.parse(code, {
-          lang: "ts",
-          astType: "js",
-          range: true
-        });
-        const extractObjectLiteral = (declaration) => {
-          if (declaration.init?.type !== "ObjectExpression") {
-            const snippet = getSnippet(...declaration.range ?? [0, 0]);
-            this.error(
-              `\u274C Invalid bf6Strings export: expected an object literal.
-
-${snippet}`
-            );
-          }
-          for (const property of declaration.init.properties) {
-            if (property.type !== "Property") {
-              const snippet = getSnippet(...property.range ?? [0, 0]);
-              this.error(
-                `\u274C Invalid bf6Strings property: expected a key/value pair.
-Found type: ${property.type}
-
-${snippet}`
-              );
-            }
-            let key = void 0;
-            if (property.key.type === "Literal") {
-              key = property.key.value;
-            } else if (property.key.type === "Identifier") {
-              key = property.key.name;
-            } else {
-              const snippet = getSnippet(...property.range ?? [0, 0]);
-              this.error(
-                `\u274C Invalid bf6Strings key: expected a string literal or identifier.
-Found type: ${property.key.type}
-
-${snippet}`
-              );
-              continue;
-            }
-            if (property.value.type !== "Literal") {
-              const snippet = getSnippet(...property.range ?? [0, 0]);
-              this.error(
-                `\u274C Invalid bf6Strings value: expected a string literal.
-Found type: ${property.value.type}
+//#region package.json
+var version = "1.2.0";
+var description = "CLI and library for bundling BF6 mods";
+var bin = { "bf6mods": "./dist/cli/index.js" };
 
-${snippet}`
-              );
-            }
-            const value = property.value.value;
-            if (typeof key !== "string" && typeof key !== "number" && typeof key !== "bigint" && typeof key !== "boolean") {
-              const snippet = getSnippet(...property.range ?? [0, 0]);
-              this.error(
-                `\u274C bf6Strings key must be a string, found: ${typeof key}
+//#endregion
+//#region src/resources/prepare/types/config.ts
+let MapId = /* @__PURE__ */ function(MapId$1) {
+	MapId$1["FireStorm"] = "MP_FireStorm-ModBuilderCustom0";
+	MapId$1["SiegeOfCairo"] = "MP_Abbasid-ModBuilderCustom0";
+	MapId$1["EmpireState"] = "MP_Aftermath-ModBuilderCustom0";
+	MapId$1["IberianOffensive"] = "MP_Battery-ModBuilderCustom0";
+	MapId$1["LiberationPeak"] = "MP_Capstone-ModBuilderCustom0";
+	MapId$1["ManhattanBridge"] = "MP_Dumbo-ModBuilderCustom0";
+	MapId$1["SaintsQuarter"] = "MP_Limestone-ModBuilderCustom0";
+	MapId$1["NewSobekCity"] = "MP_Outskirts-ModBuilderCustom0";
+	MapId$1["MirakValley"] = "MP_Tungsten-ModBuilderCustom0";
+	return MapId$1;
+}({});
 
-${snippet}`
-              );
-            }
-            if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint" && typeof value !== "boolean") {
-              const snippet = getSnippet(...property.range ?? [0, 0]);
-              this.error(
-                `\u274C bf6Strings value must be a string, found: ${typeof value}
+//#endregion
+//#region src/cli/utils.ts
+/**
+* Safely prints a message with a right-aligned timestamp.
+*/
+const printToConsole = (message, error = false) => {
+	const now = /* @__PURE__ */ new Date();
+	const formattedTime = colors.grey(now.toLocaleTimeString());
+	const terminalWidth = process.stdout.columns || 80;
+	const timeLength = stripAnsi(formattedTime).length;
+	const available = terminalWidth - (stripAnsi(message).length + timeLength);
+	const spacing = available > 1 ? " ".repeat(available) : " ";
+	if (error) console.error(`${message}${spacing}${formattedTime}`);
+	else console.log(`${message}${spacing}${formattedTime}`);
+};
 
-${snippet}`
-              );
-            }
-            bf6Strings[`${key}`] = `${value}`;
-          }
-        };
-        for (const item of program2.body) {
-          if (item.type === "VariableDeclaration") {
-            for (const declaration of item.declarations) {
-              if (declaration.type === "VariableDeclarator" && declaration.id.type === "Identifier" && declaration.id.name === "bf6Strings") {
-                extractObjectLiteral(declaration);
-              }
-            }
-          }
-          if (item.type === "ExportNamedDeclaration" && item.declaration?.type === "VariableDeclaration") {
-            for (const declaration of item.declaration.declarations) {
-              if (declaration.type === "VariableDeclarator" && declaration.id.type === "Identifier" && declaration.id.name === "bf6Strings") {
-                extractObjectLiteral(declaration);
-              }
-            }
-          }
-        }
-      }
-    }
-  };
+//#endregion
+//#region src/cli/build/generated-strings.ts
+function extractBf6Strings(bf6Strings, generateFromLiterals) {
+	return {
+		name: "extract-bf6-strings",
+		generateBundle(_options, bundle) {
+			if (!generateFromLiterals) return;
+			let id = 0;
+			const existingStrings = new Set(Object.values(bf6Strings));
+			for (const [_file, output] of Object.entries(bundle)) {
+				if (output.type !== "chunk") continue;
+				const code = output.code;
+				const program$1 = this.parse(code, {
+					lang: "ts",
+					astType: "js",
+					range: true
+				});
+				function walk(node) {
+					if (node.type === "Literal") {
+						if (typeof node.value !== "string" || node.value === "" || node.value === "----uniquename----") return;
+						if (!(node.value in bf6Strings) && !existingStrings.has(node.value)) {
+							existingStrings.add(node.value);
+							bf6Strings[`__auto__${id++}`] = node.value;
+						}
+					}
+					for (const value of Object.values(node)) {
+						if (!value) continue;
+						if (Array.isArray(value)) {
+							for (const v of value) if (v && typeof v === "object" && "type" in v) walk(v);
+						} else if (typeof value === "object" && "type" in value) walk(value);
+					}
+				}
+				for (const item of program$1.body) walk(item);
+			}
+		},
+		moduleParsed(moduleInfo) {
+			if (moduleInfo.code && moduleInfo.exports.includes("bf6Strings")) {
+				const code = moduleInfo.code;
+				const getSnippet = (start, end, linesBefore = 2, linesAfter = 2) => {
+					const lines = code.split(/\r?\n/);
+					const startLine = Math.max(0, code.slice(0, start).split(/\r?\n/).length - 1 - linesBefore);
+					const endLine = Math.min(lines.length, code.slice(0, end).split(/\r?\n/).length - 1 + linesAfter);
+					return lines.slice(startLine, endLine).map((line, i) => {
+						return `${(startLine + i + 1).toString().padStart(3)} | ${line}`;
+					}).join("\n");
+				};
+				const program$1 = this.parse(code, {
+					lang: "ts",
+					astType: "js",
+					range: true
+				});
+				const extractObjectLiteral = (declaration) => {
+					if (declaration.init?.type !== "ObjectExpression") {
+						const snippet = getSnippet(...declaration.range ?? [0, 0]);
+						this.error(`${colors.red.bold("✗")} Invalid bf6Strings export: expected an object literal.\n\n${snippet}`);
+					}
+					for (const property of declaration.init.properties) {
+						if (property.type !== "Property") {
+							const snippet = getSnippet(...property.range ?? [0, 0]);
+							this.error(`${colors.red.bold("✗")} Invalid bf6Strings property: expected a key/value pair.\nFound type: ${property.type}\n\n${snippet}`);
+						}
+						let key;
+						if (property.key.type === "Literal") key = property.key.value;
+						else if (property.key.type === "Identifier") key = property.key.name;
+						else {
+							const snippet = getSnippet(...property.range ?? [0, 0]);
+							this.error(`${colors.red.bold("✗")} Invalid bf6Strings key: expected a string literal or identifier.\nFound type: ${property.key.type}\n\n${snippet}`);
+							continue;
+						}
+						if (property.value.type !== "Literal") {
+							const snippet = getSnippet(...property.range ?? [0, 0]);
+							this.error(`${colors.red.bold("✗")} Invalid bf6Strings value: expected a string literal.\nFound type: ${property.value.type}\n\n${snippet}`);
+						}
+						const value = property.value.value;
+						if (typeof key !== "string" && typeof key !== "number" && typeof key !== "bigint" && typeof key !== "boolean") {
+							const snippet = getSnippet(...property.range ?? [0, 0]);
+							this.error(`${colors.red.bold("✗")} bf6Strings key must be a string, found: ${typeof key}\n\n${snippet}`);
+						}
+						if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint" && typeof value !== "boolean") {
+							const snippet = getSnippet(...property.range ?? [0, 0]);
+							this.error(`${colors.red.bold("✗")} bf6Strings value must be a string, found: ${typeof value}\n\n${snippet}`);
+						}
+						bf6Strings[`${key}`] = `${value}`;
+					}
+				};
+				for (const item of program$1.body) {
+					if (item.type === "VariableDeclaration") {
+						for (const declaration of item.declarations) if (declaration.type === "VariableDeclarator" && declaration.id.type === "Identifier" && declaration.id.name === "bf6Strings") extractObjectLiteral(declaration);
+					}
+					if (item.type === "ExportNamedDeclaration" && item.declaration?.type === "VariableDeclaration") {
+						for (const declaration of item.declaration.declarations) if (declaration.type === "VariableDeclarator" && declaration.id.type === "Identifier" && declaration.id.name === "bf6Strings") extractObjectLiteral(declaration);
+					}
+				}
+			}
+		}
+	};
 }
 
-// src/cli/build/index.ts
+//#endregion
+//#region src/cli/build/index.ts
+/**
+* Dynamically imports and validates bf6.config.ts
+*/
 async function getBf6Config(rootDir) {
-  globalThis.defineBf6Config = (c) => c;
-  globalThis.MapId = MapId;
-  const jiti = createJiti(rootDir, { interopDefault: true });
-  const result = await jiti.import("./bf6.config", { default: true });
-  delete globalThis.defineBf6Config;
-  delete globalThis.MapId;
-  return result;
+	globalThis.defineBf6Config = (c) => c;
+	globalThis.MapId = MapId;
+	const result = await createJiti(rootDir, { interopDefault: true }).import("./bf6.config", { default: true });
+	delete globalThis.defineBf6Config;
+	delete globalThis.MapId;
+	return result;
 }
+/**
+* Builds the entire mod project once (for production or single run).
+*/
 async function build() {
-  const workingDir = path.resolve(".");
-  const config = await getBf6Config(workingDir);
-  const outDir = path.resolve(workingDir, config.outDir);
-  if (fs.existsSync(outDir))
-    fs.rmSync(outDir, { recursive: true, force: true });
-  fs.mkdirSync(outDir, { recursive: true });
-  const minifyJson = typeof config.minify === "boolean" ? config.minify : config.minify?.json ?? false;
-  const generatedStrings = {};
-  let tsAttachment;
-  if (config.entrypoint) {
-    const entryAbs = path.resolve(workingDir, config.entrypoint);
-    const compiled = await buildEntrypoint(
-      entryAbs,
-      generatedStrings,
-      config.generateStrings ?? true
-    );
-    tsAttachment = createTsAttachment(entryAbs, compiled);
-  }
-  const { attachments, mapRotation } = await collectAttachments(
-    config,
-    workingDir,
-    tsAttachment,
-    generatedStrings
-  );
-  await writeModJson(config, outDir, attachments, mapRotation, minifyJson);
-  console.log(`\u2714 Built mod: ${config.name}`);
+	const workingDir = path.resolve(".");
+	const config = await getBf6Config(workingDir);
+	const outDir = path.resolve(workingDir, config.outDir);
+	if (fs.existsSync(outDir)) fs.rmSync(outDir, {
+		recursive: true,
+		force: true
+	});
+	fs.mkdirSync(outDir, { recursive: true });
+	const minifyJson = typeof config.minify === "boolean" ? config.minify : config.minify?.json ?? false;
+	const generatedStrings = {};
+	let tsAttachment;
+	if (config.entrypoint) {
+		const entryAbs = path.resolve(workingDir, config.entrypoint);
+		tsAttachment = createTsAttachment(entryAbs, await buildEntrypoint(entryAbs, generatedStrings, config.generateStrings ?? true));
+	}
+	const { attachments, mapRotation } = await collectAttachments(config, workingDir, tsAttachment, generatedStrings);
+	await writeModJson(config, outDir, attachments, mapRotation, minifyJson);
+	printToConsole(`${colors.green.bold("✓")} Built mod: ${config.name}`);
 }
+/**
+* Compiles the TypeScript entrypoint using rolldown and returns the compiled code.
+*/
 async function buildEntrypoint(entry, bf6Strings, generateStringsFromLiterals) {
-  const bundle = await rolldown({
-    input: entry,
-    plugins: [extractBf6Strings(bf6Strings, generateStringsFromLiterals)],
-    logLevel: "debug"
-  });
-  const result = await bundle.generate({
-    format: "esm",
-    inlineDynamicImports: true
-  });
-  const code = result.output[0].code;
-  return code;
+	return (await (await rolldown({
+		input: entry,
+		plugins: [extractBf6Strings(bf6Strings, generateStringsFromLiterals)],
+		logLevel: "debug"
+	})).generate({
+		format: "esm",
+		inlineDynamicImports: true
+	})).output[0].code;
 }
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
-var spatialsDir = path.resolve(__dirname, "../resources/maps/spatial");
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+const spatialsDir = path.resolve(__dirname$1, "../resources/maps/spatial");
+/**
+* Collects all attachments (TS, scenes, strings) and returns them + mapRotation.
+*/
 async function collectAttachments(config, workingDir, tsAttachment, generatedStrings) {
-  const attachments = [];
-  const mapRotation = [];
-  if (tsAttachment) attachments.push(tsAttachment);
-  if (config.strings) {
-    const strPath = path.resolve(workingDir, config.strings);
-    if (!fs.existsSync(strPath)) throw new Error("Cannot find strings file");
-    const raw = await fs.promises.readFile(strPath, "utf8");
-    const attachment = createStringsAttachment(strPath, raw, generatedStrings);
-    attachments.push(attachment);
-  }
-  if (config.scenes) {
-    let mapIdx = 0;
-    for (const map of config.scenes) {
-      let mapId;
-      let scene;
-      if (Array.isArray(map)) {
-        [mapId, scene] = map;
-      } else {
-        mapId = map;
-        scene = path.resolve(spatialsDir, `${mapId}.spatial.json`);
-      }
-      const scenePath = path.resolve(workingDir, scene);
-      if (!fs.existsSync(scenePath))
-        throw new Error(`Cannot find spatial data file: ${scene}`);
-      const raw = await fs.promises.readFile(scenePath, "utf8");
-      const spatial = createSpatialAttachment(scenePath, raw, mapIdx++);
-      attachments.push(spatial);
-      mapRotation.push({ id: mapId, spatialAttachment: spatial });
-    }
-  }
-  return { attachments, mapRotation };
+	const attachments = [];
+	const mapRotation = [];
+	if (tsAttachment) attachments.push(tsAttachment);
+	if (config.strings) {
+		const strPath = path.resolve(workingDir, config.strings);
+		if (!fs.existsSync(strPath)) throw new Error("Cannot find strings file");
+		const attachment = createStringsAttachment(strPath, await fs.promises.readFile(strPath, "utf8"), generatedStrings);
+		attachments.push(attachment);
+	}
+	if (config.scenes) {
+		let mapIdx = 0;
+		for (const map of config.scenes) {
+			let mapId;
+			let scene;
+			if (Array.isArray(map)) [mapId, scene] = map;
+			else {
+				mapId = map;
+				scene = path.resolve(spatialsDir, `${mapId}.spatial.json`);
+			}
+			const scenePath = path.resolve(workingDir, scene);
+			if (!fs.existsSync(scenePath)) throw new Error(`Cannot find spatial data file: ${scene}`);
+			const spatial = createSpatialAttachment(scenePath, await fs.promises.readFile(scenePath, "utf8"), mapIdx++);
+			attachments.push(spatial);
+			mapRotation.push({
+				id: mapId,
+				spatialAttachment: spatial
+			});
+		}
+	}
+	return {
+		attachments,
+		mapRotation
+	};
 }
+/**
+* Writes the mod.json output to disk.
+*/
 async function writeModJson(config, outDir, attachments, mapRotation, minify) {
-  const baseGame = config.game;
-  const finalJson = {
-    name: config.name,
-    description: config.description,
-    gameMode: "ModBuilderCustom",
-    mutators: baseGame.mutators ?? {},
-    assetRestrictions: baseGame.assetRestrictions ?? {},
-    teamComposition: baseGame.teamComposition ?? [],
-    mapRotation,
-    attachments
-  };
-  const jsonOutput = minify ? JSON.stringify(finalJson) : JSON.stringify(finalJson, null, 2);
-  await fs.promises.writeFile(path.resolve(outDir, "mod.json"), jsonOutput);
-  if (config.outputArtifacts && finalJson?.attachments) {
-    for (const attachment of finalJson.attachments) {
-      const attachmentsDir = path.resolve(outDir, "attachments");
-      if (!fs.existsSync(attachmentsDir))
-        fs.mkdirSync(attachmentsDir, {
-          recursive: true
-        });
-      await fs.promises.writeFile(
-        path.resolve(outDir, "attachments", attachment.filename),
-        atob(attachment.attachmentData.original)
-      );
-    }
-  }
+	const baseGame = config.game;
+	const finalJson = {
+		name: config.name,
+		description: config.description,
+		gameMode: "ModBuilderCustom",
+		mutators: baseGame.mutators ?? {},
+		assetRestrictions: baseGame.assetRestrictions ?? {},
+		teamComposition: baseGame.teamComposition ?? [],
+		mapRotation,
+		attachments
+	};
+	const jsonOutput = minify ? JSON.stringify(finalJson) : JSON.stringify(finalJson, null, 2);
+	await fs.promises.writeFile(path.resolve(outDir, "mod.json"), jsonOutput);
+	if (config.outputArtifacts && finalJson?.attachments) for (const attachment of finalJson.attachments) {
+		const attachmentsDir = path.resolve(outDir, "attachments");
+		if (!fs.existsSync(attachmentsDir)) fs.mkdirSync(attachmentsDir, { recursive: true });
+		await fs.promises.writeFile(path.resolve(outDir, "attachments", attachment.filename), atob(attachment.attachmentData.original));
+	}
 }
 function createTsAttachment(filePath, compiled) {
-  return {
-    id: crypto.randomUUID(),
-    version: "1.0",
-    filename: `${path.parse(filePath).name}.js`,
-    isProcessable: true,
-    processingStatus: 2,
-    attachmentType: AttachmentType.TypeScript,
-    attachmentData: { original: toBase64(compiled), compiled: "" },
-    errors: []
-  };
+	return {
+		id: crypto.randomUUID(),
+		version: "1.0",
+		filename: `${path.parse(filePath).name}.js`,
+		isProcessable: true,
+		processingStatus: 2,
+		attachmentType: AttachmentType.TypeScript,
+		attachmentData: {
+			original: toBase64(compiled),
+			compiled: ""
+		},
+		errors: []
+	};
 }
 function createStringsAttachment(filePath, raw, generatedStrings) {
-  let result = raw;
-  if (generatedStrings) {
-    result = JSON.stringify(
-      {
-        ...generatedStrings,
-        ...JSON.parse(raw)
-      },
-      null,
-      4
-    );
-  }
-  return {
-    id: crypto.randomUUID(),
-    version: "1.0",
-    filename: path.basename(filePath),
-    isProcessable: true,
-    processingStatus: 2,
-    attachmentType: AttachmentType.Strings,
-    attachmentData: { original: toBase64(result), compiled: "" },
-    errors: []
-  };
+	let result = raw;
+	if (generatedStrings) result = JSON.stringify({
+		...generatedStrings,
+		...JSON.parse(raw)
+	}, null, 4);
+	return {
+		id: crypto.randomUUID(),
+		version: "1.0",
+		filename: path.basename(filePath),
+		isProcessable: true,
+		processingStatus: 2,
+		attachmentType: AttachmentType.Strings,
+		attachmentData: {
+			original: toBase64(result),
+			compiled: ""
+		},
+		errors: []
+	};
 }
 function createSpatialAttachment(filePath, raw, mapIdx) {
-  return {
-    id: crypto.randomUUID(),
-    version: "1.0",
-    filename: path.basename(filePath),
-    isProcessable: true,
-    processingStatus: 2,
-    attachmentType: AttachmentType.SpatialData,
-    attachmentData: { original: toBase64(raw), compiled: "" },
-    metadata: `mapIdx=${mapIdx}`,
-    errors: []
-  };
+	return {
+		id: crypto.randomUUID(),
+		version: "1.0",
+		filename: path.basename(filePath),
+		isProcessable: true,
+		processingStatus: 2,
+		attachmentType: AttachmentType.SpatialData,
+		attachmentData: {
+			original: toBase64(raw),
+			compiled: ""
+		},
+		metadata: `mapIdx=${mapIdx}`,
+		errors: []
+	};
 }
 function toBase64(input) {
-  return Buffer.isBuffer(input) ? input.toString("base64") : Buffer.from(input, "utf8").toString("base64");
+	return Buffer.isBuffer(input) ? input.toString("base64") : Buffer.from(input, "utf8").toString("base64");
 }
 
-// src/cli/dev.ts
-import fs2 from "fs";
-import { glob } from "fs/promises";
-import path2 from "path";
-import chokidar from "chokidar";
-import colors from "colors";
+//#endregion
+//#region src/cli/log.ts
+var Bf6Logger = class Bf6Logger {
+	constructor(input) {
+		if (Bf6Logger.instance) {
+			printToConsole(colors.yellow("⚠ Existing logger found — closing it first..."));
+			Bf6Logger.instance.stop();
+		}
+		if (input) this.watchTarget = path.resolve(input);
+		else if (process.env.LOCALAPPDATA) this.watchTarget = path.resolve(process.env.LOCALAPPDATA, "temp", "Battlefieldâ„¢ 6", "PortalLog.txt");
+		else throw new Error(`${colors.red.bold("✗")} Env variable LOCALAPPDATA not defined, and input file to watch was not provided!`);
+		if (!fs.existsSync(this.watchTarget)) throw new Error(`${colors.red.bold("✗")} Cannot find file '${this.watchTarget}' to watch for changes`);
+		this.lastSize = fs.statSync(this.watchTarget).size;
+		Bf6Logger.instance = this;
+	}
+	async start() {
+		printToConsole(colors.cyan(`👀 Watching Battlefield logs at: ${colors.yellow(this.watchTarget)}`));
+		this.watcher = chokidar.watch(this.watchTarget, {
+			persistent: true,
+			ignoreInitial: true
+		});
+		this.watcher.on("change", this.handleChange.bind(this));
+	}
+	async stop() {
+		if (this.watcher) {
+			this.watcher.close();
+			this.watcher = void 0;
+			printToConsole(colors.yellow(`${colors.red.bold("✗")} Stopped watching: ${colors.gray(this.watchTarget)}`));
+		}
+		Bf6Logger.instance = void 0;
+	}
+	handleChange(file, stats) {
+		if (!stats) return;
+		if (stats.size > this.lastSize) {
+			const newBytes = stats.size - this.lastSize;
+			const fd = fs.openSync(file, "r");
+			const buffer = Buffer.alloc(newBytes);
+			fs.readSync(fd, buffer, 0, newBytes, this.lastSize);
+			fs.closeSync(fd);
+			const newContent = buffer.toString("utf8").split("QuickJS: ").filter((debug) => debug.trim() !== "").map((debug) => debug.trim()).map((debug) => {
+				if (debug.startsWith("console.log: ")) return {
+					type: "console.log",
+					text: debug.replace("console.log: ", "")
+				};
+				else if (debug.startsWith("Exception:")) return {
+					type: "exception",
+					text: debug.replace("Exception:", "")
+				};
+				return {
+					type: "unknown",
+					text: debug
+				};
+			});
+			for (const content of newContent) if (content.type === "console.log") printToConsole(colors.gray(content.text));
+			else if (content.type === "exception") printToConsole(colors.red(content.text), true);
+			else printToConsole(colors.bold(content.text));
+		}
+		this.lastSize = stats.size;
+	}
+};
+
+//#endregion
+//#region src/cli/dev.ts
 async function dev() {
-  const workingDir = path2.resolve(".");
-  let config = await getBf6Config(workingDir);
-  const outDir = path2.resolve(workingDir, config.outDir);
-  if (!fs2.existsSync(outDir)) fs2.mkdirSync(outDir, { recursive: true });
-  console.log(colors.cyan(`\u25B6 Starting dev for ${config.name}`));
-  let watcher;
-  async function rebuild(trigger) {
-    console.log(
-      colors.yellow(
-        `\u21BB Change detected in ${path2.basename(trigger)}, rebuilding...`
-      )
-    );
-    const start = performance.now();
-    try {
-      await build();
-      const end = performance.now();
-      const duration = ((end - start) / 1e3).toFixed(2);
-      console.log(colors.green(`\u2714 Updated mod.json (${duration}s)`));
-    } catch (err) {
-      console.error(colors.red(`\u2716 Rebuild failed: ${err.message}`));
-    }
-  }
-  async function collectWatchTargets() {
-    const targets = [];
-    if (config.entrypoint)
-      targets.push(path2.resolve(workingDir, config.entrypoint));
-    if (config.scenes) {
-      for (const [, scene] of config.scenes) {
-        targets.push(path2.resolve(workingDir, scene));
-      }
-    }
-    if (config.strings) targets.push(path2.resolve(workingDir, config.strings));
-    const srcDir = path2.resolve(workingDir, "src");
-    for await (const entry of glob(`${srcDir}/**/*`)) targets.push(entry);
-    for await (const entry of glob("bf6.config.*")) targets.push(entry);
-    return targets;
-  }
-  async function setupWatcher() {
-    if (watcher) {
-      await watcher.close();
-      console.log(colors.grey("\u267B Reloading watcher due to config change..."));
-    }
-    const watchTargets = await collectWatchTargets();
-    watcher = chokidar.watch(watchTargets, {
-      persistent: true,
-      ignoreInitial: true,
-      awaitWriteFinish: true,
-      ignored: [path2.resolve(outDir), `${path2.resolve(outDir)}/**`]
-    });
-    watcher.on("change", async (file) => {
-      if (file.includes("bf6.config.")) {
-        console.log(
-          colors.magenta(
-            "\u2699 Config changed \u2014 reloading and rebuilding watcher..."
-          )
-        );
-        try {
-          config = await getBf6Config(workingDir);
-          await setupWatcher();
-        } catch (err) {
-          console.error(
-            colors.red(`\u2716 Failed to reload config: ${err.message}`)
-          );
-        }
-        return;
-      }
-      await rebuild(file);
-    });
-    watcher.on("add", async (file) => await rebuild(file));
-    await rebuild("initial");
-  }
-  await setupWatcher();
+	const workingDir = path.resolve(".");
+	let config = await getBf6Config(workingDir);
+	const outDir = path.resolve(workingDir, config.outDir);
+	fs.mkdirSync(outDir, { recursive: true });
+	printToConsole(colors.cyan(`▶ Starting dev for ${config.name}`));
+	let watcher;
+	function debounce(fn, delay) {
+		let timer;
+		return (...args) => {
+			if (timer) clearTimeout(timer);
+			timer = setTimeout(() => fn(...args), delay);
+		};
+	}
+	const rebuild = async (trigger) => {
+		printToConsole(colors.yellow(`↻ Change detected in ${path.basename(trigger)}, rebuilding...`));
+		const start = performance.now();
+		try {
+			await build();
+			const duration = ((performance.now() - start) / 1e3).toFixed(2);
+			printToConsole(`${colors.green.bold("✓")} Updated mod.json (${duration}s)`);
+		} catch (err) {
+			printToConsole(colors.red(`${colors.red.bold("✗")} Rebuild failed: ${err.message}`), true);
+		}
+	};
+	const debouncedRebuild = debounce(rebuild, 200);
+	async function collectWatchTargets() {
+		const targets = [];
+		if (config.entrypoint) targets.push(path.resolve(workingDir, config.entrypoint));
+		if (config.scenes) for (const [, scene] of config.scenes) targets.push(path.resolve(workingDir, scene));
+		if (config.strings) targets.push(path.resolve(workingDir, config.strings));
+		for await (const entry of glob("bf6.config.*")) targets.push(entry);
+		for await (const entry of glob("src/**/*")) targets.push(entry);
+		return targets;
+	}
+	async function setupWatcher() {
+		if (watcher) {
+			await watcher.close();
+			printToConsole(colors.grey("♻ Reloading watcher due to config change..."));
+			await new Promise((r) => setTimeout(r, 10));
+		}
+		const watchTargets = await collectWatchTargets();
+		printToConsole(colors.cyan(`👀 Watching ${watchTargets.length} files...`));
+		watcher = chokidar.watch(watchTargets, {
+			persistent: true,
+			ignoreInitial: true,
+			awaitWriteFinish: {
+				stabilityThreshold: 250,
+				pollInterval: 100
+			},
+			ignored: [
+				outDir,
+				`${outDir}/**`,
+				"node_modules/**",
+				".git/**"
+			]
+		});
+		watcher.on("error", (err) => {
+			printToConsole(colors.red(`⚠ Watcher error: ${err.message}`), true);
+			setTimeout(setupWatcher, 1e3);
+		});
+		watcher.on("change", async (file) => {
+			if (file.includes("bf6.config.")) {
+				printToConsole(colors.magenta("⚙ Config changed — reloading watcher..."));
+				config = await getBf6Config(workingDir);
+				await setupWatcher();
+				return;
+			}
+			debouncedRebuild(file);
+		});
+		watcher.on("add", debouncedRebuild);
+		await rebuild("initial");
+	}
+	process.on("SIGINT", async () => {
+		printToConsole(colors.red(`\n${colors.red.bold("✗")} Exiting dev mode...`));
+		await watcher?.close();
+		process.exit(0);
+	});
+	await setupWatcher();
+	let logger;
+	try {
+		logger = new Bf6Logger();
+		logger.start();
+	} catch (error) {
+		printToConsole(colors.grey("Failed to start logging for the following reason (building will still work)"), true);
+		printToConsole(error.message, true);
+	}
 }
 
-// src/cli/import.ts
-import fs4 from "fs";
-import path4 from "path";
-import { AttachmentType as AttachmentType2 } from "@bf6mods/sdk";
-import stringifyObject from "stringify-object";
-
-// src/cli/init.ts
-import child_process from "child_process";
-import fs3 from "fs";
-import path3 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import * as prompts from "@clack/prompts";
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path3.dirname(__filename2);
-var templatesDir = path3.resolve(__dirname2, "../resources/templates");
+//#endregion
+//#region src/cli/init.ts
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const templatesDir = path.resolve(__dirname, "../resources/templates");
 function renameFilesRecursively(dir, modName) {
-  const entries = fs3.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const oldPath = path3.join(dir, entry.name);
-    let newPath = oldPath;
-    if (entry.name.includes("{name}")) {
-      const newName = entry.name.replace("{name}", modName);
-      newPath = path3.join(dir, newName);
-      fs3.renameSync(oldPath, newPath);
-    }
-    if (entry.name === "bf6.config.ts") {
-      let content = fs3.readFileSync(newPath, "utf-8");
-      content = content.replace(/{bf6ConfigName}/g, modName);
-      fs3.writeFileSync(newPath, content, "utf-8");
-    }
-    if (entry.name === "package.json") {
-      const pkg = JSON.parse(fs3.readFileSync(newPath, "utf-8"));
-      pkg.name = modName;
-      fs3.writeFileSync(newPath, JSON.stringify(pkg, null, 2));
-    }
-    if (fs3.statSync(newPath).isDirectory()) {
-      renameFilesRecursively(newPath, modName);
-    }
-  }
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const oldPath = path.join(dir, entry.name);
+		let newPath = oldPath;
+		if (entry.name.includes("{name}")) {
+			const newName = entry.name.replace("{name}", modName);
+			newPath = path.join(dir, newName);
+			fs.renameSync(oldPath, newPath);
+		}
+		if (entry.name === "bf6.config.ts") {
+			let content = fs.readFileSync(newPath, "utf-8");
+			content = content.replace(/{bf6ConfigName}/g, modName);
+			fs.writeFileSync(newPath, content, "utf-8");
+		}
+		if (entry.name === "package.json") {
+			const pkg = JSON.parse(fs.readFileSync(newPath, "utf-8"));
+			pkg.name = modName;
+			fs.writeFileSync(newPath, JSON.stringify(pkg, null, 2));
+		}
+		if (fs.statSync(newPath).isDirectory()) renameFilesRecursively(newPath, modName);
+	}
 }
-var templates = [
-  "Basic",
-  "AcePursuit",
-  "BombSquad",
-  "Exfil",
-  "Vertigo"
+const templates = [
+	"Basic",
+	"AcePursuit",
+	"BombSquad",
+	"Exfil",
+	"Vertigo"
 ];
 async function startProject(destination, template, name) {
-  if (["AcePursuit", "BombSquad", "Exfil", "Vertigo"].includes(template)) {
-    const importPath = path3.resolve(templatesDir, `${template}.json`);
-    await importFile(importPath, destination, name);
-  } else if (template === "None") {
-  } else {
-    const templateDir = path3.resolve(templatesDir, template);
-    fs3.cpSync(templateDir, destination, { recursive: true });
-  }
-  fs3.cpSync(path3.resolve(templatesDir, "All"), destination, {
-    recursive: true
-  });
-  if (name) renameFilesRecursively(destination, name);
+	if ([
+		"AcePursuit",
+		"BombSquad",
+		"Exfil",
+		"Vertigo"
+	].includes(template)) await importFile(path.resolve(templatesDir, `${template}.json`), destination, name);
+	else if (template === "None") {} else {
+		const templateDir = path.resolve(templatesDir, template);
+		fs.cpSync(templateDir, destination, { recursive: true });
+	}
+	fs.cpSync(path.resolve(templatesDir, "All"), destination, { recursive: true });
+	if (name) renameFilesRecursively(destination, name);
 }
 function installDependencies(projectDir) {
-  try {
-    child_process.execSync(`npm install`, {
-      stdio: "inherit",
-      cwd: projectDir
-    });
-    return true;
-  } catch (_err) {
-    return false;
-  }
+	try {
+		child_process.execSync(`npm install`, {
+			stdio: "inherit",
+			cwd: projectDir
+		});
+		return true;
+	} catch (_err) {
+		return false;
+	}
 }
-var cancel2 = () => prompts.cancel("Operation cancelled");
-function isEmpty(path6) {
-  const files = fs3.readdirSync(path6);
-  return files.length === 0 || files.length === 1 && files[0] === ".git";
+const cancel = () => prompts.cancel("Operation cancelled");
+function isEmpty(path$1) {
+	const files = fs.readdirSync(path$1);
+	return files.length === 0 || files.length === 1 && files[0] === ".git";
 }
 function emptyDir(dir) {
-  if (!fs3.existsSync(dir)) {
-    return;
-  }
-  for (const file of fs3.readdirSync(dir)) {
-    if (file === ".git") {
-      continue;
-    }
-    fs3.rmSync(path3.resolve(dir, file), { recursive: true, force: true });
-  }
+	if (!fs.existsSync(dir)) return;
+	for (const file of fs.readdirSync(dir)) {
+		if (file === ".git") continue;
+		fs.rmSync(path.resolve(dir, file), {
+			recursive: true,
+			force: true
+		});
+	}
 }
 async function init(argTargetDir) {
-  prompts.intro("Initialize Bf6 Mod");
-  const path6 = argTargetDir ? argTargetDir : await prompts.text({
-    message: "Where should we create your project?",
-    placeholder: "./ace-pursuit",
-    validate: (value) => {
-      if (!value) return "Please enter a path.";
-      if (value[0] !== ".") return "Please enter a relative path.";
-    }
-  });
-  if (prompts.isCancel(path6)) return cancel2();
-  let name = await prompts.text({
-    message: "What is the name of your mod?",
-    placeholder: "Ace Pursuit",
-    validate: (value) => {
-      if (!value.trim()) return "Please enter a name.";
-    }
-  });
-  if (prompts.isCancel(name)) return cancel2();
-  name = name.trim();
-  if (fs3.existsSync(path6) && !isEmpty(path6)) {
-    let overwrite;
-    const res = await prompts.select({
-      message: (path6 === "." ? "Current directory" : `Target directory "${path6}"`) + ` is not empty. Please choose how to proceed:`,
-      options: [
-        {
-          label: "Cancel operation",
-          value: "no"
-        },
-        {
-          label: "Remove existing files and continue",
-          value: "yes"
-        },
-        {
-          label: "Ignore files and continue",
-          value: "ignore"
-        }
-      ]
-    });
-    if (prompts.isCancel(res)) return cancel2();
-    overwrite = res;
-    switch (overwrite) {
-      case "yes":
-        emptyDir(path6);
-        break;
-      case "no":
-        cancel2();
-        return;
-    }
-  }
-  const template = await prompts.select({
-    message: "Select a template:",
-    options: templates.map((template2) => {
-      return {
-        label: template2,
-        value: template2
-      };
-    })
-  });
-  if (prompts.isCancel(template)) return cancel2();
-  await startProject(path6, template, name);
-  const s = prompts.spinner();
-  s.start("Installing via npm");
-  const installed = installDependencies(path6);
-  if (installed) s.stop("Installed via npm");
-  else s.stop("Failed to install via npm", 1);
-  const nextSteps = `cd ${path6}
-npm run build`;
-  prompts.note(nextSteps, "Next steps.");
+	prompts.intro("Initialize Bf6 Mod");
+	const path$1 = argTargetDir ? argTargetDir : await prompts.text({
+		message: "Where should we create your project?",
+		placeholder: "./ace-pursuit",
+		validate: (value) => {
+			if (!value) return "Please enter a path.";
+			if (value[0] !== ".") return "Please enter a relative path.";
+		}
+	});
+	if (prompts.isCancel(path$1)) return cancel();
+	let name = await prompts.text({
+		message: "What is the name of your mod?",
+		placeholder: "Ace Pursuit",
+		validate: (value) => {
+			if (!value.trim()) return "Please enter a name.";
+		}
+	});
+	if (prompts.isCancel(name)) return cancel();
+	name = name.trim();
+	if (fs.existsSync(path$1) && !isEmpty(path$1)) {
+		let overwrite;
+		const res = await prompts.select({
+			message: (path$1 === "." ? "Current directory" : `Target directory "${path$1}"`) + ` is not empty. Please choose how to proceed:`,
+			options: [
+				{
+					label: "Cancel operation",
+					value: "no"
+				},
+				{
+					label: "Remove existing files and continue",
+					value: "yes"
+				},
+				{
+					label: "Ignore files and continue",
+					value: "ignore"
+				}
+			]
+		});
+		if (prompts.isCancel(res)) return cancel();
+		overwrite = res;
+		switch (overwrite) {
+			case "yes":
+				emptyDir(path$1);
+				break;
+			case "no":
+				cancel();
+				return;
+		}
+	}
+	const template = await prompts.select({
+		message: "Select a template:",
+		options: templates.map((template$1) => {
+			return {
+				label: template$1,
+				value: template$1
+			};
+		})
+	});
+	if (prompts.isCancel(template)) return cancel();
+	await startProject(path$1, template, name);
+	const s = prompts.spinner();
+	s.start("Installing via npm");
+	if (installDependencies(path$1)) s.stop("Installed via npm");
+	else s.stop("Failed to install via npm", 1);
+	const nextSteps = `cd ${path$1}\nnpm run build`;
+	prompts.note(nextSteps, "Next steps.");
 }
 
-// src/cli/import.ts
+//#endregion
+//#region src/cli/import.ts
 async function writeFileSafe(filePath, data) {
-  const dir = path4.dirname(filePath);
-  await fs4.promises.mkdir(dir, { recursive: true });
-  await fs4.promises.writeFile(filePath, data);
+	const dir = path.dirname(filePath);
+	await fs.promises.mkdir(dir, { recursive: true });
+	await fs.promises.writeFile(filePath, data);
 }
 function getMapKeyByValue(value) {
-  return Object.keys(MapId).find(
-    (k) => MapId[k] === value
-  );
+	return Object.keys(MapId).find((k) => MapId[k] === value);
 }
 async function importFile(input, output, name) {
-  const workingDir = path4.resolve(".");
-  const entrypoint = path4.resolve(workingDir, input);
-  const outDir = path4.resolve(workingDir, output);
-  if (!fs4.existsSync(entrypoint)) throw new Error("Cannot find strings file");
-  const config = JSON.parse(
-    await fs4.promises.readFile(entrypoint, { encoding: "utf8" })
-  );
-  if (!fs4.existsSync(outDir))
-    await fs4.promises.mkdir(outDir, { recursive: true });
-  await startProject(outDir, "None", name ?? config.name);
-  let typescriptFile;
-  let stringsFile;
-  const scenes = [];
-  const promises = [];
-  if (config.attachments) {
-    for (const attachment of config.attachments) {
-      if (attachment.attachmentType === AttachmentType2.TypeScript)
-        typescriptFile = attachment.filename;
-      if (attachment.attachmentType === AttachmentType2.Strings)
-        stringsFile = attachment.filename;
-      if (attachment.attachmentType === AttachmentType2.SpatialData) {
-        continue;
-      }
-      promises.push(
-        writeFileSafe(
-          path4.resolve(outDir, "src", attachment.filename),
-          atob(attachment.attachmentData.original)
-        )
-      );
-    }
-  }
-  if (config.mapRotation?.length) {
-    for (const map of config.mapRotation) {
-      promises.push(
-        writeFileSafe(
-          path4.resolve(outDir, "src", "scenes", map.spatialAttachment.filename),
-          atob(map.spatialAttachment.attachmentData.original)
-        )
-      );
-      scenes.push([map.id, `src/scenes/${map.spatialAttachment.filename}`]);
-    }
-  }
-  const bf6Config = {
-    name: name ?? config.name,
-    description: config.description,
-    outDir: "dist",
-    entrypoint: typescriptFile ? `src/${typescriptFile}` : void 0,
-    scenes: scenes ? scenes.map(([id, path6]) => [
-      `MapId.${getMapKeyByValue(id) ?? id}`,
-      path6
-    ]) : void 0,
-    strings: stringsFile ? `src/${stringsFile}` : void 0,
-    game: {
-      mutators: config.mutators,
-      assetRestrictions: config.assetRestrictions,
-      gameMode: config.gameMode,
-      teamComposition: config.teamComposition
-    }
-  };
-  const bf6ConfigContent = `export default defineBf6Config(${stringifyWithRaw(
-    bf6Config
-  )});
-`;
-  promises.push(
-    writeFileSafe(path4.resolve(outDir, "bf6.config.ts"), bf6ConfigContent)
-  );
-  await Promise.all(promises);
+	const workingDir = path.resolve(".");
+	const entrypoint = path.resolve(workingDir, input);
+	const outDir = path.resolve(workingDir, output);
+	if (!fs.existsSync(entrypoint)) throw new Error("Cannot find strings file");
+	const config = JSON.parse(await fs.promises.readFile(entrypoint, { encoding: "utf8" }));
+	if (!fs.existsSync(outDir)) await fs.promises.mkdir(outDir, { recursive: true });
+	await startProject(outDir, "None", name ?? config.name);
+	let typescriptFile;
+	let stringsFile;
+	const scenes = [];
+	const promises = [];
+	if (config.attachments) for (const attachment of config.attachments) {
+		if (attachment.attachmentType === AttachmentType.TypeScript) typescriptFile = attachment.filename;
+		if (attachment.attachmentType === AttachmentType.Strings) stringsFile = attachment.filename;
+		if (attachment.attachmentType === AttachmentType.SpatialData) continue;
+		promises.push(writeFileSafe(path.resolve(outDir, "src", attachment.filename), atob(attachment.attachmentData.original)));
+	}
+	if (config.mapRotation?.length) for (const map of config.mapRotation) {
+		promises.push(writeFileSafe(path.resolve(outDir, "src", "scenes", map.spatialAttachment.filename), atob(map.spatialAttachment.attachmentData.original)));
+		scenes.push([map.id, `src/scenes/${map.spatialAttachment.filename}`]);
+	}
+	const bf6ConfigContent = `export default defineBf6Config(${stringifyWithRaw({
+		name: name ?? config.name,
+		description: config.description,
+		outDir: "dist",
+		entrypoint: typescriptFile ? `src/${typescriptFile}` : void 0,
+		scenes: scenes ? scenes.map(([id, path$1]) => [`MapId.${getMapKeyByValue(id) ?? id}`, path$1]) : void 0,
+		strings: stringsFile ? `src/${stringsFile}` : void 0,
+		game: {
+			mutators: config.mutators,
+			assetRestrictions: config.assetRestrictions,
+			gameMode: config.gameMode,
+			teamComposition: config.teamComposition
+		}
+	})});\n`;
+	promises.push(writeFileSafe(path.resolve(outDir, "bf6.config.ts"), bf6ConfigContent));
+	await Promise.all(promises);
 }
 function stringifyWithRaw(value, options = {}) {
-  return stringifyObject(value, {
-    indent: "    ",
-    // 4 spaces
-    singleQuotes: true,
-    transform: (_obj, _prop, originalResult) => {
-      if (/^['"]MapId\.[A-Za-z0-9_]+['"]$/.test(originalResult)) {
-        return originalResult.slice(1, -1);
-      }
-      return originalResult;
-    },
-    ...options
-  });
+	return stringifyObject(value, {
+		indent: "    ",
+		singleQuotes: true,
+		transform: (_obj, _prop, originalResult) => {
+			if (/^['"]MapId\.[A-Za-z0-9_]+['"]$/.test(originalResult)) return originalResult.slice(1, -1);
+			return originalResult;
+		},
+		...options
+	});
 }
 
-// src/cli/prepare.ts
-import fs5 from "fs";
-import path5 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import colors3 from "colors";
-import { genExport, genInlineTypeImport } from "knitwork";
-
-// src/cli/utils.ts
-import colors2 from "colors";
-
-// ../../node_modules/ansi-regex/index.js
-function ansiRegex({ onlyFirst = false } = {}) {
-  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
-  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
-  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
-  const pattern = `${osc}|${csi}`;
-  return new RegExp(pattern, onlyFirst ? void 0 : "g");
-}
-
-// ../../node_modules/strip-ansi/index.js
-var regex = ansiRegex();
-function stripAnsi(string) {
-  if (typeof string !== "string") {
-    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
-  }
-  return string.replace(regex, "");
-}
-
-// src/cli/utils.ts
-var printToConsole = (message) => {
-  const now = /* @__PURE__ */ new Date();
-  const formattedTime = colors2.grey(now.toLocaleTimeString());
-  const terminalWidth = process.stdout.columns || 80;
-  const timeLength = stripAnsi(formattedTime).length;
-  const messageLength = stripAnsi(message).length;
-  const available = terminalWidth - (messageLength + timeLength);
-  const spacing = available > 1 ? " ".repeat(available) : " ";
-  console.log(`${message}${spacing}${formattedTime}`);
-};
-
-// src/cli/prepare.ts
+//#endregion
+//#region src/cli/prepare.ts
 async function prepare() {
-  try {
-    const __filename3 = fileURLToPath3(import.meta.url);
-    const __dirname3 = path5.dirname(__filename3);
-    const _workingDir = path5.resolve(".");
-    const buildDir = path5.resolve(".bf6");
-    const resources = path5.resolve(__dirname3, "../resources/prepare");
-    fs5.cpSync(
-      path5.resolve(resources, "tsconfig.json"),
-      path5.resolve(buildDir, "tsconfig.json")
-    );
-    fs5.cpSync(
-      path5.resolve(resources, "bf6.d.ts"),
-      path5.resolve(buildDir, "bf6.d.ts")
-    );
-    fs5.cpSync(
-      path5.resolve(resources, "types", "config.ts"),
-      path5.resolve(buildDir, "types", "config.ts")
-    );
-    const ConfigFileExports = genExport("./types/config.ts", [
-      "defineBf6Config"
-    ]);
-    fs5.writeFileSync(
-      path5.resolve(buildDir, "imports.d.ts"),
-      `${ConfigFileExports}
-`
-    );
-    const augmentations = {
-      defineBf6Config: genInlineTypeImport(
-        "./types/config.ts",
-        `defineBf6Config`
-      ),
-      MapId: genInlineTypeImport("./types/config.ts", `MapId`)
-    };
-    const args = genNamespaceAugmentation("global", augmentations);
-    fs5.writeFileSync(
-      path5.resolve(buildDir, "globals.d.ts"),
-      `export {}
-
-${args}
-`
-    );
-    printToConsole(`${colors3.green("\u2714")} Types generated in .bf6`);
-  } catch (error) {
-    console.error(error);
-    printToConsole(`${colors3.red("\u2717")} Types failed to generate in .bf6`);
-  }
+	try {
+		const __filename$2 = fileURLToPath(import.meta.url);
+		const __dirname$2 = path.dirname(__filename$2);
+		path.resolve(".");
+		const buildDir = path.resolve(".bf6");
+		const resources = path.resolve(__dirname$2, "../resources/prepare");
+		fs.cpSync(path.resolve(resources, "tsconfig.json"), path.resolve(buildDir, "tsconfig.json"));
+		fs.cpSync(path.resolve(resources, "bf6.d.ts"), path.resolve(buildDir, "bf6.d.ts"));
+		fs.cpSync(path.resolve(resources, "types", "config.ts"), path.resolve(buildDir, "types", "config.ts"));
+		const ConfigFileExports = genExport("./types/config.ts", ["defineBf6Config"]);
+		fs.writeFileSync(path.resolve(buildDir, "imports.d.ts"), `${ConfigFileExports}\n`);
+		const args = genNamespaceAugmentation("global", {
+			defineBf6Config: genInlineTypeImport("./types/config.ts", `defineBf6Config`),
+			MapId: genInlineTypeImport("./types/config.ts", `MapId`)
+		});
+		fs.writeFileSync(path.resolve(buildDir, "globals.d.ts"), `export {}\n\n${args}\n`);
+		printToConsole(`${colors.green.bold("✓")} Types generated in .bf6`);
+	} catch (error) {
+		console.error(error);
+		printToConsole(`${colors.red.bold("✗")} Types failed to generate in .bf6`, true);
+	}
 }
-var genNamespaceAugmentation = (name, contents) => {
-  if (!contents || Object.keys(contents).length === 0)
-    return `declare ${name} {}`;
-  const decls = Object.entries(contents).map(([k, v]) => `	const ${k}: ${v};`).join("\n");
-  return `declare ${name} {
-${decls}
-}`;
+const genNamespaceAugmentation = (name, contents) => {
+	if (!contents || Object.keys(contents).length === 0) return `declare ${name} {}`;
+	return `declare ${name} {\n${Object.entries(contents).map(([k, v]) => `\tconst ${k}: ${v};`).join("\n")}\n}`;
 };
 
-// src/cli/index.ts
-var program = new Command();
-program.name(Object.keys(package_default.bin)[0]).description(package_default.description).version(package_default.version);
+//#endregion
+//#region src/cli/index.ts
+const program = new Command();
+program.name(Object.keys(bin)[0]).description(description).version(version);
 program.command("init").argument("[directory]").description("Create a new bf6 mod").action(async (directory) => {
-  await init(directory);
+	await init(directory);
 });
 program.command("build").description("build the bf6 mod").action(async () => {
-  await build();
+	await build();
 });
 program.command("prepare").description("prepare the types for bf6 mod").action(async () => {
-  await prepare();
+	await prepare();
 });
 program.command("dev").description("watch the changes in src, and recompile as needed").action(async () => {
-  await dev();
+	await dev();
 });
 program.command("import").argument("<input>").argument("<output>").description("decompiles the json config of a mod into a new project").action(async (input, output) => {
-  await importFile(input, output);
-  installDependencies(output);
+	await importFile(input, output);
+	installDependencies(output);
+});
+program.command("log").argument("[input]").description("logs the output from a locally running server").action(async (input) => {
+	new Bf6Logger(input).start();
 });
 program.exitOverride((_err) => {
-  if (process.env.EXIT_CODE === "none") process.exit(0);
+	if (process.env.EXIT_CODE === "none") process.exit(0);
 });
 program.parse();
+
+//#endregion
+export {  };
 //# sourceMappingURL=index.js.map