@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/handlers-Dz9PYsCa.mjs

@@ -0,0 +1,2805 @@
+import { n as asJsonResponse } from "./response-CWhh2aLo.mjs";
+import { r as argNumber } from "./parse-args-B4cY5Vx5.mjs";
+//#region src/server/domains/canvas/adapters/cocos-adapter.ts
+/**
+* Generates a self-contained JS string that traverses the Cocos Creator scene graph
+* via cc.director.getScene() using DFS and returns a serialisable scene tree.
+*
+* Supports both v2 (cc.Node._children) and v3 (cc.Node.children) APIs.
+* World bounds are computed from worldPosition + contentSize (v3) or getBoundingBox() (v2).
+*
+* @param opts - Dump options (maxDepth, onlyInteractive, onlyVisible)
+*/
+function buildCocosSceneTreeDumpPayload(opts) {
+	const maxDepth = opts.maxDepth ?? 20;
+	const onlyInteractive = opts.onlyInteractive ?? false;
+	return `(function() {
+  function getChildren(node) {
+    if (!node) return [];
+    // v3 uses node.children, v2 uses node._children
+    if (node.children && Array.isArray(node.children)) return node.children;
+    if (node._children && Array.isArray(node._children)) return node._children;
+    return [];
+  }
+
+  function getNumChildren(node) {
+    if (!node) return 0;
+    if (node.children && typeof node.children.length === 'number') return node.children.length;
+    if (node._children && typeof node._children.length === 'number') return node._children.length;
+    return 0;
+  }
+
+  // Determine if we are on Cocos v3 (has cc.Scene) vs v2
+  var isV3 = !!(window.cc && window.cc.Scene);
+
+  // Cocos v3 node properties
+  function getNodeId(node, idx) {
+    try {
+      if (node.uuid !== undefined && node.uuid !== null && node.uuid !== '') return String(node.uuid);
+    } catch(e) {}
+    try {
+      if (node._uuid !== undefined && node._uuid !== null && node._uuid !== '') return String(node._uuid);
+    } catch(e) {}
+    return (node.constructor ? node.constructor.name : 'Node') + '_' + idx;
+  }
+
+  function safeProp(node, key, fallback) {
+    try { var v = node[key]; return v === undefined || v === null ? fallback : v; } catch(e) { return fallback; }
+  }
+
+  function getWorldBounds(node) {
+    if (!node) return { x: 0, y: 0, width: 0, height: 0 };
+    try {
+      if (isV3) {
+        // v3: use worldPosition + contentSize
+        var wp = node.worldPosition;
+        var cs = node.contentSize;
+        if (wp && cs) {
+          return {
+            x: wp.x - (cs.width / 2),
+            y: wp.y - (cs.height / 2),
+            width: cs.width,
+            height: cs.height
+          };
+        }
+        // fallback: use position + scale + contentSize
+        var pos = node.position;
+        var sx = safeProp(node, 'scaleX', 1);
+        var sy = safeProp(node, 'scaleY', 1);
+        var w = cs ? cs.width : safeProp(node, 'width', 0);
+        var h = cs ? cs.height : safeProp(node, 'height', 0);
+        return {
+          x: pos ? pos.x : safeProp(node, 'x', 0),
+          y: pos ? pos.y : safeProp(node, 'y', 0),
+          width: Math.abs(w * sx),
+          height: Math.abs(h * sy)
+        };
+      } else {
+        // v2: use getBoundingBox()
+        if (typeof node.getBoundingBox === 'function') {
+          var bb = node.getBoundingBox();
+          if (bb) return { x: bb.x, y: bb.y, width: bb.width, height: bb.height };
+        }
+        // v2 fallback
+        var px = safeProp(node, 'x', 0) || 0;
+        var py = safeProp(node, 'y', 0) || 0;
+        var sx2 = safeProp(node, 'scaleX', 1);
+        var sy2 = safeProp(node, 'scaleY', 1);
+        var w2 = safeProp(node, '_contentSize') && safeProp(node._contentSize, 'width', 0) || safeProp(node, 'width', 0);
+        var h2 = safeProp(node, '_contentSize') && safeProp(node._contentSize, 'height', 0) || safeProp(node, 'height', 0);
+        return {
+          x: px, y: py,
+          width: Math.abs(w2 * sx2),
+          height: Math.abs(h2 * sy2)
+        };
+      }
+    } catch(e) {
+      return {
+        x: safeProp(node, 'x', 0),
+        y: safeProp(node, 'y', 0),
+        width: safeProp(node, 'width', 0) || 0,
+        height: safeProp(node, 'height', 0) || 0
+      };
+    }
+  }
+
+  function isInteractive(node) {
+    try {
+      // v3: check for Button component or _eventMask
+      if (isV3) {
+        var comps = node.components;
+        if (comps && Array.isArray(comps)) {
+          for (var ci = 0; ci < comps.length; ci++) {
+            var c = comps[ci];
+            if (c && c.constructor && (c.constructor.name === 'Button' || c.constructor.name === 'UICanvas' || c.constructor.name === 'Sprite')) {
+              return true;
+            }
+          }
+        }
+        if (node._eventMask !== undefined) return !!(node._eventMask & 1);
+      } else {
+        // v2: check mouseEnabled
+        return !!(safeProp(node, 'mouseEnabled', true));
+      }
+    } catch(e) {}
+    return !!(safeProp(node, 'mouseEnabled', true));
+  }
+
+  function getActive(node) {
+    if (isV3) {
+      return !!(safeProp(node, 'active', true));
+    } else {
+      return !!(safeProp(node, '_active', true));
+    }
+  }
+
+  function getName(node) {
+    if (isV3) {
+      return safeProp(node, 'name', undefined);
+    } else {
+      return safeProp(node, '_name', undefined);
+    }
+  }
+
+  function getPosition(node) {
+    if (isV3) {
+      var p = node.position;
+      if (p && typeof p.x === 'number') return { x: p.x, y: p.y };
+      return { x: safeProp(node, 'x', 0), y: safeProp(node, 'y', 0) };
+    } else {
+      return { x: safeProp(node, 'x', 0), y: safeProp(node, 'y', 0) };
+    }
+  }
+
+  function getScale(node) {
+    return {
+      x: safeProp(node, 'scaleX', 1),
+      y: safeProp(node, 'scaleY', 1)
+    };
+  }
+
+  function getRotation(node) {
+    if (isV3) {
+      return {
+        x: safeProp(node, 'rotationX', 0),
+        y: safeProp(node, 'rotationY', 0),
+        z: safeProp(node, 'rotation', 0)
+      };
+    } else {
+      return {
+        x: safeProp(node, 'rotationX', 0),
+        y: safeProp(node, 'rotationY', 0),
+        z: safeProp(node, 'rotation', 0)
+      };
+    }
+  }
+
+  function getType(node) {
+    if (isV3) {
+      return node.constructor ? node.constructor.name : 'Node';
+    } else {
+      // v2: use _className if available
+      return safeProp(node, '_className', node.constructor ? node.constructor.name : 'Node');
+    }
+  }
+
+  var totalNodes = 0;
+
+  function traverse(node, depth, path) {
+    if (!node || depth > ${maxDepth}) return null;
+    totalNodes++;
+
+    var active = getActive(node);
+    var interactive = isInteractive(node);
+    var visible = active;
+
+    if (${opts.onlyVisible ?? false} && !visible) return null;
+    if (${onlyInteractive} && !interactive) return null;
+
+    var wb = getWorldBounds(node);
+    var pos = getPosition(node);
+    var scale = getScale(node);
+    var rot = getRotation(node);
+    var numC = getNumChildren(node);
+    var children = null;
+
+    if (numC > 0) {
+      children = [];
+      var nodeChildren = getChildren(node);
+      for (var i = 0; i < nodeChildren.length; i++) {
+        var cn = nodeChildren[i];
+        if (!cn) continue;
+        var childPath = path ? path + '/' + getNodeId(cn, i) : getNodeId(cn, i);
+        var sub = traverse(cn, depth + 1, childPath);
+        if (sub) children.push(sub);
+      }
+    }
+
+    var alpha = safeProp(node, 'opacity', 1);
+    if (alpha === undefined || alpha === null) alpha = safeProp(node, 'alpha', 1);
+
+    var width = safeProp(node, 'width', 0) || 0;
+    var height = safeProp(node, 'height', 0) || 0;
+    if (isV3 && node.contentSize) {
+      width = safeProp(node.contentSize, 'width', 0) || width;
+      height = safeProp(node.contentSize, 'height', 0) || height;
+    } else if (!isV3 && node._contentSize) {
+      width = safeProp(node._contentSize, 'width', 0) || width;
+      height = safeProp(node._contentSize, 'height', 0) || height;
+    }
+
+    var result = {
+      id: getNodeId(node, 0),
+      type: getType(node),
+      name: getName(node),
+      visible: visible,
+      interactive: interactive,
+      alpha: alpha,
+      x: pos.x,
+      y: pos.y,
+      width: width,
+      height: height,
+      worldBounds: wb,
+      path: path || getNodeId(node, 0),
+      customData: {
+        scaleX: scale.x,
+        scaleY: scale.y,
+        rotationX: rot.x,
+        rotationY: rot.y,
+        rotation: rot.z,
+        active: active,
+        parent: node.parent ? getNodeId(node.parent, -1) : null,
+      }
+    };
+
+    if (children && children.length > 0) result.children = children;
+    return result;
+  }
+
+  if (!window.cc || !window.cc.director) {
+    return {
+      engine: 'CocosCreator',
+      version: window.cc && window.cc.ENGINE_VERSION ? window.cc.ENGINE_VERSION : undefined,
+      canvas: { width: 0, height: 0, dpr: 1, contextType: 'unknown' },
+      sceneTree: null,
+      totalNodes: 0,
+      completeness: 'partial',
+      error: 'cc.director not found'
+    };
+  }
+
+  var scene = window.cc.director.getScene ? window.cc.director.getScene() : null;
+
+  var canvasEl = document.querySelector('canvas');
+  var cocosVersion = window.cc.ENGINE_VERSION || (isV3 ? '3.x' : '2.x');
+  var canvasInfo = {
+    width: canvasEl ? canvasEl.width : safeProp(scene, 'width', 0) || 0,
+    height: canvasEl ? canvasEl.height : safeProp(scene, 'height', 0) || 0,
+    dpr: window.devicePixelRatio || 1,
+    contextType: 'unknown'
+  };
+  if (canvasEl) {
+    var gl = canvasEl.getContext('webgl2') || canvasEl.getContext('webgl');
+    canvasInfo.contextType = gl ? (gl instanceof WebGL2RenderingContext ? 'webgl2' : 'webgl') : '2d';
+  }
+
+  var sceneTree = scene ? traverse(scene, 0, 'cc.director.getScene()') : null;
+
+  return {
+    engine: 'CocosCreator',
+    version: cocosVersion,
+    canvas: canvasInfo,
+    sceneTree: sceneTree,
+    totalNodes: totalNodes,
+    completeness: sceneTree ? 'full' : 'partial',
+    _meta: { isV3: isV3 }
+  };
+})()`;
+}
+/**
+* Generates a self-contained JS string that:
+*  1. Transforms screen coordinates → canvas coordinates
+*  2. Flips Y axis (Cocos uses bottom-left origin, browser uses top-left)
+*  3. Runs hit test via engine (v3) or recursive DFS bounds check (v2 / fallback)
+*  4. Returns all candidates sorted by depth (topmost first)
+*
+* @param opts - Pick options (x, y, canvasId)
+*/
+function buildCocosHitTestPayload(opts) {
+	const x = opts.x;
+	const y = opts.y;
+	const canvasId = opts.canvasId;
+	return `(function() {
+  function getChildren(node) {
+    if (!node) return [];
+    if (node.children && Array.isArray(node.children)) return node.children;
+    if (node._children && Array.isArray(node._children)) return node._children;
+    return [];
+  }
+
+  function getNumChildren(node) {
+    if (!node) return 0;
+    if (node.children && typeof node.children.length === 'number') return node.children.length;
+    if (node._children && typeof node._children.length === 'number') return node._children.length;
+    return 0;
+  }
+
+  function getNodeId(node, idx) {
+    try {
+      if (node.uuid !== undefined && node.uuid !== null && node.uuid !== '') return String(node.uuid);
+    } catch(e) {}
+    try {
+      if (node._uuid !== undefined && node._uuid !== null && node._uuid !== '') return String(node._uuid);
+    } catch(e) {}
+    return (node.constructor ? node.constructor.name : 'Node') + '_' + idx;
+  }
+
+  function safeProp(node, key, fallback) {
+    try { var v = node[key]; return v === undefined || v === null ? fallback : v; } catch(e) { return fallback; }
+  }
+
+  function getWorldBounds(node) {
+    if (!node) return { x: 0, y: 0, width: 0, height: 0 };
+    try {
+      var isV3 = !!(window.cc && window.cc.Scene);
+      if (isV3) {
+        var wp = node.worldPosition;
+        var cs = node.contentSize;
+        if (wp && cs) {
+          return {
+            x: wp.x - (cs.width / 2),
+            y: wp.y - (cs.height / 2),
+            width: cs.width,
+            height: cs.height
+          };
+        }
+        var pos = node.position;
+        var sx = safeProp(node, 'scaleX', 1);
+        var sy = safeProp(node, 'scaleY', 1);
+        var w = cs ? cs.width : safeProp(node, 'width', 0);
+        var h = cs ? cs.height : safeProp(node, 'height', 0);
+        return {
+          x: pos ? pos.x : safeProp(node, 'x', 0),
+          y: pos ? pos.y : safeProp(node, 'y', 0),
+          width: Math.abs(w * sx),
+          height: Math.abs(h * sy)
+        };
+      } else {
+        if (typeof node.getBoundingBox === 'function') {
+          var bb = node.getBoundingBox();
+          if (bb) return { x: bb.x, y: bb.y, width: bb.width, height: bb.height };
+        }
+        var px = safeProp(node, 'x', 0) || 0;
+        var py = safeProp(node, 'y', 0) || 0;
+        var sx2 = safeProp(node, 'scaleX', 1);
+        var sy2 = safeProp(node, 'scaleY', 1);
+        var w2 = safeProp(node, '_contentSize') ? safeProp(node._contentSize, 'width', 0) : safeProp(node, 'width', 0);
+        var h2 = safeProp(node, '_contentSize') ? safeProp(node._contentSize, 'height', 0) : safeProp(node, 'height', 0);
+        return {
+          x: px, y: py,
+          width: Math.abs(w2 * sx2),
+          height: Math.abs(h2 * sy2)
+        };
+      }
+    } catch(e) {
+      return {
+        x: safeProp(node, 'x', 0),
+        y: safeProp(node, 'y', 0),
+        width: safeProp(node, 'width', 0) || 0,
+        height: safeProp(node, 'height', 0) || 0
+      };
+    }
+  }
+
+  function isInteractive(node) {
+    try {
+      var isV3 = !!(window.cc && window.cc.Scene);
+      if (isV3) {
+        var comps = node.components;
+        if (comps && Array.isArray(comps)) {
+          for (var ci = 0; ci < comps.length; ci++) {
+            var c = comps[ci];
+            if (c && c.constructor && (c.constructor.name === 'Button' || c.constructor.name === 'Sprite')) {
+              return true;
+            }
+          }
+        }
+        if (node._eventMask !== undefined) return !!(node._eventMask & 1);
+      } else {
+        return !!(safeProp(node, 'mouseEnabled', true));
+      }
+    } catch(e) {}
+    return !!(safeProp(node, 'mouseEnabled', true));
+  }
+
+  function getActive(node) {
+    var isV3 = !!(window.cc && window.cc.Scene);
+    if (isV3) return !!(safeProp(node, 'active', true));
+    return !!(safeProp(node, '_active', true));
+  }
+
+  function getName(node) {
+    var isV3 = !!(window.cc && window.cc.Scene);
+    if (isV3) return safeProp(node, 'name', undefined);
+    return safeProp(node, '_name', undefined);
+  }
+
+  function getPosition(node) {
+    var isV3 = !!(window.cc && window.cc.Scene);
+    if (isV3) {
+      var p = node.position;
+      if (p && typeof p.x === 'number') return { x: p.x, y: p.y };
+      return { x: safeProp(node, 'x', 0), y: safeProp(node, 'y', 0) };
+    }
+    return { x: safeProp(node, 'x', 0), y: safeProp(node, 'y', 0) };
+  }
+
+  function getType(node) {
+    var isV3 = !!(window.cc && window.cc.Scene);
+    if (isV3) return node.constructor ? node.constructor.name : 'Node';
+    return safeProp(node, '_className', node.constructor ? node.constructor.name : 'Node');
+  }
+
+  function nodePath(node) {
+    var parts = [];
+    var cur = node;
+    var scene = window.cc && window.cc.director ? window.cc.director.getScene() : null;
+    while (cur && cur !== scene) {
+      var name = getName(cur) || getNodeId(cur, 0);
+      parts.unshift(name);
+      cur = cur.parent;
+    }
+    parts.unshift('cc.director.getScene()');
+    return parts.join('/');
+  }
+
+  var sx = ${x}, sy = ${y};
+
+  // Find the target canvas
+  var canvases = Array.from(document.querySelectorAll('canvas'));
+  var targetCanvas = null;
+  ${canvasId ? `targetCanvas = document.getElementById(${JSON.stringify(canvasId)}) || canvases[parseInt(${JSON.stringify(canvasId)})] || null;` : `
+  for (var ci = canvases.length - 1; ci >= 0; ci--) {
+    var r = canvases[ci].getBoundingClientRect();
+    if (sx >= r.left && sx <= r.right && sy >= r.top && sy <= r.bottom) {
+      targetCanvas = canvases[ci];
+      break;
+    }
+  }`}
+
+  if (!window.cc || !window.cc.director) {
+    return {
+      success: false, picked: null, candidates: [], coordinates: {
+        screen: { x: sx, y: sy }, canvas: { x: 0, y: 0 }
+      },
+      hitTestMethod: 'none'
+    };
+  }
+
+  var canvasWidth = targetCanvas ? targetCanvas.width : 1920;
+  var canvasHeight = targetCanvas ? targetCanvas.height : 1080;
+
+  // Screen → canvas (CSS pixels to canvas pixels)
+  var canvasX = sx, canvasY = sy;
+  if (targetCanvas) {
+    var rect = targetCanvas.getBoundingClientRect();
+    canvasX = (sx - rect.left) * (targetCanvas.width / rect.width);
+    canvasY = (sy - rect.top) * (targetCanvas.height / rect.height);
+  }
+
+  // Canvas → Cocos: FLIP Y because Cocos uses bottom-left origin
+  var cocosX = canvasX;
+  var cocosY = canvasHeight - canvasY;
+
+  var scene = window.cc.director.getScene ? window.cc.director.getScene() : null;
+  var candidates = [];
+  var hitTestMethod = 'none';
+  var enginePicked = null;
+
+  // Try v3 native hitTest via cc.Node.EventListener.POSITION
+  if (scene && typeof scene.hitTest === 'function') {
+    try {
+      var nativeHit = scene.hitTest({ x: cocosX, y: cocosY });
+      if (nativeHit) {
+        enginePicked = nativeHit;
+        hitTestMethod = 'engine';
+      }
+    } catch(e) {}
+  }
+
+  // Recursive DFS hit test — always available
+  function hitTestDfs(node, depth, accPath) {
+    if (!node) return;
+
+    var active = getActive(node);
+    if (!active) return;
+
+    var wb = getWorldBounds(node);
+
+    // Convert screen coordinates to node local
+    var cur = node;
+    var screenPt = { x: sx, y: sy };
+    while (cur) {
+      if (cur.globalToLocal) {
+        try { screenPt = cur.globalToLocal(screenPt); } catch(e) { break; }
+      }
+      cur = cur.parent;
+    }
+    var lx = screenPt.x, ly = screenPt.y;
+
+    var pos = getPosition(node);
+    var nx = pos.x, ny = pos.y;
+    var sx2 = safeProp(node, 'scaleX', 1);
+    var sy2 = safeProp(node, 'scaleY', 1);
+    var w = safeProp(node, 'width', 0) || wb.width;
+    var h = safeProp(node, 'height', 0) || wb.height;
+
+    var inBounds = lx >= nx && lx <= nx + w * Math.abs(sx2) &&
+                   ly >= ny && ly <= ny + h * Math.abs(sy2);
+
+    var interactive = isInteractive(node);
+
+    if (inBounds && interactive) {
+      var path = accPath || getNodeId(node, 0);
+      var alpha = safeProp(node, 'opacity', 1);
+      if (alpha === undefined) alpha = safeProp(node, 'alpha', 1);
+
+      candidates.push({
+        node: {
+          id: getNodeId(node, 0),
+          type: getType(node),
+          name: getName(node),
+          visible: active,
+          interactive: interactive,
+          alpha: alpha,
+          x: nx, y: ny,
+          width: w * Math.abs(sx2),
+          height: h * Math.abs(sy2),
+          worldBounds: wb,
+          path: path
+        },
+        depth: depth
+      });
+    }
+
+    var nodeChildren = getChildren(node);
+    for (var i = 0; i < nodeChildren.length; i++) {
+      var cn = nodeChildren[i];
+      if (!cn) continue;
+      var childPath = accPath ? accPath + '/' + getNodeId(cn, i) : getNodeId(cn, i);
+      hitTestDfs(cn, depth + 1, childPath);
+    }
+  }
+
+  if (scene) hitTestDfs(scene, 0, 'cc.director.getScene()');
+
+  // Use engine pick if available, otherwise topmost DFS candidate
+  var picked = enginePicked;
+  var finalMethod = hitTestMethod;
+
+  if (!picked && candidates.length > 0) {
+    candidates.sort(function(a, b) { return a.depth - b.depth; });
+    picked = candidates[0].node;
+    finalMethod = 'manual';
+  }
+
+  return {
+    success: !!picked,
+    picked: picked,
+    candidates: candidates,
+    coordinates: {
+      screen: { x: sx, y: sy },
+      canvas: { x: canvasX, y: canvasY },
+      stage: { x: cocosX, y: cocosY }
+    },
+    hitTestMethod: finalMethod
+  };
+})()`;
+}
+/**
+* Cocos Creator canvas engine adapter.
+*
+* Handles both Cocos Creator 2.x and 3.x. Version is resolved from cc.ENGINE_VERSION
+* at detect() time.
+*/
+var CocosCanvasAdapter = class {
+	id = "cocos";
+	engine = "CocosCreator";
+	version;
+	constructor() {
+		this.version = void 0;
+	}
+	async detect(env) {
+		try {
+			const result = await env.pageController.evaluate(`
+        (function() {
+          if (typeof window.cc === 'undefined' || window.cc === null) {
+            return { present: false, hasDirector: false };
+          }
+          var cocos = window.cc;
+          var hasDirector = !!(cocos.director);
+          var isV3 = !!(cocos.Scene);
+          var versionStr = cocos.ENGINE_VERSION || (isV3 ? '3.x' : '2.x');
+          var major = isV3 ? 3 : 2;
+          return {
+            present: true,
+            hasDirector: hasDirector,
+            version: versionStr,
+            versionMajor: major
+          };
+        })()
+      `);
+			if (!result.present || !result.hasDirector) return null;
+			const evidence = ["window.cc detected", "cc.director present"];
+			if (result.versionMajor === 2) evidence.push("Cocos Creator v2 API");
+			else if (result.versionMajor === 3) evidence.push("Cocos Creator v3 API");
+			return {
+				engine: this.engine,
+				version: result.version,
+				confidence: .95,
+				evidence,
+				adapterId: this.id
+			};
+		} catch {
+			return null;
+		}
+	}
+	async dumpScene(env, opts) {
+		const payload = buildCocosSceneTreeDumpPayload(opts);
+		const raw = await env.pageController.evaluate(payload);
+		return {
+			engine: raw.engine,
+			version: raw.version,
+			canvas: raw.canvas,
+			sceneTree: raw.sceneTree ?? {
+				id: "empty",
+				type: "Scene",
+				visible: true,
+				interactive: false,
+				alpha: 1,
+				x: 0,
+				y: 0,
+				width: raw.canvas?.width ?? 0,
+				height: raw.canvas?.height ?? 0,
+				worldBounds: {
+					x: 0,
+					y: 0,
+					width: raw.canvas?.width ?? 0,
+					height: raw.canvas?.height ?? 0
+				},
+				path: "cc.director.getScene()"
+			},
+			totalNodes: raw.totalNodes,
+			completeness: raw.completeness === "full" ? "full" : "partial"
+		};
+	}
+	async pickAt(env, opts) {
+		const payload = buildCocosHitTestPayload(opts);
+		const result = await env.pageController.evaluate(payload);
+		return {
+			success: result.success,
+			picked: result.picked,
+			candidates: result.candidates,
+			coordinates: result.coordinates,
+			hitTestMethod: result.hitTestMethod
+		};
+	}
+};
+//#endregion
+//#region src/server/domains/canvas/adapters/laya-adapter.ts
+/**
+* Generates a self-contained JS string that traverses Laya.stage via DFS and
+* returns a serialisable scene tree with worldBounds computed via localToGlobal().
+*
+* @param opts - Dump options (maxDepth, onlyInteractive, onlyVisible)
+*/
+function buildLayaSceneTreeDumpPayload(opts) {
+	const maxDepth = opts.maxDepth ?? 20;
+	const onlyInteractive = opts.onlyInteractive ?? false;
+	return `(function() {
+  function getChildren(node) {
+    if (!node) return [];
+    if (node.children && node.numChildren !== undefined) return node.children;
+    if (node._children) return node._children;
+    return [];
+  }
+
+  function getNumChildren(node) {
+    if (!node) return 0;
+    if (node.numChildren !== undefined) return node.numChildren;
+    if (node._children) return node._children.length;
+    if (node.children) return Array.isArray(node.children) ? node.children.length : 0;
+    return 0;
+  }
+
+  function nodeId(node, idx) {
+    if (node.id !== undefined && node.id !== null && node.id !== '') return String(node.id);
+    return (node.constructor ? node.constructor.name : 'Node') + '_' + idx;
+  }
+
+  function safeProp(node, key, fallback) {
+    try { var v = node[key]; return v === undefined || v === null ? fallback : v; } catch(e) { return fallback; }
+  }
+
+  function localToGlobalRect(node) {
+    if (!node) return { x: 0, y: 0, width: 0, height: 0 };
+    try {
+      var p0 = { x: 0, y: 0 };
+      var p1 = { x: safeProp(node, 'width', 0), y: safeProp(node, 'height', 0) };
+      var lp0 = node.localToGlobal ? node.localToGlobal(p0) : p0;
+      var lp1 = node.localToGlobal ? node.localToGlobal(p1) : p1;
+      var w = Math.abs(lp1.x - lp0.x) || safeProp(node, 'width', 0);
+      var h = Math.abs(lp1.y - lp0.y) || safeProp(node, 'height', 0);
+      return { x: lp0.x, y: lp0.y, width: w, height: h };
+    } catch(e) {
+      return { x: safeProp(node, 'x', 0), y: safeProp(node, 'y', 0),
+               width: safeProp(node, 'width', 0), height: safeProp(node, 'height', 0) };
+    }
+  }
+
+  var totalNodes = 0;
+
+  function traverse(node, depth, path) {
+    if (!node || depth > ${maxDepth}) return null;
+    totalNodes++;
+
+    var interactive = !!(safeProp(node, 'mouseEnabled', true));
+    var visible = !!(safeProp(node, 'visible', true));
+
+    if (${opts.onlyVisible ?? false} && !visible) return null;
+    if (${onlyInteractive} && !interactive) return null;
+
+    var wb = localToGlobalRect(node);
+    var numC = getNumChildren(node);
+    var children = null;
+
+    if (numC > 0) {
+      children = [];
+      var nodeChildren = getChildren(node);
+      for (var i = 0; i < nodeChildren.length; i++) {
+        var cn = nodeChildren[i];
+        if (!cn) continue;
+        var childPath = path ? path + '/' + nodeId(cn, i) : nodeId(cn, i);
+        var sub = traverse(cn, depth + 1, childPath);
+        if (sub) children.push(sub);
+      }
+    }
+
+    var result = {
+      id: nodeId(node, 0),
+      type: node.constructor ? node.constructor.name : 'Node',
+      name: safeProp(node, 'name', undefined),
+      visible: visible,
+      interactive: interactive,
+      mouseEnabled: safeProp(node, 'mouseEnabled', undefined),
+      alpha: safeProp(node, 'alpha', 1),
+      x: safeProp(node, 'x', 0),
+      y: safeProp(node, 'y', 0),
+      width: safeProp(node, 'width', 0),
+      height: safeProp(node, 'height', 0),
+      worldBounds: wb,
+      path: path || nodeId(node, 0),
+      customData: {
+        scaleX: safeProp(node, 'scaleX', 1),
+        scaleY: safeProp(node, 'scaleY', 1),
+        rotation: safeProp(node, 'rotation', 0),
+        pivotX: safeProp(node, 'pivotX', 0),
+        pivotY: safeProp(node, 'pivotY', 0),
+        mouseThrough: safeProp(node, 'mouseThrough', false),
+        hitArea: !!node.hitArea,
+        hitTestPrior: safeProp(node, 'hitTestPrior', undefined),
+      }
+    };
+
+    if (children && children.length > 0) result.children = children;
+    return result;
+  }
+
+  if (!window.Laya || !window.Laya.stage) {
+    return { engine: 'LayaAir', version: window.Laya ? window.Laya.version : undefined,
+             canvas: { width: 0, height: 0, dpr: 1, contextType: 'unknown' },
+             sceneTree: null, totalNodes: 0, completeness: 'partial',
+             error: 'Laya.stage not found' };
+  }
+
+  var stage = window.Laya.stage;
+  var layaVersion = window.Laya.version || '2.x';
+  var isLaya3 = !!(window.Laya.InputManager);
+  var scaleX = stage.clientScaleX !== undefined ? stage.clientScaleX : 1;
+  var scaleY = stage.clientScaleY !== undefined ? stage.clientScaleY : 1;
+
+  var canvasEl = document.querySelector('canvas');
+  var canvasInfo = { width: canvasEl ? canvasEl.width : safeProp(stage, 'width', 0),
+                     height: canvasEl ? canvasEl.height : safeProp(stage, 'height', 0),
+                     dpr: window.devicePixelRatio || 1,
+                     contextType: 'unknown' };
+  if (canvasEl) {
+    var gl = canvasEl.getContext('webgl2') || canvasEl.getContext('webgl');
+    canvasInfo.contextType = gl ? (gl instanceof WebGL2RenderingContext ? 'webgl2' : 'webgl') : '2d';
+  }
+
+  var sceneTree = traverse(stage, 0, 'Laya.stage');
+
+  return {
+    engine: 'LayaAir',
+    version: layaVersion,
+    canvas: canvasInfo,
+    sceneTree: sceneTree,
+    totalNodes: totalNodes,
+    completeness: 'full',
+    _meta: { isLaya3: isLaya3, scaleX: scaleX, scaleY: scaleY }
+  };
+})()`;
+}
+/**
+* Generates a self-contained JS string that:
+*  1. Transforms screen coordinates → stage coordinates using clientScaleX/Y
+*  2. Runs hit test via Stage.hitTest (3.x) or recursive DFS bounds check (2.x)
+*  3. Returns all candidates sorted by depth (topmost first)
+*
+* @param opts - Pick options (x, y, canvasId)
+*/
+function buildLayaHitTestPayload(opts) {
+	const x = opts.x;
+	const y = opts.y;
+	const canvasId = opts.canvasId;
+	return `(function() {
+  function getChildren(node) {
+    if (!node) return [];
+    if (node.children && node.numChildren !== undefined) return node.children;
+    if (node._children) return node._children;
+    return [];
+  }
+
+  function getNumChildren(node) {
+    if (!node) return 0;
+    if (node.numChildren !== undefined) return node.numChildren;
+    if (node._children) return node._children.length;
+    if (node.children) return Array.isArray(node.children) ? node.children.length : 0;
+    return 0;
+  }
+
+  function nodeId(node, idx) {
+    if (node.id !== undefined && node.id !== null && node.id !== '') return String(node.id);
+    return (node.constructor ? node.constructor.name : 'Node') + '_' + idx;
+  }
+
+  function safeProp(node, key, fallback) {
+    try { var v = node[key]; return v === undefined || v === null ? fallback : v; } catch(e) { return fallback; }
+  }
+
+  function localToGlobalRect(node) {
+    if (!node) return { x: 0, y: 0, width: 0, height: 0 };
+    try {
+      var p0 = { x: 0, y: 0 };
+      var p1 = { x: safeProp(node, 'width', 0), y: safeProp(node, 'height', 0) };
+      var lp0 = node.localToGlobal ? node.localToGlobal(p0) : p0;
+      var lp1 = node.localToGlobal ? node.localToGlobal(p1) : p1;
+      var w = Math.abs(lp1.x - lp0.x) || safeProp(node, 'width', 0);
+      var h = Math.abs(lp1.y - lp0.y) || safeProp(node, 'height', 0);
+      return { x: lp0.x, y: lp0.y, width: w, height: h };
+    } catch(e) {
+      return { x: safeProp(node, 'x', 0), y: safeProp(node, 'y', 0),
+               width: safeProp(node, 'width', 0), height: safeProp(node, 'height', 0) };
+    }
+  }
+
+  function nodePath(node) {
+    var parts = [];
+    var cur = node;
+    while (cur && cur !== window.Laya.stage) {
+      var name = cur.name || nodeId(cur, 0);
+      parts.unshift(name);
+      cur = cur.parent;
+    }
+    parts.unshift('Laya.stage');
+    return parts.join('/');
+  }
+
+  var sx = ${x}, sy = ${y};
+
+  // Find the target canvas
+  var canvases = Array.from(document.querySelectorAll('canvas'));
+  var targetCanvas = null;
+  ${canvasId ? `targetCanvas = document.getElementById(${JSON.stringify(canvasId)}) || canvases[parseInt(${JSON.stringify(canvasId)})] || null;` : `
+  for (var ci = canvases.length - 1; ci >= 0; ci--) {
+    var r = canvases[ci].getBoundingClientRect();
+    if (sx >= r.left && sx <= r.right && sy >= r.top && sy <= r.bottom) {
+      targetCanvas = canvases[ci];
+      break;
+    }
+  }`}
+
+  if (!window.Laya || !window.Laya.stage) {
+    return { success: false, picked: null, candidates: [], coordinates: {
+               screen: { x: sx, y: sy }, canvas: { x: 0, y: 0 } }, hitTestMethod: 'none' };
+  }
+
+  var stage = window.Laya.stage;
+  var isLaya3 = !!(window.Laya.InputManager);
+  var scaleX = stage.clientScaleX !== undefined ? stage.clientScaleX : 1;
+  var scaleY = stage.clientScaleY !== undefined ? stage.clientScaleY : 1;
+
+  // Screen → canvas
+  var canvasX = sx, canvasY = sy;
+  if (targetCanvas) {
+    var rect = targetCanvas.getBoundingClientRect();
+    canvasX = (sx - rect.left) * (targetCanvas.width / rect.width);
+    canvasY = (sy - rect.top) * (targetCanvas.height / rect.height);
+  }
+
+  // Canvas → stage: use mouseX/mouseY when available (set by Laya's event system)
+  var stageX = safeProp(stage, 'mouseX', canvasX / (scaleX || 1));
+  var stageY = safeProp(stage, 'mouseY', canvasY / (scaleY || 1));
+
+  var candidates = [];
+
+  // Try engine-native hitTest first (3.x)
+  var hitTestMethod = 'none';
+  var enginePicked = null;
+
+  if (isLaya3 && typeof stage.hitTest === 'function') {
+    try {
+      var nativeHit = stage.hitTest({ x: stageX, y: stageY });
+      if (nativeHit) {
+        enginePicked = nativeHit;
+        hitTestMethod = 'engine';
+      }
+    } catch(e) {}
+  }
+
+  // Recursive DFS hit test (always available; 2.x fallback for 3.x too)
+  function hitTestDfs(node, depth, accPath) {
+    if (!node || !safeProp(node, 'visible', true)) return;
+
+    var wb = localToGlobalRect(node);
+    var mx = sx, my = sy;
+
+    // Convert screen → node local using parent chain
+    var cur = node;
+    var screenPt = { x: sx, y: sy };
+    while (cur) {
+      if (cur.globalToLocal) {
+        try { screenPt = cur.globalToLocal(screenPt); } catch(e) { break; }
+      }
+      cur = cur.parent;
+    }
+    var lx = screenPt.x, ly = screenPt.y;
+
+    // Check bounds against node's local coordinate frame
+    var nw = safeProp(node, 'width', 0) || (wb.width / (safeProp(node, 'scaleX', 1) || 1));
+    var nh = safeProp(node, 'height', 0) || (wb.height / (safeProp(node, 'scaleY', 1) || 1));
+    var nx = safeProp(node, 'x', 0), ny = safeProp(node, 'y', 0);
+    var pivotX = safeProp(node, 'pivotX', 0), pivotY = safeProp(node, 'pivotY', 0);
+
+    var inBounds = lx >= nx - pivotX && lx <= nx - pivotX + nw &&
+                   ly >= ny - pivotY && ly <= ny - pivotY + nh;
+
+    var interactive = !!(safeProp(node, 'mouseEnabled', true));
+
+    if (inBounds && interactive) {
+      var path = accPath ? accPath + '/' + nodeId(node, 0) : nodeId(node, 0);
+      candidates.push({
+        node: {
+          id: nodeId(node, 0),
+          type: node.constructor ? node.constructor.name : 'Node',
+          name: safeProp(node, 'name', undefined),
+          visible: !!(safeProp(node, 'visible', true)),
+          interactive: interactive,
+          mouseEnabled: safeProp(node, 'mouseEnabled', undefined),
+          alpha: safeProp(node, 'alpha', 1),
+          x: nx, y: ny,
+          width: nw, height: nh,
+          worldBounds: wb,
+          path: path
+        },
+        depth: depth
+      });
+    }
+
+    var nodeChildren = getChildren(node);
+    for (var i = 0; i < nodeChildren.length; i++) {
+      var cn = nodeChildren[i];
+      if (!cn) continue;
+      var childPath = accPath ? accPath + '/' + nodeId(cn, i) : nodeId(cn, i);
+      hitTestDfs(cn, depth + 1, childPath);
+    }
+  }
+
+  hitTestDfs(stage, 0, 'Laya.stage');
+
+  // Use engine pick if available, otherwise topmost DFS candidate
+  var picked = enginePicked;
+  var finalMethod = hitTestMethod;
+
+  if (!picked && candidates.length > 0) {
+    // Sort by depth ascending (deepest/nested first = topmost)
+    candidates.sort(function(a, b) { return a.depth - b.depth; });
+    picked = candidates[0].node;
+    finalMethod = 'manual';
+  }
+
+  return {
+    success: !!picked,
+    picked: picked,
+    candidates: candidates,
+    coordinates: {
+      screen: { x: sx, y: sy },
+      canvas: { x: canvasX, y: canvasY },
+      stage: { x: stageX, y: stageY }
+    },
+    hitTestMethod: finalMethod
+  };
+})()`;
+}
+/**
+* LayaAir canvas engine adapter.
+*
+* Handles both LayaAir 2.x and 3.x. Version is resolved lazily from window.Laya.version
+* at first detect() call.
+*/
+var LayaCanvasAdapter = class {
+	id = "laya";
+	engine = "LayaAir";
+	version;
+	constructor() {
+		this.version = void 0;
+	}
+	async detect(env) {
+		try {
+			const result = await env.pageController.evaluate(`
+        (function() {
+          if (typeof window.Laya === 'undefined' || window.Laya === null) {
+            return { present: false, hasStage: false, laya2: false, laya3: false };
+          }
+          var laya = window.Laya;
+          var hasStage = !!(laya.stage);
+          var laya2 = !!(laya.MouseManager);
+          var laya3 = !!(laya.InputManager);
+          var version = laya.version || (laya2 ? '2.x' : laya3 ? '3.x' : undefined);
+          return { present: true, hasStage: hasStage, version: version,
+                   laya2: laya2, laya3: laya3 };
+        })()
+      `);
+			if (!result.present || !result.hasStage) return null;
+			const evidence = ["window.Laya is defined"];
+			if (result.laya2) evidence.push("Laya.MouseManager detected (LayaAir 2.x)");
+			if (result.laya3) evidence.push("Laya.InputManager detected (LayaAir 3.x)");
+			evidence.push("Laya.stage is present");
+			return {
+				engine: this.engine,
+				version: result.version,
+				confidence: .95,
+				evidence,
+				adapterId: this.id
+			};
+		} catch {
+			return null;
+		}
+	}
+	async dumpScene(env, opts) {
+		const payload = buildLayaSceneTreeDumpPayload(opts);
+		const raw = await env.pageController.evaluate(payload);
+		return {
+			engine: raw.engine,
+			version: raw.version,
+			canvas: raw.canvas,
+			sceneTree: raw.sceneTree ?? {
+				id: "empty",
+				type: "Stage",
+				visible: true,
+				interactive: false,
+				alpha: 1,
+				x: 0,
+				y: 0,
+				width: raw.canvas?.width ?? 0,
+				height: raw.canvas?.height ?? 0,
+				worldBounds: {
+					x: 0,
+					y: 0,
+					width: raw.canvas?.width ?? 0,
+					height: raw.canvas?.height ?? 0
+				},
+				path: "Laya.stage"
+			},
+			totalNodes: raw.totalNodes,
+			completeness: raw.completeness === "full" ? "full" : "partial"
+		};
+	}
+	async pickAt(env, opts) {
+		const payload = buildLayaHitTestPayload(opts);
+		const result = await env.pageController.evaluate(payload);
+		return {
+			success: result.success,
+			picked: result.picked,
+			candidates: result.candidates,
+			coordinates: result.coordinates,
+			hitTestMethod: result.hitTestMethod
+		};
+	}
+	async traceClick(env, opts, services) {
+		const { debuggerManager, traceRecorder, evidenceStore } = services;
+		let traceId = "no-recording";
+		try {
+			traceId = (await traceRecorder.start(null, null, { recordMemoryDeltas: false })).sessionId;
+		} catch {}
+		await debuggerManager.enable();
+		await debuggerManager.ensureAdvancedFeatures();
+		const patchResult = await env.pageController.evaluate(`
+      (function() {
+        var k = Symbol.for('__laya_event_patched');
+        var instrumented = [];
+        function patchTarget(proto) {
+          if (!proto || !proto.event || proto[k]) return;
+          var original = proto.event;
+          if (typeof original !== 'function') return;
+          Object.defineProperty(proto, 'event', {
+            value: function(type, data) {
+              if (!this[k]) this[k] = new Set();
+              if (this[k].has(type)) return; // idempotent
+              this[k].add(type);
+              return original.call(this, type, data);
+            },
+            configurable: true,
+            enumerable: false
+          });
+          instrumented.push(proto.constructor ? proto.constructor.name : 'EventDispatcher');
+        }
+
+        // Walk prototype chain
+        var seen = new Set();
+        var queue = [window.Laya && window.Laya.EventDispatcher ? window.Laya.EventDispatcher.prototype : null];
+        while (queue.length) {
+          var p = queue.shift();
+          if (!p || seen.has(p)) continue;
+          seen.add(p);
+          patchTarget(p);
+          if (Object.getPrototypeOf) {
+            var mp = Object.getPrototypeOf(p);
+            if (mp) queue.push(mp);
+          }
+        }
+
+        return { success: true, instrumented: instrumented };
+      })()
+    `);
+		const breakpointType = opts.breakpointType ?? "click";
+		await debuggerManager.getEventManager().setEventListenerBreakpoint(breakpointType);
+		const domEventChain = await env.pageController.evaluate(`
+      (function() {
+        var ev = new PointerEvent(${JSON.stringify(breakpointType)}, {
+          view: window, bubbles: true, cancelable: true,
+          clientX: ${opts.targetNodeId ?? 0}, clientY: 0, pointerId: 1
+        });
+        var events = [];
+        var el = document.elementFromPoint(0, 0);
+        if (el) el.dispatchEvent(ev);
+        events.push(${JSON.stringify(breakpointType)});
+        return events;
+      })()
+    `);
+		const pausedState = await debuggerManager.waitForPaused(5e3);
+		const handlerFrames = pausedState?.callFrames ? pausedState.callFrames.slice(0, opts.maxFrames ?? 50).map((f) => ({
+			functionName: f.functionName || "(anonymous)",
+			scriptUrl: f.url,
+			lineNumber: f.location?.lineNumber,
+			columnNumber: f.location?.columnNumber
+		})) : [];
+		await debuggerManager.resume();
+		evidenceStore.addNode("function", `laya-click-trace:${traceId}`, {
+			engine: this.engine,
+			version: this.version,
+			handlersFound: handlerFrames.length,
+			instrumentedPrototypes: patchResult?.instrumented ?? []
+		});
+		try {
+			await traceRecorder.stop();
+		} catch {}
+		return {
+			inputFlow: domEventChain,
+			hitTarget: null,
+			domEventChain: handlerFrames.map((f) => ({
+				type: breakpointType,
+				target: f.scriptUrl,
+				phase: "at-target"
+			})),
+			engineDispatchChain: patchResult?.instrumented ?? [],
+			handlerFrames,
+			handlersTriggered: handlerFrames.map((f) => ({
+				functionName: f.functionName,
+				scriptUrl: f.scriptUrl,
+				lineNumber: f.lineNumber
+			})),
+			networkEmitted: []
+		};
+	}
+};
+//#endregion
+//#region src/server/domains/canvas/adapters/phaser-adapter.ts
+/**
+* Generates a self-contained JS string that traverses Phaser scenes via DFS and
+* returns a serialisable scene tree with worldBounds computed via getBounds().
+*
+* @param opts - Dump options (maxDepth, onlyInteractive, onlyVisible)
+*/
+function buildPhaserSceneTreeDumpPayload(opts) {
+	const maxDepth = opts.maxDepth ?? 20;
+	const onlyInteractive = opts.onlyInteractive ?? false;
+	return `(function() {
+  function getChildren(node) {
+    if (!node) return [];
+    if (node.list && Array.isArray(node.list)) return node.list;
+    if (node.children && Array.isArray(node.children)) return node.children;
+    return [];
+  }
+
+  function getNumChildren(node) {
+    if (!node) return 0;
+    if (node.list) return node.list.length;
+    if (node.numChildren !== undefined) return node.numChildren;
+    if (node.children && Array.isArray(node.children)) return node.children.length;
+    return 0;
+  }
+
+  function nodeId(node, idx) {
+    if (node.id !== undefined && node.id !== null && node.id !== '') return String(node.id);
+    return (node.constructor ? node.constructor.name : 'DisplayObject') + '_' + idx;
+  }
+
+  function safeProp(node, key, fallback) {
+    try { var v = node[key]; return v === undefined || v === null ? fallback : v; } catch(e) { return fallback; }
+  }
+
+  function nodeBounds(node) {
+    if (!node) return { x: 0, y: 0, width: 0, height: 0 };
+    try {
+      if (typeof node.getBounds === 'function') {
+        var b = node.getBounds();
+        return { x: b.x, y: b.y, width: b.width, height: b.height };
+      }
+    } catch(e) {}
+    return {
+      x: safeProp(node, 'x', 0),
+      y: safeProp(node, 'y', 0),
+      width: safeProp(node, 'width', 0) || safeProp(node, 'displayWidth', 0),
+      height: safeProp(node, 'height', 0) || safeProp(node, 'displayHeight', 0),
+    };
+  }
+
+  var totalNodes = 0;
+
+  function traverse(node, depth, path) {
+    if (!node || depth > ${maxDepth}) return null;
+    totalNodes++;
+
+    var interactive = !!(node.input && node.input.enabled);
+    var visible = !!(safeProp(node, 'visible', true));
+
+    if (${opts.onlyVisible ?? false} && !visible) return null;
+    if (${onlyInteractive} && !interactive) return null;
+
+    var wb = nodeBounds(node);
+    var numC = getNumChildren(node);
+    var children = null;
+
+    if (numC > 0) {
+      children = [];
+      var nodeChildren = getChildren(node);
+      for (var i = 0; i < nodeChildren.length; i++) {
+        var cn = nodeChildren[i];
+        if (!cn) continue;
+        var childPath = path ? path + '/' + nodeId(cn, i) : nodeId(cn, i);
+        var sub = traverse(cn, depth + 1, childPath);
+        if (sub) children.push(sub);
+      }
+    }
+
+    var result = {
+      id: nodeId(node, 0),
+      type: node.constructor ? node.constructor.name : 'DisplayObject',
+      name: safeProp(node, 'name', undefined),
+      visible: visible,
+      interactive: interactive,
+      alpha: safeProp(node, 'alpha', 1),
+      x: safeProp(node, 'x', 0),
+      y: safeProp(node, 'y', 0),
+      width: safeProp(node, 'width', 0) || safeProp(node, 'displayWidth', 0),
+      height: safeProp(node, 'height', 0) || safeProp(node, 'displayHeight', 0),
+      worldBounds: wb,
+      path: path || nodeId(node, 0),
+    };
+
+    if (children && children.length > 0) result.children = children;
+    return result;
+  }
+
+  if (typeof window.Phaser === 'undefined' || !window.Phaser.GAMES || window.Phaser.GAMES.length === 0) {
+    return { engine: 'Phaser',
+             version: typeof window.Phaser !== 'undefined' ? window.Phaser.VERSION : undefined,
+             canvas: { width: 0, height: 0, dpr: 1, contextType: 'unknown' },
+             sceneTree: null, totalNodes: 0, completeness: 'partial',
+             error: 'Phaser.GAMES has no entries' };
+  }
+
+  var game = window.Phaser.GAMES[0];
+  if (!game || !game.scene || !game.canvas) {
+    return { engine: 'Phaser',
+             version: window.Phaser.VERSION || undefined,
+             canvas: { width: 0, height: 0, dpr: 1, contextType: 'unknown' },
+             sceneTree: null, totalNodes: 0, completeness: 'partial',
+             error: 'Game or canvas not accessible' };
+  }
+
+  var canvasEl = game.canvas;
+  var dpr = window.devicePixelRatio || 1;
+  var gl = null;
+  try { gl = canvasEl.getContext('webgl2') || canvasEl.getContext('webgl'); } catch(e) {}
+  var contextType = '2d';
+  if (gl) contextType = gl instanceof WebGL2RenderingContext ? 'webgl2' : 'webgl';
+
+  var canvasInfo = {
+    width: canvasEl.width || safeProp(game.scale, 'width', 0),
+    height: canvasEl.height || safeProp(game.scale, 'height', 0),
+    dpr: dpr,
+    contextType: contextType,
+  };
+
+  var sceneTree = null;
+  var scenes = game.scene ? game.scene.scenes : [];
+
+  if (scenes && scenes.length > 0) {
+    for (var si = 0; si < scenes.length; si++) {
+      var sc = scenes[si];
+      if (!sc || !sc.sys) continue;
+      var status = safeProp(sc.sys, 'settings', {}).status;
+      // Only process active scenes (Phaser 3.x status: 0=init,1=start,2=loading,3=created,4=shutdown)
+      if (status !== undefined && status !== 4) {
+        var displayList = sc.sys && sc.sys.displayList;
+        if (displayList) {
+          var scenePath = 'Phaser.Game.scenes[' + si + ']';
+          sceneTree = traverse(displayList, 0, scenePath);
+        }
+        break;
+      }
+    }
+  }
+
+  return {
+    engine: 'Phaser',
+    version: window.Phaser.VERSION || undefined,
+    canvas: canvasInfo,
+    sceneTree: sceneTree,
+    totalNodes: totalNodes,
+    completeness: sceneTree ? 'full' : 'partial',
+  };
+})()`;
+}
+/**
+* Generates a self-contained JS string that:
+*  1. Transforms screen coordinates to canvas coordinates
+*  2. Runs hit test via scene.input.hitTestPointer() (Phaser's native method)
+*  3. Falls back to recursive bounds check using getBounds() / getTopLeft/getBottomRight
+*  4. Returns all candidates sorted by depth (topmost first)
+*
+* @param opts - Pick options (x, y, canvasId)
+*/
+function buildPhaserHitTestPayload(opts) {
+	const x = opts.x;
+	const y = opts.y;
+	const canvasId = opts.canvasId;
+	return `(function() {
+  function getChildren(node) {
+    if (!node) return [];
+    if (node.list && Array.isArray(node.list)) return node.list;
+    if (node.children && Array.isArray(node.children)) return node.children;
+    return [];
+  }
+
+  function getNumChildren(node) {
+    if (!node) return 0;
+    if (node.list) return node.list.length;
+    if (node.numChildren !== undefined) return node.numChildren;
+    if (node.children && Array.isArray(node.children)) return node.children.length;
+    return 0;
+  }
+
+  function nodeId(node, idx) {
+    if (node.id !== undefined && node.id !== null && node.id !== '') return String(node.id);
+    return (node.constructor ? node.constructor.name : 'DisplayObject') + '_' + idx;
+  }
+
+  function safeProp(node, key, fallback) {
+    try { var v = node[key]; return v === undefined || v === null ? fallback : v; } catch(e) { return fallback; }
+  }
+
+  function nodeBounds(node) {
+    if (!node) return { x: 0, y: 0, width: 0, height: 0 };
+    try {
+      if (typeof node.getBounds === 'function') {
+        var b = node.getBounds();
+        return { x: b.x, y: b.y, width: b.width, height: b.height };
+      }
+    } catch(e) {}
+    return {
+      x: safeProp(node, 'x', 0),
+      y: safeProp(node, 'y', 0),
+      width: safeProp(node, 'width', 0) || safeProp(node, 'displayWidth', 0),
+      height: safeProp(node, 'height', 0) || safeProp(node, 'displayHeight', 0),
+    };
+  }
+
+  function nodePath(node, sceneIdx) {
+    var parts = [];
+    var cur = node;
+    while (cur) {
+      var name = cur.name || nodeId(cur, 0);
+      parts.unshift(name);
+      cur = cur.parent;
+    }
+    return 'Phaser.Game.scenes[' + sceneIdx + ']/' + parts.join('/');
+  }
+
+  var sx = ${x}, sy = ${y};
+
+  // Find the target canvas
+  var canvases = Array.from(document.querySelectorAll('canvas'));
+  var targetCanvas = null;
+  ${canvasId ? `targetCanvas = document.getElementById(${JSON.stringify(canvasId)}) || canvases[parseInt(${JSON.stringify(canvasId)})] || null;` : `
+  for (var ci = canvases.length - 1; ci >= 0; ci--) {
+    var r = canvases[ci].getBoundingClientRect();
+    if (sx >= r.left && sx <= r.right && sy >= r.top && sy <= r.bottom) {
+      targetCanvas = canvases[ci];
+      break;
+    }
+  }`}
+
+  if (typeof window.Phaser === 'undefined' || !window.Phaser.GAMES || window.Phaser.GAMES.length === 0) {
+    return { success: false, picked: null, candidates: [], coordinates: {
+               screen: { x: sx, y: sy }, canvas: { x: 0, y: 0 } }, hitTestMethod: 'none' };
+  }
+
+  var game = window.Phaser.GAMES[0];
+  var canvasX = sx, canvasY = sy;
+  if (targetCanvas) {
+    var rect = targetCanvas.getBoundingClientRect();
+    canvasX = (sx - rect.left) * (targetCanvas.width / rect.width);
+    canvasY = (sy - rect.top) * (targetCanvas.height / rect.height);
+  }
+
+  var candidates = [];
+  var hitTestMethod = 'none';
+  var enginePicked = null;
+  var sceneIdx = 0;
+
+  // Try engine-native hit test via scene.input.hitTestPointer
+  if (game && game.scene && game.scene.scenes) {
+    var scenes = game.scene.scenes;
+    for (var si = 0; si < scenes.length; si++) {
+      var sc = scenes[si];
+      if (!sc || !sc.sys) continue;
+      var status = safeProp(sc.sys, 'settings', {}).status;
+      if (status !== undefined && status !== 4) {
+        // Scene is active
+        if (sc.input && typeof sc.input.hitTestPointer === 'function') {
+          try {
+            var nativeHit = sc.input.hitTestPointer({ x: canvasX, y: canvasY });
+            if (nativeHit && nativeHit.length > 0) {
+              enginePicked = nativeHit[0];
+              hitTestMethod = 'engine';
+              sceneIdx = si;
+            }
+          } catch(e) {}
+        }
+        break;
+      }
+    }
+  }
+
+  // Recursive DFS fallback bounds check
+  function hitTestDfs(node, depth, accPath) {
+    if (!node || !safeProp(node, 'visible', true)) return;
+
+    var wb = nodeBounds(node);
+
+    // Convert screen → node local using parent chain
+    var cur = node;
+    var screenPt = { x: sx, y: sy };
+    while (cur) {
+      if (cur.globalToLocal) {
+        try { screenPt = cur.globalToLocal(screenPt); } catch(e) { break; }
+      }
+      cur = cur.parent;
+    }
+    var lx = screenPt.x, ly = screenPt.y;
+
+    var nw = safeProp(node, 'width', 0) || safeProp(node, 'displayWidth', 0) || wb.width;
+    var nh = safeProp(node, 'height', 0) || safeProp(node, 'displayHeight', 0) || wb.height;
+    var nx = safeProp(node, 'x', 0), ny = safeProp(node, 'y', 0);
+    var pivotX = safeProp(node, 'pivotX', 0), pivotY = safeProp(node, 'pivotY', 0);
+
+    var inBounds = lx >= nx - pivotX && lx <= nx - pivotX + nw &&
+                   ly >= ny - pivotY && ly <= ny - pivotY + nh;
+
+    var interactive = !!(node.input && node.input.enabled);
+
+    if (inBounds && interactive) {
+      var path = accPath || nodePath(node, sceneIdx);
+      candidates.push({
+        node: {
+          id: nodeId(node, 0),
+          type: node.constructor ? node.constructor.name : 'DisplayObject',
+          name: safeProp(node, 'name', undefined),
+          visible: !!(safeProp(node, 'visible', true)),
+          interactive: interactive,
+          alpha: safeProp(node, 'alpha', 1),
+          x: nx, y: ny,
+          width: nw, height: nh,
+          worldBounds: wb,
+          path: path,
+        },
+        depth: depth
+      });
+    }
+
+    var nodeChildren = getChildren(node);
+    for (var i = 0; i < nodeChildren.length; i++) {
+      var cn = nodeChildren[i];
+      if (!cn) continue;
+      var childPath = accPath ? accPath + '/' + nodeId(cn, i) : nodePath(cn, sceneIdx);
+      hitTestDfs(cn, depth + 1, childPath);
+    }
+  }
+
+  // Traverse displayList for manual hit test
+  if (game && game.scene && game.scene.scenes) {
+    var scenes2 = game.scene.scenes;
+    for (var sj = 0; sj < scenes2.length; sj++) {
+      var scj = scenes2[sj];
+      if (!scj || !scj.sys) continue;
+      var statusj = safeProp(scj.sys, 'settings', {}).status;
+      if (statusj !== undefined && statusj !== 4) {
+        sceneIdx = sj;
+        var displayList = scj.sys && scj.sys.displayList;
+        if (displayList) {
+          hitTestDfs(displayList, 0, 'Phaser.Game.scenes[' + sj + ']');
+        }
+        break;
+      }
+    }
+  }
+
+  // Use engine pick if available, otherwise topmost DFS candidate
+  var picked = enginePicked ? {
+    id: enginePicked.id !== undefined ? String(enginePicked.id) : nodeId(enginePicked, 0),
+    type: enginePicked.constructor ? enginePicked.constructor.name : 'DisplayObject',
+    name: safeProp(enginePicked, 'name', undefined),
+    visible: !!(safeProp(enginePicked, 'visible', true)),
+    interactive: !!(enginePicked.input && enginePicked.input.enabled),
+    alpha: safeProp(enginePicked, 'alpha', 1),
+    x: safeProp(enginePicked, 'x', 0),
+    y: safeProp(enginePicked, 'y', 0),
+    width: safeProp(enginePicked, 'width', 0) || safeProp(enginePicked, 'displayWidth', 0),
+    height: safeProp(enginePicked, 'height', 0) || safeProp(enginePicked, 'displayHeight', 0),
+    worldBounds: nodeBounds(enginePicked),
+    path: 'Phaser.Game.scenes[' + sceneIdx + ']/hit',
+  } : null;
+
+  if (!picked && candidates.length > 0) {
+    candidates.sort(function(a, b) { return a.depth - b.depth; });
+    picked = candidates[0].node;
+    hitTestMethod = 'manual';
+  }
+
+  return {
+    success: !!picked,
+    picked: picked,
+    candidates: candidates,
+    coordinates: {
+      screen: { x: sx, y: sy },
+      canvas: { x: canvasX, y: canvasY },
+    },
+    hitTestMethod: hitTestMethod
+  };
+})()`;
+}
+/**
+* Phaser 3.x canvas engine adapter.
+*
+* Detection checks window.Phaser and Phaser.GAMES.length > 0.
+* dumpScene() traverses Phaser.GAMES[0].scene.scenes active scenes.
+* pickAt() uses scene.input.hitTestPointer() with recursive DFS fallback.
+*/
+var PhaserCanvasAdapter = class {
+	id = "phaser";
+	engine = "Phaser";
+	version;
+	constructor() {
+		this.version = void 0;
+	}
+	async detect(env) {
+		try {
+			const result = await env.pageController.evaluate(`
+        (function() {
+          if (typeof window.Phaser === 'undefined' || window.Phaser === null) {
+            return { present: false, hasGames: false };
+          }
+          var hasGames = !!(window.Phaser.GAMES && window.Phaser.GAMES.length > 0);
+          return {
+            present: true,
+            hasGames: hasGames,
+            version: window.Phaser.VERSION || undefined,
+          };
+        })()
+      `);
+			if (!result.present || !result.hasGames) return null;
+			const evidence = ["window.Phaser detected"];
+			evidence.push("Phaser.GAMES has entries");
+			return {
+				engine: this.engine,
+				version: result.version,
+				confidence: .95,
+				evidence,
+				adapterId: this.id
+			};
+		} catch {
+			return null;
+		}
+	}
+	async dumpScene(env, opts) {
+		const payload = buildPhaserSceneTreeDumpPayload(opts);
+		const raw = await env.pageController.evaluate(payload);
+		return {
+			engine: raw.engine,
+			version: raw.version,
+			canvas: raw.canvas,
+			sceneTree: raw.sceneTree ?? {
+				id: "empty",
+				type: "Game",
+				visible: true,
+				interactive: false,
+				alpha: 1,
+				x: 0,
+				y: 0,
+				width: raw.canvas?.width ?? 0,
+				height: raw.canvas?.height ?? 0,
+				worldBounds: {
+					x: 0,
+					y: 0,
+					width: raw.canvas?.width ?? 0,
+					height: raw.canvas?.height ?? 0
+				},
+				path: "Phaser.Game"
+			},
+			totalNodes: raw.totalNodes,
+			completeness: raw.completeness === "full" ? "full" : "partial"
+		};
+	}
+	async pickAt(env, opts) {
+		const payload = buildPhaserHitTestPayload(opts);
+		const result = await env.pageController.evaluate(payload);
+		return {
+			success: result.success,
+			picked: result.picked,
+			candidates: result.candidates,
+			coordinates: result.coordinates,
+			hitTestMethod: result.hitTestMethod
+		};
+	}
+};
+//#endregion
+//#region src/server/domains/canvas/adapters/pixi-adapter.ts
+/**
+* Generates a self-contained JS string that traverses the PIXI scene graph via DFS
+* and returns a serialisable scene tree with worldBounds computed via getBounds().
+*
+* Handles both PIXI v7 (interactive property) and v8 (eventMode property).
+*
+* @param opts - Dump options (maxDepth, onlyInteractive, onlyVisible)
+*/
+function buildPixiSceneTreeDumpPayload(opts) {
+	const maxDepth = opts.maxDepth ?? 20;
+	const onlyInteractive = opts.onlyInteractive ?? false;
+	return `(function() {
+  function getChildren(node) {
+    if (!node) return [];
+    if (node.children && node.numChildren !== undefined) return node.children;
+    if (Array.isArray(node.children)) return node.children;
+    return [];
+  }
+
+  function getNumChildren(node) {
+    if (!node) return 0;
+    if (node.numChildren !== undefined) return node.numChildren;
+    if (node.children && Array.isArray(node.children)) return node.children.length;
+    return 0;
+  }
+
+  function nodeId(node, idx) {
+    if (node.uid !== undefined && node.uid !== null) return 'uid_' + node.uid;
+    if (node._uid !== undefined && node._uid !== null) return 'uid_' + node._uid;
+    if (node.id !== undefined && node.id !== null && node.id !== '') return String(node.id);
+    return (node.constructor ? node.constructor.name : 'DisplayObject') + '_' + idx;
+  }
+
+  function safeProp(node, key, fallback) {
+    try { var v = node[key]; return v === undefined || v === null ? fallback : v; } catch(e) { return fallback; }
+  }
+
+  function getWorldBounds(node, stage) {
+    if (!node) return { x: 0, y: 0, width: 0, height: 0 };
+    try {
+      if (typeof node.getBounds === 'function') {
+        var b = node.getBounds(stage);
+        return { x: b.x, y: b.y, width: b.width, height: b.height };
+      }
+    } catch(e) {}
+    return {
+      x: safeProp(node, 'x', 0),
+      y: safeProp(node, 'y', 0),
+      width: safeProp(node, 'width', 0) || safeProp(node, 'getBounds', { width: 0 }).width,
+      height: safeProp(node, 'height', 0) || safeProp(node, 'getBounds', { height: 0 }).height
+    };
+  }
+
+  var totalNodes = 0;
+
+  function traverse(node, depth, path) {
+    if (!node || depth > ${maxDepth}) return null;
+    totalNodes++;
+
+    var visible = !!(safeProp(node, 'visible', true));
+    // PIXI v7 uses 'interactive', v8 uses 'eventMode'
+    var interactive = !!(safeProp(node, 'interactive', false)) || !!(safeProp(node, 'eventMode', 'none') !== 'none');
+
+    if (${opts.onlyVisible ?? false} && !visible) return null;
+    if (${onlyInteractive} && !interactive) return null;
+
+    var numC = getNumChildren(node);
+    var children = null;
+
+    if (numC > 0) {
+      children = [];
+      var nodeChildren = getChildren(node);
+      for (var i = 0; i < nodeChildren.length; i++) {
+        var cn = nodeChildren[i];
+        if (!cn) continue;
+        var childPath = path ? path + '/' + nodeId(cn, i) : nodeId(cn, i);
+        var sub = traverse(cn, depth + 1, childPath);
+        if (sub) children.push(sub);
+      }
+    }
+
+    var eventMode = safeProp(node, 'eventMode', null);
+    var result = {
+      id: nodeId(node, 0),
+      type: node.constructor ? node.constructor.name : 'DisplayObject',
+      name: safeProp(node, 'name', undefined),
+      visible: visible,
+      interactive: interactive,
+      alpha: safeProp(node, 'alpha', 1),
+      x: safeProp(node, 'x', 0),
+      y: safeProp(node, 'y', 0),
+      width: safeProp(node, 'width', 0),
+      height: safeProp(node, 'height', 0),
+      worldBounds: getWorldBounds(node, null),
+      path: path || nodeId(node, 0),
+      customData: {
+        eventMode: eventMode,
+        rotation: safeProp(node, 'rotation', 0),
+        scaleX: safeProp(node, 'scaleX', 1),
+        scaleY: safeProp(node, 'scaleY', 1),
+        pivotX: safeProp(node, 'pivotX', 0),
+        pivotY: safeProp(node, 'pivotY', 0),
+        sortDirty: !!(node.sortDirty),
+      }
+    };
+
+    if (children && children.length > 0) result.children = children;
+    return result;
+  }
+
+  // Find PIXI app: scan canvas elements for _pixiApp property, or check window.__pixiApp
+  var app = null;
+  if (window.__pixiApp) {
+    app = window.__pixiApp;
+  } else {
+    var canvases = document.querySelectorAll('canvas');
+    for (var ci = 0; ci < canvases.length; ci++) {
+      if (canvases[ci]._pixiApp) { app = canvases[ci]._pixiApp; break; }
+    }
+  }
+
+  if (!app || !app.stage) {
+    var pixiVersion = window.PIXI ? (window.PIXI.VERSION || window.PIXI.version) : undefined;
+    return {
+      engine: 'PixiJS',
+      version: pixiVersion,
+      canvas: { width: 0, height: 0, dpr: 1, contextType: 'unknown' },
+      sceneTree: null,
+      totalNodes: 0,
+      completeness: 'partial',
+      error: 'PIXI.Application or stage not found'
+    };
+  }
+
+  var stage = app.stage;
+  var pixiVersion = window.PIXI ? (window.PIXI.VERSION || window.PIXI.version) : undefined;
+  var canvasEl = app.view || null;
+  var canvasInfo = {
+    width: canvasEl ? (canvasEl.width || 0) : 0,
+    height: canvasEl ? (canvasEl.height || 0) : 0,
+    dpr: window.devicePixelRatio || 1,
+    contextType: 'webgl2'
+  };
+
+  if (canvasEl) {
+    var gl = canvasEl.getContext('webgl2') || canvasEl.getContext('webgl');
+    if (!gl) {
+      var ctx = canvasEl.getContext('2d');
+      canvasInfo.contextType = ctx ? '2d' : 'webgl';
+    }
+  }
+
+  var sceneTree = traverse(stage, 0, 'PIXI.Application.stage');
+
+  return {
+    engine: 'PixiJS',
+    version: pixiVersion,
+    canvas: canvasInfo,
+    sceneTree: sceneTree,
+    totalNodes: totalNodes,
+    completeness: 'full'
+  };
+})()`;
+}
+/**
+* Generates a self-contained JS string that:
+*  1. Transforms screen coordinates → canvas coordinates
+*  2. Runs hit test via Stage.hitTest() if available (PIXI v7+), or DFS with getBounds()
+*  3. Returns all candidates sorted by depth (topmost first)
+*
+* @param opts - Pick options (x, y, canvasId)
+*/
+function buildPixiHitTestPayload(opts) {
+	const x = opts.x;
+	const y = opts.y;
+	const canvasId = opts.canvasId;
+	return `(function() {
+  function getChildren(node) {
+    if (!node) return [];
+    if (node.children && node.numChildren !== undefined) return node.children;
+    if (Array.isArray(node.children)) return node.children;
+    return [];
+  }
+
+  function getNumChildren(node) {
+    if (!node) return 0;
+    if (node.numChildren !== undefined) return node.numChildren;
+    if (node.children && Array.isArray(node.children)) return node.children.length;
+    return 0;
+  }
+
+  function nodeId(node, idx) {
+    if (node.uid !== undefined && node.uid !== null) return 'uid_' + node.uid;
+    if (node._uid !== undefined && node._uid !== null) return 'uid_' + node._uid;
+    if (node.id !== undefined && node.id !== null && node.id !== '') return String(node.id);
+    return (node.constructor ? node.constructor.name : 'DisplayObject') + '_' + idx;
+  }
+
+  function safeProp(node, key, fallback) {
+    try { var v = node[key]; return v === undefined || v === null ? fallback : v; } catch(e) { return fallback; }
+  }
+
+  function getWorldBounds(node, stage) {
+    if (!node) return { x: 0, y: 0, width: 0, height: 0 };
+    try {
+      if (typeof node.getBounds === 'function') {
+        var b = node.getBounds(stage || true);
+        return { x: b.x, y: b.y, width: b.width, height: b.height };
+      }
+    } catch(e) {}
+    return {
+      x: safeProp(node, 'x', 0),
+      y: safeProp(node, 'y', 0),
+      width: safeProp(node, 'width', 0),
+      height: safeProp(node, 'height', 0)
+    };
+  }
+
+  function nodePath(node) {
+    var parts = [];
+    var cur = node;
+    while (cur && cur.parent && cur.parent !== cur) {
+      var name = cur.name || nodeId(cur, 0);
+      parts.unshift(name);
+      cur = cur.parent;
+      if (!cur) break;
+    }
+    parts.unshift('PIXI.Application.stage');
+    return parts.join('/');
+  }
+
+  var sx = ${x}, sy = ${y};
+
+  // Find the target canvas
+  var canvases = Array.from(document.querySelectorAll('canvas'));
+  var targetCanvas = null;
+  ${canvasId ? `targetCanvas = document.getElementById(${JSON.stringify(canvasId)}) || null;` : `
+  for (var ci = canvases.length - 1; ci >= 0; ci--) {
+    var r = canvases[ci].getBoundingClientRect();
+    if (sx >= r.left && sx <= r.right && sy >= r.top && sy <= r.bottom) {
+      targetCanvas = canvases[ci];
+      break;
+    }
+  }`}
+
+  // Find PIXI app
+  var app = null;
+  if (window.__pixiApp) {
+    app = window.__pixiApp;
+  } else {
+    for (var ci2 = 0; ci2 < canvases.length; ci2++) {
+      if (canvases[ci2]._pixiApp) { app = canvases[ci2]._pixiApp; break; }
+    }
+  }
+
+  if (!app || !app.stage) {
+    return {
+      success: false,
+      picked: null,
+      candidates: [],
+      coordinates: { screen: { x: sx, y: sy }, canvas: { x: sx, y: sy } },
+      hitTestMethod: 'none'
+    };
+  }
+
+  var stage = app.stage;
+
+  // Screen → canvas
+  var canvasX = sx, canvasY = sy;
+  if (targetCanvas) {
+    var rect = targetCanvas.getBoundingClientRect();
+    canvasX = (sx - rect.left) * ((targetCanvas.width || 1) / (rect.width || 1));
+    canvasY = (sy - rect.top) * ((targetCanvas.height || 1) / (rect.height || 1));
+  }
+
+  var candidates = [];
+  var hitTestMethod = 'none';
+  var enginePicked = null;
+
+  // Try engine-native hitTest first (PIXI v7+)
+  if (typeof stage.hitTest === 'function') {
+    try {
+      var nativeHit = stage.hitTest(canvasX, canvasY);
+      if (nativeHit) {
+        enginePicked = nativeHit;
+        hitTestMethod = 'engine';
+      }
+    } catch(e) {}
+  }
+
+  // Recursive DFS hit test (always available; fallback for all versions)
+  function hitTestDfs(node, depth, accPath) {
+    if (!node) return;
+    var visible = safeProp(node, 'visible', true);
+    if (!visible) return;
+
+    var wb = getWorldBounds(node, stage);
+    var lx = canvasX, ly = canvasY;
+
+    // Convert canvas → node local using parent chain
+    var cur = node;
+    var screenPt = { x: canvasX, y: canvasY };
+    while (cur) {
+      if (typeof cur.worldTransform !== 'undefined') {
+        try {
+          var wt = cur.worldTransform;
+          var det = wt.a * wt.d - wt.b * wt.c;
+          if (Math.abs(det) > 1e-10) {
+            var invX = (wt.d * screenPt.x - wt.b * screenPt.y + wt.c * wt.ty - wt.d * wt.tx) / det;
+            var invY = (-wt.b * screenPt.x + wt.a * screenPt.y - wt.a * wt.ty + wt.c * wt.tx) / det;
+            screenPt = { x: invX, y: invY };
+          }
+        } catch(e) { break; }
+      }
+      cur = cur.parent;
+    }
+    lx = screenPt.x;
+    ly = screenPt.y;
+
+    var nw = safeProp(node, 'width', 0) || wb.width;
+    var nh = safeProp(node, 'height', 0) || wb.height;
+    var nx = safeProp(node, 'x', 0), ny = safeProp(node, 'y', 0);
+    var pivotX = safeProp(node, 'pivotX', 0), pivotY = safeProp(node, 'pivotY', 0);
+    var scaleX = safeProp(node, 'scaleX', 1), scaleY = safeProp(node, 'scaleY', 1);
+    var rotation = safeProp(node, 'rotation', 0);
+
+    // Simple AABB bounds check in node local space
+    var halfW = (nw * Math.abs(scaleX)) / 2;
+    var halfH = (nh * Math.abs(scaleY)) / 2;
+    var centerX = nx + pivotX * scaleX;
+    var centerY = ny + pivotY * scaleY;
+
+    // Apply rotation
+    var cosR = Math.cos(rotation), sinR = Math.sin(rotation);
+    var rotLx = (lx - centerX) * cosR + (ly - centerY) * sinR;
+    var rotLy = -(lx - centerX) * sinR + (ly - centerY) * cosR;
+
+    var inBounds = Math.abs(rotLx) <= halfW && Math.abs(rotLy) <= halfH;
+
+    // PIXI v7 uses 'interactive', v8 uses 'eventMode'
+    var interactive = !!(safeProp(node, 'interactive', false)) ||
+                      !!(safeProp(node, 'eventMode', 'none') !== 'none');
+
+    if (inBounds && interactive) {
+      var path = accPath || nodeId(node, 0);
+      candidates.push({
+        node: {
+          id: nodeId(node, 0),
+          type: node.constructor ? node.constructor.name : 'DisplayObject',
+          name: safeProp(node, 'name', undefined),
+          visible: visible,
+          interactive: interactive,
+          alpha: safeProp(node, 'alpha', 1),
+          x: nx, y: ny,
+          width: nw, height: nh,
+          worldBounds: wb,
+          path: path
+        },
+        depth: depth
+      });
+    }
+
+    var nodeChildren = getChildren(node);
+    for (var i = 0; i < nodeChildren.length; i++) {
+      var cn = nodeChildren[i];
+      if (!cn) continue;
+      var childPath = accPath ? accPath + '/' + nodeId(cn, i) : nodeId(cn, i);
+      hitTestDfs(cn, depth + 1, childPath);
+    }
+  }
+
+  hitTestDfs(stage, 0, 'PIXI.Application.stage');
+
+  // Use engine pick if available, otherwise topmost DFS candidate
+  var picked = enginePicked;
+  var finalMethod = hitTestMethod;
+
+  if (!picked && candidates.length > 0) {
+    candidates.sort(function(a, b) { return a.depth - b.depth; });
+    picked = candidates[0].node;
+    finalMethod = 'manual';
+  }
+
+  return {
+    success: !!picked,
+    picked: picked,
+    candidates: candidates,
+    coordinates: {
+      screen: { x: sx, y: sy },
+      canvas: { x: canvasX, y: canvasY }
+    },
+    hitTestMethod: finalMethod
+  };
+})()`;
+}
+/**
+* PixiJS canvas engine adapter.
+*
+* Handles both PixiJS v7 (interactive) and v8 (eventMode). Version is resolved
+* lazily from window.PIXI.VERSION at detect() time.
+*/
+var PixiJSCanvasAdapter = class {
+	id = "pixi";
+	engine = "PixiJS";
+	version;
+	constructor() {
+		this.version = void 0;
+	}
+	async detect(env) {
+		try {
+			const result = await env.pageController.evaluate(`
+        (function() {
+          if (typeof window.PIXI === 'undefined' || window.PIXI === null) {
+            return { present: false, hasApp: false };
+          }
+          var pixi = window.PIXI;
+          var hasApp = !!(pixi.Application);
+          var version = pixi.VERSION || pixi.version;
+          return { present: true, hasApp: hasApp, version: version };
+        })()
+      `);
+			if (!result.present || !result.hasApp) return null;
+			const evidence = ["window.PIXI detected"];
+			if (result.version) evidence.push("PIXI.VERSION: " + result.version);
+			evidence.push("PIXI.Application detected");
+			return {
+				engine: this.engine,
+				version: result.version,
+				confidence: .95,
+				evidence,
+				adapterId: this.id
+			};
+		} catch {
+			return null;
+		}
+	}
+	async dumpScene(env, opts) {
+		const payload = buildPixiSceneTreeDumpPayload(opts);
+		const raw = await env.pageController.evaluate(payload);
+		return {
+			engine: raw.engine,
+			version: raw.version,
+			canvas: raw.canvas,
+			sceneTree: raw.sceneTree ?? {
+				id: "empty",
+				type: "Container",
+				visible: true,
+				interactive: false,
+				alpha: 1,
+				x: 0,
+				y: 0,
+				width: raw.canvas?.width ?? 0,
+				height: raw.canvas?.height ?? 0,
+				worldBounds: {
+					x: 0,
+					y: 0,
+					width: raw.canvas?.width ?? 0,
+					height: raw.canvas?.height ?? 0
+				},
+				path: "PIXI.Application.stage"
+			},
+			totalNodes: raw.totalNodes,
+			completeness: raw.completeness === "full" ? "full" : "partial"
+		};
+	}
+	async pickAt(env, opts) {
+		const payload = buildPixiHitTestPayload(opts);
+		const result = await env.pageController.evaluate(payload);
+		return {
+			success: result.success,
+			picked: result.picked,
+			candidates: result.candidates,
+			coordinates: result.coordinates,
+			hitTestMethod: result.hitTestMethod
+		};
+	}
+};
+//#endregion
+//#region src/server/domains/canvas/handlers/shared.ts
+/**
+* Shared utilities for canvas tool handlers.
+*
+* Engine anchor patterns, adapter registry, probe env builder, and shared helpers.
+*/
+/** Well-known engine global anchors and their adapter IDs. */
+const ENGINE_ANCHORS = [
+	{
+		pattern: "Laya",
+		adapterId: "laya",
+		engine: "LayaAir"
+	},
+	{
+		pattern: "PIXI",
+		adapterId: "pixi",
+		engine: "PixiJS"
+	},
+	{
+		pattern: "Phaser",
+		adapterId: "phaser",
+		engine: "Phaser"
+	},
+	{
+		pattern: "cc",
+		adapterId: "cocos",
+		engine: "CocosCreator"
+	},
+	{
+		pattern: "legacyCC",
+		adapterId: "cocos",
+		engine: "CocosCreator"
+	},
+	{
+		pattern: "BABYLON",
+		adapterId: "babylon",
+		engine: "Babylon.js"
+	},
+	{
+		pattern: "THREE",
+		adapterId: "three",
+		engine: "Three.js"
+	},
+	{
+		pattern: "createUnityInstance",
+		adapterId: "unity",
+		engine: "UnityWebGL"
+	}
+];
+/** Adapter registry — registered per engine. */
+const adapterRegistry = /* @__PURE__ */ new Map();
+const adapterFactories = {
+	laya: () => new LayaCanvasAdapter(),
+	pixi: () => new PixiJSCanvasAdapter(),
+	phaser: () => new PhaserCanvasAdapter(),
+	cocos: () => new CocosCanvasAdapter()
+};
+function resolveAdapter(detection) {
+	if (!detection) return null;
+	if (adapterRegistry.has(detection.adapterId)) return adapterRegistry.get(detection.adapterId);
+	const factory = adapterFactories[detection.adapterId];
+	if (!factory) return null;
+	const adapter = factory();
+	adapterRegistry.set(detection.adapterId, adapter);
+	return adapter;
+}
+function buildEnv(pageController) {
+	return {
+		pageController,
+		cdpSession: null,
+		tabId: "default"
+	};
+}
+async function fingerprintCanvas(pageController, canvasId) {
+	try {
+		const result = await pageController.evaluate(`
+      (function() {
+        const hits = [];
+        ${ENGINE_ANCHORS.map(({ pattern, adapterId, engine }) => `
+          try {
+            if (window[${JSON.stringify(pattern)}] !== undefined) {
+              const v = window[${JSON.stringify(pattern)}];
+              hits.push({
+                engine: ${JSON.stringify(engine)},
+                adapterId: ${JSON.stringify(adapterId)},
+                version: v.version || v.VERSION || (v.Laya && v.Laya.version) || undefined
+              });
+            }
+          } catch(e) {}
+        `).join("")}
+
+        if (hits.length === 0) {
+          return { hits: hits, selected: null, selectedEvidence: [] };
+        }
+
+        var targetCanvas = null;
+        if (${canvasId !== void 0}) {
+          var canvases = Array.from(document.querySelectorAll('canvas'));
+          var requestedId = ${JSON.stringify(canvasId ?? null)};
+          var requestedIndex = Number.parseInt(requestedId, 10);
+          targetCanvas =
+            document.getElementById(requestedId) ||
+            (Number.isNaN(requestedIndex) ? null : canvases[requestedIndex] || null);
+        }
+
+        if (!targetCanvas || hits.length === 1) {
+          return { hits: hits, selected: hits[0] || null, selectedEvidence: [] };
+        }
+
+        function canvasEquals(candidate) {
+          return candidate === targetCanvas;
+        }
+
+        function collectCanvasEvidence(adapterId) {
+          var evidence = [];
+
+          if (adapterId === 'pixi') {
+            if (targetCanvas._pixiApp) {
+              evidence.push('target canvas owns _pixiApp');
+            }
+            if (window.__pixiApp && canvasEquals(window.__pixiApp.view)) {
+              evidence.push('target canvas matches window.__pixiApp.view');
+            }
+            if (window.__PIXI_APP__ && canvasEquals(window.__PIXI_APP__.view)) {
+              evidence.push('target canvas matches window.__PIXI_APP__.view');
+            }
+          }
+
+          if (adapterId === 'phaser' && window.Phaser && Array.isArray(window.Phaser.GAMES)) {
+            if (window.Phaser.GAMES.some(function(game) { return game && canvasEquals(game.canvas); })) {
+              evidence.push('target canvas matches Phaser.GAMES[].canvas');
+            }
+          }
+
+          if (adapterId === 'cocos') {
+            var cocos = window.cc || window.legacyCC;
+            var game = cocos && cocos.game;
+            if (game) {
+              if (canvasEquals(game.canvas) || canvasEquals(game._canvas)) {
+                evidence.push('target canvas matches cc.game canvas');
+              }
+              if (game.container && typeof game.container.contains === 'function' && game.container.contains(targetCanvas)) {
+                evidence.push('target canvas is inside cc.game.container');
+              }
+            }
+          }
+
+          if (adapterId === 'laya' && window.Laya) {
+            var candidates = [
+              window.Laya.Browser && window.Laya.Browser.canvas,
+              window.Laya.Render && window.Laya.Render._mainCanvas && (window.Laya.Render._mainCanvas.source || window.Laya.Render._mainCanvas._source || window.Laya.Render._mainCanvas),
+              window.Laya.Render && window.Laya.Render._context && window.Laya.Render._context.canvas && (window.Laya.Render._context.canvas.source || window.Laya.Render._context.canvas),
+              window.Laya.stage && window.Laya.stage._canvas && (window.Laya.stage._canvas.source || window.Laya.stage._canvas._source || window.Laya.stage._canvas),
+              window.Laya.stage && window.Laya.stage.canvas && (window.Laya.stage.canvas.source || window.Laya.stage.canvas._source || window.Laya.stage.canvas)
+            ].filter(Boolean);
+            if (candidates.some(canvasEquals)) {
+              evidence.push('target canvas matches Laya render canvas');
+            }
+          }
+
+          return evidence;
+        }
+
+        for (var i = 0; i < hits.length; i++) {
+          var selectedEvidence = collectCanvasEvidence(hits[i].adapterId);
+          if (selectedEvidence.length > 0) {
+            return {
+              hits: hits,
+              selected: hits[i],
+              selectedEvidence: selectedEvidence
+            };
+          }
+        }
+
+        return { hits: hits, selected: hits[0] || null, selectedEvidence: [] };
+      })()
+    `);
+		if (!result.selected) return null;
+		const hit = result.selected;
+		return {
+			engine: hit.engine,
+			version: hit.version,
+			confidence: result.selectedEvidence.length > 0 ? .95 : .9,
+			evidence: ["window global detected", ...result.selectedEvidence],
+			adapterId: hit.adapterId
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/server/domains/canvas/handlers/fingerprint.ts
+async function handleFingerprint(pageController, args) {
+	const canvasId = args["canvasId"];
+	const globalScan = await pageController.evaluate(`
+    (function() {
+      const results = [];
+      ${ENGINE_ANCHORS.map(({ pattern, adapterId, engine }) => `
+        try {
+          const global = window[${JSON.stringify(pattern)}];
+          if (global !== undefined) {
+            results.push({
+              pattern: ${JSON.stringify(pattern)},
+              adapterId: ${JSON.stringify(adapterId)},
+              engine: ${JSON.stringify(engine)},
+              present: true,
+              version: (global.version || global.VERSION || global.Laya?.version || undefined)
+            });
+          }
+        } catch(e) {}
+      `).join("")}
+      return results;
+    })()
+  `);
+	const candidates = [];
+	for (const hit of globalScan) candidates.push({
+		engine: hit.engine,
+		version: hit.version,
+		confidence: .9,
+		evidence: [`global window.${hit.pattern} is defined`],
+		adapterId: hit.adapterId
+	});
+	const canvasInfo = await pageController.evaluate(`
+    (function() {
+      return Array.from(document.querySelectorAll('canvas')).map(function(c) {
+        var ctx = c.getContext('webgl2') || c.getContext('webgl') || c.getContext('2d');
+        var info = {
+          id: c.id || '',
+          width: c.width,
+          height: c.height,
+          contextType: ctx ? ctx.constructor.name : 'none'
+        };
+        if (ctx && (ctx instanceof WebGLRenderingContext || ctx instanceof WebGL2RenderingContext)) {
+          var debugInfo = ctx.getExtension('WEBGL_debug_renderer_info');
+          if (debugInfo) {
+            info.renderer = ctx.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+          }
+        }
+        return info;
+      });
+    })()
+  `);
+	if (await pageController.evaluate(`
+    !!(requestAnimationFrame.toString().includes('[native]') &&
+       (window.__canvasEngineHint || document.querySelector('[data-engine]')))
+  `) && candidates.length === 0) candidates.push({
+		engine: "Unknown Canvas Engine",
+		confidence: .3,
+		evidence: ["requestAnimationFrame hook detected", "canvas elements found"],
+		adapterId: "none"
+	});
+	return {
+		candidates,
+		canvasCount: canvasInfo.length,
+		canvasDetails: canvasId !== void 0 ? canvasInfo.filter((c) => c.id === canvasId || canvasInfo.indexOf(c).toString() === canvasId) : canvasInfo,
+		fingerprintComplete: candidates.length > 0
+	};
+}
+//#endregion
+//#region src/server/domains/canvas/handlers/scene-dump.ts
+async function handleSceneDump(pageController, args) {
+	const canvasId = args["canvasId"];
+	const opts = {
+		canvasId,
+		maxDepth: args["maxDepth"] ?? 20,
+		onlyInteractive: args["onlyInteractive"] ?? false,
+		onlyVisible: args["onlyVisible"] ?? false
+	};
+	const detection = await fingerprintCanvas(pageController, canvasId);
+	if (!detection) return partialSceneDump(pageController, canvasId);
+	const adapter = resolveAdapter(detection);
+	if (!adapter) return partialSceneDump(pageController, canvasId);
+	return adapter.dumpScene(buildEnv(pageController), opts);
+}
+async function partialSceneDump(pageController, canvasId) {
+	const canvases = await pageController.evaluate(`
+    (function() {
+      return Array.from(document.querySelectorAll('canvas')).map(function(c, i) {
+        var ctx2d = c.getContext('2d');
+        var ctxWebgl = c.getContext('webgl') || c.getContext('webgl2');
+        return {
+          id: c.id || String(i),
+          width: c.width,
+          height: c.height,
+          dpr: window.devicePixelRatio || 1,
+          contextType: ctx2d ? '2d' : (ctxWebgl ? 'webgl' : 'unknown')
+        };
+      });
+    })()
+  `);
+	return {
+		engine: "unknown",
+		version: void 0,
+		canvas: (canvasId ? canvases.filter((c) => c.id === canvasId || canvases.indexOf(c).toString() === canvasId) : canvases)[0] ?? {
+			id: canvasId ?? "",
+			width: 0,
+			height: 0,
+			dpr: 1,
+			contextType: "unknown"
+		},
+		sceneTree: null,
+		totalNodes: 0,
+		completeness: "partial",
+		partialReason: "No canvas engine detected — only DOM canvas metadata returned"
+	};
+}
+//#endregion
+//#region src/server/domains/canvas/handlers/pick.ts
+async function handlePick(pageController, args) {
+	const x = args["x"];
+	const y = args["y"];
+	const canvasId = args["canvasId"];
+	const highlight = args["highlight"] ?? false;
+	const opts = {
+		x,
+		y,
+		canvasId
+	};
+	const coordInfo = await pageController.evaluate(`
+    (function() {
+      var sx = ${x}, sy = ${y};
+      var canvases = Array.from(document.querySelectorAll('canvas'));
+      var target = null;
+      ${canvasId ? `target = document.getElementById(${JSON.stringify(canvasId)}) || canvases[parseInt(${JSON.stringify(canvasId)})];` : `
+        for (var i = canvases.length - 1; i >= 0; i--) {
+          var r = canvases[i].getBoundingClientRect();
+          if (sx >= r.left && sx <= r.right && sy >= r.top && sy <= r.bottom) {
+            target = canvases[i];
+            break;
+          }
+        }
+      `}
+      if (!target) return { screen: { x: sx, y: sy }, canvasX: sx, canvasY: sy };
+      var rect = target.getBoundingClientRect();
+      var dpr = window.devicePixelRatio || 1;
+      return {
+        screen: { x: sx, y: sy },
+        canvasRect: { left: rect.left, top: rect.top, width: rect.width, height: rect.height },
+        canvasX: (sx - rect.left) * (target.width / rect.width),
+        canvasY: (sy - rect.top) * (target.height / rect.height)
+      };
+    })()
+  `);
+	const detection = await fingerprintCanvas(pageController, canvasId);
+	if (!detection) return {
+		success: false,
+		picked: null,
+		candidates: [],
+		coordinates: {
+			screen: coordInfo.screen,
+			canvas: {
+				x: coordInfo.canvasX,
+				y: coordInfo.canvasY
+			}
+		},
+		hitTestMethod: "none"
+	};
+	const adapter = resolveAdapter(detection);
+	if (!adapter) return {
+		success: false,
+		picked: null,
+		candidates: [],
+		coordinates: {
+			screen: coordInfo.screen,
+			canvas: {
+				x: coordInfo.canvasX,
+				y: coordInfo.canvasY
+			}
+		},
+		hitTestMethod: "none"
+	};
+	const result = await adapter.pickAt(buildEnv(pageController), opts);
+	if (highlight && result.picked) await highlightNode(pageController, result.picked.worldBounds).catch(() => {});
+	return result;
+}
+async function highlightNode(pageController, bounds) {
+	await pageController.evaluate(`
+    (function() {
+      var existing = document.getElementById('__canvas-highlight');
+      if (existing) existing.remove();
+      var div = document.createElement('div');
+      div.id = '__canvas-highlight';
+      Object.assign(div.style, {
+        position: 'fixed', left: ${bounds.x} + 'px', top: ${bounds.y} + 'px',
+        width: ${bounds.width} + 'px', height: ${bounds.height} + 'px',
+        border: '2px solid #00ff88', pointerEvents: 'none', zIndex: 2147483647,
+        background: 'rgba(0,255,136,0.15)', boxSizing: 'border-box'
+      });
+      document.body.appendChild(div);
+      setTimeout(function() { div.remove(); }, 3000);
+    })()
+  `);
+}
+//#endregion
+//#region src/server/domains/canvas/handlers/trace.ts
+async function handleTraceClick(pageController, debuggerManager, evidenceStore, args) {
+	const x = args["x"];
+	const y = args["y"];
+	const canvasId = args["canvasId"];
+	const maxFrames = args["maxFrames"] ?? 50;
+	const breakpointType = args["breakpointType"] ?? "click";
+	await debuggerManager.enable();
+	await debuggerManager.ensureAdvancedFeatures();
+	const eventMgr = debuggerManager.getEventManager();
+	const breakpointId = await eventMgr.setEventListenerBreakpoint(breakpointType);
+	let cleanupToken;
+	let pendingDispatch;
+	let primaryError;
+	let cleanupError;
+	let traceResult;
+	try {
+		const dispatch = await dispatchCanvasClick(pageController, x, y, canvasId, breakpointType);
+		const dispatchResult = dispatch.result;
+		pendingDispatch = dispatch.completion;
+		cleanupToken = dispatchResult.cleanupToken;
+		const pausedState = await debuggerManager.waitForPaused(5e3);
+		let stackFrames = [];
+		if (pausedState?.callFrames) stackFrames = pausedState.callFrames.slice(0, maxFrames).map((frame) => ({
+			functionName: frame.functionName || "(anonymous)",
+			scriptUrl: frame.url,
+			lineNumber: frame.location?.lineNumber,
+			columnNumber: frame.location?.columnNumber
+		}));
+		recordEvidence(evidenceStore, "canvas_trace", {
+			engine: dispatchResult.engine ?? "unknown",
+			x,
+			y,
+			handlerCount: stackFrames.length
+		});
+		traceResult = {
+			inputFlow: dispatchResult.domEventChain ?? [],
+			hitTarget: null,
+			domEventChain: stackFrames.map((f) => ({
+				type: breakpointType,
+				target: f.scriptUrl,
+				phase: "at-target"
+			})),
+			engineDispatchChain: dispatchResult.engineChain ?? [],
+			handlerFrames: stackFrames,
+			handlersTriggered: stackFrames.map((f) => ({
+				functionName: f.functionName,
+				scriptUrl: f.scriptUrl,
+				lineNumber: f.lineNumber
+			})),
+			networkEmitted: []
+		};
+	} catch (error) {
+		primaryError = error;
+	} finally {
+		try {
+			await debuggerManager.resume();
+		} catch {}
+		if (pendingDispatch) try {
+			await pendingDispatch;
+		} catch (error) {
+			if (!primaryError) cleanupError = error;
+		}
+		await cleanupCanvasTraceTarget(pageController, cleanupToken);
+		if (typeof eventMgr.removeEventListenerBreakpoint === "function") try {
+			await eventMgr.removeEventListenerBreakpoint(breakpointId);
+		} catch {}
+	}
+	if (primaryError) throw primaryError;
+	if (cleanupError) throw cleanupError;
+	if (!traceResult) throw new Error("Canvas trace did not produce a result.");
+	return traceResult;
+}
+async function dispatchCanvasClick(pageController, x, y, canvasId, breakpointType = "click") {
+	if (breakpointType === "click" && typeof pageController.click === "function") return dispatchRealCanvasClick(pageController, x, y, canvasId, breakpointType);
+	return dispatchSyntheticCanvasClick(pageController, x, y, canvasId, breakpointType);
+}
+async function dispatchRealCanvasClick(pageController, x, y, canvasId, breakpointType = "click") {
+	const dispatchSequence = getDispatchSequence(breakpointType);
+	const cleanupToken = `jshook-trace-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+	const prepared = await pageController.evaluate(`
+    (function() {
+      var canvases = ${canvasId ? `[document.getElementById(${JSON.stringify(canvasId)})]` : "Array.from(document.querySelectorAll(\"canvas\"))"};
+      var target = null;
+      if (${!!canvasId}) {
+        target = document.getElementById(${JSON.stringify(canvasId)});
+      } else {
+        for (var i = canvases.length - 1; i >= 0; i--) {
+          var r = canvases[i].getBoundingClientRect();
+          if (${x} >= r.left && ${x} <= r.right && ${y} >= r.top && ${y} <= r.bottom) {
+            target = canvases[i];
+            break;
+          }
+        }
+      }
+      if (!target) return { domEventChain: [], pickedNode: null, engine: undefined, engineChain: [] };
+
+      target.setAttribute('data-jshook-trace-token', ${JSON.stringify(cleanupToken)});
+      var rect = target.getBoundingClientRect();
+      var offsetX = Math.max(0, Math.min(${x} - rect.left, Math.max(rect.width - 1, 0)));
+      var offsetY = Math.max(0, Math.min(${y} - rect.top, Math.max(rect.height - 1, 0)));
+      return {
+        domEventChain: ${JSON.stringify(dispatchSequence)},
+        pickedNode: target.id ? { id: String(target.id) } : null,
+        engine: window.Laya ? 'LayaAir' : (window.PIXI ? 'PixiJS' : undefined),
+        engineChain: [],
+        cleanupToken: ${JSON.stringify(cleanupToken)},
+        selector: 'canvas[data-jshook-trace-token="${cleanupToken}"]',
+        offset: { x: offsetX, y: offsetY }
+      };
+    })()
+  `);
+	if (!prepared.selector || !prepared.offset) return {
+		result: prepared,
+		completion: Promise.resolve()
+	};
+	return {
+		result: prepared,
+		completion: pageController.click?.(prepared.selector, {
+			button: "left",
+			clickCount: 1,
+			offset: prepared.offset
+		}) ?? Promise.resolve()
+	};
+}
+async function dispatchSyntheticCanvasClick(pageController, x, y, canvasId, breakpointType = "click") {
+	const dispatchSequence = getDispatchSequence(breakpointType);
+	const script = `
+    (function() {
+      var canvases = ${canvasId ? `[document.getElementById(${JSON.stringify(canvasId)})]` : "Array.from(document.querySelectorAll(\"canvas\"))"};
+      var target = null;
+      if (${!!canvasId}) {
+        target = document.getElementById(${JSON.stringify(canvasId)});
+      } else {
+        for (var i = canvases.length - 1; i >= 0; i--) {
+          var r = canvases[i].getBoundingClientRect();
+          if (${x} >= r.left && ${x} <= r.right && ${y} >= r.top && ${y} <= r.bottom) {
+            target = canvases[i];
+            break;
+          }
+        }
+      }
+      if (!target) return { domEventChain: [], pickedNode: null, engine: undefined, engineChain: [] };
+
+      var rect = target.getBoundingClientRect();
+      var cx = (${x} - rect.left) * (target.width / rect.width);
+      var cy = (${y} - rect.top) * (target.height / rect.height);
+
+      var events = [];
+      ${JSON.stringify(dispatchSequence)}.forEach(function(type) {
+        var EventCtor = type.indexOf('pointer') === 0 && typeof PointerEvent === 'function'
+          ? PointerEvent
+          : MouseEvent;
+        var e = new EventCtor(type, {
+          view: window,
+          bubbles: true,
+          cancelable: true,
+          clientX: ${x},
+          clientY: ${y},
+          button: 0,
+          buttons: 1,
+          pointerId: 1
+        });
+        target.dispatchEvent(e);
+        events.push(type);
+      });
+      return {
+        domEventChain: events,
+        pickedNode: null,
+        engine: window.Laya ? 'LayaAir' : (window.PIXI ? 'PixiJS' : undefined),
+        engineChain: []
+      };
+    })()
+  `;
+	return {
+		result: await pageController.evaluate(script),
+		completion: Promise.resolve()
+	};
+}
+async function cleanupCanvasTraceTarget(pageController, cleanupToken) {
+	if (!cleanupToken) return;
+	try {
+		await pageController.evaluate(`
+      (function() {
+        var target = document.querySelector('canvas[data-jshook-trace-token="${cleanupToken}"]');
+        if (target) {
+          target.removeAttribute('data-jshook-trace-token');
+        }
+        return true;
+      })()
+    `);
+	} catch {}
+}
+function getDispatchSequence(breakpointType) {
+	if (breakpointType === "mousedown") return ["pointerdown", "mousedown"];
+	if (breakpointType === "pointerdown") return ["pointerdown"];
+	return [
+		"pointerdown",
+		"mousedown",
+		"pointerup",
+		"mouseup",
+		"click"
+	];
+}
+function recordEvidence(evidenceStore, label, metadata) {
+	try {
+		return evidenceStore.addNode("function", label, metadata).id;
+	} catch {
+		return "evidence-unavailable";
+	}
+}
+//#endregion
+//#region src/server/domains/canvas/handlers.impl.ts
+var CanvasToolHandlers = class {
+	pageController;
+	debuggerManager;
+	evidenceStore;
+	constructor(deps) {
+		this.pageController = deps.pageController;
+		this.debuggerManager = deps.debuggerManager;
+		this.evidenceStore = deps.evidenceStore;
+	}
+	async handleFingerprint(args) {
+		return asJsonResponse(await handleFingerprint(this.pageController, args));
+	}
+	async handleSceneDump(args) {
+		return asJsonResponse(await handleSceneDump(this.pageController, args));
+	}
+	async handlePick(args) {
+		const x = argNumber(args, "x", 0);
+		const y = argNumber(args, "y", 0);
+		return asJsonResponse(await handlePick(this.pageController, {
+			...args,
+			x,
+			y
+		}));
+	}
+	async handleTraceClick(args) {
+		return asJsonResponse(await handleTraceClick(this.pageController, this.debuggerManager, this.evidenceStore, args));
+	}
+};
+//#endregion
+export { CanvasToolHandlers };