killscript 0.1.0

package/dist/cli.js

@@ -0,0 +1,2571 @@
+#!/usr/bin/env node
+import {
+  VERSION
+} from "./chunk-T3XTQIWG.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/build.ts
+import path6 from "path";
+
+// src/config.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+var PROJECT_CONFIG_FILE = "killscript.config.json";
+function createProjectConfig(input) {
+  return {
+    id: randomUUID(),
+    name: input.name,
+    version: "0.1.0",
+    author: input.author ?? "",
+    reflex: input.reflex ?? false
+  };
+}
+async function readProjectConfig(projectDir) {
+  const file = path.join(projectDir, PROJECT_CONFIG_FILE);
+  const parsed = JSON.parse(await readFile(file, "utf8"));
+  validateProjectConfig(parsed);
+  return parsed;
+}
+async function writeProjectConfig(projectDir, config) {
+  await writeFile(
+    path.join(projectDir, PROJECT_CONFIG_FILE),
+    `${JSON.stringify(config, null, 2)}
+`
+  );
+}
+async function readLocalConfig(projectDir) {
+  try {
+    const parsed = JSON.parse(
+      await readFile(path.join(projectDir, ".killscript", "local.json"), "utf8")
+    );
+    if (parsed.modulesPath !== void 0 && typeof parsed.modulesPath !== "string") {
+      throw new Error(".killscript/local.json has an invalid modulesPath.");
+    }
+    if (parsed.installedTarget !== void 0 && typeof parsed.installedTarget !== "string") {
+      throw new Error(".killscript/local.json has an invalid installedTarget.");
+    }
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
+  }
+}
+async function writeLocalConfig(projectDir, config) {
+  await mkdir(path.join(projectDir, ".killscript"), { recursive: true });
+  await writeFile(
+    path.join(projectDir, ".killscript", "local.json"),
+    `${JSON.stringify(config, null, 2)}
+`
+  );
+}
+function validateProjectConfig(config) {
+  if (typeof config.id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(config.id)) {
+    throw new Error(`${PROJECT_CONFIG_FILE}: id must be a UUID.`);
+  }
+  if (typeof config.name !== "string" || !/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(config.name)) {
+    throw new Error(`${PROJECT_CONFIG_FILE}: name must be a safe module name (1-64 characters).`);
+  }
+  if (typeof config.version !== "string" || !/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(config.version)) {
+    throw new Error(`${PROJECT_CONFIG_FILE}: version must be semantic, for example 1.2.0.`);
+  }
+  if (typeof config.author !== "string" || config.author.length > 128) {
+    throw new Error(`${PROJECT_CONFIG_FILE}: author must be a string up to 128 characters.`);
+  }
+  if (config.description !== void 0 && (typeof config.description !== "string" || config.description.length > 500)) {
+    throw new Error(`${PROJECT_CONFIG_FILE}: description must be a string up to 500 characters.`);
+  }
+  if (typeof config.reflex !== "boolean") {
+    throw new Error(`${PROJECT_CONFIG_FILE}: reflex must be true or false.`);
+  }
+  if (config.tags !== void 0 && (!Array.isArray(config.tags) || config.tags.length > 16 || config.tags.some((tag) => typeof tag !== "string" || !/^[A-Za-z0-9][A-Za-z0-9 _-]{0,31}$/.test(tag)) || new Set(config.tags.map((tag) => tag.toLowerCase())).size !== config.tags.length)) {
+    throw new Error(`${PROJECT_CONFIG_FILE}: tags must contain up to 16 unique safe strings.`);
+  }
+}
+
+// src/compiler/build.ts
+import { cp, lstat, mkdir as mkdir2, readdir, rm, stat, writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
+
+// src/compiler/errors.ts
+var CompileError = class extends Error {
+  file;
+  position;
+  constructor(message, node) {
+    super(message);
+    this.name = "CompileError";
+    let file;
+    let position;
+    if (node !== void 0) {
+      try {
+        file = node.getSourceFile();
+        if (file !== void 0) position = node.getStart(file);
+      } catch {
+      }
+    }
+    this.file = file;
+    this.position = position;
+  }
+};
+function formatCompileError(error) {
+  if (error.file === void 0 || error.position === void 0) return error.message;
+  const location = error.file.getLineAndCharacterOfPosition(error.position);
+  return `${error.file.fileName}:${location.line + 1}:${location.character + 1} - ${error.message}`;
+}
+
+// src/compiler/compile-context.ts
+import path3 from "path";
+import * as ts3 from "typescript";
+import {
+  LuaLibImportKind,
+  LuaTarget,
+  Transpiler
+} from "typescript-to-lua";
+
+// src/compiler/extract.ts
+import path2 from "path";
+import * as ts from "typescript";
+var keyboardPaths = Object.fromEntries([
+  ..."ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((key) => [key, key.toLowerCase()]),
+  ...Array.from({ length: 12 }, (_, index) => [`F${index + 1}`, `f${index + 1}`]),
+  ["Space", "space"],
+  ["Enter", "enter"],
+  ["Escape", "escape"],
+  ["Tab", "tab"],
+  ["Backspace", "backspace"],
+  ["LeftShift", "leftShift"],
+  ["RightShift", "rightShift"],
+  ["LeftCtrl", "leftCtrl"],
+  ["RightCtrl", "rightCtrl"],
+  ["LeftAlt", "leftAlt"],
+  ["RightAlt", "rightAlt"],
+  ["Up", "upArrow"],
+  ["Down", "downArrow"],
+  ["Left", "leftArrow"],
+  ["Right", "rightArrow"],
+  ...Array.from({ length: 10 }, (_, index) => [`Digit${index}`, String(index)]),
+  ["Home", "home"],
+  ["End", "end"],
+  ["PageUp", "pageUp"],
+  ["PageDown", "pageDown"],
+  ["Insert", "insert"],
+  ["Delete", "delete"],
+  ["CapsLock", "capsLock"],
+  ["Comma", "comma"],
+  ["Period", "period"],
+  ["Slash", "slash"],
+  ["Semicolon", "semicolon"],
+  ["Quote", "quote"],
+  ["Backquote", "backquote"],
+  ["Minus", "minus"],
+  ["Equals", "equals"],
+  ["LeftBracket", "leftBracket"],
+  ["RightBracket", "rightBracket"],
+  ["Backslash", "backslash"]
+]);
+var mousePaths = {
+  Left: "leftButton",
+  Right: "rightButton",
+  Middle: "middleButton",
+  Back: "backButton",
+  Forward: "forwardButton",
+  Scroll: "scroll",
+  Delta: "delta",
+  Position: "position"
+};
+var gamepadPaths = {
+  South: "buttonSouth",
+  East: "buttonEast",
+  West: "buttonWest",
+  North: "buttonNorth",
+  LeftShoulder: "leftShoulder",
+  RightShoulder: "rightShoulder",
+  LeftTrigger: "leftTrigger",
+  RightTrigger: "rightTrigger",
+  LeftStick: "leftStick",
+  RightStick: "rightStick",
+  LeftStickPress: "leftStickPress",
+  RightStickPress: "rightStickPress",
+  Dpad: "dpad",
+  DpadUp: "dpad/up",
+  DpadDown: "dpad/down",
+  DpadLeft: "dpad/left",
+  DpadRight: "dpad/right",
+  Start: "start",
+  Select: "select"
+};
+function extractMacros(program2, projectSourceDir) {
+  const checker = program2.getTypeChecker();
+  const bindings = collectBindings(program2, checker);
+  const settings = [];
+  const controls = [];
+  const settingsHandles = /* @__PURE__ */ new Map();
+  const controlsHandles = /* @__PURE__ */ new Map();
+  const networkHandles = /* @__PURE__ */ new Map();
+  for (const sourceFile of program2.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile || !isInside(sourceFile.fileName, projectSourceDir)) {
+      continue;
+    }
+    visitSourceFile(sourceFile);
+  }
+  assertUnique(settings, (item) => item.key, "setting");
+  assertUnique(controls, (item) => item.name, "control");
+  return { settings, controls, settingsHandles, controlsHandles, networkHandles, bindings };
+  function visitSourceFile(sourceFile) {
+    const visit = (node) => {
+      if (ts.isCallExpression(node)) {
+        if (isImportedIdentifier(node.expression, bindings.defineSettings, checker)) {
+          registerSettings(node);
+        } else if (isImportedIdentifier(node.expression, bindings.defineControls, checker)) {
+          registerControls(node);
+        } else if (isImportedIdentifier(node.expression, bindings.defineNetwork, checker)) {
+          registerNetwork(node);
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+  }
+  function registerNetwork(call) {
+    const declaration = getTopLevelVariableDeclaration(call, "defineNetwork");
+    if (call.arguments.length > 1) {
+      throw new CompileError("defineNetwork() accepts only an optional namespace.", call);
+    }
+    const namespace = call.arguments[0] === void 0 ? void 0 : readString(call.arguments[0]);
+    if (namespace !== void 0 && !/^[A-Za-z0-9_.-]+$/.test(namespace)) {
+      throw new CompileError("Network namespace may contain letters, numbers, _, . and -.", call);
+    }
+    const symbol = checker.getSymbolAtLocation(declaration.name);
+    if (symbol === void 0) throw new CompileError("Unable to resolve network handle.", declaration);
+    networkHandles.set(symbol, { ...namespace === void 0 ? {} : { namespace } });
+  }
+  function registerSettings(call) {
+    const declaration = getTopLevelVariableDeclaration(call, "defineSettings");
+    const { namespace, object } = readDefinitionArguments(call, "defineSettings");
+    const properties = /* @__PURE__ */ new Map();
+    for (const property of object.properties) {
+      if (!ts.isPropertyAssignment(property)) {
+        throw new CompileError("Settings must use plain property assignments.", property);
+      }
+      const sourceName = readPropertyName(property.name);
+      const key = namespace === void 0 ? sourceName : `${namespace}.${sourceName}`;
+      assertRegistrationId(key, "setting", property.name);
+      const registration = parseSetting(sourceName, key, property.initializer);
+      properties.set(sourceName, registration);
+      settings.push(registration);
+    }
+    const symbol = checker.getSymbolAtLocation(declaration.name);
+    if (symbol === void 0) throw new CompileError("Unable to resolve settings handle.", declaration);
+    settingsHandles.set(symbol, { properties });
+  }
+  function registerControls(call) {
+    const declaration = getTopLevelVariableDeclaration(call, "defineControls");
+    const { namespace, object } = readDefinitionArguments(call, "defineControls");
+    const properties = /* @__PURE__ */ new Map();
+    for (const property of object.properties) {
+      if (!ts.isPropertyAssignment(property)) {
+        throw new CompileError("Controls must use plain property assignments.", property);
+      }
+      const sourceName = readPropertyName(property.name);
+      const name = namespace === void 0 ? sourceName : `${namespace}.${sourceName}`;
+      assertRegistrationId(name, "control", property.name);
+      const registration = parseControl(sourceName, name, property.initializer);
+      properties.set(sourceName, registration);
+      controls.push(registration);
+    }
+    const symbol = checker.getSymbolAtLocation(declaration.name);
+    if (symbol === void 0) throw new CompileError("Unable to resolve controls handle.", declaration);
+    controlsHandles.set(symbol, { properties });
+  }
+  function parseSetting(sourceName, key, expression) {
+    expression = unwrap(expression);
+    const label = humanize(sourceName);
+    if (expression.kind === ts.SyntaxKind.TrueKeyword || expression.kind === ts.SyntaxKind.FalseKeyword) {
+      return { sourceName, key, label, type: "bool", value: expression.kind === ts.SyntaxKind.TrueKeyword };
+    }
+    if (ts.isNumericLiteral(expression) || isNegativeNumber(expression)) {
+      return { sourceName, key, label, type: "number", value: readNumber(expression) };
+    }
+    if (!ts.isCallExpression(expression)) {
+      throw new CompileError(
+        "Use a boolean, number or setting(...) declaration for this setting.",
+        expression
+      );
+    }
+    const callKind = getSettingCallKind(expression.expression);
+    if (callKind === void 0) {
+      throw new CompileError("Unsupported setting declaration.", expression);
+    }
+    if (callKind === "setting") {
+      const defaultValue = expression.arguments[0];
+      if (defaultValue === void 0) throw new CompileError("setting() needs a default value.", expression);
+      const options2 = readOptions(expression.arguments[1]);
+      const value = unwrap(defaultValue);
+      if (value.kind === ts.SyntaxKind.TrueKeyword || value.kind === ts.SyntaxKind.FalseKeyword) {
+        return {
+          sourceName,
+          key,
+          label: options2.label ?? label,
+          type: "bool",
+          value: value.kind === ts.SyntaxKind.TrueKeyword
+        };
+      }
+      const numericValue = readNumber(value);
+      validateNumberOptions(numericValue, options2, expression);
+      return {
+        sourceName,
+        key,
+        label: options2.label ?? label,
+        type: "number",
+        value: numericValue,
+        ...options2.min === void 0 ? {} : { min: options2.min },
+        ...options2.max === void 0 ? {} : { max: options2.max }
+      };
+    }
+    if (callKind === "choice") {
+      const choices = readStringArray(requiredArgument(expression, 0));
+      validateChoices(choices, expression);
+      const defaultValue = readString(requiredArgument(expression, 1));
+      const defaultIndex = choices.indexOf(defaultValue);
+      if (defaultIndex < 0) {
+        throw new CompileError(`Default choice '${defaultValue}' is not in the options.`, expression);
+      }
+      const options2 = readOptions(expression.arguments[2]);
+      return {
+        sourceName,
+        key,
+        label: options2.label ?? label,
+        type: "enum",
+        value: defaultIndex,
+        options: choices
+      };
+    }
+    if (callKind === "flags") {
+      const choices = readStringArray(requiredArgument(expression, 0));
+      validateChoices(choices, expression);
+      if (choices.length > 31) throw new CompileError("Flag settings support at most 31 options.", expression);
+      const defaults = expression.arguments[1] === void 0 ? [] : readStringArray(expression.arguments[1]);
+      let mask = 0;
+      for (const item of defaults) {
+        const index = choices.indexOf(item);
+        if (index < 0) throw new CompileError(`Default flag '${item}' is not in the options.`, expression);
+        mask |= 1 << index;
+      }
+      const options2 = readOptions(expression.arguments[2]);
+      return {
+        sourceName,
+        key,
+        label: options2.label ?? label,
+        type: "maskEnum",
+        value: mask,
+        options: choices
+      };
+    }
+    const rgba = readColor(requiredArgument(expression, 0));
+    if (rgba.some((component) => component < 0 || component > 1)) {
+      throw new CompileError("Color components must be between 0 and 1.", expression);
+    }
+    const options = readOptions(expression.arguments[1]);
+    return {
+      sourceName,
+      key,
+      label: options.label ?? label,
+      type: "color",
+      value: rgba
+    };
+  }
+  function parseControl(sourceName, name, rawExpression) {
+    const expression = unwrap(rawExpression);
+    const directPath = readBindingConstant(expression);
+    if (directPath !== void 0) {
+      return { sourceName, name, type: "Button", binding: { path: directPath } };
+    }
+    if (!ts.isCallExpression(expression)) {
+      throw new CompileError("Use Keyboard.*, Mouse.* or control(...) for a control.", expression);
+    }
+    const kind = getControlCallKind(expression.expression);
+    if (kind === void 0) throw new CompileError("Unsupported control declaration.", expression);
+    if (kind === "raw") {
+      const definition = readObject(requiredArgument(expression, 0));
+      assertKnownKeys(definition, ["type", "binding"], expression);
+      const type = readControlType(definition.get("type"), expression);
+      const bindingNode2 = definition.get("binding");
+      if (bindingNode2 === void 0) throw new CompileError("Raw control needs a binding.", expression);
+      return { sourceName, name, type, binding: readBinding(bindingNode2) };
+    }
+    if (["hold", "tap", "multiTap", "onRelease"].includes(kind)) {
+      const binding = readBinding(requiredArgument(expression, 0));
+      if (kind === "onRelease") {
+        return {
+          sourceName,
+          name,
+          type: "Button",
+          binding: { ...binding, interactions: "press(behavior=1)" }
+        };
+      }
+      if (kind === "multiTap") {
+        const tapCount = expression.arguments[1] === void 0 ? 2 : readNumber(expression.arguments[1]);
+        const maxDelay = expression.arguments[2] === void 0 ? 0.3 : readNumber(expression.arguments[2]);
+        if (!Number.isInteger(tapCount) || tapCount < 2) {
+          throw new CompileError("control.multiTap() needs an integer tap count of at least 2.", expression);
+        }
+        if (maxDelay <= 0) {
+          throw new CompileError("control.multiTap() max delay must be greater than zero.", expression);
+        }
+        return {
+          sourceName,
+          name,
+          type: "Button",
+          binding: {
+            ...binding,
+            interactions: `multiTap(tapCount=${tapCount},tapDelay=${maxDelay})`
+          }
+        };
+      }
+      const duration = expression.arguments[1] === void 0 ? kind === "hold" ? 0.4 : 0.2 : readNumber(expression.arguments[1]);
+      if (duration <= 0) {
+        throw new CompileError(`control.${kind}() duration must be greater than zero.`, expression);
+      }
+      return {
+        sourceName,
+        name,
+        type: "Button",
+        binding: { ...binding, interactions: `${kind}(duration=${duration})` }
+      };
+    }
+    const bindingNode = requiredArgument(expression, 0);
+    const options = expression.arguments[1] === void 0 ? /* @__PURE__ */ new Map() : readObject(expression.arguments[1]);
+    assertKnownKeys(options, ["type"], expression);
+    const typeNode = options.get("type");
+    return {
+      sourceName,
+      name,
+      type: typeNode === void 0 ? "Button" : readControlType(typeNode, expression),
+      binding: readBinding(bindingNode)
+    };
+  }
+  function getSettingCallKind(expression) {
+    if (isImportedIdentifier(expression, bindings.setting, checker)) return "setting";
+    if (ts.isPropertyAccessExpression(expression) && isImportedIdentifier(expression.expression, bindings.setting, checker)) {
+      if (["choice", "flags", "color"].includes(expression.name.text)) {
+        return expression.name.text;
+      }
+    }
+    return void 0;
+  }
+  function getControlCallKind(expression) {
+    if (isImportedIdentifier(expression, bindings.control, checker)) return "control";
+    if (ts.isPropertyAccessExpression(expression) && isImportedIdentifier(expression.expression, bindings.control, checker)) {
+      if (["raw", "hold", "tap", "multiTap", "onRelease"].includes(expression.name.text)) {
+        return expression.name.text;
+      }
+    }
+    return void 0;
+  }
+  function readBinding(expression) {
+    expression = unwrap(expression);
+    const constant = readBindingConstant(expression);
+    if (constant !== void 0) return { path: constant };
+    if (ts.isStringLiteralLike(expression)) return { path: expression.text };
+    const object = readObject(expression);
+    assertKnownKeys(object, ["path", "interactions", "processors", "groups"], expression);
+    const pathNode = object.get("path");
+    if (pathNode === void 0) throw new CompileError("Binding needs a path.", expression);
+    const pathValue = readBindingConstant(unwrap(pathNode)) ?? readString(pathNode);
+    const interactions = readOptionalString(object.get("interactions"));
+    const processors = readOptionalString(object.get("processors"));
+    const groups = readOptionalString(object.get("groups"));
+    return {
+      path: pathValue,
+      ...interactions === void 0 ? {} : { interactions },
+      ...processors === void 0 ? {} : { processors },
+      ...groups === void 0 ? {} : { groups }
+    };
+  }
+  function readBindingConstant(expression) {
+    if (!ts.isPropertyAccessExpression(expression)) return void 0;
+    if (isImportedIdentifier(expression.expression, bindings.keyboard, checker)) {
+      const value = keyboardPaths[expression.name.text];
+      if (value === void 0) throw new CompileError(`Unknown keyboard key '${expression.name.text}'.`, expression);
+      return `<Keyboard>/${value}`;
+    }
+    if (isImportedIdentifier(expression.expression, bindings.mouse, checker)) {
+      const value = mousePaths[expression.name.text];
+      if (value === void 0) throw new CompileError(`Unknown mouse control '${expression.name.text}'.`, expression);
+      return `<Mouse>/${value}`;
+    }
+    if (isImportedIdentifier(expression.expression, bindings.gamepad, checker)) {
+      const value = gamepadPaths[expression.name.text];
+      if (value === void 0) throw new CompileError(`Unknown gamepad control '${expression.name.text}'.`, expression);
+      return `<Gamepad>/${value}`;
+    }
+    return void 0;
+  }
+}
+function collectBindings(program2, checker) {
+  const result = {
+    defineSettings: /* @__PURE__ */ new Set(),
+    defineControls: /* @__PURE__ */ new Set(),
+    setting: /* @__PURE__ */ new Set(),
+    control: /* @__PURE__ */ new Set(),
+    keyboard: /* @__PURE__ */ new Set(),
+    mouse: /* @__PURE__ */ new Set(),
+    gamepad: /* @__PURE__ */ new Set(),
+    agents: /* @__PURE__ */ new Set(),
+    scheduler: /* @__PURE__ */ new Set(),
+    camera: /* @__PURE__ */ new Set(),
+    time: /* @__PURE__ */ new Set(),
+    arrays: /* @__PURE__ */ new Set(),
+    vector2: /* @__PURE__ */ new Set(),
+    vector3: /* @__PURE__ */ new Set(),
+    quaternion: /* @__PURE__ */ new Set(),
+    defineNetwork: /* @__PURE__ */ new Set(),
+    logger: /* @__PURE__ */ new Set(),
+    visuals: /* @__PURE__ */ new Set(),
+    input: /* @__PURE__ */ new Set(),
+    scope: /* @__PURE__ */ new Set()
+  };
+  for (const sourceFile of program2.getSourceFiles()) {
+    for (const statement of sourceFile.statements) {
+      if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || !statement.moduleSpecifier.text.startsWith("@killscript/sdk") || statement.importClause?.namedBindings === void 0 || !ts.isNamedImports(statement.importClause.namedBindings)) continue;
+      for (const specifier of statement.importClause.namedBindings.elements) {
+        const importedName = (specifier.propertyName ?? specifier.name).text;
+        const key = importNameToBinding(importedName);
+        if (key === void 0) continue;
+        const symbol = checker.getSymbolAtLocation(specifier.name);
+        if (symbol !== void 0) result[key].add(symbol);
+      }
+    }
+  }
+  return result;
+}
+function importNameToBinding(name) {
+  switch (name) {
+    case "defineSettings":
+      return "defineSettings";
+    case "defineControls":
+      return "defineControls";
+    case "setting":
+      return "setting";
+    case "control":
+      return "control";
+    case "Keyboard":
+      return "keyboard";
+    case "Mouse":
+      return "mouse";
+    case "Gamepad":
+      return "gamepad";
+    case "agents":
+      return "agents";
+    case "scheduler":
+      return "scheduler";
+    case "camera":
+      return "camera";
+    case "time":
+      return "time";
+    case "arrays":
+      return "arrays";
+    case "vector2":
+      return "vector2";
+    case "vector3":
+      return "vector3";
+    case "quaternion":
+      return "quaternion";
+    case "defineNetwork":
+      return "defineNetwork";
+    case "logger":
+      return "logger";
+    case "visuals":
+      return "visuals";
+    case "input":
+      return "input";
+    case "scope":
+      return "scope";
+    default:
+      return void 0;
+  }
+}
+function isImportedIdentifier(expression, symbols, checker) {
+  const symbol = checker.getSymbolAtLocation(expression);
+  return symbol !== void 0 && symbols.has(symbol);
+}
+function resolveAliasedSymbol(symbol, checker) {
+  return (symbol.flags & ts.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
+}
+function getTopLevelVariableDeclaration(call, macroName) {
+  const declaration = call.parent;
+  if (!ts.isVariableDeclaration(declaration) || declaration.initializer !== call || !ts.isIdentifier(declaration.name) || !ts.isVariableDeclarationList(declaration.parent) || !ts.isVariableStatement(declaration.parent.parent) || !ts.isSourceFile(declaration.parent.parent.parent)) {
+    throw new CompileError(`${macroName}() must initialize a top-level const.`, call);
+  }
+  return declaration;
+}
+function readDefinitionArguments(call, macroName) {
+  const first = call.arguments[0];
+  if (first === void 0) throw new CompileError(`${macroName}() needs a definition object.`, call);
+  if (ts.isStringLiteralLike(unwrap(first))) {
+    const second = call.arguments[1];
+    if (second === void 0) throw new CompileError(`${macroName}() needs a definition object.`, call);
+    const namespace = readString(first);
+    assertRegistrationId(namespace, `${macroName} namespace`, first);
+    return { namespace, object: readObjectLiteral(second) };
+  }
+  return { object: readObjectLiteral(first) };
+}
+function readObjectLiteral(expression) {
+  expression = unwrap(expression);
+  if (!ts.isObjectLiteralExpression(expression)) {
+    throw new CompileError("Compile-time definitions must use an object literal.", expression);
+  }
+  return expression;
+}
+function readObject(expression) {
+  const object = readObjectLiteral(expression);
+  const result = /* @__PURE__ */ new Map();
+  for (const property of object.properties) {
+    if (!ts.isPropertyAssignment(property)) {
+      throw new CompileError("Compile-time objects must use plain property assignments.", property);
+    }
+    const name = readPropertyName(property.name);
+    if (result.has(name)) throw new CompileError(`Duplicate compile-time property '${name}'.`, property);
+    result.set(name, property.initializer);
+  }
+  return result;
+}
+function readOptions(expression) {
+  if (expression === void 0) return {};
+  const object = readObject(expression);
+  assertKnownKeys(object, ["label", "min", "max"], expression);
+  const label = readOptionalString(object.get("label"));
+  const min = object.get("min") === void 0 ? void 0 : readNumber(object.get("min"));
+  const max = object.get("max") === void 0 ? void 0 : readNumber(object.get("max"));
+  if (label !== void 0 && (label.trim() === "" || label.length > 100)) {
+    throw new CompileError("Setting label must contain 1-100 characters.", expression);
+  }
+  if (min !== void 0 && max !== void 0 && min > max) {
+    throw new CompileError("Setting min cannot be greater than max.", expression);
+  }
+  return {
+    ...label === void 0 ? {} : { label },
+    ...min === void 0 ? {} : { min },
+    ...max === void 0 ? {} : { max }
+  };
+}
+function readPropertyName(name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteralLike(name) || ts.isNumericLiteral(name)) {
+    return name.text;
+  }
+  throw new CompileError("Computed property names are not supported in compile-time definitions.", name);
+}
+function readString(expression) {
+  expression = unwrap(expression);
+  if (!ts.isStringLiteralLike(expression)) throw new CompileError("Expected a string literal.", expression);
+  return expression.text;
+}
+function readOptionalString(expression) {
+  return expression === void 0 ? void 0 : readString(expression);
+}
+function readNumber(expression) {
+  expression = unwrap(expression);
+  if (ts.isNumericLiteral(expression)) return Number(expression.text);
+  if (isNegativeNumber(expression)) return -Number(expression.operand.text);
+  throw new CompileError("Expected a number literal.", expression);
+}
+function isNegativeNumber(expression) {
+  return ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(expression.operand);
+}
+function readStringArray(expression) {
+  expression = unwrap(expression);
+  if (!ts.isArrayLiteralExpression(expression)) throw new CompileError("Expected a string array literal.", expression);
+  return expression.elements.map((element) => readString(element));
+}
+function readColor(expression) {
+  expression = unwrap(expression);
+  if (ts.isStringLiteralLike(expression)) {
+    const normalized = expression.text.startsWith("#") ? expression.text.slice(1) : expression.text;
+    if (!/^[\da-f]{6}([\da-f]{2})?$/i.test(normalized)) {
+      throw new CompileError("Colors must use #RRGGBB or #RRGGBBAA.", expression);
+    }
+    return [
+      Number.parseInt(normalized.slice(0, 2), 16) / 255,
+      Number.parseInt(normalized.slice(2, 4), 16) / 255,
+      Number.parseInt(normalized.slice(4, 6), 16) / 255,
+      normalized.length === 8 ? Number.parseInt(normalized.slice(6, 8), 16) / 255 : 1
+    ];
+  }
+  if (!ts.isArrayLiteralExpression(expression) || expression.elements.length < 3 || expression.elements.length > 4) {
+    throw new CompileError("Colors need three or four numeric components.", expression);
+  }
+  return [
+    readNumber(expression.elements[0]),
+    readNumber(expression.elements[1]),
+    readNumber(expression.elements[2]),
+    expression.elements[3] === void 0 ? 1 : readNumber(expression.elements[3])
+  ];
+}
+function readControlType(expression, owner) {
+  if (expression === void 0) throw new CompileError("Control type is required.", owner);
+  const value = readString(expression);
+  if (value !== "Button" && value !== "Value" && value !== "PassThrough") {
+    throw new CompileError(`Unknown control type '${value}'.`, expression);
+  }
+  return value;
+}
+function requiredArgument(call, index) {
+  const value = call.arguments[index];
+  if (value === void 0) throw new CompileError(`Missing argument ${index + 1}.`, call);
+  return value;
+}
+function unwrap(expression) {
+  while (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isSatisfiesExpression(expression)) expression = expression.expression;
+  return expression;
+}
+function humanize(value) {
+  const spaced = value.replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/[-_.]+/g, " ").trim();
+  return spaced.length === 0 ? value : spaced[0].toUpperCase() + spaced.slice(1);
+}
+function isInside(file, directory) {
+  const relative = path2.relative(path2.resolve(directory), path2.resolve(file));
+  return relative !== "" && !relative.startsWith("..") && !path2.isAbsolute(relative);
+}
+function assertUnique(values, key, kind) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const current = key(value);
+    if (seen.has(current)) throw new CompileError(`Duplicate ${kind} id '${current}'.`);
+    seen.add(current);
+  }
+}
+function assertRegistrationId(value, kind, owner) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(value)) {
+    throw new CompileError(`${kind} id must contain only letters, numbers, _, . and - (max 96).`, owner);
+  }
+}
+function validateChoices(values, owner) {
+  if (values.length === 0) throw new CompileError("Choice settings need at least one option.", owner);
+  if (new Set(values).size !== values.length) throw new CompileError("Choice options must be unique.", owner);
+  if (values.some((value) => value.length === 0 || value.length > 64)) {
+    throw new CompileError("Choice options must contain 1-64 characters.", owner);
+  }
+}
+function validateNumberOptions(value, options, owner) {
+  if (!Number.isFinite(value)) throw new CompileError("Setting values must be finite.", owner);
+  if (options.min !== void 0 && value < options.min) {
+    throw new CompileError(`Default value ${value} is below min ${options.min}.`, owner);
+  }
+  if (options.max !== void 0 && value > options.max) {
+    throw new CompileError(`Default value ${value} is above max ${options.max}.`, owner);
+  }
+}
+function assertKnownKeys(values, allowed, owner) {
+  for (const key of values.keys()) {
+    if (!allowed.includes(key)) throw new CompileError(`Unknown compile-time option '${key}'.`, owner);
+  }
+}
+
+// src/compiler/transform.ts
+import * as ts2 from "typescript";
+function createMacroTransformer(program2, extraction) {
+  const checker = program2.getTypeChecker();
+  return (context) => {
+    const factory = context.factory;
+    const visitor = (node) => {
+      if (ts2.isVariableStatement(node)) {
+        const declarations = node.declarationList.declarations.filter(
+          (declaration) => declaration.initializer === void 0 || !isDefinitionCall(declaration.initializer)
+        );
+        if (declarations.length === 0) return void 0;
+        if (declarations.length !== node.declarationList.declarations.length) {
+          return factory.updateVariableStatement(
+            node,
+            node.modifiers,
+            factory.updateVariableDeclarationList(node.declarationList, declarations)
+          );
+        }
+      }
+      if (ts2.isImportDeclaration(node) && ts2.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text.startsWith("@killscript/sdk")) {
+        return void 0;
+      }
+      if (ts2.isImportDeclaration(node) && ts2.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text.startsWith(".") && node.moduleSpecifier.text.endsWith(".js")) {
+        return factory.updateImportDeclaration(
+          node,
+          node.modifiers,
+          node.importClause,
+          factory.createStringLiteral(node.moduleSpecifier.text.slice(0, -3)),
+          node.attributes
+        );
+      }
+      if (ts2.isExportDeclaration(node) && node.moduleSpecifier !== void 0 && ts2.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text.startsWith(".") && node.moduleSpecifier.text.endsWith(".js")) {
+        return factory.updateExportDeclaration(
+          node,
+          node.modifiers,
+          node.isTypeOnly,
+          node.exportClause,
+          factory.createStringLiteral(node.moduleSpecifier.text.slice(0, -3)),
+          node.attributes
+        );
+      }
+      if (ts2.isCallExpression(node)) {
+        const transformedCall = transformCall(node);
+        if (transformedCall !== void 0) return transformedCall;
+      }
+      if (ts2.isBinaryExpression(node)) {
+        const setting = matchSettingAccess(node.left);
+        if (setting?.type === "enum" && isAssignmentOperator(node.operatorToken.kind)) {
+          if (node.operatorToken.kind !== ts2.SyntaxKind.EqualsToken) {
+            throw new CompileError("Enum settings only support direct assignment.", node);
+          }
+          const options = setting.options ?? [];
+          const value = ts2.visitNode(node.right, visitor);
+          return factory.createBinaryExpression(
+            configAccess(setting.key),
+            factory.createToken(ts2.SyntaxKind.EqualsToken),
+            factory.createCallExpression(
+              factory.createParenthesizedExpression(
+                factory.createArrowFunction(
+                  void 0,
+                  void 0,
+                  [
+                    factory.createParameterDeclaration(
+                      void 0,
+                      void 0,
+                      factory.createIdentifier("____settingValue")
+                    )
+                  ],
+                  void 0,
+                  factory.createToken(ts2.SyntaxKind.EqualsGreaterThanToken),
+                  choiceIndexExpression(options)
+                )
+              ),
+              void 0,
+              [value]
+            )
+          );
+        }
+      }
+      if (ts2.isPropertyAccessExpression(node)) {
+        const setting = matchSettingAccess(node);
+        if (setting !== void 0) return settingRead(setting);
+        const control = matchControlAccess(node);
+        if (control !== void 0) return controlAction(control);
+        if (node.name.text === "length" && isArrayHelperResult(node.expression)) {
+          return helperCall("____killscriptTsArrayLength", [node.expression]);
+        }
+      }
+      return ts2.visitEachChild(node, visitor, context);
+    };
+    return (sourceFile) => ts2.visitNode(sourceFile, visitor);
+    function transformCall(node) {
+      if (isImportedIdentifier(node.expression, extraction.bindings.logger, checker)) {
+        return helperCall("____killscriptLogger", node.arguments);
+      }
+      if (isImportedIdentifier(node.expression, extraction.bindings.scope, checker)) {
+        if (node.arguments.length !== 0) throw new CompileError("scope() does not accept arguments.", node);
+        return helperCall("____killscriptScope", []);
+      }
+      if (isImportedIdentifier(node.expression, extraction.bindings.defineSettings, checker) || isImportedIdentifier(node.expression, extraction.bindings.defineControls, checker) || isImportedIdentifier(node.expression, extraction.bindings.defineNetwork, checker)) {
+        return factory.createObjectLiteralExpression();
+      }
+      if (ts2.isPropertyAccessExpression(node.expression)) {
+        const method = node.expression.name.text;
+        const control = matchControlAccess(node.expression.expression);
+        if (control !== void 0) return transformControlCall(control, method, node.arguments);
+        const network = matchNetworkHandle(node.expression.expression);
+        if (network !== void 0) return transformNetworkCall(network, method, node.arguments, node);
+        const owner = node.expression.expression;
+        if ((method === "reduce" || method === "reduceRight") && isTypeScriptArray(owner)) {
+          if (node.arguments.length !== 2) {
+            throw new CompileError(
+              `Array.${method}() requires an initial value in KILLSCRIPT modules.`,
+              node
+            );
+          }
+          return factory.createCallExpression(
+            factory.createIdentifier(
+              method === "reduce" ? "____killscriptTsArrayReduce" : "____killscriptTsArrayReduceRight"
+            ),
+            void 0,
+            [
+              ts2.visitNode(owner, visitor),
+              ts2.visitNode(node.arguments[0], visitor),
+              ts2.visitNode(node.arguments[1], visitor)
+            ]
+          );
+        }
+        if (isImportedIdentifier(owner, extraction.bindings.agents, checker)) {
+          if (method === "select") {
+            return helperCall("____killscriptAgentSelection", node.arguments);
+          }
+          const nativeMethod = agentMethod(method);
+          if (nativeMethod === void 0) throw new CompileError(`Unknown agents wrapper '${method}'.`, node);
+          return factory.createCallExpression(
+            factory.createPropertyAccessExpression(factory.createIdentifier("Agents"), nativeMethod),
+            void 0,
+            node.arguments.map((argument) => ts2.visitNode(argument, visitor))
+          );
+        }
+        if (isImportedIdentifier(owner, extraction.bindings.scheduler, checker)) {
+          const helper = {
+            afterTicks: "____killscriptSchedulerAfterTicks",
+            every: "____killscriptSchedulerEvery",
+            everyTicks: "____killscriptSchedulerEveryTicks",
+            until: "____killscriptSchedulerUntil",
+            debounce: "____killscriptSchedulerDebounce",
+            throttle: "____killscriptSchedulerThrottle"
+          }[method];
+          if (helper !== void 0) return helperCall(helper, node.arguments);
+          const nativeMethod = schedulerMethod(method);
+          if (nativeMethod === void 0) throw new CompileError(`Unknown scheduler wrapper '${method}'.`, node);
+          return factory.createCallExpression(
+            factory.createPropertyAccessExpression(factory.createIdentifier("Scheduler"), nativeMethod),
+            void 0,
+            node.arguments.map((argument) => ts2.visitNode(argument, visitor))
+          );
+        }
+        if (isImportedIdentifier(owner, extraction.bindings.camera, checker)) {
+          if (method === "main") {
+            return factory.createPropertyAccessExpression(factory.createIdentifier("Cameras"), "Main");
+          }
+          const nativeMethod = { create: "CreateCamera", remove: "RemoveCamera" }[method];
+          if (nativeMethod === void 0) throw new CompileError(`Unknown camera wrapper '${method}'.`, node);
+          return factory.createCallExpression(
+            factory.createPropertyAccessExpression(factory.createIdentifier("Cameras"), nativeMethod),
+            void 0,
+            node.arguments.map((argument) => ts2.visitNode(argument, visitor))
+          );
+        }
+        if (isImportedIdentifier(owner, extraction.bindings.time, checker)) {
+          const property = { seconds: "Seconds", tick: "Tick" }[method];
+          if (property !== void 0) {
+            return factory.createPropertyAccessExpression(factory.createIdentifier("Time"), property);
+          }
+          if (method === "ceilTicks") {
+            const seconds = node.arguments[0];
+            if (seconds === void 0) throw new CompileError("time.ceilTicks() needs seconds.", node);
+            return factory.createCallExpression(
+              factory.createIdentifier("____killscriptCeilTicks"),
+              void 0,
+              [ts2.visitNode(seconds, visitor)]
+            );
+          }
+          const nativeMethod = { toTicks: "SecondsToTick", toSeconds: "TickToSeconds" }[method];
+          if (nativeMethod === void 0) throw new CompileError(`Unknown time wrapper '${method}'.`, node);
+          return factory.createCallExpression(
+            factory.createPropertyAccessExpression(factory.createIdentifier("Time"), nativeMethod),
+            void 0,
+            node.arguments.map((argument) => ts2.visitNode(argument, visitor))
+          );
+        }
+        if (isImportedIdentifier(owner, extraction.bindings.arrays, checker)) {
+          const helper = {
+            forEach: "____killscriptArrayForEach",
+            some: "____killscriptArraySome",
+            every: "____killscriptArrayEvery",
+            find: "____killscriptArrayFind",
+            map: "____killscriptArrayMap",
+            filter: "____killscriptArrayFilter",
+            toArray: "____killscriptArrayToArray",
+            first: "____killscriptArrayFirst",
+            last: "____killscriptArrayLast"
+          }[method];
+          if (helper === void 0) throw new CompileError(`Unknown arrays helper '${method}'.`, node);
+          return factory.createCallExpression(
+            factory.createIdentifier(helper),
+            void 0,
+            node.arguments.map((argument) => ts2.visitNode(argument, visitor))
+          );
+        }
+        if (isImportedIdentifier(owner, extraction.bindings.visuals, checker)) {
+          const helper = {
+            line: "____killscriptVisualLine",
+            overlay: "____killscriptVisualOverlay",
+            remove: "____killscriptVisualRemove"
+          }[method];
+          if (helper === void 0) throw new CompileError(`Unknown visuals helper '${method}'.`, node);
+          return helperCall(helper, node.arguments);
+        }
+        if (isImportedIdentifier(owner, extraction.bindings.input, checker)) {
+          const helper = {
+            anyPressed: "____killscriptInputAnyPressed",
+            allPressed: "____killscriptInputAllPressed",
+            onAnyPressed: "____killscriptInputOnAnyPressed",
+            onChord: "____killscriptInputOnChord",
+            toggle: "____killscriptInputToggle"
+          }[method];
+          if (helper === void 0) throw new CompileError(`Unknown input helper '${method}'.`, node);
+          return helperCall(helper, node.arguments);
+        }
+        const operator = operatorForWrapper(owner, method);
+        if (operator !== void 0) {
+          if (node.arguments.length !== 2) throw new CompileError(`${operator.name}() needs two values.`, node);
+          return factory.createBinaryExpression(
+            ts2.visitNode(node.arguments[0], visitor),
+            operator.token,
+            ts2.visitNode(node.arguments[1], visitor)
+          );
+        }
+      }
+      return void 0;
+    }
+    function helperCall(name, args) {
+      return factory.createCallExpression(
+        factory.createIdentifier(name),
+        void 0,
+        args.map((argument) => ts2.visitNode(argument, visitor))
+      );
+    }
+    function isTypeScriptArray(expression) {
+      const type = checker.getTypeAtLocation(expression);
+      return checker.isArrayType(type) || checker.isTupleType(type);
+    }
+    function isArrayHelperResult(expression) {
+      if (!ts2.isCallExpression(expression) || !ts2.isPropertyAccessExpression(expression.expression)) {
+        return false;
+      }
+      const method = expression.expression.name.text;
+      return ["map", "filter", "toArray"].includes(method) && isImportedIdentifier(expression.expression.expression, extraction.bindings.arrays, checker);
+    }
+    function isDefinitionCall(expression) {
+      return ts2.isCallExpression(expression) && (isImportedIdentifier(expression.expression, extraction.bindings.defineSettings, checker) || isImportedIdentifier(expression.expression, extraction.bindings.defineControls, checker) || isImportedIdentifier(expression.expression, extraction.bindings.defineNetwork, checker));
+    }
+    function transformNetworkCall(network, method, args, owner) {
+      if (method !== "send" && method !== "on") {
+        throw new CompileError(`Unknown network method '${method}'.`, owner);
+      }
+      if (args.length !== 2) throw new CompileError(`network.${method}() needs a kind and value.`, owner);
+      const kind = args[0];
+      if (!ts2.isStringLiteralLike(kind)) {
+        throw new CompileError("Network message kind must be a string literal.", kind);
+      }
+      const qualified = network.namespace === void 0 ? kind.text : `${network.namespace}.${kind.text}`;
+      return factory.createCallExpression(
+        factory.createIdentifier(method === "send" ? "____killscriptNetworkSend" : "____killscriptNetworkOn"),
+        void 0,
+        [
+          factory.createStringLiteral(qualified),
+          ts2.visitNode(args[1], visitor)
+        ]
+      );
+    }
+    function transformControlCall(control, method, args) {
+      const action = controlAction(control);
+      if (method === "native") return action;
+      const helper = {
+        onPressed: "____killscriptControlOnPressed",
+        onChanged: "____killscriptControlOnChanged",
+        onReleased: "____killscriptControlOnReleased",
+        whilePressed: "____killscriptControlWhilePressed",
+        isPressed: "____killscriptControlIsPressed"
+      }[method];
+      if (helper !== void 0) {
+        return factory.createCallExpression(
+          factory.createIdentifier(helper),
+          void 0,
+          [action, ...args.map((argument) => ts2.visitNode(argument, visitor))]
+        );
+      }
+      throw new CompileError(`Unknown control method '${method}'.`);
+    }
+    function controlAction(control) {
+      return factory.createCallExpression(
+        factory.createPropertyAccessExpression(factory.createIdentifier("InputActions"), "FindAction"),
+        void 0,
+        [factory.createStringLiteral(control.name)]
+      );
+    }
+    function matchSettingAccess(node) {
+      if (!ts2.isPropertyAccessExpression(node)) return void 0;
+      const handle = resolveHandle(node.expression, extraction.settingsHandles);
+      return handle?.properties.get(node.name.text);
+    }
+    function matchControlAccess(node, seen = /* @__PURE__ */ new Set()) {
+      if (ts2.isPropertyAccessExpression(node)) {
+        const handle = resolveHandle(node.expression, extraction.controlsHandles);
+        return handle?.properties.get(node.name.text);
+      }
+      const symbol = symbolForExpression(node);
+      if (symbol === void 0 || seen.has(symbol)) return void 0;
+      seen.add(symbol);
+      const initializer = variableInitializer(symbol);
+      return initializer === void 0 ? void 0 : matchControlAccess(initializer, seen);
+    }
+    function matchNetworkHandle(node) {
+      return resolveHandle(node, extraction.networkHandles);
+    }
+    function operatorForWrapper(owner, method) {
+      if (isImportedIdentifier(owner, extraction.bindings.vector2, checker)) {
+        if (method === "add") return { name: "vector2.add", token: ts2.SyntaxKind.PlusToken };
+        if (method === "subtract") return { name: "vector2.subtract", token: ts2.SyntaxKind.MinusToken };
+      }
+      if (isImportedIdentifier(owner, extraction.bindings.vector3, checker)) {
+        if (method === "add") return { name: "vector3.add", token: ts2.SyntaxKind.PlusToken };
+        if (method === "subtract") return { name: "vector3.subtract", token: ts2.SyntaxKind.MinusToken };
+      }
+      if (isImportedIdentifier(owner, extraction.bindings.quaternion, checker)) {
+        if (method === "multiply") return { name: "quaternion.multiply", token: ts2.SyntaxKind.AsteriskToken };
+        if (method === "rotate") return { name: "quaternion.rotate", token: ts2.SyntaxKind.AsteriskToken };
+      }
+      return void 0;
+    }
+    function resolveHandle(expression, handles, seen = /* @__PURE__ */ new Set()) {
+      const symbol = symbolForExpression(expression);
+      if (symbol === void 0) return void 0;
+      const direct = handles.get(symbol);
+      if (direct !== void 0 || seen.has(symbol)) return direct;
+      seen.add(symbol);
+      const initializer = variableInitializer(symbol);
+      return initializer === void 0 ? void 0 : resolveHandle(initializer, handles, seen);
+    }
+    function symbolForExpression(expression) {
+      const target = ts2.isPropertyAccessExpression(expression) ? expression.name : expression;
+      const symbol = checker.getSymbolAtLocation(target);
+      return symbol === void 0 ? void 0 : resolveAliasedSymbol(symbol, checker);
+    }
+    function variableInitializer(symbol) {
+      const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+      return declaration !== void 0 && ts2.isVariableDeclaration(declaration) ? declaration.initializer : void 0;
+    }
+    function settingRead(setting) {
+      const value = configAccess(setting.key);
+      if (setting.type !== "enum") return value;
+      return factory.createElementAccessExpression(
+        factory.createArrayLiteralExpression(
+          (setting.options ?? []).map((item) => factory.createStringLiteral(item))
+        ),
+        factory.createBinaryExpression(
+          factory.createAsExpression(value, factory.createKeywordTypeNode(ts2.SyntaxKind.NumberKeyword)),
+          factory.createToken(ts2.SyntaxKind.PlusToken),
+          factory.createNumericLiteral(1)
+        )
+      );
+    }
+    function configAccess(key) {
+      return factory.createElementAccessExpression(
+        factory.createIdentifier("Config"),
+        factory.createStringLiteral(key)
+      );
+    }
+    function choiceIndexExpression(options) {
+      let result = factory.createNumericLiteral(0);
+      for (let index = options.length - 1; index >= 0; index -= 1) {
+        result = factory.createConditionalExpression(
+          factory.createBinaryExpression(
+            factory.createIdentifier("____settingValue"),
+            factory.createToken(ts2.SyntaxKind.EqualsEqualsEqualsToken),
+            factory.createStringLiteral(options[index])
+          ),
+          factory.createToken(ts2.SyntaxKind.QuestionToken),
+          factory.createNumericLiteral(index),
+          factory.createToken(ts2.SyntaxKind.ColonToken),
+          result
+        );
+      }
+      return result;
+    }
+  };
+}
+function isAssignmentOperator(kind) {
+  return kind >= ts2.SyntaxKind.FirstAssignment && kind <= ts2.SyntaxKind.LastAssignment;
+}
+function agentMethod(method) {
+  return {
+    local: "GetLocalAgent",
+    localOrSpectated: "GetLocalOrSpectatedAgent",
+    all: "GetAll",
+    allies: "GetAllies",
+    enemies: "GetEnemies"
+  }[method];
+}
+function schedulerMethod(method) {
+  return {
+    frame: "OnFrame",
+    tick: "OnTick",
+    after: "Schedule"
+  }[method];
+}
+
+// src/compiler/compile-context.ts
+function compileContext(projectDir, context) {
+  const sourceRoot = path3.join(projectDir, "src");
+  const entry = path3.join(sourceRoot, context, "main.ts");
+  const bundleName = context === "client" ? "main.lua" : "server.lua";
+  const options = {
+    target: ts3.ScriptTarget.ES2022,
+    lib: ["lib.es2022.d.ts"],
+    module: ts3.ModuleKind.ESNext,
+    moduleResolution: ts3.ModuleResolutionKind.Bundler,
+    strict: true,
+    skipLibCheck: true,
+    esModuleInterop: true,
+    rootDir: sourceRoot,
+    outDir: path3.join(projectDir, ".killscript", "compiler", context),
+    types: [`@killscript/types/${context}`],
+    luaTarget: LuaTarget.Lua54,
+    luaLibImport: LuaLibImportKind.Inline,
+    luaBundle: bundleName,
+    luaBundleEntry: entry,
+    noImplicitGlobalVariables: false,
+    noHeader: false,
+    sourceMap: false,
+    declaration: false
+  };
+  const program2 = ts3.createProgram({ rootNames: [entry], options });
+  validateProgram(program2, projectDir, sourceRoot, context);
+  const diagnostics = ts3.getPreEmitDiagnostics(program2);
+  const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts3.DiagnosticCategory.Error);
+  if (errors.length > 0) throw new CompileError(formatDiagnostics(errors, projectDir));
+  const extraction = extractMacros(program2, sourceRoot);
+  const files = /* @__PURE__ */ new Map();
+  const result = new Transpiler().emit({
+    program: program2,
+    customTransformers: { before: [createMacroTransformer(program2, extraction)] },
+    writeFile(fileName, data) {
+      files.set(path3.basename(fileName), data);
+    }
+  });
+  const emitErrors = result.diagnostics.filter(
+    (diagnostic) => diagnostic.category === ts3.DiagnosticCategory.Error
+  );
+  if (emitErrors.length > 0) {
+    throw new CompileError(formatDiagnostics(emitErrors, projectDir));
+  }
+  if (result.emitSkipped) throw new CompileError(`${context} Lua emit was skipped.`);
+  const lua = files.get(bundleName);
+  if (lua === void 0) {
+    throw new CompileError(
+      `${context} compilation did not emit ${bundleName}. Emitted: ${[...files.keys()].join(", ")}`
+    );
+  }
+  const finalized = addCompilerRuntime(makeBundleSandboxSafe(lua), context, extraction);
+  assertSandboxSafe(finalized, context);
+  return { lua: finalized, extraction };
+}
+function validateProgram(program2, projectDir, sourceRoot, context) {
+  for (const sourceFile of program2.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile || !isInside2(sourceFile.fileName, sourceRoot)) continue;
+    const visit = (node) => {
+      if (ts3.isTryStatement(node)) {
+        throw new CompileError("try/catch is unavailable because the game sandbox does not expose pcall().", node);
+      }
+      if (ts3.isTypeOfExpression(node)) {
+        throw new CompileError("typeof is unavailable because the game sandbox does not expose type().", node);
+      }
+      if (ts3.isThrowStatement(node)) {
+        throw new CompileError("throw is unavailable because the game sandbox does not expose error().", node);
+      }
+      if (ts3.isAwaitExpression(node) || ts3.isYieldExpression(node) || hasAsyncModifier(node)) {
+        throw new CompileError("async, await and generators are not supported by the KILLSCRIPT runtime.", node);
+      }
+      if (ts3.isCallExpression(node) && ts3.isIdentifier(node.expression) && ["pcall", "xpcall", "type", "load", "loadfile", "dofile", "require", "eval"].includes(node.expression.text)) {
+        throw new CompileError(`Direct ${node.expression.text}() calls are not supported in module source.`, node);
+      }
+      if (ts3.isCallExpression(node) && node.expression.kind === ts3.SyntaxKind.ImportKeyword) {
+        throw new CompileError("Dynamic import() is not supported; use static imports so the compiler can bundle them.", node);
+      }
+      ts3.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    for (const statement of sourceFile.statements) {
+      if (!ts3.isImportDeclaration(statement) || !ts3.isStringLiteral(statement.moduleSpecifier)) continue;
+      const specifier = statement.moduleSpecifier.text;
+      const typeOnly = isTypeOnlyImport(statement);
+      if (specifier === `@killscript/sdk/${context}` || specifier === "@killscript/sdk" || specifier.startsWith(".")) {
+        if (specifier.startsWith(".")) {
+          const resolved = path3.resolve(path3.dirname(sourceFile.fileName), specifier);
+          if (!isInside2(resolved, sourceRoot)) {
+            throw new CompileError("Relative implementation imports must stay inside src/.", statement);
+          }
+          const opposite = context === "client" ? "server" : "client";
+          if (!typeOnly && isInside2(resolved, path3.join(sourceRoot, opposite))) {
+            throw new CompileError(`${context} code cannot import ${opposite} implementation files.`, statement);
+          }
+        }
+        continue;
+      }
+      if (typeOnly) continue;
+      throw new CompileError(
+        `Runtime package import '${specifier}' cannot be bundled safely. Keep runtime code in src/ and use relative imports.`,
+        statement
+      );
+    }
+  }
+  function hasAsyncModifier(node) {
+    return ts3.canHaveModifiers(node) && (ts3.getModifiers(node)?.some((modifier) => modifier.kind === ts3.SyntaxKind.AsyncKeyword) ?? false);
+  }
+  function isTypeOnlyImport(node) {
+    const clause = node.importClause;
+    if (clause === void 0 || clause.name !== void 0) return clause?.isTypeOnly ?? false;
+    if (clause.isTypeOnly) return true;
+    const bindings = clause.namedBindings;
+    return bindings !== void 0 && ts3.isNamedImports(bindings) && bindings.elements.length > 0 && bindings.elements.every((element) => element.isTypeOnly);
+  }
+}
+function addCompilerRuntime(lua, context, extraction) {
+  const blocks = [];
+  if (lua.includes("____killscriptArray")) blocks.push(ARRAY_RUNTIME);
+  if (lua.includes("____killscriptTsArrayReduce") || lua.includes("____killscriptTsArrayLength")) blocks.push(TS_ARRAY_RUNTIME);
+  if (lua.includes("____killscriptCeilTicks")) blocks.push(TIME_RUNTIME);
+  if (lua.includes("____killscriptLogger")) blocks.push(LOGGER_RUNTIME);
+  if (lua.includes("____killscriptAgentSelection")) blocks.push(AGENT_SELECTION_RUNTIME);
+  if (lua.includes("____killscriptScheduler")) blocks.push(schedulerRuntime(context));
+  if (lua.includes("____killscriptInput") || lua.includes("____killscriptControl")) {
+    blocks.push(INPUT_RUNTIME);
+  }
+  const needsScope = lua.includes("____killscriptScope");
+  if (lua.includes("____killscriptVisual") || needsScope && context === "client") {
+    blocks.push(VISUAL_RUNTIME);
+  }
+  if (needsScope) blocks.push(scopeRuntime(context));
+  if (extraction.networkHandles.size > 0) blocks.push(networkRuntime(context));
+  return blocks.length === 0 ? lua : `${blocks.join("\n\n")}
+
+${lua}`;
+}
+var ARRAY_RUNTIME = `local function ____killscriptArrayForEach(_, values, callback)
+    for index = 1, values.Length do callback(nil, values[index], index) end
+end
+
+local function ____killscriptArraySome(_, values, predicate)
+    for index = 1, values.Length do
+        if predicate(nil, values[index], index) then return true end
+    end
+    return false
+end
+
+local function ____killscriptArrayEvery(_, values, predicate)
+    for index = 1, values.Length do
+        if not predicate(nil, values[index], index) then return false end
+    end
+    return true
+end
+
+local function ____killscriptArrayFind(_, values, predicate)
+    for index = 1, values.Length do
+        local value = values[index]
+        if predicate(nil, value, index) then return value end
+    end
+    return nil
+end
+
+local function ____killscriptArrayMap(_, values, transform)
+    local result = {}
+    for index = 1, values.Length do result[index] = transform(nil, values[index], index) end
+    return result
+end
+
+local function ____killscriptArrayFilter(_, values, predicate)
+    local result = {}
+    for index = 1, values.Length do
+        local value = values[index]
+        if predicate(nil, value, index) then result[#result + 1] = value end
+    end
+    return result
+end
+
+local function ____killscriptArrayToArray(_, values)
+    local result = {}
+    for index = 1, values.Length do result[index] = values[index] end
+    return result
+end
+
+local function ____killscriptArrayFirst(_, values)
+    if values.Length == 0 then return nil end
+    return values[1]
+end
+
+local function ____killscriptArrayLast(_, values)
+    if values.Length == 0 then return nil end
+    return values[values.Length]
+end`;
+var TIME_RUNTIME = `local function ____killscriptCeilTicks(_, seconds)
+    return math.ceil(seconds / Time:TickToSeconds(1))
+end`;
+var LOGGER_RUNTIME = `local function ____killscriptLogger(_, name)
+    local prefix = "[" .. name .. "] "
+    local seen = {}
+    local lastPrintedAt = {}
+    local result = {}
+
+    function result:info(message) print(prefix .. message) end
+    function result:debug(message) print(prefix .. "[DEBUG] " .. message) end
+    function result:warn(message) print(prefix .. "[WARN] " .. message) end
+
+    function result:batch(lines)
+        local output = prefix
+        for index = 1, #lines do
+            if index > 1 then output = output .. "\\n" end
+            output = output .. lines[index]
+        end
+        print(output)
+    end
+
+    function result:once(key, message)
+        if seen[key] then return end
+        seen[key] = true
+        print(prefix .. message)
+    end
+
+    function result:throttled(key, seconds, message)
+        local now = Time.Seconds
+        local previous = lastPrintedAt[key]
+        if previous ~= nil and now - previous < seconds then return end
+        lastPrintedAt[key] = now
+        print(prefix .. message)
+    end
+
+    return result
+end`;
+var AGENT_SELECTION_RUNTIME = `local function ____killscriptAgentSelection(_, source)
+    if source == nil then source = Agents:GetAll() end
+    local values = {}
+    local sourceLength = source.Length
+    if sourceLength == nil then sourceLength = #source end
+    for index = 1, sourceLength do values[index] = source[index] end
+
+    local result = {}
+
+    local function filter(predicate)
+        local filtered = {}
+        for index = 1, #values do
+            local agent = values[index]
+            if predicate(agent) then filtered[#filtered + 1] = agent end
+        end
+        values = filtered
+        return result
+    end
+
+    function result:where(predicate)
+        return filter(function(agent) return predicate(nil, agent) end)
+    end
+
+    function result:alive()
+        return filter(function(agent)
+            if not agent.IsVisible then return false end
+            local stats = agent.Stats
+            return stats ~= nil and stats.IsAlive
+        end)
+    end
+
+    function result:dead()
+        return filter(function(agent)
+            if not agent.IsVisible then return false end
+            local stats = agent.Stats
+            return stats ~= nil and not stats.IsAlive
+        end)
+    end
+
+    function result:visible()
+        return filter(function(agent)
+            if not agent.IsVisible then return false end
+            local hitboxes = agent:GetHitboxes()
+            for index = 1, hitboxes.Length do
+                if hitboxes[index].IsVisible then return true end
+            end
+            return false
+        end)
+    end
+
+    function result:within(origin, distance)
+        return filter(function(agent)
+            if not agent.IsVisible then return false end
+            local movement = agent.Movement
+            return movement ~= nil and origin:Distance(movement.Position) <= distance
+        end)
+    end
+
+    function result:exclude(excluded)
+        if excluded == nil then return result end
+        return filter(function(agent) return agent ~= excluded end)
+    end
+
+    function result:team(team)
+        return filter(function(agent)
+            return agent.IsVisible and agent.Team == team
+        end)
+    end
+
+    function result:first()
+        return values[1]
+    end
+
+    function result:nearestTo(origin)
+        local nearest = nil
+        local nearestDistance = nil
+        for index = 1, #values do
+            local agent = values[index]
+            if agent.IsVisible then
+                local movement = agent.Movement
+                if movement ~= nil then
+                    local distance = origin:Distance(movement.Position)
+                    if nearestDistance == nil or distance < nearestDistance then
+                        nearest = agent
+                        nearestDistance = distance
+                    end
+                end
+            end
+        end
+        return nearest
+    end
+
+    function result:count() return #values end
+    function result:toArray()
+        local copy = {}
+        for index = 1, #values do copy[index] = values[index] end
+        return copy
+    end
+    return result
+end`;
+function schedulerRuntime(context) {
+  const updateMethod = context === "client" ? "OnFrame" : "OnTick";
+  return `local ____killscriptSchedulerDebounces = {}
+local ____killscriptSchedulerThrottles = {}
+
+local function ____killscriptSchedulerAfterTicks(_, ticks, callback)
+    local target = Time.Tick + ticks
+    local subscription = nil
+    subscription = Scheduler:${updateMethod}(function()
+        if Time.Tick < target then return end
+        subscription:Cancel()
+        callback(nil)
+    end)
+    return subscription
+end
+
+local function ____killscriptSchedulerEvery(_, seconds, callback)
+    local nextAt = Time.Seconds + seconds
+    return Scheduler:${updateMethod}(function()
+        local now = Time.Seconds
+        if now < nextAt then return end
+        nextAt = now + seconds
+        callback(nil)
+    end)
+end
+
+local function ____killscriptSchedulerEveryTicks(_, ticks, callback)
+    local nextAt = Time.Tick + ticks
+    return Scheduler:${updateMethod}(function()
+        local now = Time.Tick
+        if now < nextAt then return end
+        nextAt = now + ticks
+        callback(nil)
+    end)
+end
+
+local function ____killscriptSchedulerUntil(_, predicate, callback)
+    local subscription = nil
+    subscription = Scheduler:${updateMethod}(function()
+        if not predicate(nil) then return end
+        subscription:Cancel()
+        callback(nil)
+    end)
+    return subscription
+end
+
+local function ____killscriptSchedulerDebounce(_, key, seconds, callback)
+    local generation = (____killscriptSchedulerDebounces[key] or 0) + 1
+    ____killscriptSchedulerDebounces[key] = generation
+    Scheduler:Schedule(seconds, function()
+        if ____killscriptSchedulerDebounces[key] ~= generation then return end
+        ____killscriptSchedulerDebounces[key] = nil
+        callback(nil)
+    end)
+end
+
+local function ____killscriptSchedulerThrottle(_, key, seconds, callback)
+    local now = Time.Seconds
+    local availableAt = ____killscriptSchedulerThrottles[key]
+    if availableAt ~= nil and now < availableAt then return false end
+    ____killscriptSchedulerThrottles[key] = now + seconds
+    callback(nil)
+    return true
+end`;
+}
+var INPUT_RUNTIME = `local function ____killscriptInputAnyPressed(_, actions)
+    for index = 1, #actions do
+        local action = actions[index]
+        if action ~= nil and action:IsPressed() then return true end
+    end
+    return false
+end
+
+local function ____killscriptInputAllPressed(_, actions)
+    if #actions == 0 then return false end
+    for index = 1, #actions do
+        local action = actions[index]
+        if action == nil or not action:IsPressed() then return false end
+    end
+    return true
+end
+
+local function ____killscriptControlOnPressed(_, action, callback)
+    if action == nil then return end
+    action:OnPerformed(callback)
+end
+
+local function ____killscriptControlIsPressed(_, action)
+    return action ~= nil and action:IsPressed()
+end
+
+local function ____killscriptControlOnChanged(_, action, callback)
+    local previous = action ~= nil and action:IsPressed()
+    return Scheduler:OnFrame(function()
+        local current = action ~= nil and action:IsPressed()
+        if current == previous then return end
+        previous = current
+        callback(nil, current)
+    end)
+end
+
+local function ____killscriptControlOnReleased(_, action, callback)
+    local previous = action ~= nil and action:IsPressed()
+    return Scheduler:OnFrame(function()
+        local current = action ~= nil and action:IsPressed()
+        if previous and not current then callback(nil) end
+        previous = current
+    end)
+end
+
+local function ____killscriptControlWhilePressed(_, action, callback)
+    return Scheduler:OnFrame(function()
+        if action ~= nil and action:IsPressed() then callback(nil) end
+    end)
+end
+
+local function ____killscriptInputOnAnyPressed(_, actions, callback)
+    local previous = ____killscriptInputAnyPressed(nil, actions)
+    return Scheduler:OnFrame(function()
+        local current = ____killscriptInputAnyPressed(nil, actions)
+        if current and not previous then callback(nil) end
+        previous = current
+    end)
+end
+
+local function ____killscriptInputOnChord(_, actions, callback)
+    local previous = ____killscriptInputAllPressed(nil, actions)
+    return Scheduler:OnFrame(function()
+        local current = ____killscriptInputAllPressed(nil, actions)
+        if current and not previous then callback(nil) end
+        previous = current
+    end)
+end
+
+local function ____killscriptInputToggle(_, action, initialValue, callback)
+    local result = { value = initialValue == true }
+
+    local function notify()
+        if callback ~= nil then callback(nil, result.value) end
+    end
+
+    function result:set(value)
+        result.value = value == true
+        notify()
+    end
+
+    function result:flip()
+        result.value = not result.value
+        notify()
+        return result.value
+    end
+
+    if action ~= nil then
+        action:OnPerformed(function() result:flip() end)
+    end
+    return result
+end`;
+var VISUAL_RUNTIME = `local ____killscriptRemovedWorldObjects = {}
+
+local function ____killscriptVisualRemove(_, object)
+    if object == nil or ____killscriptRemovedWorldObjects[object] then return end
+    ____killscriptRemovedWorldObjects[object] = true
+    WorldVisuals:RemoveObject(object)
+end
+
+local function ____killscriptVisualLine(_, options)
+    local object = WorldVisuals:CreateLineRenderer()
+    if object == nil then return nil end
+    local points = options.points
+    object:SetPositionCount(#points)
+    for index = 1, #points do object:SetPosition(index - 1, points[index]) end
+    if options.color ~= nil then object:SetColor(options.color) end
+    if options.width ~= nil then object:SetWidth(options.width) end
+    if options.progress ~= nil then object:SetProgress(options.progress) end
+    if options.patternEnabled ~= nil then object:SetPatternEnabled(options.patternEnabled) end
+    if options.patternRepeat ~= nil then object:SetPatternRepeat(options.patternRepeat) end
+    if options.patternTexture ~= nil then object:SetPatternTexture(options.patternTexture) end
+    if options.occludedBrightness ~= nil or options.occludedTransparency ~= nil then
+        object:SetOccludedVisibility(
+            options.occludedBrightness or 1,
+            options.occludedTransparency or 1
+        )
+    end
+    if options.duration ~= nil and options.duration > 0 then
+        Scheduler:Schedule(options.duration, function()
+            ____killscriptVisualRemove(nil, object)
+        end)
+    end
+    return object
+end
+
+local function ____killscriptVisualOverlay(_, options)
+    local object = WorldVisuals:CreateSurfaceOverlay()
+    if object == nil then return nil end
+    object:SetPosition(options.position)
+    object:SetSize(options.size)
+    if options.color ~= nil then object:SetColor(options.color) end
+    if options.fillBase ~= nil then object:SetFillBase(options.fillBase) end
+    if options.occlusionEnabled ~= nil then object:SetOcclusionEnabled(options.occlusionEnabled) end
+    if options.visible ~= nil then object:SetVisible(options.visible) end
+    if options.duration ~= nil and options.duration > 0 then
+        Scheduler:Schedule(options.duration, function()
+            ____killscriptVisualRemove(nil, object)
+        end)
+    end
+    return object
+end`;
+function scopeRuntime(context) {
+  const worldMethods = context === "client" ? `    local worlds = {}
+
+    function result:world(object)
+        if object == nil then return nil end
+        if disposed then
+            ____killscriptVisualRemove(nil, object)
+        else
+            worlds[#worlds + 1] = object
+        end
+        return object
+    end
+` : "";
+  const worldCleanup = context === "client" ? `        for index = #worlds, 1, -1 do
+            ____killscriptVisualRemove(nil, worlds[index])
+        end
+` : "";
+  return `local function ____killscriptScope()
+    local disposed = false
+    local subscriptions = {}
+    local callbacks = {}
+    local result = {}
+${worldMethods}
+    function result:using(subscription)
+        if subscription == nil then return nil end
+        if disposed then
+            subscription:Cancel()
+        else
+            subscriptions[#subscriptions + 1] = subscription
+        end
+        return subscription
+    end
+
+    function result:defer(callback)
+        if disposed then
+            callback(nil)
+        else
+            callbacks[#callbacks + 1] = callback
+        end
+    end
+
+    function result:dispose()
+        if disposed then return end
+        disposed = true
+        for index = #subscriptions, 1, -1 do subscriptions[index]:Cancel() end
+${worldCleanup}        for index = #callbacks, 1, -1 do callbacks[index](nil) end
+    end
+
+    function result:isDisposed() return disposed end
+    return result
+end`;
+}
+var TS_ARRAY_RUNTIME = `local function ____killscriptTsArrayReduce(_, values, callback, initial)
+    local result = initial
+    for index = 1, #values do
+        result = callback(nil, result, values[index], index - 1, values)
+    end
+    return result
+end
+
+local function ____killscriptTsArrayLength(_, values)
+    return #values
+end
+
+local function ____killscriptTsArrayReduceRight(_, values, callback, initial)
+    local result = initial
+    for index = #values, 1, -1 do
+        result = callback(nil, result, values[index], index - 1, values)
+    end
+    return result
+end`;
+function networkRuntime(context) {
+  const scheduler = context === "client" ? `local ____killscriptNetworkLastTick = -1
+Scheduler:OnFrame(function()
+    local currentTick = Time.Tick
+    if currentTick == ____killscriptNetworkLastTick then return end
+    ____killscriptNetworkLastTick = currentTick
+    ____killscriptNetworkFlush()
+end)` : `Scheduler:OnTick(____killscriptNetworkFlush)`;
+  return `local ____killscriptNetworkQueue = {}
+local ____killscriptNetworkListeners = {}
+
+local function ____killscriptNetworkSend(_, kind, payload)
+    ____killscriptNetworkQueue[#____killscriptNetworkQueue + 1] = {
+        __killscript_channel = kind,
+        payload = payload
+    }
+end
+
+local function ____killscriptNetworkOn(_, kind, callback)
+    local listeners = ____killscriptNetworkListeners[kind]
+    if listeners == nil then
+        listeners = {}
+        ____killscriptNetworkListeners[kind] = listeners
+    end
+    listeners[#listeners + 1] = callback
+end
+
+local function ____killscriptNetworkDispatch(message)
+    local listeners = ____killscriptNetworkListeners[message.__killscript_channel]
+    if listeners == nil then return end
+    for index = 1, #listeners do listeners[index](nil, message.payload) end
+end
+
+Network:OnTableReceived(function(message)
+    local batch = message.__killscript_batch
+    if batch == nil then
+        ____killscriptNetworkDispatch(message)
+        return
+    end
+    for index = 1, #batch do
+        ____killscriptNetworkDispatch(batch[index])
+    end
+end)
+
+local function ____killscriptNetworkFlush()
+    if #____killscriptNetworkQueue == 0 then return end
+    local batch = ____killscriptNetworkQueue
+    ____killscriptNetworkQueue = {}
+    Network:SendTable({ __killscript_batch = batch })
+end
+
+${scheduler}`;
+}
+function makeBundleSandboxSafe(lua) {
+  return lua.replace(
+    '        local value = nil\n        if (select("#", ...) > 0) then value = module(...) else value = module(file) end',
+    "        local value = module(file)"
+  ).replace(
+    /        else\n            error\("module '" \.\. file \.\. "' not found"\)\n        end/g,
+    "        end\n        return nil"
+  ).replace(/local ____entry = require\(("[^"]+"), \.\.\.\)/, "local ____entry = require($1)");
+}
+function assertSandboxSafe(lua, context) {
+  const codeOnly = lua.replace(/--\[\[[\s\S]*?\]\]/g, "").replace(/--[^\n]*/g, "").replace(/"(?:\\.|[^"\\])*"/g, '""').replace(/'(?:\\.|[^'\\])*'/g, "''");
+  const unavailable = [...codeOnly.matchAll(/\b(pcall|xpcall|select|type|error)\s*\(/g)].map((match) => match[1]).filter((value, index, all) => value !== void 0 && all.indexOf(value) === index);
+  if (unavailable.length > 0) {
+    throw new CompileError(
+      `${context} output requires sandbox globals that the game does not expose: ${unavailable.join(", ")}. Replace the JavaScript built-in that generated them or use an SDK helper.`
+    );
+  }
+}
+function formatDiagnostics(diagnostics, projectDir) {
+  return ts3.formatDiagnosticsWithColorAndContext(diagnostics, {
+    getCanonicalFileName: (fileName) => path3.relative(projectDir, fileName),
+    getCurrentDirectory: () => projectDir,
+    getNewLine: () => "\n"
+  });
+}
+function isInside2(file, directory) {
+  const relative = path3.relative(path3.resolve(directory), path3.resolve(file));
+  return relative !== "" && !relative.startsWith("..") && !path3.isAbsolute(relative);
+}
+
+// src/compiler/build.ts
+async function buildProject(projectDir, config) {
+  const client = compileContext(projectDir, "client");
+  const server = config.reflex ? compileContext(projectDir, "server") : void 0;
+  if (!config.reflex && client.extraction.networkHandles.size > 0) {
+    throw new CompileError("defineNetwork() requires a Reflex module. Set reflex to true in killscript.config.json.");
+  }
+  const settings = mergeSettings([
+    ...client.extraction.settings,
+    ...server?.extraction.settings ?? []
+  ]);
+  const controls = client.extraction.controls;
+  const outputDir = path4.join(projectDir, ".killscript", "build", config.name);
+  await rm(outputDir, { recursive: true, force: true });
+  await mkdir2(path4.join(outputDir, "scripts"), { recursive: true });
+  await copyPublicAssets(projectDir, outputDir);
+  await Promise.all([
+    writeJson(path4.join(outputDir, "module.json"), {
+      Id: config.id,
+      Name: config.name,
+      Version: config.version,
+      Author: config.author,
+      Description: config.description ?? null,
+      IsReflex: config.reflex,
+      Tags: config.tags ?? []
+    }),
+    writeJson(path4.join(outputDir, "config.json"), settings.map(toConfigJson)),
+    writeJson(path4.join(outputDir, "inputs.json"), {
+      Actions: controls.map(toInputJson)
+    }),
+    writeFile2(path4.join(outputDir, "scripts", "main.lua"), client.lua),
+    ...server === void 0 ? [] : [writeFile2(path4.join(outputDir, "scripts", "server.lua"), server.lua)]
+  ]);
+  return { outputDir, settings: settings.length, controls: controls.length };
+}
+function mergeSettings(values) {
+  const result = /* @__PURE__ */ new Map();
+  for (const setting of values) {
+    const previous = result.get(setting.key);
+    if (previous === void 0) {
+      result.set(setting.key, setting);
+      continue;
+    }
+    if (JSON.stringify(toConfigJson(previous)) !== JSON.stringify(toConfigJson(setting))) {
+      throw new CompileError(`Conflicting setting '${setting.key}' between client and server.`);
+    }
+  }
+  return [...result.values()];
+}
+function toConfigJson(setting) {
+  return {
+    label: setting.label,
+    key: setting.key,
+    type: setting.type,
+    value: setting.value,
+    ...setting.min === void 0 ? {} : { min: setting.min },
+    ...setting.max === void 0 ? {} : { max: setting.max },
+    ...setting.options === void 0 ? {} : { options: setting.options }
+  };
+}
+function toInputJson(control) {
+  return {
+    Name: control.name,
+    Type: control.type,
+    Binding: {
+      Path: control.binding.path,
+      ...control.binding.interactions === void 0 ? {} : { Interactions: control.binding.interactions },
+      ...control.binding.processors === void 0 ? {} : { Processors: control.binding.processors },
+      ...control.binding.groups === void 0 ? {} : { Groups: control.binding.groups }
+    }
+  };
+}
+async function writeJson(file, value) {
+  await writeFile2(file, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function copyPublicAssets(projectDir, outputDir) {
+  const publicDir = path4.join(projectDir, "public");
+  try {
+    if (!(await stat(publicDir)).isDirectory()) return;
+    await validatePublicAssets(publicDir);
+    await cp(publicDir, outputDir, { recursive: true, force: true });
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+async function validatePublicAssets(publicDir) {
+  const reserved = /* @__PURE__ */ new Set([
+    "module.json",
+    "config.json",
+    "inputs.json",
+    "scripts",
+    ".killscript-managed.json"
+  ]);
+  for (const entry of await readdir(publicDir, { withFileTypes: true })) {
+    if (reserved.has(entry.name.toLowerCase())) {
+      throw new CompileError(`public/${entry.name} is reserved and generated by the compiler.`);
+    }
+  }
+  await walk(publicDir);
+  async function walk(directory) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      const absolute = path4.join(directory, entry.name);
+      const info = await lstat(absolute);
+      if (info.isSymbolicLink()) {
+        throw new CompileError(`Public assets cannot contain symbolic links: ${path4.relative(publicDir, absolute)}`);
+      }
+      if (info.isDirectory()) await walk(absolute);
+    }
+  }
+}
+
+// src/pack.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdir as mkdir3, readFile as readFile2, readdir as readdir2, rename, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import path5 from "path";
+import { zipSync } from "fflate";
+async function packModule(moduleDir, destination) {
+  const files = {};
+  await walk("");
+  await mkdir3(path5.dirname(destination), { recursive: true });
+  const temporary = `${destination}.${randomUUID2()}.tmp`;
+  try {
+    await writeFile3(temporary, zipSync(files, { level: 9 }));
+    await rm2(destination, { force: true });
+    await rename(temporary, destination);
+  } catch (error) {
+    await rm2(temporary, { force: true });
+    throw error;
+  }
+  async function walk(relativeDir) {
+    const entries = await readdir2(path5.join(moduleDir, relativeDir), { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name, "en"));
+    for (const entry of entries) {
+      const relative = path5.join(relativeDir, entry.name);
+      if (entry.isDirectory()) await walk(relative);
+      else if (entry.isFile()) {
+        files[relative.replaceAll(path5.sep, "/")] = [
+          await readFile2(path5.join(moduleDir, relative)),
+          { mtime: /* @__PURE__ */ new Date("1980-01-01T00:00:00.000Z") }
+        ];
+      }
+    }
+  }
+}
+
+// src/commands/build.ts
+async function runBuild(projectDir, options = {}) {
+  const config = await readProjectConfig(projectDir);
+  const result = await buildProject(projectDir, config);
+  console.log(
+    `Built ${config.name}: ${result.settings} settings, ${result.controls} controls -> ${result.outputDir}`
+  );
+  if (options.pack ?? true) {
+    const destination = path6.join(projectDir, "dist", `${config.name}.KillScript`);
+    await packModule(result.outputDir, destination);
+    console.log(`Packed ${destination}`);
+  }
+}
+
+// src/commands/clean.ts
+import { rm as rm4 } from "fs/promises";
+import path8 from "path";
+
+// src/output.ts
+import { createHash } from "crypto";
+import {
+  copyFile,
+  mkdir as mkdir4,
+  readFile as readFile3,
+  readdir as readdir3,
+  rename as rename2,
+  rm as rm3,
+  stat as stat2,
+  writeFile as writeFile4
+} from "fs/promises";
+import path7 from "path";
+var MARKER = ".killscript-managed.json";
+async function inspectManagedModule(targetDir, moduleId) {
+  const marker = await readMarker(targetDir);
+  if (marker !== void 0) return marker.id === moduleId ? "managed" : "foreign";
+  try {
+    const moduleJson = JSON.parse(await readFile3(path7.join(targetDir, "module.json"), "utf8"));
+    return moduleJson.Id === moduleId ? "same-module" : "foreign";
+  } catch (error) {
+    if (error.code === "ENOENT") return "missing";
+    throw error;
+  }
+}
+async function removeManagedModule(targetDir, moduleId) {
+  const status = await inspectManagedModule(targetDir, moduleId);
+  if (status === "missing") return false;
+  if (status !== "managed") {
+    throw new Error(`Refusing to remove ${targetDir}: it is not managed by this project.`);
+  }
+  await rm3(targetDir, { recursive: true, force: true });
+  return true;
+}
+async function syncManagedModule(sourceDir, targetDir, moduleId) {
+  await assertSafeTarget(targetDir, moduleId);
+  await mkdir4(targetDir, { recursive: true });
+  const sourceFiles = await listFiles(sourceDir);
+  const previous = await readMarker(targetDir);
+  let changed = 0;
+  const changedFiles = [];
+  const inputsFile = sourceFiles.includes("inputs.json") ? "inputs.json" : void 0;
+  for (const relative of sourceFiles) {
+    if (relative === inputsFile) continue;
+    const source = path7.join(sourceDir, relative);
+    const target = path7.join(targetDir, relative);
+    if (await filesEqual(source, target)) continue;
+    await atomicCopy(source, target);
+    changed += 1;
+    changedFiles.push(relative);
+  }
+  for (const relative of previous?.files ?? []) {
+    if (sourceFiles.includes(relative)) continue;
+    await rm3(path7.join(targetDir, relative), { force: true });
+    changed += 1;
+    changedFiles.push(relative);
+  }
+  const markerTarget = path7.join(targetDir, MARKER);
+  const markerContent = `${JSON.stringify(
+    { id: moduleId, files: sourceFiles },
+    null,
+    2
+  )}
+`;
+  if (!await contentEquals(markerTarget, markerContent)) {
+    await atomicWrite(markerTarget, markerContent);
+  }
+  if (inputsFile !== void 0) {
+    const source = path7.join(sourceDir, inputsFile);
+    const target = path7.join(targetDir, inputsFile);
+    if (!await filesEqual(source, target)) {
+      await atomicCopy(source, target);
+      changed += 1;
+      changedFiles.push(inputsFile);
+    }
+  }
+  return { changed, changedFiles };
+}
+async function assertSafeTarget(targetDir, moduleId) {
+  const status = await inspectManagedModule(targetDir, moduleId);
+  if (status === "missing" || status === "managed" || status === "same-module") return;
+  throw new Error(`Refusing to overwrite unmanaged or foreign module folder ${targetDir}.`);
+}
+async function readMarker(targetDir) {
+  try {
+    return JSON.parse(await readFile3(path7.join(targetDir, MARKER), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function listFiles(root) {
+  const result = [];
+  await walk("");
+  return result.sort();
+  async function walk(relativeDir) {
+    const absolute = path7.join(root, relativeDir);
+    for (const entry of await readdir3(absolute, { withFileTypes: true })) {
+      const relative = path7.join(relativeDir, entry.name);
+      if (entry.isDirectory()) await walk(relative);
+      else if (entry.isFile()) result.push(relative);
+    }
+  }
+}
+async function filesEqual(left, right) {
+  try {
+    const [leftStat, rightStat] = await Promise.all([stat2(left), stat2(right)]);
+    if (leftStat.size !== rightStat.size) return false;
+    const [leftData, rightData] = await Promise.all([readFile3(left), readFile3(right)]);
+    return hash(leftData) === hash(rightData);
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function contentEquals(file, expected) {
+  try {
+    return await readFile3(file, "utf8") === expected;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+function hash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+async function atomicCopy(source, target) {
+  await mkdir4(path7.dirname(target), { recursive: true });
+  const temporary = `${target}.killscript-${process.pid}.tmp`;
+  await copyFile(source, temporary);
+  await replaceWithRetry(temporary, target);
+}
+async function atomicWrite(target, content) {
+  await mkdir4(path7.dirname(target), { recursive: true });
+  const temporary = `${target}.killscript-${process.pid}.tmp`;
+  await writeFile4(temporary, content);
+  await replaceWithRetry(temporary, target);
+}
+async function replaceWithRetry(temporary, target) {
+  let lastError;
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    const backup = `${target}.killscript-${process.pid}.bak`;
+    let backedUp = false;
+    try {
+      try {
+        await rename2(temporary, target);
+        return;
+      } catch {
+      }
+      try {
+        await rename2(target, backup);
+        backedUp = true;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      await rename2(temporary, target);
+      if (backedUp) await rm3(backup, { force: true });
+      return;
+    } catch (error) {
+      lastError = error;
+      if (backedUp) {
+        try {
+          await rename2(backup, target);
+        } catch (restoreError) {
+          await rm3(temporary, { force: true });
+          throw new Error(`Failed to restore ${target} after an interrupted update.`, {
+            cause: restoreError
+          });
+        }
+      }
+      await delay(25 * 2 ** attempt);
+    }
+  }
+  await rm3(temporary, { force: true });
+  throw lastError;
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+// src/commands/clean.ts
+async function runClean(projectDir, options = {}) {
+  await Promise.all([
+    rm4(path8.join(projectDir, ".killscript", "build"), { recursive: true, force: true }),
+    rm4(path8.join(projectDir, ".killscript", "compiler"), { recursive: true, force: true }),
+    rm4(path8.join(projectDir, "dist"), { recursive: true, force: true })
+  ]);
+  let gameMessage = "";
+  if (options.game) {
+    const [config, local] = await Promise.all([
+      readProjectConfig(projectDir),
+      readLocalConfig(projectDir)
+    ]);
+    if (local.modulesPath === void 0) {
+      throw new Error("Cannot clean the game module: Modules path is not configured.");
+    }
+    const target = local.installedTarget ?? path8.join(path8.resolve(local.modulesPath), config.name);
+    gameMessage = await removeManagedModule(target, config.id) ? ` Removed managed game folder ${target}.` : " No managed game folder existed.";
+  }
+  console.log(`Removed generated output.${gameMessage}`);
+}
+
+// src/commands/dev.ts
+import path10 from "path";
+import { watch } from "chokidar";
+
+// src/commands/install.ts
+import { stat as stat3 } from "fs/promises";
+import path9 from "path";
+async function installProject(projectDir, options = {}) {
+  const local = await readLocalConfig(projectDir);
+  const configuredPath = options.modules ?? local.modulesPath;
+  if (configuredPath === void 0) {
+    throw new Error("Modules path is not configured. Pass --modules <path> once.");
+  }
+  const modulesPath = await resolveGameModulesPath(projectDir, configuredPath);
+  const config = await readProjectConfig(projectDir);
+  const build = await buildProject(projectDir, config);
+  const target = path9.join(modulesPath, config.name);
+  const sync = await syncManagedModule(build.outputDir, target, config.id);
+  let removedPreviousTarget;
+  if (local.installedTarget !== void 0) {
+    const previousTarget = path9.resolve(local.installedTarget);
+    if (previousTarget !== target) {
+      const status = await inspectManagedModule(previousTarget, config.id);
+      if (status === "managed") {
+        await removeManagedModule(previousTarget, config.id);
+        removedPreviousTarget = previousTarget;
+      }
+    }
+  }
+  await writeLocalConfig(projectDir, {
+    ...local,
+    modulesPath,
+    installedTarget: target
+  });
+  return {
+    config,
+    modulesPath,
+    target,
+    changed: sync.changed,
+    changedFiles: sync.changedFiles,
+    ...removedPreviousTarget === void 0 ? {} : { removedPreviousTarget }
+  };
+}
+async function resolveGameModulesPath(projectDir, modulesArgument) {
+  const modulesPath = path9.resolve(modulesArgument);
+  const info = await stat3(modulesPath).catch(() => void 0);
+  if (!info?.isDirectory()) {
+    throw new Error(`Modules path does not exist or is not a directory: ${modulesPath}`);
+  }
+  const projectPath = path9.resolve(projectDir);
+  const relative = path9.relative(modulesPath, projectPath);
+  const projectIsInsideModules = relative === "" || !relative.startsWith(`..${path9.sep}`) && relative !== ".." && !path9.isAbsolute(relative);
+  if (projectIsInsideModules) {
+    throw new Error(
+      `Keep the TypeScript project outside the game Modules folder. Only generated output may be installed into ${modulesPath}.`
+    );
+  }
+  return modulesPath;
+}
+async function runInstall(projectDir, options = {}) {
+  const result = await installProject(projectDir, options);
+  console.log(`Installed ${result.config.name} -> ${result.target} (${result.changed} files)`);
+  if (result.changedFiles.includes("scripts/server.lua")) {
+    console.log(
+      "Reflex server changed: folder hot reload requested for the current match."
+    );
+  }
+  if (result.removedPreviousTarget !== void 0) {
+    console.log(`Removed previous managed folder ${result.removedPreviousTarget}`);
+  }
+  console.log("Open or reopen the in-game module list, then enable the module once.");
+}
+
+// src/commands/dev.ts
+async function runDev(projectDir, options) {
+  let building = false;
+  let queued = false;
+  let firstBuild = true;
+  const rebuild = async (failFast = false) => {
+    if (building) {
+      queued = true;
+      return;
+    }
+    building = true;
+    try {
+      const result = await installProject(projectDir, {
+        ...options.modules === void 0 ? {} : { modules: options.modules }
+      });
+      const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      console.log(
+        `[${time}] ${firstBuild ? "Ready" : "Updated"} ${result.config.name} (${result.changed} files)`
+      );
+      if (result.changedFiles.includes("scripts/server.lua")) {
+        console.log(
+          `[${time}] Reflex server changed: folder hot reload requested for the current match.`
+        );
+      }
+      if (result.removedPreviousTarget !== void 0) {
+        console.log(`[${time}] Removed previous managed folder ${result.removedPreviousTarget}`);
+      }
+      firstBuild = false;
+    } catch (error) {
+      if (failFast) throw error;
+      const message = error instanceof CompileError ? formatCompileError(error) : String(error);
+      console.error(`
+Build failed; the last good game module was kept.
+${message}
+`);
+    } finally {
+      building = false;
+      if (queued) {
+        queued = false;
+        void rebuild();
+      }
+    }
+  };
+  await rebuild(options.once === true);
+  if (options.once) return;
+  const watcher = watch(
+    [path10.join(projectDir, "src"), path10.join(projectDir, "public"), path10.join(projectDir, "killscript.config.json")],
+    {
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 80, pollInterval: 20 }
+    }
+  );
+  watcher.on("all", () => void rebuild());
+  console.log(`Watching ${projectDir}`);
+  await new Promise((resolve) => {
+    const stop = () => {
+      void watcher.close().finally(resolve);
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+}
+
+// src/commands/doctor.ts
+import { access, stat as stat4 } from "fs/promises";
+import path11 from "path";
+async function runDoctor(projectDir, options = {}) {
+  const checks = [];
+  const major = Number(process.versions.node.split(".")[0]);
+  if (!Number.isFinite(major) || major < 20) {
+    throw new Error(`Node.js 20 or newer is required; found ${process.versions.node}.`);
+  }
+  checks.push({ label: "Node", detail: process.versions.node });
+  const config = await readProjectConfig(projectDir);
+  checks.push({ label: "Project", detail: `${config.name} ${config.version}${config.reflex ? " (Reflex)" : ""}` });
+  await access(path11.join(projectDir, "src", "client", "main.ts"));
+  if (config.reflex) await access(path11.join(projectDir, "src", "server", "main.ts"));
+  checks.push({ label: "Entries", detail: config.reflex ? "client + server" : "client" });
+  const result = await buildProject(projectDir, config);
+  checks.push({ label: "Compiler", detail: `${result.settings} settings, ${result.controls} controls` });
+  const local = await readLocalConfig(projectDir);
+  const modulesPath = options.modules ?? local.modulesPath;
+  if (modulesPath === void 0) {
+    checks.push({ label: "Game link", detail: "not configured (run killscript link <Modules>)" });
+  } else {
+    const absolute = path11.resolve(modulesPath);
+    if (!(await stat4(absolute).catch(() => void 0))?.isDirectory()) {
+      throw new Error(`Configured Modules folder is unavailable: ${absolute}`);
+    }
+    const target = path11.join(absolute, config.name);
+    const status = await inspectManagedModule(target, config.id);
+    if (status === "foreign") throw new Error(`Game target is owned by another module: ${target}`);
+    checks.push({ label: "Game link", detail: `${absolute} (${status})` });
+  }
+  const width = Math.max(...checks.map((check) => check.label.length));
+  for (const check of checks) console.log(`\u2713 ${check.label.padEnd(width)}  ${check.detail}`);
+  console.log("\nProject is ready.");
+}
+
+// src/commands/link.ts
+async function runLink(projectDir, modulesArgument) {
+  const modulesPath = await resolveGameModulesPath(projectDir, modulesArgument);
+  const current = await readLocalConfig(projectDir);
+  await writeLocalConfig(projectDir, { ...current, modulesPath });
+  console.log(`Linked game Modules folder: ${modulesPath}`);
+}
+
+// src/commands/new.ts
+import { spawn } from "child_process";
+import { mkdir as mkdir5, readFile as readFile4, readdir as readdir4, rm as rm5, writeFile as writeFile5 } from "fs/promises";
+import path12 from "path";
+import { fileURLToPath } from "url";
+async function runNew(destinationArgument, options) {
+  const destination = path12.resolve(destinationArgument);
+  const name = path12.basename(destination);
+  assertProjectName(name);
+  if (options.modules !== void 0) {
+    await resolveGameModulesPath(destination, options.modules);
+  }
+  await mkdir5(destination, { recursive: false });
+  await scaffold(destinationArgument, destination, name, options, true);
+}
+async function runInit(destinationArgument, options) {
+  const destination = path12.resolve(destinationArgument);
+  const name = path12.basename(destination);
+  assertProjectName(name);
+  if (options.modules !== void 0) {
+    await resolveGameModulesPath(destination, options.modules);
+  }
+  await mkdir5(destination, { recursive: true });
+  const existing = (await readdir4(destination)).filter((entry) => entry !== ".git");
+  if (existing.length > 0) {
+    throw new Error(`Cannot initialize ${destination}: the directory is not empty.`);
+  }
+  await scaffold(destinationArgument, destination, name, options, false);
+}
+async function scaffold(destinationArgument, destination, name, options, removeDestinationOnFailure) {
+  try {
+    const template = path12.resolve(
+      path12.dirname(fileURLToPath(import.meta.url)),
+      "..",
+      "templates",
+      "default"
+    );
+    const namespace = toKebabCase(name);
+    await copyTemplate(template, destination, {
+      "__MODULE_NAME__": name,
+      "__MODULE_NAMESPACE__": namespace,
+      "__TOOLCHAIN_VERSION__": VERSION
+    });
+    const config = createProjectConfig({
+      name,
+      ...options.author === void 0 ? {} : { author: options.author },
+      ...options.reflex === void 0 ? {} : { reflex: options.reflex }
+    });
+    await writeProjectConfig(destination, config);
+    if (!config.reflex) {
+      await rm5(path12.join(destination, "src", "server"), { recursive: true, force: true });
+      await rm5(path12.join(destination, "tsconfig.server.json"), { force: true });
+      await writeFile5(
+        path12.join(destination, "tsconfig.json"),
+        `${JSON.stringify({ files: [], references: [{ path: "./tsconfig.client.json" }] }, null, 2)}
+`
+      );
+    }
+    if (options.modules !== void 0) {
+      await writeLocalConfig(destination, { modulesPath: path12.resolve(options.modules) });
+    }
+    const installDependencies = options.install ?? true;
+    if (installDependencies) await run("npm", ["install"], destination);
+    if (options.git ?? true) await run("git", ["init", "-b", "master"], destination);
+    let installedTarget;
+    if (options.modules !== void 0 && installDependencies) {
+      installedTarget = (await installProject(destination)).target;
+    }
+    console.log(`
+Created ${name} in ${destination}`);
+    if (installedTarget !== void 0) {
+      console.log(`Installed game module in ${installedTarget}`);
+      console.log("Open or reopen the in-game module list, then enable it once.");
+    }
+    console.log(`  cd ${destinationArgument}`);
+    console.log(
+      options.modules === void 0 ? "  npm run dev -- --modules <path-to-game-Modules>" : installDependencies ? "  npm run dev" : "  npm install && npm run install:game"
+    );
+  } catch (error) {
+    if (removeDestinationOnFailure) {
+      await rm5(destination, { recursive: true, force: true });
+    } else {
+      for (const entry of await readdir4(destination)) {
+        if (entry !== ".git") await rm5(path12.join(destination, entry), { recursive: true, force: true });
+      }
+    }
+    throw error;
+  }
+}
+async function copyTemplate(source, destination, replacements) {
+  for (const entry of await readdir4(source, { withFileTypes: true })) {
+    const targetName = entry.name === "gitignore" ? ".gitignore" : entry.name;
+    const from = path12.join(source, entry.name);
+    const to = path12.join(destination, targetName);
+    if (entry.isDirectory()) {
+      await mkdir5(to, { recursive: true });
+      await copyTemplate(from, to, replacements);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    let content = await readFile4(from, "utf8");
+    for (const [search, replacement] of Object.entries(replacements)) {
+      content = content.replaceAll(search, replacement);
+    }
+    await writeFile5(to, content);
+  }
+}
+async function run(command, args, cwd) {
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, stdio: "inherit" });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${command} exited with code ${code ?? "unknown"}.`));
+    });
+  });
+}
+function assertProjectName(name) {
+  if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(name)) {
+    throw new Error(
+      "Module name must start with a letter and contain only letters, numbers, _ or -."
+    );
+  }
+}
+function toKebabCase(value) {
+  return value.replace(/([a-z\d])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+
+// src/cli.ts
+var program = new Command().name("killscript").description("Build TypeScript modules for KILLSCRIPT").version(VERSION).showHelpAfterError().showSuggestionAfterError();
+program.command("new").description("create a new KILLSCRIPT module").argument("<directory>").option("--author <name>", "module author").option("--reflex", "include a Reflex server entry").option("--modules <path>", "remember the game Modules folder").option("--no-install", "skip npm install").option("--no-git", "skip git init").action(async (directory, options) => runNew(directory, options));
+program.command("init").description("initialize an empty directory as a KILLSCRIPT module").argument("[directory]", "empty directory", ".").option("--author <name>", "module author").option("--reflex", "include a Reflex server entry").option("--modules <path>", "remember the game Modules folder").option("--no-install", "skip npm install").option("--no-git", "skip git init").action(async (directory, options) => runInit(directory, options));
+program.command("build").description("compile and pack the current module").option("--no-pack", "only create the module folder").action(async (options) => runBuild(process.cwd(), options));
+program.command("check").description("type-check and compile without keeping a package").action(async () => runBuild(process.cwd(), { pack: false }));
+program.command("install").description("build and install the folder module into the game once").option("--modules <path>", "game Modules folder").action(async (options) => runInstall(process.cwd(), options));
+program.command("dev").description("watch sources and sync a folder module into the game").option("--modules <path>", "game Modules folder").option("--once", "build and synchronize once without watching").action(async (options) => runDev(process.cwd(), options));
+program.command("link").description("remember the game Modules folder for this project").argument("<path>").action(async (modulesPath) => runLink(process.cwd(), modulesPath));
+program.command("doctor").description("validate the project, compiler and game folder connection").option("--modules <path>", "temporarily check a game Modules folder").action(async (options) => runDoctor(process.cwd(), options));
+program.command("clean").description("remove generated output").option("--game", "also remove this project's managed folder from the game").action(async (options) => runClean(process.cwd(), options));
+try {
+  await program.parseAsync();
+} catch (error) {
+  console.error(`
+${error instanceof Error ? error.message : String(error)}`);
+  process.exitCode = 1;
+}