tensor.js

// ==UserScript==
// @name        Tensor
// @namespace   Scripts
// @match       https://*.bloxd.io/*
// @grant       GM_getValue
// @grant       GM_setValue
// @grant       GM_addStyle
// @grant       GM_registerMenuCommand
// @grant       unsafeWindow
// @run-at      document-end
// @version     1.0.0
// @author      -
// @description Tensor Framework for Bloxd.io
// ==/UserScript==
(() => {

  // tensor-src/utils.js

  
    // src/utils.js
    // 工具函数库（基于 inject.js）
    var keys = (obj) => Object.keys(obj ?? {});
    var values = (obj) => keys(obj).map((key) => obj[key]);
    var entries = (obj) => Object.entries(obj ?? {});
    var attempt = (fn, fallback = null) => {
      try {
        return fn();
      } catch {
        return fallback;
      }
    };
    var clone = typeof structuredClone === 'function' 
      ? structuredClone 
      : (obj) => obj && JSON.parse(JSON.stringify(obj));
    var style = (el3, props) => Object.assign(el3.style, props);
    var el = (tag) => document.createElement(tag);
    var floor = Math.floor;
  
    // Export as utils object（保持 Tensor 兼容性）
    const utils = { keys, values, entries, attempt, clone, style, el, floor };

  // tensor-src/config.js

  // Configuration System
  const config = {
      keyMap: {},
      killaura: { delay: 120, range: 6.8, jitterRatio: 0.4 },
      scaffold: { interval: 20 },
      slowSwing: { duration: 2000 }
  };
  
  const moduleNames = ["Killaura", "Scaffold", "SlowSwing", "CoordsList", "ESP", "Bhop"];
  const defaultKeybinds = {
      Killaura: "KeyK", ESP: "KeyE", CoordsList: "KeyL", 
      Scaffold: "KeyG", SlowSwing: "KeyH", Bhop: "KeyB"
  };

  // tensor-src/bloxd.js

  
    // src/bloxd.js - 基于 inject.js 的注入核心（完整版本）
    // ============================================
    // 核心注入对象 B
    // ============================================
    
    var B = {
      wpRequire: null,
      _noa: null,
      bloxdProps: null,
      
      get noa() {
        if (!this._noa && this.bloxdProps) {
          this._noa = values(this.bloxdProps).find((p) => p?.entities);
        }
        return this._noa;
      },
      
      clear() {
        this.wpRequire = null;
        this._noa = null;
        this.bloxdProps = null;
      },
      
      init(force = false) {
        if (this.wpRequire && !force) return;
        this.clear();
        
        // 处理 Tampermonkey 沙盒环境
        const globalWindow = typeof unsafeWindow !== 'undefined' ? unsafeWindow : window;
        
        // 方法 1: 通过描述符查找 Webpack chunk setter
        let descriptors = Object.getOwnPropertyDescriptors(globalWindow);
        let chunkKey = Object.keys(descriptors).find((key) => {
          let setter = descriptors[key]?.set;
          return setter && setter.toString().includes("++");
        });
        
        // 方法 2: 通过数组属性查找 Webpack chunk
        if (!chunkKey) {
          chunkKey = Object.keys(globalWindow).find((key) => {
            let value = globalWindow[key];
            return Array.isArray(value) && typeof value.push === "function";
          });
        }
        
        // 如果仍然找不到，抛出错误
        if (!chunkKey) {
          throw new Error("无法定位 Webpack chunk");
        }
        
        // 注入自定义模块
        let chunk = globalWindow[chunkKey];
        let randomID = Math.floor(Math.random() * 9999999) + 1;
        chunk.push([[randomID], {}, (req) => this.wpRequire = req]);
        
        // 查找游戏属性对象
        this.bloxdProps = values(this.findModule("nonBlocksClient:")).find(
          (o) => typeof o === "object"
        );
        this._noa = null;
      },
      
      findModule(str) {
        if (!this.wpRequire) return null;
        let mods = this.wpRequire.m;
        for (let id in mods) {
          let modFn = mods[id];
          if (modFn && modFn.toString().includes(str))
            return this.wpRequire(id);
        }
        return null;
      },
      
      reinject() {
        try {
          this.init(true);
          return true;
        } catch (error) {
          return false;
        }
      }
    };
    
    // ============================================
    // 游戏上下文辅助函数
    // ============================================
    
    var getImpKey = () => attempt(() => {
      let entities = B.noa.entities;
      let target = values(entities)[2];
      return entries(entities).find(([, val]) => val === target)?.[0] ?? null;
    });
    
    var getInventoryContext = () => {
      let noa = B.noa;
      if (!noa) return null;
      let entities = noa.entities;
      let impKey = getImpKey();
      if (!impKey) return null;
      let entity = entities[impKey];
      if (!entity) return null;
      let inventoryWrapper = values(entity).find(
        (value) => value?.list?.[0]?._blockItem
      );
      if (!inventoryWrapper?.list?.length) return null;
      let listItem = inventoryWrapper.list[0];
      return { impKey, entity, inventoryWrapper, listItem };
    };
    
    var getHeldBlockContext = () => {
      let ctx = getInventoryContext();
      if (!ctx) return null;
      let heldBlock = ctx.listItem?._blockItem;
      if (!heldBlock) return null;
      let playerEntity = values(ctx.listItem).find(
        (value) => typeof value?.checkTargetedBlockCanBePlacedOver === "function"
      );
      if (!playerEntity) return null;
      let worldInstanceKey, worldInstance;
      if (keys(heldBlock).some((key) => {
        let value = heldBlock[key];
        if (value && typeof value === "object") {
          worldInstanceKey = key;
          worldInstance = value;
          return true;
        }
        return false;
      }), !worldInstanceKey || !worldInstance) return null;
      let targetedBlockKey = null, targetedBlock = null;
      keys(worldInstance).some((key) => {
        let value = worldInstance[key];
        if (value && typeof value === "object" && (value.normal || value.position)) {
          targetedBlockKey = key;
          targetedBlock = value;
          return true;
        }
        return false;
      });
      return {
        heldBlock,
        worldInstanceKey,
        worldInstance,
        targetedBlockKey,
        targetedBlock,
        playerEntity
      };
    };
    
    var createSpoofedContext = (context, position) => {
      let {
        heldBlock,
        worldInstanceKey,
        worldInstance,
        targetedBlockKey,
        targetedBlock
      } = context, safeTarget = clone(targetedBlock) || {
        normal: [0, 1, 0],
        position: [...position],
        blockPosition: position.map(floor),
        hitPoint: [...position]
      };
      return safeTarget.position = [...position], safeTarget.blockPosition = safeTarget.blockPosition ?? position.map(floor), safeTarget.normal = safeTarget.normal ?? [0, 1, 0], safeTarget.hitPoint = safeTarget.hitPoint ?? [...position], new Proxy(
        {},
        {
          get(_target, prop) {
            if (prop === worldInstanceKey)
              return new Proxy(worldInstance, {
                get(inner, key) {
                  return key === targetedBlockKey ? safeTarget : inner[key];
                }
              });
            if (prop === "checkTargetedBlockCanBePlacedOver") return () => !0;
            let value = heldBlock[prop];
            return typeof value == "function" ? value.bind(heldBlock) : value;
          }
        }
      );
    }, placeSpoofedBlock = (position, context) => {
      let ctx = context ?? getHeldBlockContext();
      return ctx?.heldBlock?.placeBlock ? attempt(() => {
        let spoofed = createSpoofedContext(ctx, position);
        return ctx.heldBlock.placeBlock.call(spoofed), !0;
      }, !1) : !1;
    };

  // tensor-src/modules/base.js

  // Tensor Module Base Class (compatible with minin)
  var Module = class {
    constructor(name) {
      this.name = name, this.enabled = !1;
    }
    onEnable() {
    }
    onDisable() {
    }
    onRender() {
    }
    toggle() {
      this.enabled ? this.disable() : this.enable();
    }
    enable() {
      this.enabled || (this.enabled = !0, this.onEnable());
    }
    disable() {
      this.enabled && (this.enabled = !1, this.onDisable());
    }
  }, base_default = Module;
  
  // TensorModule for Tensor framework compatibility
  class TensorModule extends Module {
    constructor(name, tensor) {
      super(name);
      this.tensor = tensor;
    }
    enable() { super.enable(); }
    disable() { super.disable(); }
    update() {}
    getConfig() { return this.tensor.config.modules[this.name] || {}; }
    setConfig(config) { this.tensor.config.modules[this.name] = config; this.tensor.saveConfig(); }
  }

  // tensor-src/math.js

  
    // src/math.js
    // 数学函数库（基于 inject.js）
    var norm = (v) => {
      let s = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
      if (!s) return v;
      let i = 1 / Math.sqrt(s);
      return [v[0] * i, v[1] * i, v[2] * i];
    };
    
    var dist = (a, b) => {
      let dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
      return Math.sqrt(dx * dx + dy * dy + dz * dz);
    };
    
    var distSq = (a, b) => {
      let dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
      return dx * dx + dy * dy + dz * dz;
    };
    
    // 数学对象导出（保持 Tensor 兼容性）
    var math = { norm, dist, distSq };

  // tensor-src/game.js

  // Game API for Tensor - 基于 inject.js 的完整版本
  var gameAPI = {
      /**
       * 获取实体位置
       * @param {number} id - 实体 ID
       * @returns {number[]|null} 位置数组 [x, y, z]
       */
      getPosition: (id) => attempt(() => B.noa.entities.getState(id, "position").position),
      
      /**
       * 获取实体移动状态
       * @param {number} id - 实体 ID
       * @returns {Object|null} 移动状态对象
       */
      getMoveState: (id) => attempt(() => B.noa.entities.getState(id, "movement")),
      
      /**
       * 获取游戏注册表
       */
      get registry() { 
          return attempt(() => values(B.noa)[17], {}); 
      },
      
      /**
       * 获取方块硬度检查函数
       */
      get getSolidity() { 
          return values(this.registry)[5]; 
      },
      
      /**
       * 获取方块 ID 获取函数
       */
      get getBlockID() { 
          return attempt(
              () => {
                  let names = Object.getOwnPropertyNames(B.noa.bloxd.constructor.prototype);
                  return B.noa.bloxd[names[3]].bind(B.noa.bloxd);
              }, 
              () => 0
          );
      },
      
      /**
       * 获取手持物品获取函数
       */
      getHeldItemGetter() { 
          return attempt(
              () => values(B.noa.entities).find((fn) => {
                  if (typeof fn !== "function" || fn.length !== 1) return false;
                  let body = fn.toString();
                  return body.length < 80 && body.includes(").") && !body.includes("opWrapper");
              })
          );
      },
      
      /**
       * 安全获取手持物品
       * @param {number} id - 实体 ID
       * @returns {Object|null} 手持物品对象
       */
      safeHeld(id) { 
          let getter = this.getHeldItemGetter(); 
          return getter ? attempt(() => getter(id)) : null; 
      },
      
      /**
       * 获取玩家列表（排除自己）
       */
      get playerList() { 
          return attempt(() => {
              let ids = B.noa?.bloxd?.getPlayerIds?.();
              return ids ? Object.values(ids).map(Number).filter((id) => 
                  id && id !== 1 && this.safeHeld(id)) : [];
          }, []); 
      },
      
      /**
       * 获取攻击函数
       */
      get doAttack() {
          let held = this.safeHeld(1);
          if (!held) return () => {};
          let attack = held.doAttack || held.breakingItem?.doAttack;
          return attack ? attack.bind(held) : () => {};
      },
      
      /**
       * 检查是否接触墙壁
       */
      touchingWall() {
          let pos = this.getPosition(1);
          if (!pos) return false;
          let r = 0.35, offsets = [[0,0],[r,0],[-r,0],[0,r],[0,-r],[r,r],[r,-r],[-r,r],[-r,-r]], heights = [0,1,2], getId = this.getBlockID;
          for (let [ox, oz] of offsets) for (let h of heights) {
              let id = attempt(() => getId(floor(pos[0] + ox), floor(pos[1]) + h, floor(pos[2] + oz)), null);
              if (id !== null && this.getSolidity(id)) return true;
          }
          return false;
      },
      
      /**
       * 获取手持物品状态
       */
      getHeldItemState() { 
          return getHeldBlockContext()?.playerEntity?.heldItemState || null; 
      },
      
      /**
       * 放置方块（封装）
       * @param {number[]} position - 放置位置
       * @returns {boolean} 是否成功
       */
      placeBlock: (position) => placeSpoofedBlock(position),
      
      /**
       * 获取玩家 ID 列表
       */
      getPlayerIds: () => attempt(() => B.noa?.bloxd?.getPlayerIds?.(), {}),
      
      /**
       * 获取实体名称映射
       */
      getEntityNames: () => attempt(() => B.noa?.bloxd?.entityNames, {}),
      
      /**
       * 计算距离（独立实现，避免依赖 math 变量）
       * @param {number[]} a - 点 A
       * @param {number[]} b - 点 B
       * @returns {number} 距离
       */
      distance(a, b) {
          let dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
          return Math.sqrt(dx * dx + dy * dy + dz * dz);
      },
      
      /**
       * 计算距离平方（独立实现，避免依赖 math 变量）
       * @param {number[]} a - 点 A
       * @param {number[]} b - 点 B
       * @returns {number} 距离平方
       */
      distanceSquared(a, b) {
          let dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
          return dx * dx + dy * dy + dz * dz;
      },
      
      /**
       * 向量归一化（独立实现，避免依赖 math 变量）
       * @param {number[]} v - 向量
       * @returns {number[]} 归一化后的向量
       */
      normalize(v) {
          let s = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
          if (!s) return v;
          let i = 1 / Math.sqrt(s);
          return [v[0] * i, v[1] * i, v[2] * i];
      }
  };

  // tensor-src/modules/Killaura.js

  // Killaura Module
  class KillauraModule extends TensorModule {
      constructor(name, tensor) {
          super(name, tensor);
          this.lastAttack = 0;
          this.config = { delay: 120, range: 6.8, jitter: 0.4 };
      }
      enable() { super.enable(); this.lastAttack = 0; }
      update() {
          if (!this.enabled) return;
          const now = Date.now();
          const effectiveDelay = this.config.delay + (this.config.delay * this.config.jitter * (Math.random() - 0.5));
          if (now - this.lastAttack < effectiveDelay) return;
          this.lastAttack = now;
          
          const playerPos = this.tensor.gameAPI.getPosition(1);
          if (!playerPos) return;
          
          const rangeSq = this.config.range * this.config.range;
          const players = this.tensor.gameAPI.playerList;
          for (const playerId of players) {
              const enemyPos = this.tensor.gameAPI.getPosition(playerId);
              if (!enemyPos || this.tensor.gameAPI.distanceSquared(playerPos, enemyPos) > rangeSq) continue;
              const vector = this.tensor.gameAPI.normalize([
                  enemyPos[0] - playerPos[0],
                  enemyPos[1] - playerPos[1],
                  enemyPos[2] - playerPos[2]
              ]);
              this.tensor.gameAPI.doAttack(vector, playerId.toString(), "BodyMesh");
          }
      }
  }

  // tensor-src/modules/Scaffold.js

  // Scaffold Module
  class ScaffoldModule extends TensorModule {
      constructor(name, tensor) {
          super(name, tensor);
          this.config = { interval: 20 };
          this.intervalId = null;
      }
      enable() {
          super.enable();
          this.intervalId = setInterval(() => {
              if (this.enabled) this.tryPlace();
          }, this.config.interval);
      }
      disable() {
          super.disable();
          if (this.intervalId) {
              clearInterval(this.intervalId);
              this.intervalId = null;
          }
      }
      tryPlace() {
          const ctx = getHeldBlockContext();
          if (!ctx?.playerEntity || ctx.playerEntity.heldItemState?.heldType !== "CubeBlock") return;
          const pos = this.tensor.gameAPI.getPosition(1);
          if (!pos) return;
          const blockX = Math.floor(pos[0]), blockY = Math.floor(pos[1]), blockZ = Math.floor(pos[2]);
          const target = [blockX, blockY - 1, blockZ];
          placeSpoofedBlock(target, ctx);
      }
  }

  // tensor-src/modules/SlowSwing.js

  // SlowSwing Module
  class SlowSwingModule extends TensorModule {
      constructor(name, tensor) {
          super(name, tensor);
          this.config = { duration: 2000 };
          this.normalDuration = 200;
      }
      enable() {
          super.enable();
          const heldState = this.tensor.gameAPI.getHeldItemState();
          if (heldState) heldState.swingDuration = this.config.duration;
      }
      disable() {
          super.disable();
          const heldState = this.tensor.gameAPI.getHeldItemState();
          if (heldState) heldState.swingDuration = this.normalDuration;
      }
  }

  // tensor-src/modules/CoordsList.js

  // CoordsList Module
  class CoordsListModule extends TensorModule {
      constructor(name, tensor) {
          super(name, tensor);
          this.disabled = true;
      }
      enable() { super.enable(); this.disabled = false; }
      disable() { super.disable(); this.disabled = true; }
      update() {
          if (!this.enabled || this.disabled) return;
          const entityNames = this.tensor.gameAPI.getEntityNames();
          if (!entityNames) return;
          for (let entityId in entityNames) {
              if (entityId === "1") continue;
              const entityData = entityNames[entityId];
              const position = this.tensor.gameAPI.getPosition(entityId);
              if (!position) continue;
              const x = Math.round(position[0]), y = Math.round(position[1]), z = Math.round(position[2]);
              const baseName = entityData.entityName.replace(/\s*\(\-?\d+,\s*\-?\d+,\s*\-?\d+\)$/, "");
              entityData.entityName = `${baseName} (${x}, ${y}, ${z})`;
          }
      }
  }

  // tensor-src/modules/ESP.js

  // ESP Module
  class ESPModule extends TensorModule {
      constructor(name, tensor) {
          super(name, tensor);
          this.intervalId = null;
      }
      enable() {
          super.enable();
          this.updateVisibility(true);
          this.intervalId = setInterval(() => this.updateVisibility(true), 300);
      }
      disable() {
          super.disable();
          if (this.intervalId) clearInterval(this.intervalId);
          this.updateVisibility(false);
      }
      updateVisibility(state) {
          if (!B.noa) return;
          const rendering = values(B.noa)[12];
          if (!rendering) return;
          const thinMeshes = values(rendering).find(v => v?.thinMeshes)?.thinMeshes;
          if (!Array.isArray(thinMeshes)) return;
          const renderingGroupId = state ? 2 : 0;
          for (let item of thinMeshes) {
              const mesh = item?.meshVariations?.__DEFAULT__?.mesh;
              if (mesh && typeof mesh.renderingGroupId == "number") {
                  mesh.renderingGroupId = renderingGroupId;
              }
          }
      }
  }

  // tensor-src/modules/Bhop.js

  // Bhop Module
  class BhopModule extends TensorModule {
      constructor(name, tensor) {
          super(name, tensor);
          this.intervalId = null;
          this.moveState = null;
          this.movement = null;
          this.bunnyhopping = false;
      }
      enable() {
          super.enable();
          this.startBhop();
      }
      disable() {
          super.disable();
          this.stopBhop();
      }
      startBhop() {
          this.moveState = this.tensor.gameAPI.getMoveState(1);
          if (this.moveState) this.movement = attempt(() => B.noa.entities.getState(1, "movement"));
          this.intervalId = setInterval(() => this.bhopTick(), 1);
      }
      stopBhop() {
          if (this.intervalId) clearInterval(this.intervalId);
          this.bunnyhopping = false;
          this.moveState = null;
          this.movement = null;
      }
      bhopTick() {
          if (!this.moveState) return;
          if (this.moveState._isAlive) {
              if (this.moveState.crouching || this.moveState.speed < 0.05 || this.movement?._flying) {
                  if (this.bunnyhopping) {
                      if (B.noa?.inputs?.state) B.noa.inputs.state.jump = false;
                      this.bunnyhopping = false;
                  }
              } else {
                  if (!this.bunnyhopping) this.bunnyhopping = true;
                  if (this.movement?.isOnGround?.()) {
                      if (B.noa?.inputs?.state) B.noa.inputs.state.jump = true;
                  } else {
                      if (B.noa?.inputs?.state) B.noa.inputs.state.jump = false;
                  }
              }
          }
      }
  }

  // tensor-src/modules/index.js

  // Tensor modules will be registered by Tensor framework
  var modules = [];

  // tensor-src/core/Tensor.js

  // Tensor Core Framework
  const Tensor = {
      modules: new Map(),
      gameAPI: gameAPI,
      B: B,
      utils: utils,
      get math() { 
          if (typeof math !== 'undefined') return math;
          // Fallback math implementation
          console.warn('[Tensor] math variable not found, using fallback');
          return {
              norm(v) {
                  let s = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
                  if (!s) return v;
                  let i = 1 / Math.sqrt(s);
                  return [v[0] * i, v[1] * i, v[2] * i];
              },
              dist(a, b) {
                  let dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
                  return Math.sqrt(dx * dx + dy * dy + dz * dz);
              },
              distSq(a, b) {
                  let dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
                  return dx * dx + dy * dy + dz * dz;
              }
          };
      },
      config: { 
          modules: {}, 
          ui: { theme: 'dark', position: { x: 10, y: 10 }, fontSize: 14, showSidebar: true }, 
          sounds: { enabled: true, volume: 0.5 },
          keybinds: {}
      },
      uiContainer: null,
      island: null,
      panel: null,
      toast: null,
      isDragging: false,
      audio: { on: null, off: null, initialized: false },
      // Keybind system
      keybind: {
          setting: false,           // 是否正在设置快捷键
          targetModule: null,       // 正在设置快捷键的模块名
          targetElement: null,      // 正在设置快捷键的元素
          keyMap: new Map(),        // 快捷键映射表 (key -> moduleName)
          listeners: new Map()      // 事件监听器存储
      },
      
      init() {
          console.log('[Tensor] Initializing framework...');
          console.log('[Tensor] math variable:', math);
          console.log('[Tensor] Tensor.math property:', this.math);
          this.loadConfig();
          
          // Initialize keybind system
          this.initKeybinds();
          
          console.log('[Tensor] B.noa:', B.noa);
          console.log('[Tensor] B.wpRequire:', B.wpRequire);
          console.log('[Tensor] B.bloxdProps:', B.bloxdProps);
          
          // Initialize audio system
          this.initAudio();
          
          this.initUI();
          this.loadBuiltInModules();
          this.loadUserModules();
          this.updateSidebar();
          console.log('[Tensor] Framework ready');
      },
      
      // Audio System
      initAudio() {
          if (!this.config.sounds.enabled) {
              console.log('[Tensor] Audio system disabled');
              return;
          }
          
          try {
              // Create audio elements (lazy loading)
              this.audio.on = new Audio();
              this.audio.off = new Audio();
              
              // Set audio sources
              this.audio.on.src = 'https://tuku.wigwy.xyz/down.php/b3d852a5ac7f7bd18693422bef43d6f6.wav';
              this.audio.off.src = 'https://tuku.wigwy.xyz/down.php/6c0219c7e47f836fe923fcbd953084ae.wav';
              
              // Set volume
              this.audio.on.volume = this.config.sounds.volume;
              this.audio.off.volume = this.config.sounds.volume;
              
              // Set preload to metadata (load only metadata, not the entire file)
              this.audio.on.preload = 'metadata';
              this.audio.off.preload = 'metadata';
              
              // Handle loading errors
              this.audio.on.onerror = () => console.warn('[Tensor] Failed to load ON sound');
              this.audio.off.onerror = () => console.warn('[Tensor] Failed to load OFF sound');
              
              this.audio.initialized = true;
              console.log('[Tensor] Audio system initialized (lazy loading)');
          } catch (error) {
              console.warn('[Tensor] Failed to initialize audio system:', error);
              this.audio.initialized = false;
          }
      },
      
      playSound(type) {
          if (!this.config.sounds.enabled || !this.audio.initialized) return;
          
          try {
              let audio;
              if (type === 'on') {
                  audio = this.audio.on;
              } else if (type === 'off') {
                  audio = this.audio.off;
              } else {
                  console.warn(`[Tensor] Unknown sound type: ${type}`);
                  return;
              }
              
              // Reset audio to start
              audio.currentTime = 0;
              // Play sound
              audio.play().catch(e => console.debug('[Tensor] Audio play failed:', e));
          } catch (error) {
              console.debug('[Tensor] Error playing sound:', error);
          }
      },
      
      // Keybind System
      getKeybind(moduleName) {
          // 获取模块的快捷键，如果没有则返回'none'
          return this.config.keybinds[moduleName] || 'none';
      },
      
      setKeybind(moduleName, key) {
          // 设置模块的快捷键
          if (key === 'none' || key === null || key === undefined) {
              // 移除快捷键
              delete this.config.keybinds[moduleName];
          } else {
              // 检查是否已被其他模块使用
              const existingModule = Object.keys(this.config.keybinds).find(name => 
                  this.config.keybinds[name] === key && name !== moduleName
              );
              if (existingModule) {
                  // 移除其他模块的该快捷键
                  delete this.config.keybinds[existingModule];
              }
              // 设置新快捷键
              this.config.keybinds[moduleName] = key;
          }
          this.saveConfig();
          this.updateKeyMap();
          return true;
      },
      
      removeKeybind(moduleName) {
          // 移除模块的快捷键
          delete this.config.keybinds[moduleName];
          this.saveConfig();
          this.updateKeyMap();
          return true;
      },
      
      updateKeyMap() {
          // 更新内部快捷键映射表
          this.keybind.keyMap.clear();
          Object.entries(this.config.keybinds).forEach(([moduleName, key]) => {
              if (key && key !== 'none') {
                  this.keybind.keyMap.set(key.toLowerCase(), moduleName);
              }
          });
      },
      
      initKeybinds() {
          // 初始化快捷键系统
          this.updateKeyMap();
          this.setupGlobalKeyListeners();
          console.log('[Tensor] Keybind system initialized');
      },
      
      setupGlobalKeyListeners() {
          // 移除旧的监听器
          this.keybind.listeners.forEach((listener, event) => {
              document.removeEventListener(event, listener);
          });
          this.keybind.listeners.clear();
          
          // 添加全局键盘事件监听
          const keydownHandler = (e) => {
              if (this.keybind.setting) {
                  // 如果正在设置快捷键，忽略按键触发
                  return;
              }
              
              // 获取按下的键
              let key = e.key.toLowerCase();
              
              // 处理特殊键
              if (e.ctrlKey && key !== 'control') key = 'ctrl+' + key;
              if (e.shiftKey && key !== 'shift') key = 'shift+' + key;
              if (e.altKey && key !== 'alt') key = 'alt+' + key;
              if (e.metaKey && key !== 'meta') key = 'meta+' + key;
              
              // 检查是否有模块绑定到此键
              const moduleName = this.keybind.keyMap.get(key);
              if (moduleName) {
                  // 触发模块切换
                  this.toggleModule(moduleName);
                  this.updateModuleList();
                  this.showToast(`Module "${moduleName}" toggled by keybind "${key}"`);
                  e.preventDefault();
              }
          };
          
          // 添加事件监听器
          document.addEventListener('keydown', keydownHandler);
          this.keybind.listeners.set('keydown', keydownHandler);
      },
      
      startKeybindSetting(moduleName, element) {
          // 开始设置快捷键
          if (this.keybind.setting) {
              this.cancelKeybindSetting();
          }
          
          this.keybind.setting = true;
          this.keybind.targetModule = moduleName;
          this.keybind.targetElement = element;
          
          // 更新UI显示正在设置
          element.classList.add('setting');
          element.textContent = 'Press any key...';
          
          // 添加临时全局按键监听器
          const tempKeyHandler = (e) => {
              e.preventDefault();
              e.stopPropagation();
              
              // 处理ESC键取消
              if (e.key.toLowerCase() === 'escape') {
                  this.cancelKeybindSetting();
                  return;
              }
              
              let key = e.key.toLowerCase();
              
              // 忽略部分特殊键
              if (key === 'control' || key === 'shift' || key === 'alt' || key === 'meta' ||
                  key === 'capslock' || key === 'tab' || key === 'enter' || key === ' ') {
                  // 这些键单独按下时不作为快捷键，等待组合键
                  return;
              }
              
              // 处理修饰键
              const modifiers = [];
              if (e.ctrlKey) modifiers.push('ctrl');
              if (e.shiftKey) modifiers.push('shift');
              if (e.altKey) modifiers.push('alt');
              if (e.metaKey) modifiers.push('meta');
              
              // 构建快捷键字符串
              if (modifiers.length > 0) {
                  // 组合键：修饰键 + 普通键
                  key = modifiers.join('+') + '+' + key;
              } else if (key.length === 1) {
                  // 单个字母或数字键
                  key = key;
              } else {
                  // 功能键（如F1-F12）
                  key = key;
              }
              
              // 完成设置
              this.finishKeybindSetting(key);
          };
          
          // 添加事件监听器（不使用once:true，持续监听直到完成或取消）
          document.addEventListener('keydown', tempKeyHandler);
          
          // 保存临时处理器以便取消
          this.keybind.tempHandler = tempKeyHandler;
      },
      
      finishKeybindSetting(key) {
          // 完成快捷键设置
          if (!this.keybind.setting || !this.keybind.targetModule) return;
          
          const moduleName = this.keybind.targetModule;
          const element = this.keybind.targetElement;
          
          // 移除临时事件监听器
          if (this.keybind.tempHandler) {
              document.removeEventListener('keydown', this.keybind.tempHandler);
          }
          
          // 设置快捷键
          this.setKeybind(moduleName, key);
          
          // 更新UI
          if (element) {
              element.classList.remove('setting');
              element.textContent = key === 'none' ? 'none' : key;
          }
          
          // 重置状态
          this.keybind.setting = false;
          this.keybind.targetModule = null;
          this.keybind.targetElement = null;
          this.keybind.tempHandler = null;
          
          this.showToast(`Keybind for "${moduleName}" set to "${key}"`);
      },
      
      cancelKeybindSetting() {
          // 取消快捷键设置
          if (!this.keybind.setting) return;
          
          const element = this.keybind.targetElement;
          const moduleName = this.keybind.targetModule;
          
          // 恢复原来的显示
          if (element && moduleName) {
              const currentKeybind = this.getKeybind(moduleName);
              element.classList.remove('setting');
              element.textContent = currentKeybind === 'none' ? 'none' : currentKeybind;
          }
          
          // 移除临时事件监听器
          if (this.keybind.tempHandler) {
              document.removeEventListener('keydown', this.keybind.tempHandler);
          }
          
          // 重置状态
          this.keybind.setting = false;
          this.keybind.targetModule = null;
          this.keybind.targetElement = null;
          this.keybind.tempHandler = null;
          this.keybind.tempKeyUpHandler = null;
          
          this.showToast('Keybind setting cancelled');
      },
      
      // Module Management
      registerModule(name, moduleClass, options = {}) {
          const instance = new moduleClass(name, this);
          
          // Load saved state if available
          const savedState = this.loadModuleState(name);
          
          this.modules.set(name, { instance, enabled: savedState, type: options.type || 'user' });
          console.log(`[Tensor] Module "${name}" registered (${savedState ? 'enabled' : 'disabled'})`);
          
          // Load saved configuration if available
          if (instance.config) {
              this.loadModuleConfig(name);
          }
          
          // Enable module if it was previously enabled
          if (savedState) {
              instance.enable();
          }
          
          return instance;
      },
      
      enableModule(name) {
          const module = this.modules.get(name);
          if (!module) return false;
          if (!module.enabled) {
              module.instance.enable();
              module.enabled = true;
              console.log(`[Tensor] Module "${name}" enabled`);
              this.saveModuleState(name, true);
              this.playSound('on');
              this.updateSidebar();
          }
          return true;
      },
      
      disableModule(name) {
          const module = this.modules.get(name);
          if (!module) return false;
          if (module.enabled) {
              module.instance.disable();
              module.enabled = false;
              console.log(`[Tensor] Module "${name}" disabled`);
              this.saveModuleState(name, false);
              this.playSound('off');
              this.updateSidebar();
          }
          return true;
      },
      
      toggleModule(name) {
          const module = this.modules.get(name);
          if (!module) return false;
          if (module.enabled) this.disableModule(name);
          else this.enableModule(name);
          return true;
      },
      
      // User Code Execution
      executeUserCode(code, moduleName = `user_${Date.now()}`) {
          try {
              // 检查用户代码是否是完整的类定义
              const isClassDefinition = code.includes('class ') && code.includes('extends TensorModule');
              
              let ModuleClass;
              
              if (isClassDefinition) {
                  // 完整类定义模式
                  console.log(`[Tensor] Detected full class definition for module "${moduleName}"`);
                  
                  // 提取类名（第一个class后的标识符）
                  const classMatch = code.match(/class\s+([^\s{]+)/);
                  const className = classMatch ? classMatch[1] : moduleName;
                  
                  // 执行类定义并获取类
                  const wrappedCode = `
                      ${code}
                      return ${className};
                  `;
                  ModuleClass = Function('TensorModule', wrappedCode)(TensorModule);
              } else {
                  // 包装模式（向后兼容）
                  console.log(`[Tensor] Using wrapper mode for module "${moduleName}"`);
                  
                  const wrappedCode = `
                      return class UserModule_${moduleName.replace(/\W/g, '_')} extends TensorModule {
                          enable() {
                              super.enable();
                              try { ${code} } catch(e) { console.error(e); }
                          }
                          update() {
                              if (this.enabled && typeof window._userModuleUpdate === 'function') {
                                  window._userModuleUpdate();
                              }
                          }
                          disable() {
                              super.disable();
                              if (typeof window._userModuleCleanup === 'function') {
                                  window._userModuleCleanup();
                              }
                          }
                      }
                  `;
                  ModuleClass = Function('TensorModule', wrappedCode)(TensorModule);
              }
              
              this.registerModule(moduleName, ModuleClass, { type: 'user' });
              this.enableModule(moduleName);
              this.saveUserModule(moduleName, code);
              return { success: true, moduleName };
          } catch (error) {
              return { success: false, error: error.message };
          }
      },
      
      // Built-in Modules
      loadBuiltInModules() {
          console.log('[Tensor] Loading built-in modules...');
          // Register all built-in modules (classes are defined globally)
          this.registerModule('Killaura', KillauraModule, { type: 'builtin' });
          this.registerModule('Scaffold', ScaffoldModule, { type: 'builtin' });
          this.registerModule('SlowSwing', SlowSwingModule, { type: 'builtin' });
          this.registerModule('CoordsList', CoordsListModule, { type: 'builtin' });
          this.registerModule('ESP', ESPModule, { type: 'builtin' });
          this.registerModule('Bhop', BhopModule, { type: 'builtin' });
      },
      
      // Configuration Management
      loadConfig() {
          try {
              const saved = GM_getValue('tensor_config', '{}');
              this.config = { ...this.config, ...JSON.parse(saved) };
          } catch (e) { console.error('[Tensor] Config load error:', e); }
      },
      
      saveConfig() {
          try { GM_setValue('tensor_config', JSON.stringify(this.config)); } 
          catch (e) { console.error('[Tensor] Config save error:', e); }
      },
      
      saveUserModule(name, code) {
          const modules = GM_getValue('tensor_user_modules', {});
          modules[name] = { code, created: Date.now(), enabled: true };
          GM_setValue('tensor_user_modules', modules);
      },
      
      loadUserModules() {
          const modules = GM_getValue('tensor_user_modules', {});
          Object.entries(modules).forEach(([name, data]) => {
              try {
                  this.executeUserCode(data.code, name);
                  if (data.enabled) this.enableModule(name);
                  
                  // Load saved module config
                  this.loadModuleConfig(name);
              } catch (error) {
                  console.error(`[Tensor] Error loading module "${name}":`, error);
              }
          });
      },
      
      deleteUserModule(name) {
          try {
              // 从modules Map中删除
              this.modules.delete(name);
              
              // 从GM存储中删除模块数据
              const modules = GM_getValue('tensor_user_modules', {});
              delete modules[name];
              GM_setValue('tensor_user_modules', modules);
              
              // 删除模块配置
              const moduleConfigs = GM_getValue('tensor_module_configs', {});
              delete moduleConfigs[name];
              GM_setValue('tensor_module_configs', moduleConfigs);
              
              // 删除模块状态
              const moduleStates = GM_getValue('tensor_module_states', {});
              delete moduleStates[name];
              GM_setValue('tensor_module_states', moduleStates);
              
              console.log(`[Tensor] User module "${name}" deleted`);
              return true;
          } catch (error) {
              console.error(`[Tensor] Error deleting module "${name}":`, error);
              return false;
          }
      },
      
      saveModuleState(moduleName, enabled) {
          try {
              const moduleStates = GM_getValue('tensor_module_states', {});
              moduleStates[moduleName] = enabled;
              GM_setValue('tensor_module_states', moduleStates);
          } catch (error) {
              console.error(`[Tensor] Error saving state for "${moduleName}":`, error);
          }
      },
      
      loadModuleState(moduleName) {
          try {
              const moduleStates = GM_getValue('tensor_module_states', {});
              return moduleStates[moduleName] || false;
          } catch (error) {
              console.error(`[Tensor] Error loading state for "${moduleName}":`, error);
              return false;
          }
      },
      
      saveModuleConfig(moduleName, config) {
          try {
              const moduleConfigs = GM_getValue('tensor_module_configs', {});
              moduleConfigs[moduleName] = config;
              GM_setValue('tensor_module_configs', moduleConfigs);
          } catch (error) {
              console.error(`[Tensor] Error saving config for "${moduleName}":`, error);
          }
      },
      
      loadModuleConfig(moduleName) {
          try {
              const moduleConfigs = GM_getValue('tensor_module_configs', {});
              const savedConfig = moduleConfigs[moduleName];
              if (!savedConfig) return;
              
              const moduleData = this.modules.get(moduleName);
              if (!moduleData || !moduleData.instance.config) return;
              
              // Merge saved config with current config
              Object.keys(savedConfig).forEach(key => {
                  if (moduleData.instance.config.hasOwnProperty(key)) {
                      const savedValue = savedConfig[key];
                      const currentConfig = moduleData.instance.config[key];
                      
                      if (typeof currentConfig === 'object' && currentConfig !== null && 'value' in currentConfig) {
                          // Advanced config with metadata
                          currentConfig.value = savedValue;
                      } else {
                          // Simple config value
                          moduleData.instance.config[key] = savedValue;
                      }
                  }
              });
              
              console.log(`[Tensor] Loaded config for module "${moduleName}"`);
          } catch (error) {
              console.error(`[Tensor] Error loading config for "${moduleName}":`, error);
          }
      },
      
      // UI System (Simplified)
      initUI() {
          this.injectStyles();
          this.createUI();
          this.setupEventListeners();
      },
      
      injectStyles() {
          const css = `
              /* Material Design 3 - Purple Dark Theme */
              :root {
                  /* 紫色主题色 */
                  --md3-primary: #bb86fc;          /* 主要紫色 */
                  --md3-primary-variant: #3700b3;  /* 深紫色 */
                  --md3-secondary: #03dac6;        /* 青色强调色 */
                  --md3-surface: #1e1e1e;          /* 表面颜色 */
                  --md3-surface-variant: #2d2d2d;  /* 表面变体 */
                  --md3-background: #121212;       /* 背景颜色 */
                  --md3-on-primary: #000000;       /* 主要色上的文本 */
                  --md3-on-surface: #ffffff;       /* 表面上的文本 */
                  --md3-on-surface-variant: #b3b3b3; /* 表面变体上的文本 */
                  --md3-outline: #404040;          /* 轮廓/边框 */
                  --md3-shadow: 0 2px 8px rgba(0,0,0,0.32); /* 阴影 */
                  --md3-shadow-large: 0 4px 16px rgba(0,0,0,0.48); /* 大阴影 */
                  --md3-elevated-surface: #252525; /* 提升表面 */
                  --md3-error: #cf6679;            /* 错误颜色 */
                  --md3-success: #03dac6;          /* 成功颜色（复用青色） */
                  
                  /* 圆角设计系统 */
                  --md3-radius-small: 4px;
                  --md3-radius-medium: 8px;
                  --md3-radius-large: 12px;
                  --md3-radius-extra-large: 20px;
                  --md3-radius-full: 28px;
                  
                  /* 间距系统 */
                  --md3-spacing-xs: 4px;
                  --md3-spacing-sm: 8px;
                  --md3-spacing-md: 12px;
                  --md3-spacing-lg: 16px;
                  --md3-spacing-xl: 24px;
                  
                  /* 字体 */
                  --md3-font-family: 'Roboto', 'Segoe UI', system-ui, sans-serif;
                  --md3-font-mono: 'Roboto Mono', 'Consolas', monospace;
              }
              
              .tensor-island {
                  position: fixed;
                  top: 10px;
                  left: 50%;
                  transform: translateX(-50%);
                  background: var(--md3-surface);
                  color: var(--md3-on-surface);
                  padding: var(--md3-spacing-md) var(--md3-spacing-xl);
                  border-radius: var(--md3-radius-full);
                  font-family: var(--md3-font-family);
                  font-size: 14px;
                  display: flex;
                  align-items: center;
                  gap: var(--md3-spacing-md);
                  z-index: 999999;
                  box-shadow: var(--md3-shadow-large);
                  cursor: move;
                  user-select: none;
                  pointer-events: auto;
                  border: 1px solid var(--md3-outline);
                  backdrop-filter: blur(10px);
                  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
              }
              
              .tensor-island:hover {
                  background: var(--md3-surface-variant);
                  box-shadow: 0 6px 24px rgba(0,0,0,0.56);
              }
              
              .tensor-panel {
                  position: fixed;
                  top: 50%;
                  left: 50%;
                  transform: translate(-50%, -50%) scale(0.95);
                  opacity: 0;
                  pointer-events: none;
                  background: var(--md3-surface);
                  border: 1px solid var(--md3-outline);
                  color: var(--md3-on-surface);
                  padding: 0;
                  border-radius: var(--md3-radius-extra-large);
                  z-index: 999999;
                  min-width: 480px;
                  max-width: 90vw;
                  max-height: 80vh;
                  overflow: hidden;
                  box-shadow: var(--md3-shadow-large);
                  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
                  backdrop-filter: blur(20px);
                  display: flex;
                  flex-direction: column;
              }
              
              .tensor-panel.active {
                  transform: translate(-50%, -50%) scale(1);
                  opacity: 1;
                  pointer-events: all;
                  box-shadow: 0 8px 32px rgba(0,0,0,0.64);
              }
              
              .tensor-panel.dragging {
                  transition: none;
                  cursor: grabbing;
                  user-select: none;
              }
              
              .tensor-panel-header {
                  display: flex;
                  justify-content: space-between;
                  align-items: center;
                  padding: var(--md3-spacing-xl);
                  border-bottom: 1px solid var(--md3-outline);
                  background: var(--md3-surface);
                  cursor: move;
                  border-radius: var(--md3-radius-extra-large) var(--md3-radius-extra-large) 0 0;
                  user-select: none;
              }
              
              .tensor-panel-header:hover {
                  background: var(--md3-surface-variant);
              }
              
              .tensor-panel-header:active {
                  cursor: grabbing;
              }
              
              .tensor-panel-content {
                  padding: var(--md3-spacing-xl);
                  overflow-y: auto;
                  flex: 1;
              }
              
              /* Tabs - MD3风格 */
              .tensor-tabs {
                  display: flex;
                  gap: var(--md3-spacing-xs);
                  margin-bottom: var(--md3-spacing-xl);
                  padding: var(--md3-spacing-xs);
                  background: var(--md3-surface-variant);
                  border-radius: var(--md3-radius-medium);
              }
              
              .tensor-tab {
                  flex: 1;
                  padding: var(--md3-spacing-sm) var(--md3-spacing-lg);
                  background: transparent;
                  border: none;
                  border-radius: var(--md3-radius-small);
                  color: var(--md3-on-surface-variant);
                  cursor: pointer;
                  font-family: var(--md3-font-family);
                  font-weight: 500;
                  font-size: 14px;
                  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
                  text-align: center;
              }
              
              .tensor-tab:hover {
                  background: rgba(187, 134, 252, 0.08); /* 紫色透明背景 */
                  color: var(--md3-primary);
              }
              
              .tensor-tab.active {
                  background: var(--md3-primary);
                  color: var(--md3-on-primary);
                  box-shadow: 0 1px 3px rgba(0,0,0,0.3);
              }
              
              /* Module Items - MD3风格 */
              .tensor-module-item {
                  display: flex;
                  flex-direction: column;
                  padding: var(--md3-spacing-lg);
                  background: var(--md3-surface-variant);
                  border-radius: var(--md3-radius-medium);
                  margin-bottom: var(--md3-spacing-md);
                  border: 1px solid transparent;
                  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
              }
              
              .tensor-module-item:hover {
                  border-color: var(--md3-outline);
                  background: var(--md3-elevated-surface);
              }
              
              .tensor-module-header {
                  display: flex;
                  justify-content: space-between;
                  align-items: center;
                  margin-bottom: var(--md3-spacing-md);
              }
              
              .tensor-module-name {
                  font-weight: 500;
                  font-size: 16px;
                  color: var(--md3-on-surface);
              }
              
              .tensor-module-type {
                  font-size: 12px;
                  padding: 2px 8px;
                  border-radius: 10px;
                  background: var(--md3-primary-variant);
                  color: var(--md3-primary);
                  font-weight: 500;
              }
              
              .tensor-module-footer {
                  display: flex;
                  justify-content: space-between;
                  align-items: center;
                  margin-top: var(--md3-spacing-md);
              }
              
              .tensor-module-toggle {
                  position: relative;
                  width: 52px;
                  height: 28px;
                  background: rgba(255, 255, 255, 0.12);
                  border-radius: 14px;
                  cursor: pointer;
                  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
              }
              
              .tensor-module-toggle::after {
                  content: '';
                  position: absolute;
                  top: 4px;
                  left: 4px;
                  width: 20px;
                  height: 20px;
                  background: var(--md3-on-surface);
                  border-radius: 50%;
                  transition: left 0.2s cubic-bezier(0.4, 0, 0.2, 1);
                  box-shadow: 0 1px 3px rgba(0,0,0,0.3);
              }
              
              .tensor-module-toggle.active {
                  background: var(--md3-primary);
              }
              
              .tensor-module-toggle.active::after {
                  left: 28px;
                  background: var(--md3-on-primary);
              }
              
              /* Keybind Display - MD3风格 */
              .tensor-keybind-display {
                  position: relative;
                  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
                  border: 1px solid transparent;
                  font-family: var(--md3-font-mono);
                  font-size: 11px !important;
                  letter-spacing: 0.5px;
              }
              
              .tensor-keybind-display:hover {
                  background: color-mix(in srgb, var(--md3-surface-variant) 90%, var(--md3-primary)) !important;
                  border-color: var(--md3-primary);
                  color: var(--md3-primary);
              }
              
              .tensor-keybind-display.none {
                  color: var(--md3-on-surface-variant);
                  opacity: 0.7;
                  font-style: italic;
              }
              
              .tensor-keybind-display.none:hover {
                  color: var(--md3-primary);
                  opacity: 1;
              }
              
              .tensor-keybind-display.setting {
                  background: color-mix(in srgb, var(--md3-surface-variant) 80%, var(--md3-primary)) !important;
                  border-color: var(--md3-primary) !important;
                  color: var(--md3-primary) !important;
                  animation: keybind-pulse 1.5s infinite;
              }
              
              @keyframes keybind-pulse {
                  0%, 100% {
                      box-shadow: 0 0 0 0 rgba(187, 134, 252, 0.4);
                  }
                  50% {
                      box-shadow: 0 0 0 4px rgba(187, 134, 252, 0.2);
                  }
              }
              
              /* Buttons - MD3风格 */
              .tensor-button {
                  padding: var(--md3-spacing-sm) var(--md3-spacing-xl);
                  background: var(--md3-primary);
                  border: none;
                  border-radius: var(--md3-radius-full);
                  color: var(--md3-on-primary);
                  cursor: pointer;
                  font-family: var(--md3-font-family);
                  font-weight: 500;
                  font-size: 14px;
                  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
                  box-shadow: 0 1px 3px rgba(0,0,0,0.3);
              }
              
              .tensor-button:hover {
                  background: color-mix(in srgb, var(--md3-primary) 90%, white);
                  box-shadow: 0 2px 6px rgba(0,0,0,0.4);
                  transform: translateY(-1px);
              }
              
              .tensor-button:active {
                  transform: translateY(0);
                  box-shadow: 0 1px 3px rgba(0,0,0,0.3);
              }
              
              .tensor-button.secondary {
                  background: transparent;
                  color: var(--md3-primary);
                  border: 1px solid var(--md3-outline);
                  box-shadow: none;
              }
              
              .tensor-button.secondary:hover {
                  background: rgba(187, 134, 252, 0.08);
                  border-color: var(--md3-primary);
              }
              
              /* Code Editor - MD3风格 */
              .tensor-code-editor {
                  width: 100%;
                  height: 300px;
                  background: var(--md3-background);
                  border: 1px solid var(--md3-outline);
                  border-radius: var(--md3-radius-medium);
                  color: var(--md3-on-surface);
                  font-family: var(--md3-font-mono);
                  padding: var(--md3-spacing-lg);
                  resize: vertical;
                  font-size: 14px;
                  line-height: 1.5;
                  transition: border-color 0.2s;
              }
              
              .tensor-code-editor:focus {
                  outline: none;
                  border-color: var(--md3-primary);
              }
              
              /* Toast - MD3风格 */
              .tensor-toast {
                  position: fixed;
                  bottom: 20px;
                  right: 20px;
                  background: var(--md3-surface-variant);
                  color: var(--md3-on-surface);
                  padding: var(--md3-spacing-md) var(--md3-spacing-xl);
                  border-radius: var(--md3-radius-medium);
                  z-index: 1000000;
                  transform: translateY(20px);
                  opacity: 0;
                  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
                  box-shadow: var(--md3-shadow-large);
                  border: 1px solid var(--md3-outline);
                  backdrop-filter: blur(10px);
                  font-weight: 500;
              }
              
              .tensor-toast.active {
                  transform: translateY(0);
                  opacity: 1;
              }
              
              /* Toast types */
              .tensor-toast.toast-error {
                  background: var(--md3-error);
                  color: #000000;
                  border-color: var(--md3-error);
              }
              
              .tensor-toast.toast-success {
                  background: var(--md3-success);
                  color: #000000;
                  border-color: var(--md3-success);
              }
              
              .tensor-toast.toast-info {
                  background: var(--md3-primary);
                  color: #000000;
                  border-color: var(--md3-primary);
              }
              
              .tensor-toast.toast-warning {
                  background: #ff9800;
                  color: #000000;
                  border-color: #ff9800;
              }
              
              /* Close button */
              .tensor-close-button {
                  background: none;
                  border: none;
                  color: var(--md3-on-surface-variant);
                  font-size: 28px;
                  cursor: pointer;
                  width: 40px;
                  height: 40px;
                  border-radius: 50%;
                  display: flex;
                  align-items: center;
                  justify-content: center;
                  transition: all 0.2s;
              }
              
              .tensor-close-button:hover {
                  background: rgba(255, 255, 255, 0.08);
                  color: var(--md3-on-surface);
              }
              
              /* Config Section */
              .tensor-module-config {
                  margin-top: var(--md3-spacing-lg);
                  padding: var(--md3-spacing-md);
                  background: var(--md3-background);
                  border-radius: var(--md3-radius-small);
                  border: 1px solid var(--md3-outline);
              }
              
              .tensor-config-item {
                  display: flex;
                  justify-content: space-between;
                  align-items: center;
                  padding: var(--md3-spacing-sm) 0;
                  border-bottom: 1px solid var(--md3-outline);
              }
              
              .tensor-config-item:last-child {
                  border-bottom: none;
              }
              
              .tensor-config-label {
                  color: var(--md3-on-surface-variant);
                  font-size: 14px;
              }
              
              .tensor-config-value {
                  display: flex;
                  align-items: center;
                  gap: var(--md3-spacing-sm);
              }
              
              .tensor-config-toggle {
                  width: 40px;
                  height: 20px;
                  background: rgba(255, 255, 255, 0.12);
                  border-radius: 10px;
                  cursor: pointer;
                  position: relative;
                  transition: all 0.2s;
              }
              
              .tensor-config-toggle::after {
                  content: '';
                  position: absolute;
                  top: 2px;
                  left: 2px;
                  width: 16px;
                  height: 16px;
                  background: var(--md3-on-surface);
                  border-radius: 50%;
                  transition: left 0.2s;
              }
              
              .tensor-config-toggle.active {
                  background: var(--md3-primary);
              }
              
              .tensor-config-toggle.active::after {
                  left: 22px;
                  background: var(--md3-on-primary);
              }
              
              .tensor-config-slider {
                  width: 120px;
                  -webkit-appearance: none;
                  height: 4px;
                  background: rgba(255, 255, 255, 0.12);
                  border-radius: 2px;
                  outline: none;
              }
              
              .tensor-config-slider::-webkit-slider-thumb {
                  -webkit-appearance: none;
                  width: 20px;
                  height: 20px;
                  background: var(--md3-primary);
                  border-radius: 50%;
                  cursor: pointer;
                  box-shadow: 0 1px 3px rgba(0,0,0,0.3);
              }
              
              .tensor-config-number {
                  width: 80px;
                  padding: 4px 8px;
                  background: var(--md3-surface);
                  border: 1px solid var(--md3-outline);
                  border-radius: var(--md3-radius-small);
                  color: var(--md3-on-surface);
                  font-family: var(--md3-font-family);
                  text-align: center;
              }
              
              .tensor-config-select {
                  padding: 6px 12px;
                  background: var(--md3-surface);
                  border: 1px solid var(--md3-outline);
                  border-radius: var(--md3-radius-small);
                  color: var(--md3-on-surface);
                  font-family: var(--md3-font-family);
                  font-size: 14px;
                  min-width: 120px;
                  cursor: pointer;
              }
              
              .tensor-config-select:hover {
                  border-color: var(--md3-primary);
              }
              
              .tensor-config-select:focus {
                  border-color: var(--md3-primary);
                  outline: none;
                  box-shadow: 0 0 0 2px rgba(187, 134, 252, 0.2);
              }
              
              .tensor-config-text {
                  padding: 6px 12px;
                  background: var(--md3-surface);
                  border: 1px solid var(--md3-outline);
                  border-radius: var(--md3-radius-small);
                  color: var(--md3-on-surface);
                  font-family: var(--md3-font-family);
                  font-size: 14px;
              }
              
              .tensor-config-text:focus {
                  border-color: var(--md3-primary);
                  outline: none;
                  box-shadow: 0 0 0 2px rgba(187, 134, 252, 0.2);
              }
              
              /* Enhanced MD3 Input Styles */
              .tensor-config-number {
                  width: 80px;
                  padding: 8px 12px;
                  background: var(--md3-surface);
                  border: 1px solid var(--md3-outline);
                  border-radius: var(--md3-radius-medium);
                  color: var(--md3-on-surface);
                  font-family: var(--md3-font-family);
                  font-size: 14px;
                  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
                  text-align: center;
              }
              
              .tensor-config-number:hover {
                  border-color: var(--md3-primary);
                  background: var(--md3-surface-variant);
              }
              
              .tensor-config-number:focus {
                  border-color: var(--md3-primary);
                  outline: none;
                  box-shadow: 0 0 0 3px rgba(187, 134, 252, 0.2);
                  background: var(--md3-surface);
              }
              
              .tensor-config-select {
                  padding: 10px 14px;
                  background: var(--md3-surface);
                  border: 1px solid var(--md3-outline);
                  border-radius: var(--md3-radius-medium);
                  color: var(--md3-on-surface);
                  font-family: var(--md3-font-family);
                  font-size: 14px;
                  min-width: 140px;
                  cursor: pointer;
                  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
                  appearance: none;
                  background-image: url("data:image/svg+xml;charset=UTF-8,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='%23bb86fc'%3e%3cpath d='M7 10l5 5 5-5z'/%3e%3c/svg%3e");
                  background-repeat: no-repeat;
                  background-position: right 12px center;
                  background-size: 20px;
                  padding-right: 40px;
              }
              
              .tensor-config-select:hover {
                  border-color: var(--md3-primary);
                  background-color: var(--md3-surface-variant);
              }
              
              .tensor-config-select:focus {
                  border-color: var(--md3-primary);
                  outline: none;
                  box-shadow: 0 0 0 3px rgba(187, 134, 252, 0.2);
              }
              
              .tensor-config-text {
                  padding: 10px 14px;
                  background: var(--md3-surface);
                  border: 1px solid var(--md3-outline);
                  border-radius: var(--md3-radius-medium);
                  color: var(--md3-on-surface);
                  font-family: var(--md3-font-family);
                  font-size: 14px;
                  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
                  width: 100%;
                  box-sizing: border-box;
              }
              
              .tensor-config-text:hover {
                  border-color: var(--md3-primary);
                  background: var(--md3-surface-variant);
              }
              
              .tensor-config-text:focus {
                  border-color: var(--md3-primary);
                  outline: none;
                  box-shadow: 0 0 0 3px rgba(187, 134, 252, 0.2);
                  background: var(--md3-surface);
              }
              
              /* Right Sidebar for Active Modules */
              .tensor-sidebar {
                  position: fixed;
                  top: 20px;
                  right: 20px;
                  z-index: 999997;
                  pointer-events: none;
                  display: flex;
                  flex-direction: column;
                  align-items: flex-end;
                  gap: 8px;
                  max-height: calc(100vh - 40px);
                  overflow-y: auto;
                  padding: 12px;
                  transition: opacity 0.3s ease;
              }
              
              .tensor-sidebar.hidden {
                  opacity: 0;
                  pointer-events: none;
              }
              
              .tensor-sidebar-item {
                  background: var(--md3-surface);
                  color: var(--md3-primary);
                  padding: 8px 16px;
                  border-radius: var(--md3-radius-medium);
                  font-family: var(--md3-font-family);
                  font-weight: 500;
                  font-size: 14px;
                  box-shadow: var(--md3-shadow);
                  border: 1px solid var(--md3-outline);
                  backdrop-filter: blur(10px);
                  pointer-events: auto;
                  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
                  white-space: nowrap;
                  max-width: 200px;
                  overflow: hidden;
                  text-overflow: ellipsis;
              }
              
              .tensor-sidebar-item:hover {
                  background: var(--md3-surface-variant);
                  transform: translateX(-4px);
                  box-shadow: var(--md3-shadow-large);
              }
              
              /* Settings Toggle */
              .tensor-settings-toggle {
                  display: flex;
                  align-items: center;
                  justify-content: space-between;
                  padding: var(--md3-spacing-md) 0;
                  border-bottom: 1px solid var(--md3-outline);
              }
              
              .tensor-settings-toggle:last-child {
                  border-bottom: none;
              }
              
              .tensor-settings-label {
                  color: var(--md3-on-surface);
                  font-size: 14px;
                  font-weight: 500;
              }
              
              .tensor-settings-description {
                  color: var(--md3-on-surface-variant);
                  font-size: 12px;
                  margin-top: 4px;
              }
              
              /* Header Section */
              .tensor-panel-header {
                  display: flex;
                  justify-content: space-between;
                  align-items: center;
                  margin-bottom: var(--md3-spacing-xl);
                  padding-bottom: var(--md3-spacing-md);
                  border-bottom: 1px solid var(--md3-outline);
              }
              
              .tensor-panel-title {
                  font-size: 24px;
                  font-weight: 500;
                  color: var(--md3-primary);
              }
              
              /* Scrollbar Styling - MD3圆角设计 */
              ::-webkit-scrollbar {
                  width: 12px;
              }
              
              ::-webkit-scrollbar-track {
                  background: var(--md3-surface-variant);
                  border-radius: var(--md3-radius-medium);
                  margin: 4px;
              }
              
              ::-webkit-scrollbar-thumb {
                  background: var(--md3-outline);
                  border-radius: var(--md3-radius-medium);
                  border: 2px solid var(--md3-surface-variant);
              }
              
              ::-webkit-scrollbar-thumb:hover {
                  background: var(--md3-on-surface-variant);
              }
              
              ::-webkit-scrollbar-thumb:active {
                  background: var(--md3-primary);
              }
              
              .tensor-panel::-webkit-scrollbar-track {
                  background: transparent;
              }
              
              .tensor-panel::-webkit-scrollbar-thumb {
                  background: rgba(187, 134, 252, 0.4);
                  border: 2px solid var(--md3-surface);
              }
              
              .tensor-panel::-webkit-scrollbar-thumb:hover {
                  background: rgba(187, 134, 252, 0.7);
              }
              
              /* Delete button for user modules */
              .tensor-delete-button {
                  width: 24px;
                  height: 24px;
                  background: var(--md3-error);
                  color: white;
                  border: none;
                  border-radius: var(--md3-radius-small);
                  font-size: 18px;
                  font-weight: bold;
                  display: flex;
                  align-items: center;
                  justify-content: center;
                  cursor: pointer;
                  padding: 0;
                  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
              }
              
              .tensor-delete-button:hover {
                  background: #b33951;
                  transform: scale(1.1);
              }
              
              .tensor-delete-button:active {
                  background: #9a3047;
                  transform: scale(0.95);
              }
          `;
          GM_addStyle(css);
      },
      
      createUI() {
          this.uiContainer = document.createElement('div');
          this.uiContainer.style.cssText = 'position:fixed;top:0;left:0;right:0;bottom:0;pointer-events:none;z-index:999998;';
          
          // Island - MD3风格
          this.island = document.createElement('div');
          this.island.className = 'tensor-island';
          this.island.innerHTML = `
              <div style="width:32px;height:32px;background:var(--md3-primary);border-radius:50%;display:flex;align-items:center;justify-content:center;box-shadow:0 2px 6px rgba(0,0,0,0.3);">
                  <svg viewBox="0 0 48 48" width="20" height="20" xmlns="http://www.w3.org/2000/svg">
                      <g fill="none" stroke="var(--md3-on-primary)" stroke-linecap="round" stroke-linejoin="round" stroke-width="4">
                          <path d="M30 27L24 44"></path>
                          <path d="M18 27L24 44"></path>
                          <path d="M18 27L30 27"></path>
                          <path d="M41 34L30 27"></path>
                          <path d="M41 14L30 27"></path>
                          <path d="M41 14L24 17"></path>
                          <path d="M30 27L24 17"></path>
                          <path d="M24 4V17"></path>
                          <path d="M7 14L24 17"></path>
                          <path d="M18 27L24 17"></path>
                          <path d="M18 27L7 14"></path>
                          <path d="M18 27L7 34"></path>
                          <path d="M41.3207 14L24.0002 4L6.67969 14V34L24.0002 44L41.3207 34V14Z"></path>
                      </g>
                  </svg>
              </div>
              <div style="display:flex;gap:12px;align-items:center;">
                  <span style="font-weight:500;font-size:15px;">Tensor Framework</span>
                  <div style="width:1px;height:20px;background:var(--md3-outline);"></div>
                  <span style="color:var(--md3-primary);font-weight:500;">Modules: 0</span>
              </div>
          `;
          this.makeDraggable(this.island);
          this.island.addEventListener('click', () => { if (!this.isDragging) this.togglePanel(); });
          this.uiContainer.appendChild(this.island);
          
          // Right Sidebar - 显示已启用的模块
          this.sidebar = document.createElement('div');
          this.sidebar.className = 'tensor-sidebar';
          if (!this.config.ui.showSidebar) {
              this.sidebar.classList.add('hidden');
          }
          this.uiContainer.appendChild(this.sidebar);
          
          // Panel - MD3风格，支持拖动
          this.panel = document.createElement('div');
          this.panel.className = 'tensor-panel';
          this.panel.innerHTML = `
              <div class="tensor-panel-header" id="panel-header">
                  <div class="tensor-panel-title">Tensor Control Panel</div>
                  <div style="display:flex;align-items:center;gap:12px;">
                      <button class="tensor-button secondary" id="inject-button">Inject</button>
                      <button class="tensor-close-button" id="close-panel">&times;</button>
                  </div>
              </div>
              
              <div class="tensor-panel-content">
                  <div class="tensor-tabs">
                      <button class="tensor-tab active" data-tab="modules">Modules</button>
                      <button class="tensor-tab" data-tab="editor">Code Editor</button>
                      <button class="tensor-tab" data-tab="settings">Settings</button>
                  </div>
                  
                  <div id="modules-tab">
                      <div id="module-list" style="margin-bottom:var(--md3-spacing-xl);"></div>
                      <div style="display:flex;justify-content:space-between;padding:var(--md3-spacing-md);background:var(--md3-surface-variant);border-radius:var(--md3-radius-medium);">
                          <div style="color:var(--md3-on-surface-variant);">Total: <span id="module-count" style="color:var(--md3-on-surface);font-weight:500;">0</span></div>
                          <div style="color:var(--md3-on-surface-variant);">Active: <span id="active-module-count" style="color:var(--md3-primary);font-weight:500;">0</span></div>
                      </div>
                  </div>
                  
                  <div id="editor-tab" style="display:none;">
                      <textarea class="tensor-code-editor" id="code-editor" placeholder="// Write your module code here..."></textarea>
                      <div style="display:flex;gap:var(--md3-spacing-md);margin-top:var(--md3-spacing-xl);">
                          <button class="tensor-button" id="run-code">Run Code</button>
                          <button class="tensor-button secondary" id="save-module">Save as Module</button>
                          <button class="tensor-button secondary" id="clear-code">Clear</button>
                          <button class="tensor-button secondary" id="developer-guide-btn">Developer Guide</button>
                      </div>
                      <div id="code-output" style="margin-top:var(--md3-spacing-lg);padding:var(--md3-spacing-md);background:var(--md3-surface-variant);border-radius:var(--md3-radius-medium);font-family:var(--md3-font-mono);font-size:13px;"></div>
                  </div>
                  
                  <div id="settings-tab" style="display:none;">
                      <div style="padding:var(--md3-spacing-lg);background:var(--md3-surface-variant);border-radius:var(--md3-radius-medium);">
                          <h3 style="color:var(--md3-primary);margin-top:0;">Settings</h3>
                          <div style="color:var(--md3-on-surface-variant);line-height:1.6;">
                              <div class="tensor-settings-toggle">
                                  <div>
                                      <div class="tensor-settings-label">Show Right Sidebar</div>
                                      <div class="tensor-settings-description">Display enabled modules in the top-right corner</div>
                                  </div>
                                  <label class="tensor-switch">
                                      <input type="checkbox" id="sidebar-toggle" ${this.config.ui.showSidebar ? 'checked' : ''}>
                                      <span class="tensor-slider"></span>
                                  </label>
                              </div>
                          </div>
                      </div>
                  </div>
              </div>
          `;
          this.uiContainer.appendChild(this.panel);
          
          // 为弹窗添加拖动功能，使用标题栏作为拖动句柄
          this.makeDraggable(this.panel, '.tensor-panel-header');
          
          // Toast
          this.toast = document.createElement('div');
          this.toast.className = 'tensor-toast';
          this.uiContainer.appendChild(this.toast);
          
          document.body.appendChild(this.uiContainer);
      },
      
      setupEventListeners() {
          document.getElementById('close-panel').addEventListener('click', () => this.togglePanel());
          document.getElementById('inject-button').addEventListener('click', () => this.reinject());
          
          // Tab switching
          this.panel.querySelectorAll('.tensor-tab').forEach(tab => {
              tab.addEventListener('click', () => {
                  this.panel.querySelectorAll('.tensor-tab').forEach(t => t.classList.remove('active'));
                  this.panel.querySelectorAll('[id$="-tab"]').forEach(c => c.style.display = 'none');
                  tab.classList.add('active');
                  document.getElementById(`${tab.dataset.tab}-tab`).style.display = 'block';
              });
          });
          
          // Editor buttons
          document.getElementById('run-code').addEventListener('click', () => this.runCode());
          document.getElementById('save-module').addEventListener('click', () => this.saveModule());
          document.getElementById('clear-code').addEventListener('click', () => this.clearCode());
          document.getElementById('developer-guide-btn').addEventListener('click', () => this.showDeveloperGuide());
          
          // Settings
          document.getElementById('sidebar-toggle').addEventListener('change', (e) => {
              this.config.ui.showSidebar = e.target.checked;
              GM_setValue('tensor_config', this.config);
              this.updateSidebarVisibility();
          });
          
          // Panel close when clicking outside
          document.addEventListener('click', (e) => {
              if (this.panel.classList.contains('active') && !this.panel.contains(e.target) && !this.island.contains(e.target)) {
                  this.togglePanel();
              }
          });
      },
      
      loadDeveloperGuide() {
          const guideContainer = document.getElementById('developer-guide');
          if (!guideContainer) return;
          
          const guideContent = `
              <h4 style="color:var(--md3-primary);margin-top:0;margin-bottom:12px;">Tensor Custom Module Development</h4>
              
              <div style="margin-bottom:20px;">
                  <h5 style="color:var(--md3-on-surface);margin-bottom:8px;">1. Basic Structure</h5>
                  <pre style="background:var(--md3-background);padding:12px;border-radius:8px;border:1px solid var(--md3-outline);color:var(--md3-primary);font-size:12px;overflow:auto;">
  // Template for a custom module
  class MyCustomModule extends TensorModule {
      constructor(name, tensor) {
          super(name, tensor);
          
          // Module configuration (will be shown in GUI)
          this.config = {
              enabled: false,      // Will be auto-managed by Tensor
              speed: 5.0,          // Example: numeric config
              autoActivate: true,  // Example: boolean config
              mode: "aggressive"   // Example: string config
          };
          
          // Module state (not shown in GUI)
          this.state = {
              lastActivation: 0,
              targetId: null
          };
      }
      
      enable() {
          super.enable();
          console.log(\`[\${this.name}] Module enabled\`);
          // Initialize your module here
      }
      
      disable() {
          super.disable();
          console.log(\`[\${this.name}] Module disabled\`);
          // Clean up your module here
      }
      
      update() {
          if (!this.enabled) return;
          
          // Main update logic called every frame
          // Access game API via this.tensor.gameAPI
          // Example: const playerPos = this.tensor.gameAPI.getPosition(1);
      }
  }</pre>
              </div>
              
              <div style="margin-bottom:20px;">
                  <h5 style="color:var(--md3-on-surface);margin-bottom:8px;">Module Definition Modes</h5>
                  <p style="color:var(--md3-on-surface-variant);margin-bottom:12px;">
                      Tensor supports two ways to define custom modules:
                  </p>
                  <ul style="color:var(--md3-on-surface-variant);padding-left:20px;">
                      <li><strong>Full Class Definition</strong> - Write a complete ES6 class that extends TensorModule (recommended)</li>
                      <li><strong>Simple Code Snippet</strong> - Write plain JavaScript that defines <code>enable()</code>, <code>disable()</code>, and <code>update()</code> methods</li>
                  </ul>
                  <p style="color:var(--md3-on-surface-variant);margin-bottom:12px;">
                      Tensor automatically detects which mode you're using. For full class definitions, include <code>class MyModule extends TensorModule</code> in your code.
                  </p>
              </div>
              
              <div style="margin-bottom:20px;">
                  <h5 style="color:var(--md3-on-surface);margin-bottom:8px;">2. Available APIs</h5>
                  <ul style="color:var(--md3-on-surface-variant);padding-left:20px;">
                      <li><strong>this.tensor.gameAPI</strong> - Game interaction methods</li>
                      <li><strong>this.tensor.B</strong> - Raw injection interface</li>
                      <li><strong>this.tensor.math</strong> - Math utilities (dist, normalize, etc.)</li>
                      <li><strong>this.tensor.utils</strong> - Utility functions (keys, values, attempt, etc.)</li>
                      <li><strong>this.tensor.modules</strong> - Access other modules</li>
                  </ul>
                  
                  <h5 style="color:var(--md3-on-surface);margin-bottom:8px;margin-top:16px;">GameAPI Methods:</h5>
                  <pre style="background:var(--md3-background);padding:12px;border-radius:8px;border:1px solid var(--md3-outline);color:var(--md3-on-surface-variant);font-size:12px;overflow:auto;">
  - getPosition(id)           // Get entity position [x, y, z]
  - getMoveState(id)          // Get movement state
  - playerList                // Array of other player IDs
  - doAttack                  // Attack function
  - placeBlock(position)      // Place block at position
  - distance(a, b)            // Calculate distance between points
  - normalize(v)              // Normalize vector</pre>
              </div>
              
              <div style="margin-bottom:20px;">
                  <h5 style="color:var(--md3-on-surface);margin-bottom:8px;">3. Configuration System</h5>
                  <p style="color:var(--md3-on-surface-variant);margin-bottom:12px;">
                      The <strong>this.config</strong> object is automatically exposed in the GUI. Tensor supports:
                  </p>
                  <ul style="color:var(--md3-on-surface-variant);padding-left:20px;">
                      <li><strong>Numbers</strong> - Displayed as sliders with min/max values</li>
                      <li><strong>Booleans</strong> - Displayed as toggle switches</li>
                      <li><strong>Strings</strong> - Displayed as text inputs or dropdowns</li>
                      <li><strong>Arrays/Objects</strong> - Displayed as JSON editors</li>
                  </ul>
                  
                  <pre style="background:var(--md3-background);padding:12px;border-radius:8px;border:1px solid var(--md3-outline);color:var(--md3-primary);font-size:12px;overflow:auto;">
  // Advanced config with metadata
  this.config = {
      speed: {
          value: 5.0,
          min: 0.1,
          max: 20.0,
          step: 0.1,
          label: "Movement Speed"
      },
      mode: {
          value: "normal",
          options: ["normal", "aggressive", "stealth"],
          label: "AI Mode"
      },
      targetDistance: {
          value: 10.0,
          min: 1.0,
          max: 50.0,
          step: 0.5,
          label: "Target Distance"
      }
  };</pre>
              </div>
              
              <div style="margin-bottom:20px;">
                  <h5 style="color:var(--md3-on-surface);margin-bottom:8px;">4. Best Practices</h5>
                  <ul style="color:var(--md3-on-surface-variant);padding-left:20px;">
                      <li>Use <strong>this.tensor.attempt()</strong> for safe function calls</li>
                      <li>Check <strong>this.enabled</strong> in update() before execution</li>
                      <li>Store module state in <strong>this.state</strong> (not in config)</li>
                      <li>Use <strong>console.log(\`[\${this.name}] message\`)</strong> for debugging</li>
                      <li>Clean up resources in <strong>disable()</strong> method</li>
                      <li>Don't block the main thread - use incremental processing</li>
                  </ul>
              </div>
              
              <div style="margin-bottom:20px;">
                  <h5 style="color:var(--md3-on-surface);margin-bottom:8px;">5. Example Module</h5>
                  <pre style="background:var(--md3-background);padding:12px;border-radius:8px;border:1px solid var(--md3-outline);color:var(--md3-primary);font-size:12px;overflow:auto;">
  // Simple auto-clicker module
  class AutoClicker extends TensorModule {
      constructor(name, tensor) {
          super(name, tensor);
          
          this.config = {
              enabled: false,
              cps: 10,                // Clicks per second
              jitter: 0.2,            // Random variation
              holdTime: 50            // ms to hold button
          };
          
          this.state = {
              lastClick: 0,
              clickInterval: 1000 / 10
          };
      }
      
      enable() {
          super.enable();
          this.state.clickInterval = 1000 / this.config.cps;
          console.log(\`[\${this.name}] Auto-clicker enabled (\${this.config.cps} CPS)\`);
      }
      
      update() {
          if (!this.enabled) return;
          
          const now = Date.now();
          if (now - this.state.lastClick > this.state.clickInterval) {
              this.tensor.gameAPI.doAttack();
              this.state.lastClick = now;
              
              // Add jitter
              const jitter = (Math.random() - 0.5) * this.config.jitter * this.state.clickInterval;
              this.state.clickInterval = (1000 / this.config.cps) + jitter;
          }
      }
  }</pre>
              </div>
              
              <div style="padding:12px;background:rgba(187,134,252,0.1);border-radius:8px;border:1px solid var(--md3-primary);">
                  <strong style="color:var(--md3-primary);">Tip:</strong>
                  <span style="color:var(--md3-on-surface-variant);">
                      You can test modules directly in the Code Editor tab. Write your module class, click "Run Code" to test, then "Save as Module" to add it permanently.
                  </span>
              </div>
          `;
          
          guideContainer.innerHTML = guideContent;
      },
      
      showDeveloperGuide() {
          // 创建模态框显示开发者指南
          const modal = document.createElement('div');
          modal.style.cssText = `
              position: fixed;
              top: 50%;
              left: 50%;
              transform: translate(-50%, -50%);
              background: var(--md3-surface);
              border: 1px solid var(--md3-outline);
              border-radius: var(--md3-radius-medium);
              z-index: 999999;
              width: 80%;
              max-width: 800px;
              max-height: 80vh;
              overflow: hidden;
              box-shadow: var(--md3-shadow-large);
              display: flex;
              flex-direction: column;
          `;
          
          const header = document.createElement('div');
          header.style.cssText = `
              padding: var(--md3-spacing-lg);
              background: var(--md3-primary);
              color: var(--md3-on-primary);
              display: flex;
              justify-content: space-between;
              align-items: center;
              border-bottom: 1px solid var(--md3-outline);
          `;
          header.innerHTML = `
              <h3 style="margin:0;font-weight:500;">Developer Guide</h3>
              <button class="tensor-close-button" style="font-size:24px;background:none;border:none;color:var(--md3-on-primary);cursor:pointer;">&times;</button>
          `;
          
          const content = document.createElement('div');
          content.id = 'developer-guide-modal';
          content.style.cssText = `
              padding: var(--md3-spacing-lg);
              overflow-y: auto;
              flex-grow: 1;
              color: var(--md3-on-surface-variant);
          `;
          
          modal.appendChild(header);
          modal.appendChild(content);
          document.body.appendChild(modal);
          
          // 加载内容
          content.innerHTML = this.loadDeveloperGuideContent();
          
          // 事件监听器
          header.querySelector('button').addEventListener('click', () => modal.remove());
          modal.addEventListener('click', (e) => {
              if (e.target === modal) modal.remove();
          });
      },
      
      loadDeveloperGuideContent() {
          // 返回开发者指南的HTML内容
          return `
              <h4 style="color:var(--md3-primary);margin-top:0;margin-bottom:12px;">Tensor Custom Module Development</h4>
              
              <div style="margin-bottom:20px;">
                  <h5 style="color:var(--md3-on-surface);margin-bottom:8px;">1. Basic Structure</h5>
                  <pre style="background:var(--md3-background);padding:12px;border-radius:8px;border:1px solid var(--md3-outline);color:var(--md3-primary);font-size:12px;overflow:auto;">
  // Template for a custom module
  class MyCustomModule extends TensorModule {
      constructor(name, tensor) {
          super(name, tensor);
          
          // Module configuration (will be shown in GUI)
          this.config = {
              enabled: false,      // Will be auto-managed by Tensor
              speed: 5.0,          // Example: numeric config
              autoActivate: true,  // Example: boolean config
              mode: "aggressive"   // Example: string config
          };
          
          // Module state (not shown in GUI)
          this.state = {
              lastActivation: 0,
              targetId: null
          };
      }
      
      enable() {
          super.enable();
          console.log(\`[\${this.name}] Module enabled\`);
          // Initialize your module here
      }
      
      disable() {
          super.disable();
          console.log(\`[\${this.name}] Module disabled\`);
          // Clean up your module here
      }
      
      update() {
          if (!this.enabled) return;
          
          // Main update logic called every frame
          // Access game API via this.tensor.gameAPI
          // Example: const playerPos = this.tensor.gameAPI.getPosition(1);
      }
  }</pre>
              </div>
              
              <div style="margin-bottom:20px;">
                  <h5 style="color:var(--md3-on-surface);margin-bottom:8px;">Module Definition Modes</h5>
                  <p style="color:var(--md3-on-surface-variant);margin-bottom:12px;">
                      Tensor supports two ways to define custom modules:
                  </p>
                  <ul style="color:var(--md3-on-surface-variant);padding-left:20px;">
                      <li><strong>Full Class Definition</strong> - Write a complete ES6 class that extends TensorModule (recommended)</li>
                      <li><strong>Simple Code Snippet</strong> - Write plain JavaScript that defines <code>enable()</code>, <code>disable()</code>, and <code>update()</code> methods</li>
                  </ul>
                  <p style="color:var(--md3-on-surface-variant);margin-bottom:12px;">
                      Tensor automatically detects which mode you're using. For full class definitions, include <code>class MyModule extends TensorModule</code> in your code.
                  </p>
              </div>
              
              <div style="margin-bottom:20px;">
                  <h5 style="color:var(--md3-on-surface);margin-bottom:8px;">2. Available APIs</h5>
                  <ul style="color:var(--md3-on-surface-variant);padding-left:20px;">
                      <li><strong>this.tensor.gameAPI</strong> - Game interaction methods</li>
                      <li><strong>this.tensor.B</strong> - Raw injection interface</li>
                      <li><strong>this.tensor.math</strong> - Math utilities (dist, normalize, etc.)</li>
                      <li><strong>this.tensor.utils</strong> - Utility functions (keys, values, attempt, etc.)</li>
                      <li><strong>this.tensor.modules</strong> - Access other modules</li>
                  </ul>
                  
                  <h5 style="color:var(--md3-on-surface);margin-bottom:8px;margin-top:16px;">GameAPI Methods:</h5>
                  <pre style="background:var(--md3-background);padding:12px;border-radius:8px;border:1px solid var(--md3-outline);color:var(--md3-on-surface-variant);font-size:12px;overflow:auto;">
  - getPosition(id)           // Get entity position [x, y, z]
  - getMoveState(id)          // Get movement state
  - playerList                // Array of other player IDs
  - doAttack                  // Attack function
  - placeBlock(position)      // Place block at position
  - distance(a, b)            // Calculate distance between points
  - normalize(v)              // Normalize vector</pre>
              </div>
              
              <div style="padding:12px;background:rgba(187,134,252,0.1);border-radius:8px;border:1px solid var(--md3-primary);">
                  <strong style="color:var(--md3-primary);">Tip:</strong>
                  <span style="color:var(--md3-on-surface-variant);">
                      You can test modules directly in the Code Editor tab. Write your module class, click "Run Code" to test, then "Save as Module" to add it permanently.
                  </span>
              </div>
          `;
      },
      
      updateSidebarVisibility() {
          if (this.sidebar) {
              if (this.config.ui.showSidebar) {
                  this.sidebar.classList.remove('hidden');
              } else {
                  this.sidebar.classList.add('hidden');
              }
          }
      },
      
      updateSidebar() {
          if (!this.sidebar) return;
          
          // 清空当前内容
          this.sidebar.innerHTML = '';
          
          // 收集所有启用的模块
          const enabledModules = [];
          for (const [moduleName, moduleData] of this.modules) {
              if (moduleData.enabled) {
                  enabledModules.push({
                      name: moduleName,
                      module: moduleData
                  });
              }
          }
          
          // 按名称排序
          enabledModules.sort((a, b) => a.name.localeCompare(b.name));
          
          // 为每个启用的模块创建条目
          enabledModules.forEach(item => {
              const itemElement = document.createElement('div');
              itemElement.className = 'tensor-sidebar-item';
              itemElement.textContent = item.name;
              itemElement.title = `Click to toggle ${item.name}`;
              itemElement.style.cursor = 'pointer';
              
              // 点击切换模块启用状态
              itemElement.addEventListener('click', (e) => {
                  e.stopPropagation();
                  this.toggleModule(item.name);
              });
              
              // 右键显示快捷键信息
              itemElement.addEventListener('contextmenu', (e) => {
                  e.preventDefault();
                  const keybind = this.getKeybind(item.name);
                  this.showToast(`Module: ${item.name}\nKeybind: ${keybind}`, 3000);
              });
              
              this.sidebar.appendChild(itemElement);
          });
          
          // 如果没有启用的模块，显示占位符
          if (enabledModules.length === 0) {
              const placeholder = document.createElement('div');
              placeholder.className = 'tensor-sidebar-item';
              placeholder.textContent = 'No active modules';
              placeholder.style.opacity = '0.7';
              placeholder.style.fontStyle = 'italic';
              placeholder.style.pointerEvents = 'none';
              this.sidebar.appendChild(placeholder);
          }
      },
      
      makeDraggable(element, handleSelector = null) {
          let isDragging = false, startX, startY, elementX, elementY;
          const dragHandle = handleSelector ? element.querySelector(handleSelector) : element;
          
          // 设置拖动光标
          if (dragHandle === element) {
              element.style.cursor = 'move';
          } else {
              dragHandle.style.cursor = 'move';
          }
          
          const startDrag = (e) => {
              // 如果点击的是按钮或其他交互元素，不启动拖动
              if (e.target.tagName === 'BUTTON' || e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA' || e.target.tagName === 'SELECT') {
                  return;
              }
              
              isDragging = true; 
              this.isDragging = true;
              
              // 添加拖动样式
              element.classList.add('dragging');
              if (dragHandle === element) {
                  element.style.cursor = 'grabbing';
              } else {
                  dragHandle.style.cursor = 'grabbing';
              }
              
              startX = e.clientX; 
              startY = e.clientY;
              const rect = element.getBoundingClientRect();
              elementX = rect.left; 
              elementY = rect.top;
              
              // 移除transform以支持绝对定位
              element.style.transform = 'none';
              element.style.transition = 'none';
              
              e.preventDefault();
              e.stopPropagation();
          };
          
          const doDrag = (e) => {
              if (!isDragging) return;
              
              const newX = elementX + e.clientX - startX;
              const newY = elementY + e.clientY - startY;
              
              // 确保元素不会移出视口
              const viewportWidth = window.innerWidth;
              const viewportHeight = window.innerHeight;
              const elementWidth = element.offsetWidth;
              const elementHeight = element.offsetHeight;
              
              const boundedX = Math.max(0, Math.min(newX, viewportWidth - elementWidth));
              const boundedY = Math.max(0, Math.min(newY, viewportHeight - elementHeight));
              
              element.style.left = `${boundedX}px`;
              element.style.top = `${boundedY}px`;
              element.style.right = 'auto'; 
              element.style.bottom = 'auto';
          };
          
          const stopDrag = () => {
              if (isDragging) {
                  isDragging = false; 
                  this.isDragging = false;
                  element.classList.remove('dragging');
                  
                  if (dragHandle === element) {
                      element.style.cursor = 'move';
                  } else {
                      dragHandle.style.cursor = 'move';
                  }
                  
                  // 恢复过渡效果
                  element.style.transition = '';
              }
          };
          
          dragHandle.addEventListener('mousedown', startDrag);
          document.addEventListener('mousemove', doDrag);
          document.addEventListener('mouseup', stopDrag);
          
          // 防止拖动时选择文本
          dragHandle.addEventListener('selectstart', (e) => {
              if (isDragging) e.preventDefault();
          });
      },
      
      togglePanel(force) {
          const wasActive = this.panel.classList.contains('active');
          let shouldBeActive;
          
          if (force === undefined) {
              // Toggle if no force parameter
              shouldBeActive = !wasActive;
          } else {
              // Force to specific state
              shouldBeActive = force;
          }
          
          // Only change if state is different
          if (shouldBeActive !== wasActive) {
              if (shouldBeActive) {
                  this.panel.classList.add('active');
                  this.playSound('on');
                  this.updateModuleList();
              } else {
                  this.panel.classList.remove('active');
                  this.playSound('off');
              }
          }
      },
      
      updateModuleList() {
          const moduleList = document.getElementById('module-list');
          const moduleCount = document.getElementById('module-count');
          const activeCount = document.getElementById('active-module-count');
          if (!moduleList) return;
          
          let active = 0, html = '';
          this.modules.forEach((moduleData, name) => {
              const module = moduleData.instance;
              if (moduleData.enabled) active++;
              
              // Determine module type color
              const typeColor = moduleData.type === 'builtin' ? 'var(--md3-primary)' : 'var(--md3-secondary)';
              const typeBg = moduleData.type === 'builtin' ? 'rgba(187,134,252,0.15)' : 'rgba(3,218,198,0.15)';
              
              // Start building module HTML
              let moduleHtml = `
                  <div class="tensor-module-item" data-module="${name}">
                      <div class="tensor-module-header">
                          <div class="tensor-module-name">${name}</div>
                          <div class="tensor-module-type" style="background:${typeBg};color:${typeColor};">${moduleData.type}</div>
                      </div>
              `;
              
              // Add config section if module has config
              if (module.config && typeof module.config === 'object') {
                  moduleHtml += `<div class="tensor-module-config" id="config-${name}">`;
                  
                  // Render each config item
                  Object.entries(module.config).forEach(([key, value]) => {
                      const configId = `config-${name}-${key}`;
                      const configValue = typeof value === 'object' && value !== null && 'value' in value ? value.value : value;
                      
                      if (typeof configValue === 'boolean') {
                          // Boolean toggle
                          moduleHtml += `
                              <div class="tensor-config-item">
                                  <span class="tensor-config-label">${key}</span>
                                  <div class="tensor-config-value">
                                      <div class="tensor-config-toggle ${configValue ? 'active' : ''}" 
                                           data-module="${name}" data-key="${key}" id="${configId}"></div>
                                  </div>
                              </div>
                          `;
                      } else if (typeof configValue === 'number') {
                          // Number slider
                          const meta = typeof value === 'object' ? value : {};
                          const min = meta.min !== undefined ? meta.min : 0;
                          const max = meta.max !== undefined ? meta.max : Math.max(100, configValue * 2);
                          const step = meta.step !== undefined ? meta.step : 0.1;
                          const label = meta.label || key;
                          
                          moduleHtml += `
                              <div class="tensor-config-item">
                                  <span class="tensor-config-label">${label}</span>
                                  <div class="tensor-config-value">
                                      <input type="range" class="tensor-config-slider" id="${configId}"
                                             min="${min}" max="${max}" step="${step}" value="${configValue}"
                                             data-module="${name}" data-key="${key}">
                                      <input type="number" class="tensor-config-number" 
                                             value="${configValue}" data-module="${name}" data-key="${key}"
                                             min="${min}" max="${max}" step="${step}">
                                  </div>
                              </div>
                          `;
                      } else if (typeof configValue === 'string' && value.options) {
                          // String with predefined options (dropdown)
                          const options = value.options || [];
                          const label = value.label || key;
                          
                          moduleHtml += `
                              <div class="tensor-config-item">
                                  <span class="tensor-config-label">${label}</span>
                                  <div class="tensor-config-value">
                                      <select class="tensor-config-select" id="${configId}" 
                                              data-module="${name}" data-key="${key}">
                                          ${options.map(opt => `
                                              <option value="${opt}" ${opt === configValue ? 'selected' : ''}>${opt}</option>
                                          `).join('')}
                                      </select>
                                  </div>
                              </div>
                          `;
                      } else if (typeof configValue === 'string') {
                          // Simple string input
                          const label = value.label || key;
                          
                          moduleHtml += `
                              <div class="tensor-config-item">
                                  <span class="tensor-config-label">${label}</span>
                                  <div class="tensor-config-value">
                                      <input type="text" class="tensor-config-text" id="${configId}"
                                             value="${configValue}" data-module="${name}" data-key="${key}"
                                             style="width:120px;">
                                  </div>
                              </div>
                          `;
                      } else {
                          // Complex object (show as JSON)
                          moduleHtml += `
                              <div class="tensor-config-item">
                                  <span class="tensor-config-label">${key}</span>
                                  <div class="tensor-config-value">
                                      <button class="tensor-button secondary" onclick="console.log(JSON.parse('${JSON.stringify(configValue).replace(/'/g, "\\'")}'))">View JSON</button>
                                  </div>
                              </div>
                          `;
                      }
                  });
                  
                  moduleHtml += `</div>`;
              }
              
              // Add footer with keybind, config info, toggle and delete button
              const keybind = this.getKeybind(name);
              moduleHtml += `
                  <div class="tensor-module-footer">
                      <div style="display:flex;flex-direction:column;gap:4px;">
                          <div style="color:var(--md3-on-surface-variant);font-size:13px;">
                              ${module.config ? Object.keys(module.config).length + ' configs' : 'No config'}
                          </div>
                          <div class="tensor-keybind-container" style="display:flex;align-items:center;gap:4px;">
                              <span style="color:var(--md3-on-surface-variant);font-size:12px;">Keybind:</span>
                              <div class="tensor-keybind-display ${keybind === 'none' ? 'none' : ''}" 
                                   data-module="${name}"
                                   style="padding:2px 8px;background:var(--md3-surface-variant);border-radius:4px;font-size:12px;cursor:pointer;user-select:none;min-width:60px;text-align:center;">
                                  ${keybind === 'none' ? 'none' : keybind}
                              </div>
                          </div>
                      </div>
                      <div style="display:flex;align-items:center;gap:8px;">
                          ${moduleData.type === 'user' ? `
                          <button class="tensor-delete-button" data-module="${name}" title="Delete module">
                              ×
                          </button>
                          ` : ''}
                          <div class="tensor-module-toggle ${moduleData.enabled ? 'active' : ''}" 
                               data-module="${name}" id="toggle-${name}"></div>
                      </div>
                  </div>
              </div>`;
              
              html += moduleHtml;
          });
          
          moduleList.innerHTML = html || '<div style="text-align:center;color:var(--md3-on-surface-variant);padding:var(--md3-spacing-xl);">No modules loaded</div>';
          moduleCount.textContent = this.modules.size;
          activeCount.textContent = active;
          
          // Update island module count
          const moduleCountSpan = this.island.querySelector('span:nth-child(3)');
          if (moduleCountSpan) {
              moduleCountSpan.textContent = `Modules: ${this.modules.size}`;
          }
          
          // Add event listeners
          this.setupModuleEventListeners();
      },
      
      setupModuleEventListeners() {
          // Module toggle switches
          document.querySelectorAll('.tensor-module-toggle').forEach(toggle => {
              toggle.addEventListener('click', (e) => {
                  const name = e.target.dataset.module;
                  this.toggleModule(name);
                  this.updateModuleList();
                  this.showToast(`Module "${name}" ${this.modules.get(name).enabled ? 'enabled' : 'disabled'}`);
              });
          });
          
          // Delete buttons for user modules
          document.querySelectorAll('.tensor-delete-button').forEach(button => {
              button.addEventListener('click', (e) => {
                  const name = e.target.dataset.module;
                  if (confirm(`Are you sure you want to delete module "${name}"?`)) {
                      if (this.deleteUserModule(name)) {
                          this.updateModuleList();
                          this.showToast(`Module "${name}" deleted`);
                      } else {
                          this.showToast(`Failed to delete module "${name}"`, 3000, 'error');
                      }
                  }
                  e.stopPropagation(); // 防止触发父元素点击事件
              });
          });
          
          // Keybind displays
          document.querySelectorAll('.tensor-keybind-display').forEach(display => {
              // Left click to set keybind
              display.addEventListener('click', (e) => {
                  const name = e.target.dataset.module;
                  this.startKeybindSetting(name, e.target);
                  e.stopPropagation();
              });
              
              // Right click to clear keybind
              display.addEventListener('contextmenu', (e) => {
                  e.preventDefault();
                  const name = e.target.dataset.module;
                  this.removeKeybind(name);
                  this.updateModuleList();
                  this.showToast(`Keybind for "${name}" cleared`);
                  return false;
              });
          });
          
          // Boolean toggles
          document.querySelectorAll('.tensor-config-toggle').forEach(toggle => {
              toggle.addEventListener('click', (e) => {
                  const name = e.target.dataset.module;
                  const key = e.target.dataset.key;
                  this.updateModuleConfig(name, key, !this.getModuleConfigValue(name, key));
                  this.showToast(`Config updated: ${name}.${key}`);
              });
          });
          
          // Number sliders
          document.querySelectorAll('.tensor-config-slider').forEach(slider => {
              slider.addEventListener('input', (e) => {
                  const name = e.target.dataset.module;
                  const key = e.target.dataset.key;
                  const value = parseFloat(e.target.value);
                  this.updateModuleConfig(name, key, value);
                  
                  // Update corresponding number input
                  const numberInput = document.querySelector(`.tensor-config-number[data-module="${name}"][data-key="${key}"]`);
                  if (numberInput) numberInput.value = value;
              });
          });
          
          // Number inputs
          document.querySelectorAll('.tensor-config-number').forEach(input => {
              input.addEventListener('change', (e) => {
                  const name = e.target.dataset.module;
                  const key = e.target.dataset.key;
                  const value = parseFloat(e.target.value);
                  this.updateModuleConfig(name, key, value);
                  
                  // Update corresponding slider
                  const slider = document.querySelector(`.tensor-config-slider[data-module="${name}"][data-key="${key}"]`);
                  if (slider) slider.value = value;
              });
          });
          
          // String selects
          document.querySelectorAll('.tensor-config-select').forEach(select => {
              select.addEventListener('change', (e) => {
                  const name = e.target.dataset.module;
                  const key = e.target.dataset.key;
                  this.updateModuleConfig(name, key, e.target.value);
              });
          });
          
          // String text inputs
          document.querySelectorAll('.tensor-config-text').forEach(input => {
              input.addEventListener('change', (e) => {
                  const name = e.target.dataset.module;
                  const key = e.target.dataset.key;
                  this.updateModuleConfig(name, key, e.target.value);
              });
          });
      },
      
      getModuleConfigValue(moduleName, configKey) {
          const moduleData = this.modules.get(moduleName);
          if (!moduleData || !moduleData.instance.config) return null;
          
          const config = moduleData.instance.config[configKey];
          if (typeof config === 'object' && config !== null && 'value' in config) {
              return config.value;
          }
          return config;
      },
      
      updateModuleConfig(moduleName, configKey, newValue) {
          const moduleData = this.modules.get(moduleName);
          if (!moduleData || !moduleData.instance.config) return false;
          
          const config = moduleData.instance.config[configKey];
          if (typeof config === 'object' && config !== null && 'value' in config) {
              config.value = newValue;
          } else {
              moduleData.instance.config[configKey] = newValue;
          }
          
          // Save to persistent storage
          this.saveModuleConfig(moduleName, moduleData.instance.config);
          
          // Update UI
          this.updateModuleConfigUI(moduleName, configKey, newValue);
          
          return true;
      },
      
      updateModuleConfigUI(moduleName, configKey, value) {
          // Update toggle state
          const toggle = document.getElementById(`config-${moduleName}-${configKey}`);
          if (toggle && toggle.classList.contains('tensor-config-toggle')) {
              toggle.classList.toggle('active', !!value);
          }
          
          // Update slider value
          const slider = document.querySelector(`.tensor-config-slider[data-module="${moduleName}"][data-key="${configKey}"]`);
          if (slider) slider.value = value;
          
          // Update number input
          const numberInput = document.querySelector(`.tensor-config-number[data-module="${moduleName}"][data-key="${configKey}"]`);
          if (numberInput) numberInput.value = value;
          
          // Update select
          const select = document.querySelector(`.tensor-config-select[data-module="${moduleName}"][data-key="${configKey}"]`);
          if (select) select.value = value;
          
          // Update text input
          const textInput = document.querySelector(`.tensor-config-text[data-module="${moduleName}"][data-key="${configKey}"]`);
          if (textInput) textInput.value = value;
      },
      
      runCode() {
          const code = document.getElementById('code-editor').value;
          const output = document.getElementById('code-output');
          if (!code.trim()) { output.innerHTML = '<span style="color:#ff6b6b;">Enter code</span>'; return; }
          const result = this.executeUserCode(code, `temp_${Date.now()}`);
          output.innerHTML = result.success ? 
              '<span style="color:#4ade80;">✓ Code executed!</span>' :
              `<span style="color:#ff6b6b;">✗ ${result.error}</span>`;
      },
      
      saveModule() {
          const code = document.getElementById('code-editor').value;
          const name = prompt('Module name:', `user_${Date.now()}`);
          if (!name) return;
          const result = this.executeUserCode(code, name);
          if (result.success) {
              this.showToast(`Module "${name}" saved`);
              this.updateModuleList();
          } else {
              this.showToast(`Error: ${result.error}`);
          }
      },
      
      clearCode() {
          document.getElementById('code-editor').value = '';
          document.getElementById('code-output').innerHTML = '';
      },
      
      showToast(message, duration = 3000, type = 'info') {
          this.toast.textContent = message;
          this.toast.classList.add('active');
          
          // 清除所有类型类
          this.toast.classList.remove('toast-error', 'toast-success', 'toast-info', 'toast-warning');
          
          // 根据类型添加相应的类
          this.toast.classList.add(`toast-${type}`);
          
          setTimeout(() => this.toast.classList.remove('active'), duration);
      },
      
      reinject() {
          try {
              B.init(true);
              console.log('[Tensor] Re-injection successful');
          } catch (error) {
              console.warn('[Tensor] Re-inject init failed', error);
          }
          
          // Re-enable all active modules
          this.modules.forEach((module, name) => {
              if (module.enabled) {
                  try {
                      module.instance.disable();
                  } catch (error) {
                      console.debug(`[Tensor] Disable ${name} failed`, error);
                  }
                  try {
                      module.instance.enable();
                  } catch (error) {
                      console.debug(`[Tensor] Enable ${name} failed`, error);
                  }
              }
          });
          
          this.updateModuleList();
          this.showToast('Re-injected game client');
      },
      
      startUpdateLoop() {
          const update = () => {
              this.modules.forEach((module, name) => {
                  if (module.enabled && module.instance.update) {
                      try { module.instance.update(); } catch(e) { console.error(`[${name}] Update error:`, e); }
                  }
              });
              requestAnimationFrame(update);
          };
          update();
      }
  };
  
  // ============================================================================
  // tensor() Function API - Developer-friendly interface
  // ============================================================================
  
  /**
   * Tensor函数API - 为开发者提供简单易用的接口
   * 
   * 使用方式:
   * 1. tensor()                      - 返回Tensor对象
   * 2. tensor('method', ...args)     - 调用Tensor对象的方法
   * 3. tensor.module('name')         - 获取指定模块
   * 4. tensor.api                    - 访问游戏API
   * 5. tensor.math                   - 访问数学函数
   * 6. tensor.utils                  - 访问工具函数
   * 
   * @example
   * // 获取Tensor对象
   * const t = tensor();
   * 
   * // 调用方法
   * tensor('registerModule', 'MyModule', MyModuleClass);
   * tensor('enableModule', 'MyModule');
   * 
   * // 链式调用
   * tensor.module('Killaura').config({ range: 8 });
   * 
   * // 访问API
   * const playerPos = tensor.api.getPosition(1);
   * const distance = tensor.math.dist(a, b);
   */
  function tensor(method, ...args) {
      // 如果没有参数，返回Tensor对象
      if (method === undefined) {
          return Tensor;
      }
      
      // 如果第一个参数是字符串，调用Tensor对象的对应方法
      if (typeof method === 'string') {
          if (method in Tensor) {
              return Tensor[method](...args);
          } else {
              console.warn(`[Tensor API] Method "${method}" not found in Tensor object`);
              return null;
          }
      }
      
      // 如果第一个参数是函数，将其作为回调执行
      if (typeof method === 'function') {
          return method(Tensor, ...args);
      }
      
      return Tensor;
  }
  
  // 为tensor函数添加便捷属性
  Object.defineProperties(tensor, {
      // 核心对象访问
      tensor: {
          get() { return Tensor; },
          enumerable: true
      },
      api: {
          get() { return Tensor.gameAPI; },
          enumerable: true
      },
      math: {
          get() { return Tensor.math; },
          enumerable: true
      },
      utils: {
          get() { return Tensor.utils; },
          enumerable: true
      },
      B: {
          get() { return Tensor.B; },
          enumerable: true
      },
      config: {
          get() { return Tensor.config; },
          enumerable: true
      },
      
      // 模块管理快捷方式
      modules: {
          get() { return Tensor.modules; },
          enumerable: true
      },
      
      // 便捷方法
      register: {
          value: function(name, moduleClass, options = {}) {
              return Tensor.registerModule(name, moduleClass, options);
          },
          enumerable: true
      },
      
      enable: {
          value: function(name) {
              return Tensor.enableModule(name);
          },
          enumerable: true
      },
      
      disable: {
          value: function(name) {
              return Tensor.disableModule(name);
          },
          enumerable: true
      },
      
      toggle: {
          value: function(name) {
              return Tensor.toggleModule(name);
          },
          enumerable: true
      },
      
      // 模块获取器（链式API）
      module: {
          value: function(name) {
              const moduleData = Tensor.modules.get(name);
              if (!moduleData) {
                  console.warn(`[Tensor API] Module "${name}" not found`);
                  return null;
              }
              
              // 返回模块代理对象，支持链式调用
              return {
                  name,
                  instance: moduleData.instance,
                  enabled: moduleData.enabled,
                  type: moduleData.type,
                  
                  // 模块操作方法
                  enable() {
                      Tensor.enableModule(name);
                      return this;
                  },
                  
                  disable() {
                      Tensor.disableModule(name);
                      return this;
                  },
                  
                  toggle() {
                      Tensor.toggleModule(name);
                      return this;
                  },
                  
                  // 配置管理
                  config(newConfig) {
                      if (newConfig && moduleData.instance.config) {
                          Object.assign(moduleData.instance.config, newConfig);
                          Tensor.updateModuleConfigUI(name);
                      }
                      return this;
                  },
                  
                  // 获取配置值
                  getConfig(key) {
                      if (moduleData.instance.config && key in moduleData.instance.config) {
                          const config = moduleData.instance.config[key];
                          return typeof config === 'object' && config !== null && 'value' in config 
                              ? config.value 
                              : config;
                      }
                      return undefined;
                  },
                  
                  // 设置配置值
                  setConfig(key, value) {
                      if (moduleData.instance.config && key in moduleData.instance.config) {
                          Tensor.updateModuleConfig(name, key, value);
                      }
                      return this;
                  },
                  
                  // 更新方法
                  update() {
                      if (moduleData.enabled && moduleData.instance.update) {
                          try {
                              moduleData.instance.update();
                          } catch (e) {
                              console.error(`[${name}] Update error:`, e);
                          }
                      }
                      return this;
                  },
                  
                  // 获取原始模块实例
                  getInstance() {
                      return moduleData.instance;
                  }
              };
          },
          enumerable: true
      },
      
      // 游戏API快捷方式
      getPosition: {
          value: function(entityId = 1) {
              return Tensor.gameAPI.getPosition(entityId);
          },
          enumerable: true
      },
      
      getEntityNames: {
          value: function() {
              return Tensor.gameAPI.getEntityNames();
          },
          enumerable: true
      },
      
      distance: {
          value: function(a, b) {
              return Tensor.math.dist(a, b);
          },
          enumerable: true
      },
      
      // 工具函数快捷方式
      attempt: {
          value: function(fn, fallback = null) {
              return Tensor.utils.attempt(fn, fallback);
          },
          enumerable: true
      },
      
      clone: {
          value: function(obj) {
              return Tensor.utils.clone(obj);
          },
          enumerable: true
      },
      
      // UI控制
      showPanel: {
          value: function() {
              Tensor.togglePanel(true);
              return tensor;
          },
          enumerable: true
      },
      
      hidePanel: {
          value: function() {
              Tensor.togglePanel(false);
              return tensor;
          },
          enumerable: true
      },
      
      toast: {
          value: function(message, duration = 3000, type = 'info') {
              Tensor.showToast(message, duration, type);
              return tensor;
          },
          enumerable: true
      },
      
      // 开发工具
      eval: {
          value: function(code, moduleName = `eval_${Date.now()}`) {
              return Tensor.executeUserCode(code, moduleName);
          },
          enumerable: true
      },
      
      // 注入控制
      reinject: {
          value: function() {
              Tensor.reinject();
              return tensor;
          },
          enumerable: true
      }
  });
  
  // 导出tensor函数到全局作用域（优先使用unsafeWindow以支持Tampermonkey沙箱）
  const globalObject = typeof unsafeWindow !== 'undefined' ? unsafeWindow : window;
  if (typeof globalObject !== 'undefined') {
      globalObject.tensor = tensor;
  }
  
  // 导出到模块系统（如果可用）
  if (typeof module !== 'undefined' && module.exports) {
      module.exports = tensor;
  }

  // tensor-src/ui.js

  // Tensor UI setup
  // This file is loaded after core/Tensor.js, so Tensor object is available
  if (typeof Tensor !== 'undefined') {
    // UI is already initialized by Tensor.init()
    // No additional setup needed
  }

  // tensor-src/listeners.js

  // Event listeners for Tensor
  // Setup key listeners and other events
  if (typeof Tensor !== 'undefined') {
    // Tensor already sets up its own listeners
  }

  // tensor-src/loop.js

  // Main update loop for Tensor
  // Tensor manages its own update loop via Tensor.startUpdateLoop()
  if (typeof Tensor !== 'undefined') {
    // Loop already started by Tensor
  }

  // tensor-src/index.js

  // Re-inject function - calls Tensor.reinject() when available
  const globalReinject = () => {
      const globalObj = typeof unsafeWindow !== 'undefined' ? unsafeWindow : window;
      if (globalObj.Tensor && typeof globalObj.Tensor.reinject === 'function') {
          globalObj.Tensor.reinject();
      } else {
          // Fallback if Tensor not initialized yet
          try {
              B.init(true);
              console.log('[Tensor] Re-injection successful');
          } catch (error) {
              console.warn('[Tensor] Re-inject init failed', error);
          }
      }
  };
  
  // Tensor Framework Initialization - Wait for page to fully load
  const initTensor = () => {
      // Attempt to initialize B with retry logic
      let retryCount = 0;
      const maxRetries = 10;
      const retryDelay = 500;
      
      const tryInitB = () => {
          console.log(`[Tensor] Attempting B.init() - retry ${retryCount}/${maxRetries}`);
          try {
              B.init();
              console.log('[Tensor] B.init() succeeded, B.wpRequire:', B.wpRequire);
          } catch (error) {
              console.error(`[Tensor] B.init() failed on retry ${retryCount}:`, error);
          }
          
          if (B.wpRequire || retryCount >= maxRetries) {
              // Success or max retries reached, continue with Tensor initialization
              console.log('[Tensor] B initialization condition met, proceeding with Tensor init');
              // 暴露Tensor到全局作用域（优先使用unsafeWindow）
              (typeof unsafeWindow !== 'undefined' ? unsafeWindow : window).Tensor = Tensor;
              
              // Initialize Tensor framework
              Tensor.init();
              
              // Start update loop
              Tensor.startUpdateLoop();
              
              // Register Tampermonkey menu commands
              if (typeof GM_registerMenuCommand === 'function') {
                  GM_registerMenuCommand('Open Tensor Panel', () => Tensor.togglePanel());
                  GM_registerMenuCommand('Re-inject Game', globalReinject);
                  GM_registerMenuCommand('Reload Modules', () => {
                      Tensor.loadUserModules();
                      Tensor.showToast('Modules reloaded');
                  });
              }
              
              Tensor.showToast('Tensor Framework v1.0.0 loaded!');
          } else {
              // Retry
              retryCount++;
              console.log(`[Tensor] Retrying B.init() in ${retryDelay}ms (attempt ${retryCount})`);
              setTimeout(tryInitB, retryDelay);
          }
      };
      
      tryInitB();
  };
  
  // Wait for page to fully load, or execute immediately if already loaded
  if (document.readyState === 'complete') {
      initTensor();
  } else {
      window.addEventListener('load', initTensor, { once: true });
  }

})();