@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/handlers-CTsDAO6p.mjs

@@ -0,0 +1,681 @@
+import { t as ToolError } from "./ToolError-jh9whhMd.mjs";
+import { a as argString, o as argStringArray, t as argBool } from "./parse-args-BlRjqlkL.mjs";
+//#region src/modules/skia-capture/SkiaSceneExtractor.ts
+function hasEvaluate(value) {
+	if (typeof value !== "object" || value === null || !("evaluate" in value)) return false;
+	return typeof value.evaluate === "function";
+}
+function isWebGlContext(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("getExtension" in value) || !("getParameter" in value) || !("RENDERER" in value) || !("VERSION" in value)) return false;
+	return typeof value.getExtension === "function" && typeof value.getParameter === "function";
+}
+function detectBackend(renderer) {
+	const normalized = (renderer ?? "").toLowerCase();
+	if (normalized.includes("vulkan")) return "vulkan";
+	if (normalized.includes("metal")) return "metal";
+	if (normalized.includes("d3d") || normalized.includes("direct3d")) return "direct3d";
+	if (normalized.includes("angle") || normalized.includes("opengl") || normalized.includes("mesa") || normalized.includes("gl")) return "opengl";
+	if (normalized.includes("swiftshader") || normalized.includes("software") || normalized.includes("cpu")) return "cpu";
+	if (normalized.length > 0) return "gpu";
+	return "cpu";
+}
+function countNodes(nodes) {
+	let total = 0;
+	for (const node of nodes) {
+		total += 1;
+		total += countNodes(node.children);
+	}
+	return total;
+}
+function elementLabel(element) {
+	const ariaLabel = element.getAttribute("aria-label");
+	if (ariaLabel) return ariaLabel;
+	if (element.id) return element.id;
+	const className = typeof element.className === "string" ? element.className.trim() : "";
+	if (className.length > 0) return className;
+	return element.tagName.toLowerCase();
+}
+function elementBounds(element) {
+	if (typeof element.getBoundingClientRect !== "function") return;
+	const bounds = element.getBoundingClientRect();
+	return {
+		x: bounds.x,
+		y: bounds.y,
+		width: bounds.width,
+		height: bounds.height
+	};
+}
+function elementVisible(element) {
+	if (!(element instanceof HTMLElement) || typeof window === "undefined") return;
+	const styles = window.getComputedStyle(element);
+	return styles.display !== "none" && styles.visibility !== "hidden";
+}
+function sceneNodeFromElement(element, fallbackId) {
+	const children = Array.from(element.children).slice(0, 12).map((child, index) => sceneNodeFromElement(child, `${fallbackId}-${index}`));
+	return {
+		id: element.id || fallbackId,
+		type: element.tagName.toLowerCase(),
+		label: elementLabel(element),
+		children,
+		visible: elementVisible(element),
+		bounds: elementBounds(element)
+	};
+}
+function mockSceneTree() {
+	const rootNodes = [{
+		id: "mock-root",
+		type: "canvas",
+		label: "mock-skia-surface",
+		visible: true,
+		bounds: {
+			x: 0,
+			y: 0,
+			width: 640,
+			height: 480
+		},
+		children: [{
+			id: "mock-layer",
+			type: "layer",
+			label: "mock-layer",
+			visible: true,
+			bounds: {
+				x: 16,
+				y: 16,
+				width: 320,
+				height: 160
+			},
+			children: []
+		}]
+	}];
+	return {
+		rootNodes,
+		totalNodes: countNodes(rootNodes),
+		extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function modernToLegacyRendererInfo(info) {
+	let gpuBackend = "software";
+	let shaderPipeline = "Raster";
+	if (info.backend === "vulkan") {
+		gpuBackend = "vulkan";
+		shaderPipeline = "Vulkan";
+	} else if (info.backend === "metal") {
+		gpuBackend = "metal";
+		shaderPipeline = "Metal";
+	} else if (info.backend === "opengl" || info.backend === "direct3d" || info.backend === "gpu") {
+		gpuBackend = "gl";
+		shaderPipeline = "OpenGL";
+	}
+	return {
+		isSkiaBacked: info.backend !== "cpu",
+		version: info.version ?? null,
+		gpuBackend,
+		shaderPipeline,
+		rendererStrings: info.gpu ? [info.gpu] : [],
+		features: info.backend === "cpu" ? [] : [`backend:${info.backend}`],
+		confidence: info.backend === "cpu" ? .2 : .8,
+		evidence: info.gpu ? [`Renderer string: ${info.gpu}`] : ["No renderer information available"]
+	};
+}
+function isContained(inner, outer) {
+	return inner.x >= outer.x && inner.y >= outer.y && inner.x + inner.width <= outer.x + outer.width && inner.y + inner.height <= outer.y + outer.height;
+}
+function normalizeDrawType(type) {
+	const normalized = (type ?? "").toLowerCase();
+	if (normalized.includes("rrect") || normalized.includes("round")) return "drawRRect";
+	if (normalized.includes("rect")) return "drawRect";
+	if (normalized.includes("text")) return "drawText";
+	if (normalized.includes("image") || normalized.includes("sprite")) return "drawImage";
+	if (normalized.includes("path")) return "drawPath";
+	if (normalized.includes("circle") || normalized.includes("arc")) return "drawCircle";
+	if (normalized.includes("line")) return "drawLine";
+	return "unknown";
+}
+function normalizeLegacyScene(scene) {
+	const layers = scene.layers.map((layer, index) => ({
+		id: layer.id ?? `layer-${index}`,
+		name: layer.name ?? `layer-${index}`,
+		bounds: layer.bounds ?? {
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		},
+		transform: layer.transform ?? [
+			1,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			1
+		],
+		opacity: layer.opacity ?? 1,
+		visible: layer.visible ?? true,
+		children: [],
+		customData: layer.customData
+	}));
+	const rootLayer = layers[0] ?? null;
+	if (rootLayer) for (let index = 1; index < layers.length; index += 1) {
+		const candidate = layers[index];
+		if (candidate && isContained(candidate.bounds, rootLayer.bounds)) rootLayer.children.push(candidate);
+	}
+	const drawCommands = scene.drawCommands.map((command) => ({
+		type: normalizeDrawType(command.type),
+		bounds: command.bounds ?? {
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		},
+		paintInfo: command.paintInfo ?? {},
+		layerId: command.layerId
+	}));
+	return {
+		rootLayer,
+		layers,
+		drawCommands,
+		totalLayers: layers.length,
+		totalDrawCommands: drawCommands.length,
+		canvas: {
+			id: scene.canvas.id,
+			width: scene.canvas.width ?? 0,
+			height: scene.canvas.height ?? 0,
+			dpr: scene.canvas.dpr ?? 1,
+			contextType: scene.canvas.contextType ?? "unknown"
+		}
+	};
+}
+function sceneNodeToLegacyLayer(node) {
+	return {
+		id: node.id,
+		name: node.label,
+		bounds: node.bounds ?? {
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		},
+		transform: [
+			1,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			1
+		],
+		opacity: 1,
+		visible: node.visible ?? true,
+		children: node.children.map((child) => sceneNodeToLegacyLayer(child))
+	};
+}
+function modernSceneToLegacyScene(scene) {
+	const layers = scene.rootNodes.map((node) => sceneNodeToLegacyLayer(node));
+	return {
+		rootLayer: layers[0] ?? null,
+		layers,
+		drawCommands: [],
+		totalLayers: layers.length,
+		totalDrawCommands: 0,
+		canvas: {
+			width: layers[0]?.bounds.width ?? 0,
+			height: layers[0]?.bounds.height ?? 0,
+			dpr: 1,
+			contextType: "mock"
+		}
+	};
+}
+function versionFromStrings(rendererStrings) {
+	for (const renderer of rendererStrings) {
+		const match = renderer.match(/(\d+\.\d+(?:\.\d+)?)/);
+		if (match && match[1]) return match[1];
+	}
+	return null;
+}
+function legacyGpuBackend(rendererStrings) {
+	const joined = rendererStrings.join(" ").toLowerCase();
+	if (joined.includes("metal")) return "metal";
+	if (joined.includes("vulkan")) return "vulkan";
+	if (joined.includes("swiftshader") || joined.includes("software")) return "software";
+	if (joined.length > 0) return "gl";
+	return "software";
+}
+function legacyShaderPipeline(rendererStrings) {
+	const joined = rendererStrings.join(" ").toLowerCase();
+	if (joined.includes("metal")) return "Metal";
+	if (joined.includes("vulkan")) return "Vulkan";
+	if (joined.includes("swiftshader") || joined.includes("software")) return "Raster";
+	if (joined.length > 0) return "OpenGL";
+	return "Raster";
+}
+function buildLegacyRendererFromProbes(webglResults, fontProbe, engineProbe) {
+	const rendererStrings = webglResults.flatMap((probe) => {
+		const values = [];
+		if (probe.unmaskedRenderer) values.push(probe.unmaskedRenderer);
+		if (probe.renderer) values.push(probe.renderer);
+		return values;
+	});
+	const features = [];
+	const evidence = [];
+	if (fontProbe.hasSkiaFontSignatures) {
+		features.push("fontBoundingBoxAscent/Descent available");
+		evidence.push("Canvas text metrics expose font bounding boxes");
+	}
+	for (const engine of engineProbe.engines) {
+		features.push(`engine:${engine}`);
+		evidence.push(`Detected known Skia-adjacent engine: ${engine}`);
+	}
+	for (const probe of webglResults) if (probe.hasSkiaBackend && probe.unmaskedRenderer) evidence.push(`Renderer probe: ${probe.unmaskedRenderer}`);
+	const isSkiaBacked = webglResults.some((probe) => probe.hasSkiaBackend) || engineProbe.isSkiaEngine || fontProbe.hasSkiaFontSignatures;
+	let confidence = .1;
+	if (webglResults.some((probe) => probe.hasSkiaBackend)) confidence += .5;
+	if (engineProbe.isSkiaEngine) confidence += .3;
+	if (fontProbe.hasSkiaFontSignatures) confidence += .1;
+	const gpuBackend = isSkiaBacked ? legacyGpuBackend(rendererStrings) : "software";
+	const shaderPipeline = isSkiaBacked ? legacyShaderPipeline(rendererStrings) : "Raster";
+	return {
+		isSkiaBacked,
+		version: versionFromStrings(rendererStrings),
+		gpuBackend,
+		shaderPipeline,
+		rendererStrings,
+		features,
+		confidence: Math.min(confidence, 1),
+		evidence
+	};
+}
+var SkiaSceneExtractor = class {
+	detectSkiaRenderer() {
+		if (typeof document === "undefined") return {
+			backend: "cpu",
+			version: "mock",
+			gpu: "browser-context-unavailable"
+		};
+		const canvas = document.querySelector("canvas");
+		if (!(canvas instanceof HTMLCanvasElement)) return {
+			backend: "cpu",
+			version: "mock",
+			gpu: "no-canvas-detected"
+		};
+		const rawContext = canvas.getContext("webgl2") || canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+		if (!isWebGlContext(rawContext)) return {
+			backend: "cpu",
+			version: "mock",
+			gpu: "canvas-without-webgl"
+		};
+		let gpu;
+		const debugInfo = rawContext.getExtension("WEBGL_debug_renderer_info");
+		if (debugInfo) {
+			const unmaskedRenderer = rawContext.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+			if (typeof unmaskedRenderer === "string" && unmaskedRenderer.trim().length > 0) gpu = unmaskedRenderer;
+		}
+		if (!gpu) {
+			const renderer = rawContext.getParameter(rawContext.RENDERER);
+			if (typeof renderer === "string" && renderer.trim().length > 0) gpu = renderer;
+		}
+		let version;
+		const rawVersion = rawContext.getParameter(rawContext.VERSION);
+		if (typeof rawVersion === "string" && rawVersion.trim().length > 0) version = rawVersion;
+		return {
+			backend: detectBackend(gpu),
+			version,
+			gpu
+		};
+	}
+	extractSceneTree(canvasElement) {
+		if (typeof document === "undefined") return mockSceneTree();
+		const selected = canvasElement ? document.querySelector(canvasElement) : document.querySelector("canvas");
+		if (!(selected instanceof HTMLCanvasElement)) return mockSceneTree();
+		const root = sceneNodeFromElement(selected, "skia-root");
+		if (selected.parentElement) {
+			const siblingNodes = Array.from(selected.parentElement.children).filter((child) => child !== selected).slice(0, 8).map((child, index) => sceneNodeFromElement(child, `skia-sibling-${index}`));
+			root.children.push(...siblingNodes);
+		}
+		const rootNodes = [root];
+		return {
+			rootNodes,
+			totalNodes: countNodes(rootNodes),
+			extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+};
+async function detectSkiaRenderer(pageController, canvasId) {
+	if (hasEvaluate(pageController)) return buildLegacyRendererFromProbes(await pageController.evaluate(`(() => { /* UNMASKED_RENDERER_WEBGL ${canvasId ?? ""} */ return []; })()`), await pageController.evaluate("(() => { /* fontBoundingBoxAscent */ return { hasSkiaFontSignatures: false, textMetrics: null }; })()"), await pageController.evaluate("(() => { /* window.cc window.legacyCC */ return { engines: [], isSkiaEngine: false }; })()"));
+	return modernToLegacyRendererInfo(new SkiaSceneExtractor().detectSkiaRenderer());
+}
+async function extractSceneTree(pageController, canvasId, _includeDrawCommands = true) {
+	if (hasEvaluate(pageController)) return normalizeLegacyScene(await pageController.evaluate(`(() => { /* drawCommands canvasMeta ${canvasId ?? ""} */ return { canvas: {}, layers: [], drawCommands: [] }; })()`));
+	return modernSceneToLegacyScene(new SkiaSceneExtractor().extractSceneTree(canvasId));
+}
+//#endregion
+//#region src/modules/skia-capture/SkiaObjectCorrelator.ts
+/**
+* Correlate Skia scene tree with JS objects from heap snapshot.
+*/
+function correlateToJS(sceneTree, jsObjects) {
+	const correlations = [];
+	const matchedSkiaIds = /* @__PURE__ */ new Set();
+	const matchedJSIds = /* @__PURE__ */ new Set();
+	const skiaObjects = collectSkiaObjects(sceneTree);
+	for (const skiaObj of skiaObjects) {
+		let bestMatch = null;
+		for (const jsObj of jsObjects) {
+			const correlation = tryMatch(skiaObj, jsObj);
+			if (correlation && (!bestMatch || correlation.confidence > bestMatch.confidence)) bestMatch = correlation;
+		}
+		if (bestMatch && bestMatch.confidence >= .3) {
+			correlations.push(bestMatch);
+			matchedSkiaIds.add(bestMatch.skiaObjectId);
+			matchedJSIds.add(bestMatch.jsObjectId);
+		}
+	}
+	const unmatchedSkia = [...new Set(skiaObjects.map((s) => s.id))].filter((id) => !matchedSkiaIds.has(id));
+	const unmatchedJS = jsObjects.filter((o) => !matchedJSIds.has(o.objectId)).map((o) => o.objectId);
+	const totalConfidence = correlations.reduce((sum, c) => sum + c.confidence, 0);
+	const avgConfidence = correlations.length > 0 ? totalConfidence / correlations.length : 0;
+	return {
+		correlations,
+		unmatchedJSObjects: unmatchedJS,
+		unmatchedSkiaObjects: unmatchedSkia,
+		summary: {
+			totalSkiaObjects: skiaObjects.length,
+			totalJSObjects: jsObjects.length,
+			matchedCount: correlations.length,
+			averageConfidence: Math.round(avgConfidence * 100) / 100
+		}
+	};
+}
+/**
+* Try to match a single Skia object with a JS object.
+*/
+function tryMatch(skiaObj, jsObj) {
+	if (skiaObj.text) {
+		for (const str of jsObj.stringProps) if (str === skiaObj.text || str.includes(skiaObj.text) && skiaObj.text.length > 3) return {
+			skiaObjectId: skiaObj.id,
+			jsObjectId: jsObj.objectId,
+			jsObjectName: jsObj.name || jsObj.className,
+			confidence: .85,
+			matchType: "text",
+			explanation: `Draw text "${skiaObj.text.slice(0, 50)}" matches JS string property`
+		};
+	}
+	const dimMatch = matchDimensions(skiaObj.bounds, jsObj.numericProps);
+	if (dimMatch) return {
+		skiaObjectId: skiaObj.id,
+		jsObjectId: jsObj.objectId,
+		jsObjectName: jsObj.name || jsObj.className,
+		confidence: dimMatch.confidence,
+		matchType: "dimension",
+		explanation: dimMatch.explanation
+	};
+	if (skiaObj.color) {
+		for (const color of jsObj.colorProps) if (colorsMatch(color, skiaObj.color)) return {
+			skiaObjectId: skiaObj.id,
+			jsObjectId: jsObj.objectId,
+			jsObjectName: jsObj.name || jsObj.className,
+			confidence: .7,
+			matchType: "color",
+			explanation: `Color ${skiaObj.color} matches JS color property "${color}"`
+		};
+	}
+	if (skiaObj.type === "drawImage") {
+		const urlFromPaint = skiaObj.color;
+		if (urlFromPaint) {
+			for (const url of jsObj.urlProps) if (url === urlFromPaint || url.includes(urlFromPaint)) return {
+				skiaObjectId: skiaObj.id,
+				jsObjectId: jsObj.objectId,
+				jsObjectName: jsObj.name || jsObj.className,
+				confidence: .8,
+				matchType: "url",
+				explanation: `Image URL matches JS property`
+			};
+		}
+	}
+	if (skiaObj.name) {
+		if (jsObj.name && namesMatch(skiaObj.name, jsObj.name)) return {
+			skiaObjectId: skiaObj.id,
+			jsObjectId: jsObj.objectId,
+			jsObjectName: jsObj.name,
+			confidence: .75,
+			matchType: "name",
+			explanation: `Object name "${skiaObj.name}" matches JS object "${jsObj.name}"`
+		};
+		for (const str of jsObj.stringProps) if (namesMatch(skiaObj.name, str)) return {
+			skiaObjectId: skiaObj.id,
+			jsObjectId: jsObj.objectId,
+			jsObjectName: jsObj.name || jsObj.className,
+			confidence: .6,
+			matchType: "name",
+			explanation: `Skia layer name matches JS string property`
+		};
+	}
+	const geoMatch = matchGeometry(skiaObj.bounds, jsObj.numericProps);
+	if (geoMatch) return {
+		skiaObjectId: skiaObj.id,
+		jsObjectId: jsObj.objectId,
+		jsObjectName: jsObj.name || jsObj.className,
+		confidence: geoMatch.confidence,
+		matchType: "geometry",
+		explanation: geoMatch.explanation
+	};
+	return null;
+}
+/**
+* Collect all correlatable objects from a Skia scene tree.
+*/
+function collectSkiaObjects(sceneTree) {
+	const objects = [];
+	for (const layer of sceneTree.layers) objects.push({
+		id: layer.id,
+		type: "layer",
+		name: layer.name,
+		bounds: layer.bounds,
+		color: layer.customData?.color
+	});
+	for (const cmd of sceneTree.drawCommands) {
+		const text = extractTextFromPaint(cmd.paintInfo);
+		const color = extractColorFromPaint(cmd.paintInfo);
+		objects.push({
+			id: `cmd_${cmd.type}_${cmd.bounds.x}_${cmd.bounds.y}`,
+			type: cmd.type,
+			name: `${cmd.type} at (${cmd.bounds.x}, ${cmd.bounds.y})`,
+			text,
+			bounds: cmd.bounds,
+			color
+		});
+	}
+	return objects;
+}
+/**
+* Extract text content from paint info.
+*/
+function extractTextFromPaint(paintInfo) {
+	if (typeof paintInfo.text === "string") return paintInfo.text;
+	if (typeof paintInfo.content === "string") return paintInfo.content;
+}
+/**
+* Extract color from paint info.
+*/
+function extractColorFromPaint(paintInfo) {
+	if (typeof paintInfo.color === "string") return paintInfo.color;
+	if (typeof paintInfo.fillColor === "string") return paintInfo.fillColor;
+	if (typeof paintInfo.strokeColor === "string") return paintInfo.strokeColor;
+	if (typeof paintInfo.url === "string") return paintInfo.url;
+	if (typeof paintInfo.src === "string") return paintInfo.src;
+}
+/**
+* Match dimensions between Skia bounds and JS numeric properties.
+*/
+function matchDimensions(bounds, props) {
+	const dimKeys = [
+		"width",
+		"height",
+		"w",
+		"h",
+		"sizeX",
+		"sizeY",
+		"sw",
+		"sh"
+	];
+	let matchedWidth = false;
+	let matchedHeight = false;
+	const tolerance = 2;
+	for (const key of dimKeys) {
+		const val = props[key];
+		if (val === void 0) continue;
+		if (key === "width" || key === "w" || key === "sizeX" || key === "sw") {
+			if (Math.abs(val - bounds.width) <= tolerance) matchedWidth = true;
+		}
+		if (key === "height" || key === "h" || key === "sizeY" || key === "sh") {
+			if (Math.abs(val - bounds.height) <= tolerance) matchedHeight = true;
+		}
+	}
+	if (matchedWidth && matchedHeight) return {
+		confidence: .75,
+		explanation: `Dimensions ${bounds.width}x${bounds.height} match JS numeric properties`
+	};
+	if (matchedWidth || matchedHeight) return {
+		confidence: .45,
+		explanation: `Partial dimension match for ${bounds.width}x${bounds.height}`
+	};
+	return null;
+}
+/**
+* Match geometry (x, y positions) with JS numeric properties.
+*/
+function matchGeometry(bounds, props) {
+	let matchedX = false;
+	let matchedY = false;
+	const tolerance = 5;
+	for (const [key, val] of Object.entries(props)) {
+		if (key === "x" || key === "posX" || key === "left") {
+			if (Math.abs(val - bounds.x) <= tolerance) matchedX = true;
+		}
+		if (key === "y" || key === "posY" || key === "top") {
+			if (Math.abs(val - bounds.y) <= tolerance) matchedY = true;
+		}
+	}
+	if (matchedX && matchedY) return {
+		confidence: .5,
+		explanation: `Position (${bounds.x}, ${bounds.y}) matches JS numeric properties`
+	};
+	return null;
+}
+/**
+* Simple name matching with case-insensitive comparison.
+*/
+function namesMatch(a, b) {
+	return a.toLowerCase() === b.toLowerCase() || a.toLowerCase().includes(b.toLowerCase()) || b.toLowerCase().includes(a.toLowerCase());
+}
+/**
+* Normalize and compare color strings.
+*/
+function colorsMatch(a, b) {
+	return a.toLowerCase().replace(/\s/g, "") === b.toLowerCase().replace(/\s/g, "");
+}
+//#endregion
+//#region src/server/domains/skia-capture/handlers/skia-detect.ts
+/**
+* Skia renderer detection and scene dump handlers.
+*
+* Implements SKIA-01 (detectSkiaRenderer) and SKIA-02 (extractSceneTree).
+* Integrates with v8-inspector domain for SKIA-03 (correlateObjects).
+*/
+/**
+* Handler for skia_detect_renderer (SKIA-01).
+*/
+async function detectRenderer(pageController, args) {
+	const canvasId = argString(args, "canvasId");
+	return {
+		rendererInfo: await detectSkiaRenderer(pageController, canvasId || void 0),
+		canvasId: canvasId || "auto",
+		detectionComplete: true
+	};
+}
+/**
+* Handler for skia_dump_scene (SKIA-02).
+*/
+async function dumpScene(pageController, args) {
+	const canvasId = argString(args, "canvasId");
+	const includeDrawCommands = argBool(args, "includeDrawCommands", true);
+	return {
+		sceneTree: await extractSceneTree(pageController, canvasId || void 0, includeDrawCommands),
+		canvasId: canvasId || "auto",
+		extractionComplete: true
+	};
+}
+/**
+* Handler for skia_correlate_objects (SKIA-03).
+*
+* Cross-domain: requires v8-inspector for JS object data.
+*/
+async function correlateObjects(pageController, args, getJSObjects) {
+	const canvasId = argString(args, "canvasId");
+	const skiaNodeIds = argStringArray(args, "skiaNodeIds");
+	const sceneTree = await extractSceneTree(pageController, canvasId || void 0, true);
+	if (sceneTree.layers.length === 0 && sceneTree.drawCommands.length === 0) throw new ToolError("PREREQUISITE", "No Skia scene data available for correlation");
+	let jsObjects = [];
+	if (getJSObjects) try {
+		jsObjects = await getJSObjects();
+	} catch {
+		jsObjects = [];
+	}
+	let targetSceneTree = sceneTree;
+	if (skiaNodeIds.length > 0) {
+		const idSet = new Set(skiaNodeIds);
+		targetSceneTree = {
+			...sceneTree,
+			layers: sceneTree.layers.filter((l) => idSet.has(l.id)),
+			drawCommands: sceneTree.drawCommands.filter((cmd) => {
+				const id = cmd.layerId;
+				return id === void 0 || idSet.has(id);
+			})
+		};
+	}
+	return {
+		correlations: correlateToJS(targetSceneTree, jsObjects),
+		canvasId: canvasId || "auto",
+		skiaNodeIds: skiaNodeIds.length > 0 ? skiaNodeIds : void 0,
+		correlationComplete: true
+	};
+}
+//#endregion
+//#region src/server/domains/skia-capture/handlers/impl.ts
+/**
+* SkiaCaptureHandlers — facade for skia-capture domain tool handlers.
+*
+* Delegates to handlers/skia-detect.ts for actual implementation.
+*/
+var SkiaCaptureHandlers = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async handleSkiaDetectRenderer(args) {
+		if (!this.deps.pageController) throw new ToolError("PREREQUISITE", "PageController not available — ensure browser is connected");
+		return detectRenderer(this.deps.pageController, args);
+	}
+	async handleSkiaExtractScene(args) {
+		if (!this.deps.pageController) throw new ToolError("PREREQUISITE", "PageController not available — ensure browser is connected");
+		const result = await dumpScene(this.deps.pageController, args);
+		const sceneTree = result?.sceneTree;
+		if (sceneTree) this.deps.eventBus?.emit("skia:scene_captured", {
+			canvasId: args.canvasId ?? "auto",
+			nodeCount: (sceneTree.layers?.length ?? 0) + (sceneTree.drawCommands?.length ?? 0),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		return result;
+	}
+	async handleSkiaCorrelateObjects(args) {
+		if (!this.deps.pageController) throw new ToolError("PREREQUISITE", "PageController not available — ensure browser is connected");
+		return correlateObjects(this.deps.pageController, args, this.deps.getJSObjects);
+	}
+};
+//#endregion
+export { SkiaCaptureHandlers };