graphwise 1.9.1 → 1.11.0

package/dist/operations-D9otVlIH.js

@@ -0,0 +1,2198 @@
+import { n as data_exports, t as src_default } from "./typegpu-DwnJf28i.js";
+import { a as overlapFromIntersection, c as graphToCSR, i as jaccardFromIntersection, n as hubPromotedFromIntersection, o as sorensenDiceFromIntersection, r as intersectionBatch, s as csrToTypedBuffers, t as cosineFromIntersection } from "./logic-DyBzRg1A.js";
+//#region src/gpu/detect.ts
+/**
+* Detect WebGPU availability in the current environment.
+*
+* Checks for:
+* - Browser: navigator.gpu
+* - Node.js: global GPU constructor (Node.js 21+ with --experimental-webgpu)
+* - Deno: global GPU constructor
+*
+* @returns Detection result with availability status and reason
+*/
+function detectWebGPU() {
+	if (typeof navigator !== "undefined" && "gpu" in navigator) return { available: true };
+	if (typeof globalThis !== "undefined" && "GPU" in globalThis) return { available: true };
+	const reasons = [];
+	if (typeof navigator === "undefined" && typeof globalThis === "undefined") reasons.push("no global scope detected");
+	else if (typeof navigator !== "undefined" && !("gpu" in navigator)) reasons.push("navigator.gpu not present (browser may not support WebGPU)");
+	else if (typeof globalThis !== "undefined" && !("GPU" in globalThis)) reasons.push("global GPU not present (Node.js requires v21+ with --experimental-webgpu flag)");
+	return {
+		available: false,
+		reason: reasons.length > 0 ? reasons.join("; ") : "unknown environment"
+	};
+}
+/**
+* Check if WebGPU is available (convenience function).
+*
+* @returns true if WebGPU is available, false otherwise
+*/
+function isWebGPUAvailable() {
+	return detectWebGPU().available;
+}
+/**
+* Assert that WebGPU is available, throwing an error if not.
+*
+* @throws Error if WebGPU is not available
+*/
+function assertWebGPUAvailable() {
+	const result = detectWebGPU();
+	if (!result.available) throw new Error(`WebGPU required but not available: ${result.reason ?? "unknown reason"}`);
+}
+//#endregion
+//#region src/gpu/types.ts
+/**
+* Error thrown when GPU backend is requested but unavailable.
+*/
+var GPUNotAvailableError = class extends Error {
+	constructor(reason) {
+		super(`WebGPU not available: ${reason}`);
+		this.name = "GPUNotAvailableError";
+	}
+};
+//#endregion
+//#region src/gpu/dispatch.ts
+/**
+* Backend selection and dispatch utilities for GPU compute operations.
+*
+* Provides the `withBackend` function that handles auto/gpu/cpu backend
+* selection with timing and fallback logic.
+*
+* @module gpu/dispatch
+*/
+/**
+* Execute a compute operation with automatic backend selection.
+*
+* @param options - Backend selection and cancellation options
+* @param cpuFn - CPU fallback implementation
+* @param gpuFn - GPU implementation (receives TypeGPU root)
+* @returns Compute result with backend used and timing
+*/
+async function withBackend(options, cpuFn, gpuFn) {
+	const backend = options.backend ?? "auto";
+	if (options.signal?.aborted === true) throw new DOMException("Operation aborted", "AbortError");
+	if (backend === "cpu") {
+		const start = performance.now();
+		return {
+			value: cpuFn(),
+			backend: "cpu",
+			elapsedMs: performance.now() - start
+		};
+	}
+	if (backend === "gpu") {
+		const detection = detectWebGPU();
+		if (!detection.available) throw new GPUNotAvailableError(detection.reason ?? "Unknown reason");
+		const root = options.root;
+		if (root === void 0) throw new Error("GPU backend requires a GraphwiseGPURoot. Pass one via options.root or use backend: 'auto'.");
+		const start = performance.now();
+		return {
+			value: await gpuFn(root),
+			backend: "gpu",
+			elapsedMs: performance.now() - start
+		};
+	}
+	if (!detectWebGPU().available) {
+		const start = performance.now();
+		return {
+			value: cpuFn(),
+			backend: "cpu",
+			elapsedMs: performance.now() - start
+		};
+	}
+	const root = options.root;
+	if (root === void 0) {
+		const start = performance.now();
+		return {
+			value: cpuFn(),
+			backend: "cpu",
+			elapsedMs: performance.now() - start
+		};
+	}
+	const start = performance.now();
+	return {
+		value: await gpuFn(root),
+		backend: "gpu",
+		elapsedMs: performance.now() - start
+	};
+}
+//#endregion
+//#region src/gpu/kernels/spmv/kernel.ts
+/**
+* TypeGPU compute kernel for Sparse Matrix-Vector Multiplication (SpMV).
+*
+* Computes y = A * x where A is a sparse matrix in CSR format.
+* Uses TypeGPU's compute pipeline for parallel GPU execution.
+*
+* @module gpu/kernels/spmv/kernel
+*/
+/**
+* Bind group layout for SpMV kernel.
+*/
+var SpMVLayout = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	rowOffsets: { storage: data_exports.arrayOf(data_exports.u32) },
+	colIndices: { storage: data_exports.arrayOf(data_exports.u32) },
+	values: { storage: data_exports.arrayOf(data_exports.f32) },
+	x: { storage: data_exports.arrayOf(data_exports.f32) },
+	y: {
+		storage: data_exports.arrayOf(data_exports.f32),
+		access: "mutable"
+	},
+	nodeCount: { uniform: data_exports.u32 },
+	hasValues: { uniform: data_exports.u32 }
+}), "SpMVLayout");
+/**
+* SpMV compute pipeline: y[row] = sum(A[row,col] * x[col]).
+*
+* Each thread computes one row of the output vector using the CSR format:
+* - rowOffsets: start/end indices for each row
+* - colIndices: column index for each non-zero entry
+* - values: edge weights (optional, defaults to 1.0)
+*/
+var spmvPipeline = (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((row) => {
+	"use gpu";
+	const start = SpMVLayout.$.rowOffsets[row] ?? 0;
+	const end = SpMVLayout.$.rowOffsets[__tsover_add(row, 1)] ?? 0;
+	let sum = 0;
+	for (let i = start; i < end; i = __tsover_add(i, 1)) {
+		const col = SpMVLayout.$.colIndices[i] ?? 0;
+		const weight = SpMVLayout.$.hasValues !== 0 ? SpMVLayout.$.values[i] ?? 1 : 1;
+		sum = __tsover_add(sum, __tsover_mul(weight, SpMVLayout.$.x[col] ?? 0));
+	}
+	SpMVLayout.$.y[row] = sum;
+}), {
+	v: 1,
+	name: "spmvPipeline",
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "row"
+		}],
+		"body": [0, [
+			[
+				13,
+				"start",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"SpMVLayout",
+								"$"
+							],
+							"rowOffsets"
+						],
+						"row"
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"end",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"SpMVLayout",
+								"$"
+							],
+							"rowOffsets"
+						],
+						[
+							1,
+							"row",
+							"+",
+							[5, "1"]
+						]
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				12,
+				"sum",
+				[5, "0"]
+			],
+			[
+				14,
+				[
+					12,
+					"i",
+					"start"
+				],
+				[
+					1,
+					"i",
+					"<",
+					"end"
+				],
+				[
+					2,
+					"i",
+					"=",
+					[
+						1,
+						"i",
+						"+",
+						[5, "1"]
+					]
+				],
+				[0, [
+					[
+						13,
+						"col",
+						[
+							3,
+							[
+								8,
+								[
+									7,
+									[
+										7,
+										"SpMVLayout",
+										"$"
+									],
+									"colIndices"
+								],
+								"i"
+							],
+							"??",
+							[5, "0"]
+						]
+					],
+					[
+						13,
+						"weight",
+						[
+							105,
+							[
+								1,
+								[
+									7,
+									[
+										7,
+										"SpMVLayout",
+										"$"
+									],
+									"hasValues"
+								],
+								"!==",
+								[5, "0"]
+							],
+							[
+								3,
+								[
+									8,
+									[
+										7,
+										[
+											7,
+											"SpMVLayout",
+											"$"
+										],
+										"values"
+									],
+									"i"
+								],
+								"??",
+								[5, "1"]
+							],
+							[5, "1"]
+						]
+					],
+					[
+						2,
+						"sum",
+						"=",
+						[
+							1,
+							"sum",
+							"+",
+							[
+								1,
+								"weight",
+								"*",
+								[
+									3,
+									[
+										8,
+										[
+											7,
+											[
+												7,
+												"SpMVLayout",
+												"$"
+											],
+											"x"
+										],
+										"col"
+									],
+									"??",
+									[5, "0"]
+								]
+							]
+						]
+					]
+				]]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"SpMVLayout",
+							"$"
+						],
+						"y"
+					],
+					"row"
+				],
+				"=",
+				"sum"
+			]
+		]],
+		"externalNames": ["SpMVLayout"]
+	},
+	externals: () => ({ SpMVLayout })
+}) && $.f)({});
+/**
+* Dispatch SpMV on GPU.
+*
+* @param root - TypeGPU root instance
+* @param csrBuffers - CSR matrix as typed buffers
+* @param x - Input vector buffer
+* @param y - Output vector buffer (mutable)
+* @param nodeCount - Number of nodes/rows
+* @param hasValues - Whether edge weights are present
+*/
+function dispatchSpmv(root, csrBuffers, x, y, nodeCount, hasValues) {
+	const pipeline = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createGuardedComputePipeline(spmvPipeline), "pipeline");
+	const valuesBuffer = csrBuffers.values ?? root.createBuffer(data_exports.arrayOf(data_exports.f32, csrBuffers.edgeCount), new Array(csrBuffers.edgeCount).fill(1)).$usage("storage");
+	const nodeCountBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.u32, nodeCount).$usage("uniform"), "nodeCountBuffer");
+	const hasValuesBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.u32, hasValues ? 1 : 0).$usage("uniform"), "hasValuesBuffer");
+	const bindGroup = root.createBindGroup(SpMVLayout, {
+		rowOffsets: csrBuffers.rowOffsets,
+		colIndices: csrBuffers.colIndices,
+		values: valuesBuffer,
+		x,
+		y,
+		nodeCount: nodeCountBuffer,
+		hasValues: hasValuesBuffer
+	});
+	pipeline.with(bindGroup).dispatchThreads(nodeCount);
+}
+//#endregion
+//#region src/gpu/kernels/pagerank/kernel.ts
+/**
+* TypeGPU compute kernel for PageRank power iteration.
+*
+* Computes one iteration of PageRank:
+*   r(v) = (1 - d)/N + d * sum(r(u) / deg_out(u)) for u -> v
+*
+* Uses TypeGPU's compute pipeline for parallel GPU execution.
+*
+* @module gpu/kernels/pagerank/kernel
+*/
+/**
+* Bind group layout for PageRank kernel.
+*/
+var PageRankLayout = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	rowOffsets: { storage: data_exports.arrayOf(data_exports.u32) },
+	colIndices: { storage: data_exports.arrayOf(data_exports.u32) },
+	ranks: { storage: data_exports.arrayOf(data_exports.f32) },
+	outDegrees: { storage: data_exports.arrayOf(data_exports.u32) },
+	newRanks: {
+		storage: data_exports.arrayOf(data_exports.f32),
+		access: "mutable"
+	},
+	nodeCount: { uniform: data_exports.u32 },
+	damping: { uniform: data_exports.f32 }
+}), "PageRankLayout");
+/**
+* PageRank compute pipeline: one power iteration per dispatch.
+*
+* Each thread computes one node's new rank from incoming neighbours:
+*   newRank[v] = (1 - damping) / N + damping * sum(rank[u] / outDegree[u])
+*/
+var pagerankPipeline = (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((node) => {
+	"use gpu";
+	const n = PageRankLayout.$.nodeCount ?? 0;
+	const damp = PageRankLayout.$.damping ?? .85;
+	const start = PageRankLayout.$.rowOffsets[node] ?? 0;
+	const end = PageRankLayout.$.rowOffsets[__tsover_add(node, 1)] ?? 0;
+	let contribution = 0;
+	for (let i = start; i < end; i = __tsover_add(i, 1)) {
+		const source = PageRankLayout.$.colIndices[i] ?? 0;
+		const deg = PageRankLayout.$.outDegrees[source] ?? 0;
+		if (deg > 0) {
+			const rank = PageRankLayout.$.ranks[source] ?? 0;
+			contribution = __tsover_add(contribution, __tsover_div(rank, deg));
+		}
+	}
+	const teleport = __tsover_div(__tsover_sub(1, damp), n);
+	PageRankLayout.$.newRanks[node] = __tsover_add(teleport, __tsover_mul(damp, contribution));
+}), {
+	v: 1,
+	name: "pagerankPipeline",
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "node"
+		}],
+		"body": [0, [
+			[
+				13,
+				"n",
+				[
+					3,
+					[
+						7,
+						[
+							7,
+							"PageRankLayout",
+							"$"
+						],
+						"nodeCount"
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"damp",
+				[
+					3,
+					[
+						7,
+						[
+							7,
+							"PageRankLayout",
+							"$"
+						],
+						"damping"
+					],
+					"??",
+					[5, "0.85"]
+				]
+			],
+			[
+				13,
+				"start",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"PageRankLayout",
+								"$"
+							],
+							"rowOffsets"
+						],
+						"node"
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"end",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"PageRankLayout",
+								"$"
+							],
+							"rowOffsets"
+						],
+						[
+							1,
+							"node",
+							"+",
+							[5, "1"]
+						]
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				12,
+				"contribution",
+				[5, "0"]
+			],
+			[
+				14,
+				[
+					12,
+					"i",
+					"start"
+				],
+				[
+					1,
+					"i",
+					"<",
+					"end"
+				],
+				[
+					2,
+					"i",
+					"=",
+					[
+						1,
+						"i",
+						"+",
+						[5, "1"]
+					]
+				],
+				[0, [
+					[
+						13,
+						"source",
+						[
+							3,
+							[
+								8,
+								[
+									7,
+									[
+										7,
+										"PageRankLayout",
+										"$"
+									],
+									"colIndices"
+								],
+								"i"
+							],
+							"??",
+							[5, "0"]
+						]
+					],
+					[
+						13,
+						"deg",
+						[
+							3,
+							[
+								8,
+								[
+									7,
+									[
+										7,
+										"PageRankLayout",
+										"$"
+									],
+									"outDegrees"
+								],
+								"source"
+							],
+							"??",
+							[5, "0"]
+						]
+					],
+					[
+						11,
+						[
+							1,
+							"deg",
+							">",
+							[5, "0"]
+						],
+						[0, [[
+							13,
+							"rank",
+							[
+								3,
+								[
+									8,
+									[
+										7,
+										[
+											7,
+											"PageRankLayout",
+											"$"
+										],
+										"ranks"
+									],
+									"source"
+								],
+								"??",
+								[5, "0"]
+							]
+						], [
+							2,
+							"contribution",
+							"=",
+							[
+								1,
+								"contribution",
+								"+",
+								[
+									1,
+									"rank",
+									"/",
+									"deg"
+								]
+							]
+						]]]
+					]
+				]]
+			],
+			[
+				13,
+				"teleport",
+				[
+					1,
+					[
+						1,
+						[5, "1"],
+						"-",
+						"damp"
+					],
+					"/",
+					"n"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"PageRankLayout",
+							"$"
+						],
+						"newRanks"
+					],
+					"node"
+				],
+				"=",
+				[
+					1,
+					"teleport",
+					"+",
+					[
+						1,
+						"damp",
+						"*",
+						"contribution"
+					]
+				]
+			]
+		]],
+		"externalNames": ["PageRankLayout"]
+	},
+	externals: () => ({ PageRankLayout })
+}) && $.f)({});
+/**
+* Dispatch one PageRank iteration on GPU.
+*
+* @param root - TypeGPU root instance
+* @param csrBuffers - CSR matrix as typed buffers (transpose graph: in-edges)
+* @param ranks - Current rank values buffer
+* @param outDegrees - Out-degree buffer for each node
+* @param newRanks - Output buffer for new rank values (mutable)
+* @param nodeCount - Number of nodes
+* @param damping - Damping factor (typically 0.85)
+*/
+function dispatchPagerank(root, csrBuffers, ranks, outDegrees, newRanks, nodeCount, damping) {
+	const pipeline = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createGuardedComputePipeline(pagerankPipeline), "pipeline");
+	const nodeCountBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.u32, nodeCount).$usage("uniform"), "nodeCountBuffer");
+	const dampingBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.f32, damping).$usage("uniform"), "dampingBuffer");
+	const bindGroup = root.createBindGroup(PageRankLayout, {
+		rowOffsets: csrBuffers.rowOffsets,
+		colIndices: csrBuffers.colIndices,
+		ranks,
+		outDegrees,
+		newRanks,
+		nodeCount: nodeCountBuffer,
+		damping: dampingBuffer
+	});
+	pipeline.with(bindGroup).dispatchThreads(nodeCount);
+}
+//#endregion
+//#region src/gpu/kernels/jaccard/kernel.ts
+/**
+* TypeGPU compute kernel for batch Jaccard similarity.
+*
+* Computes Jaccard coefficient for multiple node pairs in parallel:
+*   J(u, v) = |N(u) ∩ N(v)| / |N(u) ∪ N(v)|
+*
+* Uses binary search optimisation: iterate smaller neighbourhood, search in larger.
+*
+* @module gpu/kernels/jaccard/kernel
+*/
+/**
+* Bind group layout for Jaccard kernel.
+*/
+var JaccardLayout = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	rowOffsets: { storage: data_exports.arrayOf(data_exports.u32) },
+	colIndices: { storage: data_exports.arrayOf(data_exports.u32) },
+	pairsU: { storage: data_exports.arrayOf(data_exports.u32) },
+	pairsV: { storage: data_exports.arrayOf(data_exports.u32) },
+	results: {
+		storage: data_exports.arrayOf(data_exports.f32),
+		access: "mutable"
+	},
+	pairCount: { uniform: data_exports.u32 }
+}), "JaccardLayout");
+/**
+* Jaccard compute pipeline: one thread per pair.
+*
+* For each pair (u, v):
+*   - Count intersection by iterating smaller neighbourhood
+*   - Binary search in larger neighbourhood
+*   - Jaccard = intersection / (degU + degV - intersection)
+*/
+var jaccardPipeline = (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pairIdx) => {
+	"use gpu";
+	const u = JaccardLayout.$.pairsU[pairIdx] ?? 0;
+	const v = JaccardLayout.$.pairsV[pairIdx] ?? 0;
+	const uStart = JaccardLayout.$.rowOffsets[u] ?? 0;
+	const uEnd = JaccardLayout.$.rowOffsets[__tsover_add(u, 1)] ?? 0;
+	const vStart = JaccardLayout.$.rowOffsets[v] ?? 0;
+	const vEnd = JaccardLayout.$.rowOffsets[__tsover_add(v, 1)] ?? 0;
+	const degU = __tsover_sub(uEnd, uStart);
+	const degV = __tsover_sub(vEnd, vStart);
+	if (degU === 0 || degV === 0) {
+		JaccardLayout.$.results[pairIdx] = 0;
+		return;
+	}
+	let intersection = 0;
+	if (degU <= degV) for (let i = uStart; i < uEnd; i = __tsover_add(i, 1)) {
+		const neighbour = JaccardLayout.$.colIndices[i] ?? 0;
+		let lo = vStart;
+		let hi = vEnd;
+		while (lo < hi) {
+			const mid = __tsover_add(lo, __tsover_div(__tsover_sub(hi, lo), 2));
+			const midVal = JaccardLayout.$.colIndices[mid] ?? 0;
+			if (midVal === neighbour) {
+				intersection = __tsover_add(intersection, 1);
+				lo = hi;
+			} else if (midVal < neighbour) lo = __tsover_add(mid, 1);
+			else hi = mid;
+		}
+	}
+	else for (let i = vStart; i < vEnd; i = __tsover_add(i, 1)) {
+		const neighbour = JaccardLayout.$.colIndices[i] ?? 0;
+		let lo = uStart;
+		let hi = uEnd;
+		while (lo < hi) {
+			const mid = __tsover_add(lo, __tsover_div(__tsover_sub(hi, lo), 2));
+			const midVal = JaccardLayout.$.colIndices[mid] ?? 0;
+			if (midVal === neighbour) {
+				intersection = __tsover_add(intersection, 1);
+				lo = hi;
+			} else if (midVal < neighbour) lo = __tsover_add(mid, 1);
+			else hi = mid;
+		}
+	}
+	const unionSize = __tsover_sub(__tsover_add(degU, degV), intersection);
+	JaccardLayout.$.results[pairIdx] = __tsover_div(intersection, unionSize);
+}), {
+	v: 1,
+	name: "jaccardPipeline",
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "pairIdx"
+		}],
+		"body": [0, [
+			[
+				13,
+				"u",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"JaccardLayout",
+								"$"
+							],
+							"pairsU"
+						],
+						"pairIdx"
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"v",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"JaccardLayout",
+								"$"
+							],
+							"pairsV"
+						],
+						"pairIdx"
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"uStart",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"JaccardLayout",
+								"$"
+							],
+							"rowOffsets"
+						],
+						"u"
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"uEnd",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"JaccardLayout",
+								"$"
+							],
+							"rowOffsets"
+						],
+						[
+							1,
+							"u",
+							"+",
+							[5, "1"]
+						]
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"vStart",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"JaccardLayout",
+								"$"
+							],
+							"rowOffsets"
+						],
+						"v"
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"vEnd",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"JaccardLayout",
+								"$"
+							],
+							"rowOffsets"
+						],
+						[
+							1,
+							"v",
+							"+",
+							[5, "1"]
+						]
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"degU",
+				[
+					1,
+					"uEnd",
+					"-",
+					"uStart"
+				]
+			],
+			[
+				13,
+				"degV",
+				[
+					1,
+					"vEnd",
+					"-",
+					"vStart"
+				]
+			],
+			[
+				11,
+				[
+					3,
+					[
+						1,
+						"degU",
+						"===",
+						[5, "0"]
+					],
+					"||",
+					[
+						1,
+						"degV",
+						"===",
+						[5, "0"]
+					]
+				],
+				[0, [[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"JaccardLayout",
+								"$"
+							],
+							"results"
+						],
+						"pairIdx"
+					],
+					"=",
+					[5, "0"]
+				], [10]]]
+			],
+			[
+				12,
+				"intersection",
+				[5, "0"]
+			],
+			[
+				11,
+				[
+					1,
+					"degU",
+					"<=",
+					"degV"
+				],
+				[0, [[
+					14,
+					[
+						12,
+						"i",
+						"uStart"
+					],
+					[
+						1,
+						"i",
+						"<",
+						"uEnd"
+					],
+					[
+						2,
+						"i",
+						"=",
+						[
+							1,
+							"i",
+							"+",
+							[5, "1"]
+						]
+					],
+					[0, [
+						[
+							13,
+							"neighbour",
+							[
+								3,
+								[
+									8,
+									[
+										7,
+										[
+											7,
+											"JaccardLayout",
+											"$"
+										],
+										"colIndices"
+									],
+									"i"
+								],
+								"??",
+								[5, "0"]
+							]
+						],
+						[
+							12,
+							"lo",
+							"vStart"
+						],
+						[
+							12,
+							"hi",
+							"vEnd"
+						],
+						[
+							15,
+							[
+								1,
+								"lo",
+								"<",
+								"hi"
+							],
+							[0, [
+								[
+									13,
+									"mid",
+									[
+										1,
+										"lo",
+										"+",
+										[
+											1,
+											[
+												1,
+												"hi",
+												"-",
+												"lo"
+											],
+											"/",
+											[5, "2"]
+										]
+									]
+								],
+								[
+									13,
+									"midVal",
+									[
+										3,
+										[
+											8,
+											[
+												7,
+												[
+													7,
+													"JaccardLayout",
+													"$"
+												],
+												"colIndices"
+											],
+											"mid"
+										],
+										"??",
+										[5, "0"]
+									]
+								],
+								[
+									11,
+									[
+										1,
+										"midVal",
+										"===",
+										"neighbour"
+									],
+									[0, [[
+										2,
+										"intersection",
+										"=",
+										[
+											1,
+											"intersection",
+											"+",
+											[5, "1"]
+										]
+									], [
+										2,
+										"lo",
+										"=",
+										"hi"
+									]]],
+									[
+										11,
+										[
+											1,
+											"midVal",
+											"<",
+											"neighbour"
+										],
+										[0, [[
+											2,
+											"lo",
+											"=",
+											[
+												1,
+												"mid",
+												"+",
+												[5, "1"]
+											]
+										]]],
+										[0, [[
+											2,
+											"hi",
+											"=",
+											"mid"
+										]]]
+									]
+								]
+							]]
+						]
+					]]
+				]]],
+				[0, [[
+					14,
+					[
+						12,
+						"i",
+						"vStart"
+					],
+					[
+						1,
+						"i",
+						"<",
+						"vEnd"
+					],
+					[
+						2,
+						"i",
+						"=",
+						[
+							1,
+							"i",
+							"+",
+							[5, "1"]
+						]
+					],
+					[0, [
+						[
+							13,
+							"neighbour",
+							[
+								3,
+								[
+									8,
+									[
+										7,
+										[
+											7,
+											"JaccardLayout",
+											"$"
+										],
+										"colIndices"
+									],
+									"i"
+								],
+								"??",
+								[5, "0"]
+							]
+						],
+						[
+							12,
+							"lo",
+							"uStart"
+						],
+						[
+							12,
+							"hi",
+							"uEnd"
+						],
+						[
+							15,
+							[
+								1,
+								"lo",
+								"<",
+								"hi"
+							],
+							[0, [
+								[
+									13,
+									"mid",
+									[
+										1,
+										"lo",
+										"+",
+										[
+											1,
+											[
+												1,
+												"hi",
+												"-",
+												"lo"
+											],
+											"/",
+											[5, "2"]
+										]
+									]
+								],
+								[
+									13,
+									"midVal",
+									[
+										3,
+										[
+											8,
+											[
+												7,
+												[
+													7,
+													"JaccardLayout",
+													"$"
+												],
+												"colIndices"
+											],
+											"mid"
+										],
+										"??",
+										[5, "0"]
+									]
+								],
+								[
+									11,
+									[
+										1,
+										"midVal",
+										"===",
+										"neighbour"
+									],
+									[0, [[
+										2,
+										"intersection",
+										"=",
+										[
+											1,
+											"intersection",
+											"+",
+											[5, "1"]
+										]
+									], [
+										2,
+										"lo",
+										"=",
+										"hi"
+									]]],
+									[
+										11,
+										[
+											1,
+											"midVal",
+											"<",
+											"neighbour"
+										],
+										[0, [[
+											2,
+											"lo",
+											"=",
+											[
+												1,
+												"mid",
+												"+",
+												[5, "1"]
+											]
+										]]],
+										[0, [[
+											2,
+											"hi",
+											"=",
+											"mid"
+										]]]
+									]
+								]
+							]]
+						]
+					]]
+				]]]
+			],
+			[
+				13,
+				"unionSize",
+				[
+					1,
+					[
+						1,
+						"degU",
+						"+",
+						"degV"
+					],
+					"-",
+					"intersection"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"JaccardLayout",
+							"$"
+						],
+						"results"
+					],
+					"pairIdx"
+				],
+				"=",
+				[
+					1,
+					"intersection",
+					"/",
+					"unionSize"
+				]
+			]
+		]],
+		"externalNames": ["JaccardLayout"]
+	},
+	externals: () => ({ JaccardLayout })
+}) && $.f)({});
+/**
+* Dispatch batch Jaccard on GPU.
+*
+* @param root - TypeGPU root instance
+* @param csrBuffers - CSR matrix as typed buffers
+* @param pairsU - First node of each pair (u32 array)
+* @param pairsV - Second node of each pair (u32 array)
+* @param results - Output Jaccard coefficients (f32 array, mutable)
+* @param pairCount - Number of pairs to compute
+*/
+function dispatchJaccard(root, csrBuffers, pairsU, pairsV, results, pairCount) {
+	const pipeline = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createGuardedComputePipeline(jaccardPipeline), "pipeline");
+	const pairCountBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.u32, pairCount).$usage("uniform"), "pairCountBuffer");
+	const bindGroup = root.createBindGroup(JaccardLayout, {
+		rowOffsets: csrBuffers.rowOffsets,
+		colIndices: csrBuffers.colIndices,
+		pairsU,
+		pairsV,
+		results,
+		pairCount: pairCountBuffer
+	});
+	pipeline.with(bindGroup).dispatchThreads(pairCount);
+}
+//#endregion
+//#region src/gpu/kernels/degree-histogram/kernel.ts
+/**
+* TypeGPU compute kernel for degree computation.
+*
+* Computes degree per node from CSR row offsets.
+* Note: Histogram aggregation requires atomic operations or CPU reduction.
+*
+* @module gpu/kernels/degree-histogram/kernel
+*/
+/**
+* Bind group layout for degree kernel.
+*/
+var DegreeLayout = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	rowOffsets: { storage: data_exports.arrayOf(data_exports.u32) },
+	degrees: {
+		storage: data_exports.arrayOf(data_exports.u32),
+		access: "mutable"
+	},
+	nodeCount: { uniform: data_exports.u32 }
+}), "DegreeLayout");
+/**
+* Degree compute pipeline: compute degree for each node.
+*
+* Each thread computes one node's degree from CSR row offsets:
+*   degree[node] = rowOffsets[node+1] - rowOffsets[node]
+*/
+var degreePipeline = (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((node) => {
+	"use gpu";
+	if (node >= (DegreeLayout.$.nodeCount ?? 0)) return;
+	const start = DegreeLayout.$.rowOffsets[node] ?? 0;
+	const end = DegreeLayout.$.rowOffsets[__tsover_add(node, 1)] ?? 0;
+	const deg = __tsover_sub(end, start);
+	DegreeLayout.$.degrees[node] = deg;
+}), {
+	v: 1,
+	name: "degreePipeline",
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "node"
+		}],
+		"body": [0, [
+			[
+				13,
+				"n",
+				[
+					3,
+					[
+						7,
+						[
+							7,
+							"DegreeLayout",
+							"$"
+						],
+						"nodeCount"
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				11,
+				[
+					1,
+					"node",
+					">=",
+					"n"
+				],
+				[0, [[10]]]
+			],
+			[
+				13,
+				"start",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"DegreeLayout",
+								"$"
+							],
+							"rowOffsets"
+						],
+						"node"
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"end",
+				[
+					3,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"DegreeLayout",
+								"$"
+							],
+							"rowOffsets"
+						],
+						[
+							1,
+							"node",
+							"+",
+							[5, "1"]
+						]
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"deg",
+				[
+					1,
+					"end",
+					"-",
+					"start"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"DegreeLayout",
+							"$"
+						],
+						"degrees"
+					],
+					"node"
+				],
+				"=",
+				"deg"
+			]
+		]],
+		"externalNames": ["DegreeLayout"]
+	},
+	externals: () => ({ DegreeLayout })
+}) && $.f)({});
+/**
+* Dispatch degree computation on GPU.
+*
+* Note: This computes per-node degrees. Histogram aggregation should be
+* done on CPU or with a separate reduction kernel.
+*
+* @param root - TypeGPU root instance
+* @param csrBuffers - CSR matrix as typed buffers
+* @param degrees - Output degree array (u32, mutable)
+* @param nodeCount - Number of nodes
+*/
+function dispatchDegreeHistogram(root, csrBuffers, degrees, nodeCount) {
+	const pipeline = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createGuardedComputePipeline(degreePipeline), "pipeline");
+	const nodeCountBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.u32, nodeCount).$usage("uniform"), "nodeCountBuffer");
+	const bindGroup = root.createBindGroup(DegreeLayout, {
+		rowOffsets: csrBuffers.rowOffsets,
+		degrees,
+		nodeCount: nodeCountBuffer
+	});
+	pipeline.with(bindGroup).dispatchThreads(nodeCount);
+}
+//#endregion
+//#region src/gpu/operations.ts
+/**
+* Sparse matrix-vector multiply on GPU.
+*
+* Computes y = A * x where A is the graph adjacency matrix in CSR format.
+*
+* @param graph - Input graph
+* @param x - Input vector (must have length = graph.nodeCount)
+* @param options - Compute options (backend, root, signal)
+* @returns Result vector y
+*/
+async function gpuSpmv(graph, x, options) {
+	const nodeCount = graph.nodeCount;
+	if (x.length !== nodeCount) throw new Error(`Input vector length (${String(x.length)}) must match node count (${String(nodeCount)})`);
+	const cpuFn = () => {
+		const { csr } = graphToCSR(graph);
+		const y = new Float32Array(nodeCount);
+		for (let row = 0; row < nodeCount; row++) {
+			const start = csr.rowOffsets[row] ?? 0;
+			const end = csr.rowOffsets[row + 1] ?? 0;
+			let sum = 0;
+			for (let i = start; i < end; i++) {
+				const col = csr.colIndices[i] ?? 0;
+				const weight = csr.values?.[i] ?? 1;
+				sum += weight * (x[col] ?? 0);
+			}
+			y[row] = sum;
+		}
+		return y;
+	};
+	const gpuFn = async (root) => {
+		const { csr } = graphToCSR(graph);
+		const csrBuffers = csrToTypedBuffers(root, csr);
+		const xBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.f32, nodeCount), Array.from(x)).$usage("storage"), "xBuffer");
+		const yBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.f32, nodeCount)).$usage("storage"), "yBuffer");
+		dispatchSpmv(root, csrBuffers, xBuffer, yBuffer, nodeCount, csr.values !== void 0);
+		const result = await yBuffer.read();
+		return new Float32Array(result);
+	};
+	return withBackend({
+		backend: options?.backend,
+		root: options?.root,
+		signal: options?.signal
+	}, cpuFn, gpuFn);
+}
+/**
+* PageRank via GPU-accelerated power iteration.
+*
+* @param graph - Input graph (will be converted to transpose CSR for in-edges)
+* @param options - Compute options plus damping factor and iteration count
+* @returns PageRank scores for each node
+*/
+async function gpuPageRank(graph, options) {
+	const nodeCount = graph.nodeCount;
+	const damping = options?.damping ?? .85;
+	const iterations = options?.iterations ?? 20;
+	const cpuFn = () => {
+		const { csr } = graphToCSR(graph);
+		const ranks = new Float32Array(nodeCount).fill(1 / nodeCount);
+		const outDegrees = new Uint32Array(nodeCount);
+		for (let i = 0; i < nodeCount; i++) outDegrees[i] = (csr.rowOffsets[i + 1] ?? 0) - (csr.rowOffsets[i] ?? 0);
+		for (let iter = 0; iter < iterations; iter++) {
+			const newRanks = new Float32Array(nodeCount);
+			for (let v = 0; v < nodeCount; v++) {
+				const start = csr.rowOffsets[v] ?? 0;
+				const end = csr.rowOffsets[v + 1] ?? 0;
+				let contribution = 0;
+				for (let i = start; i < end; i++) {
+					const source = csr.colIndices[i] ?? 0;
+					const deg = outDegrees[source] ?? 0;
+					if (deg > 0) contribution += (ranks[source] ?? 0) / deg;
+				}
+				newRanks[v] = (1 - damping) / nodeCount + damping * contribution;
+			}
+			ranks.set(newRanks);
+		}
+		return ranks;
+	};
+	const gpuFn = async (root) => {
+		const { csr } = graphToCSR(graph);
+		const csrBuffers = csrToTypedBuffers(root, csr);
+		const outDegrees = new Uint32Array(nodeCount);
+		for (let i = 0; i < nodeCount; i++) outDegrees[i] = (csr.rowOffsets[i + 1] ?? 0) - (csr.rowOffsets[i] ?? 0);
+		const outDegreesBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, nodeCount), Array.from(outDegrees)).$usage("storage"), "outDegreesBuffer");
+		const ranksBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.f32, nodeCount), Array.from(new Float32Array(nodeCount).fill(1 / nodeCount))).$usage("storage"), "ranksBuffer");
+		const newRanksBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.f32, nodeCount)).$usage("storage"), "newRanksBuffer");
+		for (let iter = 0; iter < iterations; iter++) {
+			dispatchPagerank(root, csrBuffers, ranksBuffer, outDegreesBuffer, newRanksBuffer, nodeCount, damping);
+			const newRanks = await newRanksBuffer.read();
+			ranksBuffer.write(Array.from(newRanks));
+		}
+		const result = await ranksBuffer.read();
+		return new Float32Array(result);
+	};
+	return withBackend({
+		backend: options?.backend,
+		root: options?.root,
+		signal: options?.signal
+	}, cpuFn, gpuFn);
+}
+/**
+* Batch Jaccard similarity for node pairs on GPU.
+*
+* @param graph - Input graph
+* @param pairs - Array of [u, v] node ID pairs
+* @param options - Compute options
+* @returns Jaccard coefficients for each pair
+*/
+async function gpuJaccardBatch(graph, pairs, options) {
+	const pairCount = pairs.length;
+	const { indexMap } = graphToCSR(graph);
+	const cpuFn = () => {
+		const { csr } = graphToCSR(graph);
+		const results = new Float32Array(pairCount);
+		for (let p = 0; p < pairCount; p++) {
+			const pair = pairs[p];
+			if (pair === void 0) continue;
+			const [u, v] = pair;
+			const uIdx = indexMap.nodeToIndex.get(u);
+			const vIdx = indexMap.nodeToIndex.get(v);
+			if (uIdx === void 0 || vIdx === void 0) {
+				results[p] = 0;
+				continue;
+			}
+			const uStart = csr.rowOffsets[uIdx] ?? 0;
+			const uEnd = csr.rowOffsets[uIdx + 1] ?? 0;
+			const vStart = csr.rowOffsets[vIdx] ?? 0;
+			const vEnd = csr.rowOffsets[vIdx + 1] ?? 0;
+			const uNeighbours = new Set(Array.from(csr.colIndices.slice(uStart, uEnd)));
+			const vNeighbours = new Set(Array.from(csr.colIndices.slice(vStart, vEnd)));
+			let intersection = 0;
+			for (const n of uNeighbours) if (vNeighbours.has(n)) intersection++;
+			const union = uNeighbours.size + vNeighbours.size - intersection;
+			results[p] = union > 0 ? intersection / union : 0;
+		}
+		return results;
+	};
+	const gpuFn = async (root) => {
+		const { csr } = graphToCSR(graph);
+		const csrBuffers = csrToTypedBuffers(root, csr);
+		const pairsU = new Uint32Array(pairCount);
+		const pairsV = new Uint32Array(pairCount);
+		for (let i = 0; i < pairCount; i++) {
+			const pair = pairs[i];
+			if (pair === void 0) continue;
+			const uIdx = indexMap.nodeToIndex.get(pair[0]);
+			const vIdx = indexMap.nodeToIndex.get(pair[1]);
+			pairsU[i] = uIdx ?? 0;
+			pairsV[i] = vIdx ?? 0;
+		}
+		const pairsUBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, pairCount), Array.from(pairsU)).$usage("storage"), "pairsUBuffer");
+		const pairsVBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, pairCount), Array.from(pairsV)).$usage("storage"), "pairsVBuffer");
+		const resultsBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.f32, pairCount)).$usage("storage"), "resultsBuffer");
+		dispatchJaccard(root, csrBuffers, pairsUBuffer, pairsVBuffer, resultsBuffer, pairCount);
+		const result = await resultsBuffer.read();
+		return new Float32Array(result);
+	};
+	return withBackend({
+		backend: options?.backend,
+		root: options?.root,
+		signal: options?.signal
+	}, cpuFn, gpuFn);
+}
+/**
+* BFS level assignment from source node on GPU.
+*
+* Note: Full GPU BFS requires atomics not yet available in TypeGPU.
+* This implementation uses CPU for now but maintains the API.
+*
+* @param graph - Input graph
+* @param source - Source node ID
+* @param options - Compute options
+* @returns BFS level for each node (-1 for unreachable)
+*/
+async function gpuBfsLevels(graph, source, options) {
+	const nodeCount = graph.nodeCount;
+	const { indexMap } = graphToCSR(graph);
+	const cpuFn = () => {
+		const { csr } = graphToCSR(graph);
+		const levels = new Int32Array(nodeCount).fill(-1);
+		const visited = new Uint8Array(nodeCount);
+		const sourceIndex = indexMap.nodeToIndex.get(source);
+		if (sourceIndex === void 0) throw new Error(`Source node ${source} not found in graph`);
+		const queue = [sourceIndex];
+		levels[sourceIndex] = 0;
+		visited[sourceIndex] = 1;
+		while (queue.length > 0) {
+			const current = queue.shift();
+			if (current === void 0) break;
+			const currentLevel = levels[current] ?? 0;
+			const start = csr.rowOffsets[current] ?? 0;
+			const end = csr.rowOffsets[current + 1] ?? 0;
+			for (let i = start; i < end; i++) {
+				const neighbour = csr.colIndices[i] ?? 0;
+				if (visited[neighbour] === 0) {
+					visited[neighbour] = 1;
+					levels[neighbour] = currentLevel + 1;
+					queue.push(neighbour);
+				}
+			}
+		}
+		return levels;
+	};
+	const gpuFn = (_root) => {
+		return cpuFn();
+	};
+	return withBackend({
+		backend: options?.backend,
+		root: options?.root,
+		signal: options?.signal
+	}, cpuFn, gpuFn);
+}
+/**
+* Degree histogram and statistics on GPU.
+*
+* @param graph - Input graph
+* @param options - Compute options
+* @returns Degree statistics with histogram
+*/
+async function gpuDegreeHistogram(graph, options) {
+	const nodeCount = graph.nodeCount;
+	const cpuFn = () => {
+		const { csr } = graphToCSR(graph);
+		const degrees = new Uint32Array(nodeCount);
+		for (let i = 0; i < nodeCount; i++) degrees[i] = (csr.rowOffsets[i + 1] ?? 0) - (csr.rowOffsets[i] ?? 0);
+		const max = degrees.length > 0 ? Math.max(...degrees) : 0;
+		const histogram = Array.from({ length: max + 1 }, () => 0);
+		let sum = 0;
+		let min = Infinity;
+		for (const d of degrees) {
+			histogram[d] = (histogram[d] ?? 0) + 1;
+			sum += d;
+			if (d < min) min = d;
+		}
+		if (degrees.length === 0) min = 0;
+		return {
+			min,
+			max,
+			mean: nodeCount > 0 ? sum / nodeCount : 0,
+			histogram
+		};
+	};
+	const gpuFn = async (root) => {
+		const { csr } = graphToCSR(graph);
+		const csrBuffers = csrToTypedBuffers(root, csr);
+		const degreesBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, nodeCount)).$usage("storage"), "degreesBuffer");
+		dispatchDegreeHistogram(root, csrBuffers, degreesBuffer, nodeCount);
+		const degrees = await degreesBuffer.read();
+		const max = degrees.length > 0 ? Math.max(...degrees) : 0;
+		const histogram = Array.from({ length: max + 1 }, () => 0);
+		let sum = 0;
+		let min = Infinity;
+		for (const d of degrees) {
+			histogram[d] = (histogram[d] ?? 0) + 1;
+			sum += d;
+			if (d < min) min = d;
+		}
+		if (degrees.length === 0) min = 0;
+		return {
+			min,
+			max,
+			mean: nodeCount > 0 ? sum / nodeCount : 0,
+			histogram
+		};
+	};
+	return withBackend({
+		backend: options?.backend,
+		root: options?.root,
+		signal: options?.signal
+	}, cpuFn, gpuFn);
+}
+/**
+* Batch MI computation for multiple node pairs on GPU.
+*
+* For Jaccard-family variants, uses the intersection kernel for raw counts
+* then applies the variant-specific formula on CPU.
+*
+* @param graph - Input graph
+* @param pairs - Array of [u, v] node ID pairs
+* @param variant - MI variant to compute (default: jaccard)
+* @param options - Compute options
+* @returns MI scores and raw intersection data for each pair
+*/
+async function gpuMIBatch(graph, pairs, variant = "jaccard", options) {
+	const pairCount = pairs.length;
+	const { csr, indexMap } = graphToCSR(graph);
+	const cpuFn = () => {
+		const indexPairs = [];
+		const validPair = [];
+		for (const pair of pairs) {
+			const uIdx = indexMap.nodeToIndex.get(pair[0]);
+			const vIdx = indexMap.nodeToIndex.get(pair[1]);
+			if (uIdx !== void 0 && vIdx !== void 0) {
+				indexPairs.push([uIdx, vIdx]);
+				validPair.push(true);
+			} else {
+				indexPairs.push([0, 0]);
+				validPair.push(false);
+			}
+		}
+		const { intersections, sizeUs, sizeVs } = intersectionBatch(csr.rowOffsets, csr.colIndices, indexPairs);
+		const scores = new Float32Array(pairCount);
+		for (let i = 0; i < pairCount; i++) {
+			if (validPair[i] !== true) {
+				scores[i] = 0;
+				continue;
+			}
+			const result = {
+				intersection: intersections[i] ?? 0,
+				sizeU: sizeUs[i] ?? 0,
+				sizeV: sizeVs[i] ?? 0
+			};
+			const base = applyMIVariant(result, "jaccard");
+			switch (variant) {
+				case "scale": {
+					const rho = computeGraphDensity(csr);
+					scores[i] = rho > 0 ? base / rho : base;
+					break;
+				}
+				case "skew": {
+					const N = csr.rowOffsets.length - 1;
+					const degU = result.sizeU;
+					const degV = result.sizeV;
+					scores[i] = base * (Math.log(N / (degU + 1)) * Math.log(N / (degV + 1)));
+					break;
+				}
+				case "span": {
+					const clustering = computeClusteringCoefficients(csr);
+					const pair = pairs[i];
+					const u0 = pair ? indexMap.nodeToIndex.get(pair[0]) : void 0;
+					const v0 = pair ? indexMap.nodeToIndex.get(pair[1]) : void 0;
+					const cu = (u0 !== void 0 ? clustering[u0] : void 0) ?? 0;
+					const cv = (v0 !== void 0 ? clustering[v0] : void 0) ?? 0;
+					scores[i] = base * (1 - Math.max(cu, cv));
+					break;
+				}
+				default: scores[i] = applyMIVariant(result, variant);
+			}
+		}
+		return {
+			scores,
+			intersections,
+			sizeUs,
+			sizeVs
+		};
+	};
+	const gpuFn = async (root) => {
+		const csrBuffers = csrToTypedBuffers(root, csr);
+		const uArr = new Uint32Array(pairCount);
+		const vArr = new Uint32Array(pairCount);
+		const validPair = Array.from({ length: pairCount }, () => false);
+		for (let i = 0; i < pairCount; i++) {
+			const p = pairs[i];
+			const uIdxRaw = p ? indexMap.nodeToIndex.get(p[0]) : void 0;
+			const vIdxRaw = p ? indexMap.nodeToIndex.get(p[1]) : void 0;
+			const uIdx = uIdxRaw ?? 0;
+			const vIdx = vIdxRaw ?? 0;
+			if (uIdxRaw !== void 0 && vIdxRaw !== void 0) {
+				uArr[i] = uIdx;
+				vArr[i] = vIdx;
+				validPair[i] = true;
+			} else {
+				uArr[i] = 0;
+				vArr[i] = 0;
+				validPair[i] = false;
+			}
+		}
+		const pairsUBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, pairCount), Array.from(uArr)).$usage("storage"), "pairsUBuffer");
+		const pairsVBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, pairCount), Array.from(vArr)).$usage("storage"), "pairsVBuffer");
+		const intersectionsBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, pairCount)).$usage("storage"), "intersectionsBuffer");
+		const sizeUsBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, pairCount)).$usage("storage"), "sizeUsBuffer");
+		const sizeVsBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, pairCount)).$usage("storage"), "sizeVsBuffer");
+		if (variant === "adamic-adar") {
+			const resultsBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.f32, pairCount)).$usage("storage"), "resultsBuffer");
+			const { dispatchAdamicAdar } = await import("./kernel-CvnRsF7E.js");
+			dispatchAdamicAdar(root, csrBuffers, pairsUBuffer, pairsVBuffer, resultsBuffer, intersectionsBuffer, sizeUsBuffer, sizeVsBuffer, pairCount);
+			const scoresRaw = await resultsBuffer.read();
+			const intersectionsRaw = await intersectionsBuffer.read();
+			const sizeUsRaw = await sizeUsBuffer.read();
+			const sizeVsRaw = await sizeVsBuffer.read();
+			const scores = new Float32Array(scoresRaw);
+			const intersections = new Uint32Array(intersectionsRaw);
+			const sizeUs = new Uint32Array(sizeUsRaw);
+			const sizeVs = new Uint32Array(sizeVsRaw);
+			for (let i = 0; i < pairCount; i++) if (validPair[i] !== true) {
+				scores[i] = 0;
+				intersections[i] = 0;
+				sizeUs[i] = 0;
+				sizeVs[i] = 0;
+			}
+			return {
+				scores,
+				intersections,
+				sizeUs,
+				sizeVs
+			};
+		} else {
+			const { dispatchIntersection } = await import("./kernel-6deK9fh1.js");
+			dispatchIntersection(root, csrBuffers, pairsUBuffer, pairsVBuffer, intersectionsBuffer, sizeUsBuffer, sizeVsBuffer, pairCount);
+			const intersectionsRaw = await intersectionsBuffer.read();
+			const sizeUsRaw = await sizeUsBuffer.read();
+			const sizeVsRaw = await sizeVsBuffer.read();
+			const intersections = new Uint32Array(intersectionsRaw);
+			const sizeUs = new Uint32Array(sizeUsRaw);
+			const sizeVs = new Uint32Array(sizeVsRaw);
+			const scores = new Float32Array(pairCount);
+			if (variant === "scale" || variant === "skew" || variant === "span") {
+				const clustering = variant === "span" ? computeClusteringCoefficients(csr) : void 0;
+				const N = csr.rowOffsets.length - 1;
+				const rho = variant === "scale" ? computeGraphDensity(csr) : void 0;
+				for (let i = 0; i < pairCount; i++) {
+					if (validPair[i] !== true) {
+						scores[i] = 0;
+						continue;
+					}
+					const result = {
+						intersection: intersections[i] ?? 0,
+						sizeU: sizeUs[i] ?? 0,
+						sizeV: sizeVs[i] ?? 0
+					};
+					const base = applyMIVariant(result, "jaccard");
+					switch (variant) {
+						case "scale":
+							if (rho !== void 0 && rho > 0) scores[i] = base / rho;
+							else scores[i] = base;
+							break;
+						case "skew": {
+							const degU = result.sizeU;
+							const degV = result.sizeV;
+							scores[i] = base * (Math.log(N / (degU + 1)) * Math.log(N / (degV + 1)));
+							break;
+						}
+						case "span": {
+							const pair = pairs[i];
+							const uId = pair ? pair[0] : void 0;
+							const vId = pair ? pair[1] : void 0;
+							const uIdx = uId !== void 0 ? indexMap.nodeToIndex.get(uId) : void 0;
+							const vIdx = vId !== void 0 ? indexMap.nodeToIndex.get(vId) : void 0;
+							const cu = uIdx !== void 0 ? clustering?.[uIdx] ?? 0 : 0;
+							const cv = vIdx !== void 0 ? clustering?.[vIdx] ?? 0 : 0;
+							scores[i] = base * (1 - Math.max(cu, cv));
+							break;
+						}
+					}
+				}
+			} else for (let i = 0; i < pairCount; i++) {
+				if (validPair[i] !== true) {
+					scores[i] = 0;
+					continue;
+				}
+				scores[i] = applyMIVariant({
+					intersection: intersections[i] ?? 0,
+					sizeU: sizeUs[i] ?? 0,
+					sizeV: sizeVs[i] ?? 0
+				}, variant);
+			}
+			return {
+				scores,
+				intersections,
+				sizeUs,
+				sizeVs
+			};
+		}
+	};
+	return withBackend({
+		backend: options?.backend,
+		root: options?.root,
+		signal: options?.signal
+	}, cpuFn, gpuFn);
+}
+/**
+* Apply MI variant formula to intersection result.
+*/
+function computeGraphDensity(csr) {
+	const n = csr.rowOffsets.length - 1;
+	const m = csr.colIndices.length;
+	return n > 1 ? 2 * m / (n * (n - 1)) : 0;
+}
+function computeClusteringCoefficients(csr) {
+	const n = csr.rowOffsets.length - 1;
+	const coeffs = new Array(n).fill(0);
+	for (let v = 0; v < n; v++) {
+		const start = csr.rowOffsets[v] ?? 0;
+		const end = csr.rowOffsets[v + 1] ?? 0;
+		const deg = end - start;
+		if (deg < 2) {
+			coeffs[v] = 0;
+			continue;
+		}
+		const neighbours = new Set(csr.colIndices.slice(start, end));
+		let links = 0;
+		for (const u of neighbours) {
+			const uStart = csr.rowOffsets[u] ?? 0;
+			const uEnd = csr.rowOffsets[u + 1] ?? 0;
+			for (let k = uStart; k < uEnd; k++) {
+				const colIdx = csr.colIndices[k] ?? 0;
+				if (neighbours.has(colIdx)) links++;
+			}
+		}
+		coeffs[v] = 2 * links / (deg * (deg - 1));
+	}
+	return coeffs;
+}
+function applyMIVariant(result, variant) {
+	switch (variant) {
+		case "jaccard": return jaccardFromIntersection(result);
+		case "cosine": return cosineFromIntersection(result);
+		case "sorensen": return sorensenDiceFromIntersection(result);
+		case "overlap-coefficient": return overlapFromIntersection(result);
+		case "hub-promoted": return hubPromotedFromIntersection(result);
+		case "resource-allocation": return jaccardFromIntersection(result);
+		case "adamic-adar": return jaccardFromIntersection(result);
+		case "scale":
+		case "skew":
+		case "span":
+		case "etch":
+		case "notch":
+		case "adaptive": return jaccardFromIntersection(result);
+		default: return jaccardFromIntersection(result);
+	}
+}
+/**
+* Assign points to nearest centroids using GPU.
+*
+* For each point, computes distance to all centroids and assigns to nearest.
+* This is the main parallelizable operation in K-means clustering.
+*
+* @param points - Array of 3D points to assign
+* @param centroids - Array of 3D centroid coordinates
+* @param options - Compute options
+* @returns Assignment indices and distances
+*/
+async function gpuKMeansAssign(points, centroids, options) {
+	const pointCount = points.length;
+	const k = centroids.length;
+	const cpuFn = () => {
+		const assignments = new Uint32Array(pointCount);
+		const distances = new Float32Array(pointCount);
+		for (let i = 0; i < pointCount; i++) {
+			const point = points[i];
+			if (point === void 0) {
+				assignments[i] = 0;
+				distances[i] = 0;
+				continue;
+			}
+			const [px, py, pz] = point;
+			let minDist = Infinity;
+			let minIdx = 0;
+			for (let j = 0; j < k; j++) {
+				const centroid = centroids[j];
+				if (centroid === void 0) continue;
+				const [cx, cy, cz] = centroid;
+				const dx = px - cx;
+				const dy = py - cy;
+				const dz = pz - cz;
+				const distSq = dx * dx + dy * dy + dz * dz;
+				if (distSq < minDist) {
+					minDist = distSq;
+					minIdx = j;
+				}
+			}
+			assignments[i] = minIdx;
+			distances[i] = minDist;
+		}
+		return {
+			assignments,
+			distances
+		};
+	};
+	const gpuFn = async (root) => {
+		if (pointCount < 100) return cpuFn();
+		const pointsBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.vec3f, pointCount), Array.from(points)).$usage("storage"), "pointsBuffer");
+		const centroidsBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.vec3f, k), Array.from(centroids)).$usage("storage"), "centroidsBuffer");
+		const assignmentsBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, pointCount)).$usage("storage"), "assignmentsBuffer");
+		const distancesBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.f32, pointCount)).$usage("storage"), "distancesBuffer");
+		const { dispatchKMeansAssign: dispatch } = await import("./kernel-CigCjrts.js");
+		dispatch(root, pointsBuffer, centroidsBuffer, assignmentsBuffer, distancesBuffer, pointCount, k);
+		const assignments = await assignmentsBuffer.read();
+		const distances = await distancesBuffer.read();
+		return {
+			assignments: new Uint32Array(assignments),
+			distances: new Float32Array(distances)
+		};
+	};
+	return withBackend({
+		backend: options?.backend,
+		root: options?.root,
+		signal: options?.signal
+	}, cpuFn, gpuFn);
+}
+//#endregion
+export { gpuMIBatch as a, withBackend as c, detectWebGPU as d, isWebGPUAvailable as f, gpuKMeansAssign as i, GPUNotAvailableError as l, gpuDegreeHistogram as n, gpuPageRank as o, gpuJaccardBatch as r, gpuSpmv as s, gpuBfsLevels as t, assertWebGPUAvailable as u };
+
+//# sourceMappingURL=operations-D9otVlIH.js.map