@vibemancer/core 0.1.0

package/dist/index.js

@@ -0,0 +1,750 @@
+import {
+  ALL_BOTS,
+  ARENA_HEIGHT,
+  ARENA_SIZE,
+  ARENA_WATER_BUFFER,
+  ARENA_WIDTH,
+  Archlich,
+  Archmage,
+  BLINK_CAST_TIME,
+  BLINK_COOLDOWN,
+  BLINK_MAX_COOLDOWN,
+  BLINK_MAX_RANGE,
+  BLINK_MIN_COOLDOWN,
+  BLINK_RANGE,
+  BOT_GROUPS,
+  Battlemage,
+  Bonemancer,
+  BrowserManualMatchSandbox,
+  BrowserMatchSandbox,
+  CASTING_MOVEMENT_MULT,
+  COLLISION_RADIUS,
+  Critter,
+  Doombringer,
+  ENGINE_VERSION,
+  FIGHT_SPAWN_DISTANCES,
+  Flamecaller,
+  GCD_DURATION,
+  Golem,
+  Hogger,
+  Infernalist,
+  Lich,
+  MATCH_DURATION,
+  MAX_HEALTH,
+  MISSILE_BASE_CAST,
+  MISSILE_BASE_RADIUS,
+  MISSILE_DAMAGE_POWER,
+  MISSILE_DAMAGE_RADIUS_SCALE,
+  MISSILE_DAMAGE_SCALE,
+  MISSILE_HOMING_COEFF,
+  MISSILE_MIN_CAST_TIME,
+  MISSILE_MIN_DAMAGE,
+  MISSILE_MIN_DURATION,
+  MISSILE_MIN_SPEED,
+  MISSILE_RADIUS_PER_DAMAGE,
+  MISSILE_SPEED_DURATION_BASELINE,
+  MISSILE_SPEED_DURATION_COEFF,
+  MISSILE_TURN_DURATION_COEFF,
+  MOVEMENT_SPEED,
+  MOVE_SPEED,
+  ManualMatch,
+  Nightblade,
+  Pyromancer,
+  Rookie,
+  SHIELD_CAST_TIME,
+  SHIELD_DECAY_PER_SECOND,
+  SHIELD_DECAY_RATE,
+  SHIELD_MAX_BLOCK,
+  SHIELD_MAX_STRENGTH,
+  SHIELD_MIN_BLOCK,
+  SHIELD_MIN_STRENGTH,
+  SPAWN_DISTANCE,
+  Sentinel,
+  Shadowblade,
+  Spellbinder,
+  Spellseeker,
+  Spellshot,
+  Spellspinner,
+  Spelltracer,
+  Spellweaver,
+  Stormcaller,
+  Stormchaser,
+  Stormforger,
+  TICKS_PER_SECOND,
+  TICK_DURATION_MS,
+  TargetDummy,
+  Turtle,
+  Voidblade,
+  WARMUP_DURATION_TOLERANCE,
+  WARMUP_MAX_BONUS,
+  WARMUP_MAX_PENALTY,
+  WARMUP_SPEED_TOLERANCE,
+  WARMUP_TURN_TOLERANCE,
+  WIZARD_HEALTH,
+  WIZARD_RADIUS,
+  Warmage,
+  analyzeThreats,
+  angleDiff,
+  angleInRange,
+  angleTo,
+  antiHomingMissile,
+  applyDamage,
+  blink,
+  browserSandboxFight,
+  browserSandboxSimulate,
+  calculateBlinkCooldown,
+  calculateMissileCastTime,
+  calculateMissileRadius,
+  calculateMissileSimilarity,
+  calculateShieldBlock,
+  calculateWarmupMultiplier,
+  cancel,
+  cancelCast,
+  clampPositionToArena,
+  clampToArena,
+  clearHooks,
+  clearParamValues,
+  completeCast,
+  createEntitySeed,
+  createInitialState,
+  createRandom,
+  createWorkerScript,
+  diagnoseTrace,
+  directionAway,
+  directionTo,
+  distanceTo,
+  effectiveTurnRateCost,
+  extractAction,
+  extractStats,
+  extractTraceEvents,
+  fight,
+  findInRange,
+  findNearest,
+  fitMissileToBudget,
+  formatDiagnosis,
+  formatStats,
+  formatTraceEvents,
+  formatTraceSummary,
+  generateCandidates,
+  generateCombos,
+  getAdaptiveMissileConfig,
+  getBotContext,
+  getEffectiveRange,
+  getLeadPosition,
+  getMissileCastTime,
+  getPlayerState,
+  hashCombine,
+  homingMissile,
+  idle,
+  inRange,
+  interceptAngle,
+  isNewStyleBot,
+  magnitude,
+  missile,
+  move,
+  moveInDirection,
+  moveProjectile,
+  moveWizard,
+  narrowRange,
+  nextRandom,
+  normalize,
+  normalizeAngle,
+  predictPosition,
+  resetAllHooks,
+  resolveWizardCollision,
+  runBotWithContext,
+  runWithHooks,
+  scoreFight,
+  scoreFightAsWizard2,
+  seekerMissile,
+  setParamValues,
+  shield,
+  simulate,
+  sortByDistance,
+  spiralMissile,
+  startCast,
+  startDiscovery,
+  stopDiscovery,
+  straightMissile,
+  summarizeTrace,
+  sweptCircleCollision,
+  testBot,
+  tick,
+  updateShield,
+  useArenaSize,
+  useBlinkCooldown,
+  useCastProgress,
+  useCastingSpell,
+  useClosestThreat,
+  useDamageDealt,
+  useDamageTaken,
+  useEffect,
+  useEnemy,
+  useHealth,
+  useLastHitTick,
+  useMemo,
+  useMyProjectiles,
+  useMyThreatsToEnemy,
+  useParam,
+  usePosition,
+  useRef,
+  useShieldStrength,
+  useState,
+  useStatus,
+  useThreats,
+  useTick,
+  useTicksUntilReady,
+  useVelocity,
+  validateHookCall,
+  validateMissileConfig,
+  withBotContext,
+  wrapNewBot,
+  wrapWithParams
+} from "./chunk-L7Z7OFXD.js";
+
+// src/engine/sandbox.ts
+import ivm from "isolated-vm";
+
+// src/engine/sandbox-compile.ts
+import { build } from "esbuild";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+
+// src/engine/sandbox-harness.ts
+var PROTOTYPE_FREEZE_BANNER = `
+Object.freeze(Object.prototype);
+Object.freeze(Array.prototype);
+Object.freeze(Function.prototype);
+Object.freeze(String.prototype);
+Object.freeze(Number.prototype);
+Object.freeze(Boolean.prototype);
+Object.freeze(RegExp.prototype);
+Object.freeze(Date.prototype);
+Object.freeze(Error.prototype);
+Object.freeze(Map.prototype);
+Object.freeze(Set.prototype);
+Object.freeze(Math);
+Object.freeze(JSON);
+(function() {
+	var g = typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : {};
+	var blocked = [
+		'fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource',
+		'importScripts', 'Worker', 'SharedWorker',
+		'Request', 'Response', 'Headers',
+		'navigator', 'BroadcastChannel',
+		'indexedDB', 'caches'
+	];
+	for (var i = 0; i < blocked.length; i++) {
+		try { Object.defineProperty(g, blocked[i], {value: undefined, writable: false, configurable: false}); }
+		catch(e) {}
+	}
+})();
+`;
+function generateMatchEntryPoint(bot1SourcePath, bot1ExportName, bot2SourcePath, bot2ExportName, engineDir) {
+  const enginePath = engineDir.replace(/\\/g, "/");
+  const bot1Path = bot1SourcePath.replace(/\\/g, "/");
+  const bot2Path = bot2SourcePath.replace(/\\/g, "/");
+  const srcPath = enginePath.replace(/\/engine\/?$/, "");
+  return `
+import {${bot1ExportName} as __RawBot1} from '${bot1Path}';
+import {${bot2ExportName} as __RawBot2} from '${bot2Path}';
+import {fight, simulate} from '${srcPath}/engine/simulation.ts';
+import {wrapWithParams} from '${srcPath}/engine/params-runtime.ts';
+import {wrapNewBot} from '${srcPath}/hooks/bot-wrapper.ts';
+
+// Auto-detect new-style bots (hooks API) and wrap them for the simulation engine.
+// New-style: uses hooks, returns FinalAction (has _toAction method).
+// Old-style: accepts ({state, config, random}), returns WizardActions directly.
+// We detect by doing a dry-run call \u2014 if the result has _toAction, it's new-style.
+//
+// Detection is deferred until the first fight/simulate call so that malicious
+// bots (infinite loops, memory bombs) time out during fight(), not during
+// sandbox creation. __resolveBots memoizes the wrapped functions.
+function __wrap(bot) {
+	if (bot.length > 0) return bot; // Old-style: has parameters
+	// 0-param function could be either style. Try calling it to check return type.
+	try {
+		var result = bot();
+		if (result && typeof result._toAction === 'function') {
+			return wrapNewBot(bot);
+		}
+	} catch(e) {
+		// If it throws (e.g. hooks not initialized), it must be new-style
+		return wrapNewBot(bot);
+	}
+	return bot;
+}
+
+var __Bot1 = null;
+var __Bot2 = null;
+function __resolveBots() {
+	if (__Bot1 === null) __Bot1 = __wrap(__RawBot1);
+	if (__Bot2 === null) __Bot2 = __wrap(__RawBot2);
+}
+
+globalThis.__fight = function __fight(options) {
+	__resolveBots();
+	const result = fight(__Bot1, __Bot2, options);
+	return result;
+};
+
+globalThis.__simulate = function __simulate(options) {
+	__resolveBots();
+	const {params1, params2, ...simOptions} = options;
+	const bot1 = params1 ? wrapWithParams(__Bot1, params1) : __Bot1;
+	const bot2 = params2 ? wrapWithParams(__Bot2, params2) : __Bot2;
+	const result = simulate(bot1, bot2, simOptions);
+	return result;
+};
+`;
+}
+
+// src/engine/sandbox-compile.ts
+var currentFilename = fileURLToPath(import.meta.url);
+var currentDirname = path.dirname(currentFilename);
+function getEngineDir() {
+  const directPath = path.resolve(currentDirname);
+  if (fs.existsSync(path.join(directPath, "simulation.ts"))) {
+    return directPath;
+  }
+  const packageRoot2 = path.resolve(currentDirname, "..", "..");
+  const srcEngine2 = path.join(packageRoot2, "src", "engine");
+  if (fs.existsSync(path.join(srcEngine2, "simulation.ts"))) {
+    return srcEngine2;
+  }
+  const packageRoot1 = path.resolve(currentDirname, "..");
+  const srcEngine1 = path.join(packageRoot1, "src", "engine");
+  if (fs.existsSync(path.join(srcEngine1, "simulation.ts"))) {
+    return srcEngine1;
+  }
+  throw new Error("Could not find engine source directory (src/engine/simulation.ts)");
+}
+var BotBundle = class {
+  sourcePath;
+  exportName;
+  constructor(sourcePath, exportName) {
+    if (!sourcePath || typeof sourcePath !== "string") {
+      throw new Error("sourcePath must be a non-empty string");
+    }
+    if (!exportName || typeof exportName !== "string") {
+      throw new Error("exportName must be a non-empty string");
+    }
+    this.sourcePath = path.resolve(sourcePath);
+    this.exportName = exportName;
+  }
+};
+async function compileMatchBundle(bot1, bot2, options) {
+  const engineDir = getEngineDir();
+  const entryPoint = generateMatchEntryPoint(
+    bot1.sourcePath,
+    bot1.exportName,
+    bot2.sourcePath,
+    bot2.exportName,
+    engineDir
+  );
+  const result = await build({
+    stdin: {
+      contents: entryPoint,
+      resolveDir: engineDir,
+      loader: "ts"
+    },
+    bundle: true,
+    write: false,
+    format: "iife",
+    platform: "neutral",
+    target: "es2022",
+    banner: {
+      js: PROTOTYPE_FREEZE_BANNER
+    },
+    // Suppress warnings about top-level this in ESM
+    logLevel: "error",
+    // Match bundles run in sandboxed environments (Web Workers / isolated-vm)
+    // and should never include Node.js native modules
+    external: [
+      "isolated-vm",
+      "esbuild",
+      "node:path",
+      "node:fs",
+      "node:url",
+      "node:worker_threads",
+      "node:crypto",
+      "node:os",
+      "node:child_process",
+      ...options?.external ?? []
+    ],
+    ...options?.alias ? { alias: options.alias } : {}
+  });
+  if (!result.outputFiles?.[0]) {
+    throw new Error("esbuild produced no output");
+  }
+  return result.outputFiles[0].text;
+}
+
+// src/engine/sandbox.ts
+var MatchSandbox = class _MatchSandbox {
+  isolate;
+  context;
+  fightFn;
+  simulateFn;
+  timeout;
+  disposed = false;
+  constructor(isolate, context, fightFn, simulateFn, timeout) {
+    this.isolate = isolate;
+    this.context = context;
+    this.fightFn = fightFn;
+    this.simulateFn = simulateFn;
+    this.timeout = timeout;
+  }
+  /**
+   * Create a sandbox with both bots loaded. Compiles the match bundle
+   * automatically using esbuild.
+   */
+  static async create(bot1, bot2, options) {
+    const memoryLimitMB = options?.memoryLimitMB ?? 512;
+    const timeoutMs = options?.timeoutMs ?? 3e4;
+    const bundle = await compileMatchBundle(bot1, bot2, options?.compileOptions);
+    const isolate = new ivm.Isolate({ memoryLimit: memoryLimitMB });
+    try {
+      const context = await isolate.createContext();
+      const script = await isolate.compileScript(bundle, { filename: "match-bundle.js" });
+      await script.run(context, { timeout: timeoutMs });
+      const global = context.global;
+      const fightFn = await global.get("__fight", { reference: true });
+      const simulateFn = await global.get("__simulate", { reference: true });
+      return new _MatchSandbox(isolate, context, fightFn, simulateFn, timeoutMs);
+    } catch (error) {
+      try {
+        isolate.dispose();
+      } catch {
+      }
+      throw error;
+    }
+  }
+  /**
+   * Create a sandbox from a pre-compiled bundle string.
+   * Useful for caching compiled bundles across multiple MatchSandbox instances.
+   */
+  static async fromBundle(bundle, options) {
+    const memoryLimitMB = options?.memoryLimitMB ?? 512;
+    const timeoutMs = options?.timeoutMs ?? 3e4;
+    const isolate = new ivm.Isolate({ memoryLimit: memoryLimitMB });
+    try {
+      const context = await isolate.createContext();
+      const script = await isolate.compileScript(bundle, { filename: "match-bundle.js" });
+      await script.run(context, { timeout: timeoutMs });
+      const global = context.global;
+      const fightFn = await global.get("__fight", { reference: true });
+      const simulateFn = await global.get("__simulate", { reference: true });
+      return new _MatchSandbox(isolate, context, fightFn, simulateFn, timeoutMs);
+    } catch (error) {
+      try {
+        isolate.dispose();
+      } catch {
+      }
+      throw error;
+    }
+  }
+  /**
+   * Compile a match bundle without creating an isolate.
+   * Returns the compiled JS string for caching/reuse.
+   */
+  static async compile(bot1, bot2, compileOptions) {
+    return compileMatchBundle(bot1, bot2, compileOptions);
+  }
+  /**
+   * Run a full fight (10 matches: 5 spawn distances x 2 sides).
+   * Synchronous after isolate creation — runs entirely inside the isolate.
+   */
+  fight(options) {
+    this.ensureNotDisposed();
+    return this.fightFn.applySync(void 0, [options ?? {}], {
+      arguments: { copy: true },
+      result: { copy: true },
+      timeout: this.timeout
+    });
+  }
+  /**
+   * Run a single simulation.
+   * Synchronous after isolate creation.
+   *
+   * @param options.params1 - useParam overrides for bot 1 (wizard-1)
+   * @param options.params2 - useParam overrides for bot 2 (wizard-2)
+   */
+  simulate(options) {
+    this.ensureNotDisposed();
+    return this.simulateFn.applySync(void 0, [options ?? {}], {
+      arguments: { copy: true },
+      result: { copy: true },
+      timeout: this.timeout
+    });
+  }
+  /**
+   * Dispose the isolate and free all memory.
+   * The sandbox cannot be used after disposal.
+   */
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = true;
+      try {
+        this.fightFn.release();
+      } catch {
+      }
+      try {
+        this.simulateFn.release();
+      } catch {
+      }
+      try {
+        this.context.release();
+      } catch {
+      }
+      try {
+        this.isolate.dispose();
+      } catch {
+      }
+    }
+  }
+  /**
+   * Whether this sandbox has been disposed.
+   */
+  get isDisposed() {
+    return this.disposed;
+  }
+  ensureNotDisposed() {
+    if (this.disposed) {
+      throw new Error("MatchSandbox has been disposed");
+    }
+  }
+};
+async function sandboxFight(bot1, bot2, options) {
+  const sandbox = await MatchSandbox.create(bot1, bot2, options);
+  try {
+    return sandbox.fight({ seed: options?.seed, maxTicks: options?.maxTicks });
+  } finally {
+    sandbox.dispose();
+  }
+}
+async function sandboxSimulate(bot1, bot2, options) {
+  const sandbox = await MatchSandbox.create(bot1, bot2, options);
+  try {
+    return sandbox.simulate({
+      seed: options?.seed,
+      maxTicks: options?.maxTicks,
+      spawnDistance: options?.spawnDistance,
+      skipHistory: options?.skipHistory,
+      params1: options?.params1,
+      params2: options?.params2
+    });
+  } finally {
+    sandbox.dispose();
+  }
+}
+export {
+  ALL_BOTS,
+  ARENA_HEIGHT,
+  ARENA_SIZE,
+  ARENA_WATER_BUFFER,
+  ARENA_WIDTH,
+  Archlich,
+  Archmage,
+  BLINK_CAST_TIME,
+  BLINK_COOLDOWN,
+  BLINK_MAX_COOLDOWN,
+  BLINK_MAX_RANGE,
+  BLINK_MIN_COOLDOWN,
+  BLINK_RANGE,
+  BOT_GROUPS,
+  Battlemage,
+  Bonemancer,
+  BotBundle,
+  BrowserManualMatchSandbox,
+  BrowserMatchSandbox,
+  CASTING_MOVEMENT_MULT,
+  COLLISION_RADIUS,
+  Critter,
+  Doombringer,
+  ENGINE_VERSION,
+  FIGHT_SPAWN_DISTANCES,
+  Flamecaller,
+  GCD_DURATION,
+  Golem,
+  Hogger,
+  Infernalist,
+  Lich,
+  MATCH_DURATION,
+  MAX_HEALTH,
+  MISSILE_BASE_CAST,
+  MISSILE_BASE_RADIUS,
+  MISSILE_DAMAGE_POWER,
+  MISSILE_DAMAGE_RADIUS_SCALE,
+  MISSILE_DAMAGE_SCALE,
+  MISSILE_HOMING_COEFF,
+  MISSILE_MIN_CAST_TIME,
+  MISSILE_MIN_DAMAGE,
+  MISSILE_MIN_DURATION,
+  MISSILE_MIN_SPEED,
+  MISSILE_RADIUS_PER_DAMAGE,
+  MISSILE_SPEED_DURATION_BASELINE,
+  MISSILE_SPEED_DURATION_COEFF,
+  MISSILE_TURN_DURATION_COEFF,
+  MOVEMENT_SPEED,
+  MOVE_SPEED,
+  ManualMatch,
+  MatchSandbox,
+  Nightblade,
+  Pyromancer,
+  Rookie,
+  SHIELD_CAST_TIME,
+  SHIELD_DECAY_PER_SECOND,
+  SHIELD_DECAY_RATE,
+  SHIELD_MAX_BLOCK,
+  SHIELD_MAX_STRENGTH,
+  SHIELD_MIN_BLOCK,
+  SHIELD_MIN_STRENGTH,
+  SPAWN_DISTANCE,
+  Sentinel,
+  Shadowblade,
+  Spellbinder,
+  Spellseeker,
+  Spellshot,
+  Spellspinner,
+  Spelltracer,
+  Spellweaver,
+  Stormcaller,
+  Stormchaser,
+  Stormforger,
+  TICKS_PER_SECOND,
+  TICK_DURATION_MS,
+  TargetDummy,
+  Turtle,
+  Voidblade,
+  WARMUP_DURATION_TOLERANCE,
+  WARMUP_MAX_BONUS,
+  WARMUP_MAX_PENALTY,
+  WARMUP_SPEED_TOLERANCE,
+  WARMUP_TURN_TOLERANCE,
+  WIZARD_HEALTH,
+  WIZARD_RADIUS,
+  Warmage,
+  analyzeThreats,
+  angleDiff,
+  angleInRange,
+  angleTo,
+  antiHomingMissile,
+  applyDamage,
+  blink,
+  browserSandboxFight,
+  browserSandboxSimulate,
+  calculateBlinkCooldown,
+  calculateMissileCastTime,
+  calculateMissileRadius,
+  calculateMissileSimilarity,
+  calculateShieldBlock,
+  calculateWarmupMultiplier,
+  cancel,
+  cancelCast,
+  clampPositionToArena,
+  clampToArena,
+  clearHooks,
+  clearParamValues,
+  compileMatchBundle,
+  completeCast,
+  createEntitySeed,
+  createInitialState,
+  createRandom,
+  createWorkerScript,
+  diagnoseTrace,
+  directionAway,
+  directionTo,
+  distanceTo,
+  effectiveTurnRateCost,
+  extractAction,
+  extractStats,
+  extractTraceEvents,
+  fight,
+  findInRange,
+  findNearest,
+  fitMissileToBudget,
+  formatDiagnosis,
+  formatStats,
+  formatTraceEvents,
+  formatTraceSummary,
+  generateCandidates,
+  generateCombos,
+  getAdaptiveMissileConfig,
+  getBotContext,
+  getEffectiveRange,
+  getLeadPosition,
+  getMissileCastTime,
+  getPlayerState,
+  hashCombine,
+  homingMissile,
+  idle,
+  inRange,
+  interceptAngle,
+  isNewStyleBot,
+  magnitude,
+  missile,
+  move,
+  moveInDirection,
+  moveProjectile,
+  moveWizard,
+  narrowRange,
+  nextRandom,
+  normalize,
+  normalizeAngle,
+  predictPosition,
+  resetAllHooks,
+  resolveWizardCollision,
+  runBotWithContext,
+  runWithHooks,
+  sandboxFight,
+  sandboxSimulate,
+  scoreFight,
+  scoreFightAsWizard2,
+  seekerMissile,
+  setParamValues,
+  shield,
+  simulate,
+  sortByDistance,
+  spiralMissile,
+  startCast,
+  startDiscovery,
+  stopDiscovery,
+  straightMissile,
+  summarizeTrace,
+  sweptCircleCollision,
+  testBot,
+  tick,
+  updateShield,
+  useArenaSize,
+  useBlinkCooldown,
+  useCastProgress,
+  useCastingSpell,
+  useClosestThreat,
+  useDamageDealt,
+  useDamageTaken,
+  useEffect,
+  useEnemy,
+  useHealth,
+  useLastHitTick,
+  useMemo,
+  useMyProjectiles,
+  useMyThreatsToEnemy,
+  useParam,
+  usePosition,
+  useRef,
+  useShieldStrength,
+  useState,
+  useStatus,
+  useThreats,
+  useTick,
+  useTicksUntilReady,
+  useVelocity,
+  validateHookCall,
+  validateMissileConfig,
+  withBotContext,
+  wrapNewBot,
+  wrapWithParams
+};
+//# sourceMappingURL=index.js.map