graphwise 1.9.1 → 1.11.0

package/dist/kernel-6deK9fh1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel-6deK9fh1.js","names":[],"sources":["../src/gpu/kernels/intersection/kernel.ts"],"sourcesContent":["/**\n * TypeGPU compute kernel for batch neighbourhood intersection.\n *\n * Computes intersection size and neighbourhood sizes for multiple node pairs.\n * One thread per pair: iterates the smaller neighbourhood and binary-searches the other.\n *\n * @module gpu/kernels/intersection/kernel\n */\n\nimport tgpu, { d, type StorageFlag, type TgpuBuffer } from \"typegpu\";\nimport type { TypedBufferGroup } from \"../../csr\";\nimport type { GraphwiseGPURoot } from \"../../root\";\n\n/**\n * Bind group layout for Intersection kernel.\n */\nconst IntersectionLayout = tgpu.bindGroupLayout({\n\trowOffsets: { storage: d.arrayOf(d.u32) },\n\tcolIndices: { storage: d.arrayOf(d.u32) },\n\tpairsU: { storage: d.arrayOf(d.u32) },\n\tpairsV: { storage: d.arrayOf(d.u32) },\n\tintersections: { storage: d.arrayOf(d.u32), access: \"mutable\" },\n\tsizeUs: { storage: d.arrayOf(d.u32), access: \"mutable\" },\n\tsizeVs: { storage: d.arrayOf(d.u32), access: \"mutable\" },\n\tpairCount: { uniform: d.u32 },\n});\n\n/**\n * Intersection compute pipeline: one thread per pair.\n *\n * For each pair (u, v):\n *  - Count intersection by iterating smaller neighbourhood\n *  - Binary search in larger neighbourhood\n *  - Write intersection, sizeU, sizeV to output buffers\n */\nconst intersectionPipeline = (pairIdx: number): void => {\n\t\"use gpu\";\n\tconst u = IntersectionLayout.$.pairsU[pairIdx] ?? 0;\n\tconst v = IntersectionLayout.$.pairsV[pairIdx] ?? 0;\n\n\tconst uStart = IntersectionLayout.$.rowOffsets[u] ?? 0;\n\tconst uEnd = IntersectionLayout.$.rowOffsets[u + 1] ?? 0;\n\tconst vStart = IntersectionLayout.$.rowOffsets[v] ?? 0;\n\tconst vEnd = IntersectionLayout.$.rowOffsets[v + 1] ?? 0;\n\n\tconst degU = uEnd - uStart;\n\tconst degV = vEnd - vStart;\n\n\t// Write sizes first\n\tIntersectionLayout.$.sizeUs[pairIdx] = degU;\n\tIntersectionLayout.$.sizeVs[pairIdx] = degV;\n\n\t// Empty neighbourhoods → intersection = 0\n\tif (degU === 0 || degV === 0) {\n\t\tIntersectionLayout.$.intersections[pairIdx] = 0;\n\t\treturn;\n\t}\n\n\tlet intersection = 0;\n\n\tif (degU <= degV) {\n\t\t// Iterate u's neighbours, search in v's\n\t\tfor (let i = uStart; i < uEnd; i = i + 1) {\n\t\t\tconst neighbour = IntersectionLayout.$.colIndices[i] ?? 0;\n\t\t\t// Binary search in v's neighbourhood\n\t\t\tlet lo = vStart;\n\t\t\tlet hi = vEnd;\n\t\t\twhile (lo < hi) {\n\t\t\t\tconst mid = lo + (hi - lo) / 2;\n\t\t\t\tconst midVal = IntersectionLayout.$.colIndices[mid] ?? 0;\n\t\t\t\tif (midVal === neighbour) {\n\t\t\t\t\tintersection = intersection + 1;\n\t\t\t\t\tlo = hi; // break\n\t\t\t\t} else if (midVal < neighbour) {\n\t\t\t\t\tlo = mid + 1;\n\t\t\t\t} else {\n\t\t\t\t\thi = mid;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// Iterate v's neighbours, search in u's\n\t\tfor (let i = vStart; i < vEnd; i = i + 1) {\n\t\t\tconst neighbour = IntersectionLayout.$.colIndices[i] ?? 0;\n\t\t\t// Binary search in u's neighbourhood\n\t\t\tlet lo = uStart;\n\t\t\tlet hi = uEnd;\n\t\t\twhile (lo < hi) {\n\t\t\t\tconst mid = lo + (hi - lo) / 2;\n\t\t\t\tconst midVal = IntersectionLayout.$.colIndices[mid] ?? 0;\n\t\t\t\tif (midVal === neighbour) {\n\t\t\t\t\tintersection = intersection + 1;\n\t\t\t\t\tlo = hi; // break\n\t\t\t\t} else if (midVal < neighbour) {\n\t\t\t\t\tlo = mid + 1;\n\t\t\t\t} else {\n\t\t\t\t\thi = mid;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tIntersectionLayout.$.intersections[pairIdx] = intersection;\n};\n\n/**\n * Dispatch batch intersection on GPU.\n *\n * @param root - TypeGPU root instance\n * @param csrBuffers - CSR matrix as typed buffers\n * @param pairsU - First node of each pair (u32 array)\n * @param pairsV - Second node of each pair (u32 array)\n * @param intersections - Output intersections (u32 array, mutable)\n * @param sizeUs - Output sizeU per pair (u32 array, mutable)\n * @param sizeVs - Output sizeV per pair (u32 array, mutable)\n * @param pairCount - Number of pairs to compute\n */\nexport function dispatchIntersection(\n\troot: GraphwiseGPURoot,\n\tcsrBuffers: TypedBufferGroup,\n\tpairsU: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag,\n\tpairsV: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag,\n\tintersections: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> &\n\t\tStorageFlag,\n\tsizeUs: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag,\n\tsizeVs: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag,\n\tpairCount: number,\n): void {\n\tconst pipeline = root.createGuardedComputePipeline(intersectionPipeline);\n\n\tconst pairCountBuffer = root.createBuffer(d.u32, pairCount).$usage(\"uniform\");\n\n\tconst bindGroup = root.createBindGroup(IntersectionLayout, {\n\t\trowOffsets: csrBuffers.rowOffsets,\n\t\tcolIndices: csrBuffers.colIndices,\n\t\tpairsU,\n\t\tpairsV,\n\t\tintersections,\n\t\tsizeUs,\n\t\tsizeVs,\n\t\tpairCount: pairCountBuffer,\n\t});\n\n\tpipeline.with(bindGroup).dispatchThreads(pairCount);\n}\n\nexport { IntersectionLayout };\n"],"mappings":"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"}

package/dist/kernel-CXeGBH3s.cjs

@@ -0,0 +1,467 @@
+const require_typegpu = require("./typegpu-Dq5FfUB8.cjs");
+//#region src/gpu/kernels/kmeans/kernel.ts
+/**
+* TypeGPU compute kernel for K-means assignment step.
+*
+* Assigns each point to its nearest centroid in parallel.
+* This is the most parallelizable operation in K-means clustering.
+*
+* @module gpu/kernels/kmeans/kernel
+*/
+/**
+* Bind group layout for K-means assignment kernel.
+*/
+var KMeansAssignLayout = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(require_typegpu.src_default.bindGroupLayout({
+	points: { storage: require_typegpu.data_exports.arrayOf(require_typegpu.data_exports.arrayOf(require_typegpu.data_exports.f32, 3)) },
+	centroids: { storage: require_typegpu.data_exports.arrayOf(require_typegpu.data_exports.arrayOf(require_typegpu.data_exports.f32, 3)) },
+	assignments: {
+		storage: require_typegpu.data_exports.arrayOf(require_typegpu.data_exports.u32),
+		access: "mutable"
+	},
+	distances: {
+		storage: require_typegpu.data_exports.arrayOf(require_typegpu.data_exports.f32),
+		access: "mutable"
+	},
+	pointCount: { uniform: require_typegpu.data_exports.u32 },
+	k: { uniform: require_typegpu.data_exports.u32 }
+}), "KMeansAssignLayout");
+/**
+* K-means assignment compute pipeline: one thread per point.
+*
+* For each point:
+*   - Compute distance to all centroids
+*   - Assign to nearest centroid
+*   - Store squared distance
+*/
+var kmeansAssignPipeline = (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pointIdx) => {
+	"use gpu";
+	if (pointIdx >= KMeansAssignLayout.$.pointCount) return;
+	const point = KMeansAssignLayout.$.points[pointIdx];
+	if (point === void 0) {
+		KMeansAssignLayout.$.assignments[pointIdx] = 0;
+		KMeansAssignLayout.$.distances[pointIdx] = 0;
+		return;
+	}
+	const px = point[0] ?? 0;
+	const py = point[1] ?? 0;
+	const pz = point[2] ?? 0;
+	let minDist = 1e9;
+	let minIdx = 0;
+	for (let c = 0; c < KMeansAssignLayout.$.k; c = __tsover_add(c, 1)) {
+		const centroid = KMeansAssignLayout.$.centroids[c];
+		if (centroid === void 0) continue;
+		const cx = centroid[0] ?? 0;
+		const cy = centroid[1] ?? 0;
+		const cz = centroid[2] ?? 0;
+		const dx = __tsover_sub(px, cx);
+		const dy = __tsover_sub(py, cy);
+		const dz = __tsover_sub(pz, cz);
+		const distSq = __tsover_add(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy)), __tsover_mul(dz, dz));
+		if (distSq < minDist) {
+			minDist = distSq;
+			minIdx = c;
+		}
+	}
+	KMeansAssignLayout.$.assignments[pointIdx] = minIdx;
+	KMeansAssignLayout.$.distances[pointIdx] = minDist;
+}), {
+	v: 1,
+	name: "kmeansAssignPipeline",
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "pointIdx"
+		}],
+		"body": [0, [
+			[
+				11,
+				[
+					1,
+					"pointIdx",
+					">=",
+					[
+						7,
+						[
+							7,
+							"KMeansAssignLayout",
+							"$"
+						],
+						"pointCount"
+					]
+				],
+				[10]
+			],
+			[
+				13,
+				"point",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"KMeansAssignLayout",
+							"$"
+						],
+						"points"
+					],
+					"pointIdx"
+				]
+			],
+			[
+				11,
+				[
+					1,
+					"point",
+					"===",
+					"undefined"
+				],
+				[0, [
+					[
+						2,
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"KMeansAssignLayout",
+									"$"
+								],
+								"assignments"
+							],
+							"pointIdx"
+						],
+						"=",
+						[5, "0"]
+					],
+					[
+						2,
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"KMeansAssignLayout",
+									"$"
+								],
+								"distances"
+							],
+							"pointIdx"
+						],
+						"=",
+						[5, "0"]
+					],
+					[10]
+				]]
+			],
+			[
+				13,
+				"px",
+				[
+					3,
+					[
+						8,
+						"point",
+						[5, "0"]
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"py",
+				[
+					3,
+					[
+						8,
+						"point",
+						[5, "1"]
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				13,
+				"pz",
+				[
+					3,
+					[
+						8,
+						"point",
+						[5, "2"]
+					],
+					"??",
+					[5, "0"]
+				]
+			],
+			[
+				12,
+				"minDist",
+				[5, "1000000000"]
+			],
+			[
+				12,
+				"minIdx",
+				[5, "0"]
+			],
+			[
+				14,
+				[
+					12,
+					"c",
+					[5, "0"]
+				],
+				[
+					1,
+					"c",
+					"<",
+					[
+						7,
+						[
+							7,
+							"KMeansAssignLayout",
+							"$"
+						],
+						"k"
+					]
+				],
+				[
+					2,
+					"c",
+					"=",
+					[
+						1,
+						"c",
+						"+",
+						[5, "1"]
+					]
+				],
+				[0, [
+					[
+						13,
+						"centroid",
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"KMeansAssignLayout",
+									"$"
+								],
+								"centroids"
+							],
+							"c"
+						]
+					],
+					[
+						11,
+						[
+							1,
+							"centroid",
+							"===",
+							"undefined"
+						],
+						[16]
+					],
+					[
+						13,
+						"cx",
+						[
+							3,
+							[
+								8,
+								"centroid",
+								[5, "0"]
+							],
+							"??",
+							[5, "0"]
+						]
+					],
+					[
+						13,
+						"cy",
+						[
+							3,
+							[
+								8,
+								"centroid",
+								[5, "1"]
+							],
+							"??",
+							[5, "0"]
+						]
+					],
+					[
+						13,
+						"cz",
+						[
+							3,
+							[
+								8,
+								"centroid",
+								[5, "2"]
+							],
+							"??",
+							[5, "0"]
+						]
+					],
+					[
+						13,
+						"dx",
+						[
+							1,
+							"px",
+							"-",
+							"cx"
+						]
+					],
+					[
+						13,
+						"dy",
+						[
+							1,
+							"py",
+							"-",
+							"cy"
+						]
+					],
+					[
+						13,
+						"dz",
+						[
+							1,
+							"pz",
+							"-",
+							"cz"
+						]
+					],
+					[
+						13,
+						"distSq",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"dx",
+									"*",
+									"dx"
+								],
+								"+",
+								[
+									1,
+									"dy",
+									"*",
+									"dy"
+								]
+							],
+							"+",
+							[
+								1,
+								"dz",
+								"*",
+								"dz"
+							]
+						]
+					],
+					[
+						11,
+						[
+							1,
+							"distSq",
+							"<",
+							"minDist"
+						],
+						[0, [[
+							2,
+							"minDist",
+							"=",
+							"distSq"
+						], [
+							2,
+							"minIdx",
+							"=",
+							"c"
+						]]]
+					]
+				]]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"KMeansAssignLayout",
+							"$"
+						],
+						"assignments"
+					],
+					"pointIdx"
+				],
+				"=",
+				"minIdx"
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"KMeansAssignLayout",
+							"$"
+						],
+						"distances"
+					],
+					"pointIdx"
+				],
+				"=",
+				"minDist"
+			]
+		]],
+		"externalNames": ["KMeansAssignLayout", "undefined"]
+	},
+	externals: () => ({
+		KMeansAssignLayout,
+		undefined: void 0
+	})
+}) && $.f)({});
+/**
+* Dispatch K-means assignment on GPU.
+*
+* @param root - TypeGPU root
+* @param pointsBuffer - Buffer of 3D points
+* @param centroidsBuffer - Buffer of centroids
+* @param assignmentsBuffer - Output buffer for assignments
+* @param distancesBuffer - Output buffer for distances
+* @param pointCount - Number of points
+* @param k - Number of centroids
+*/
+function dispatchKMeansAssign(root, pointsBuffer, centroidsBuffer, assignmentsBuffer, distancesBuffer, pointCount, k) {
+	const pipeline = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createGuardedComputePipeline(kmeansAssignPipeline), "pipeline");
+	const pairCountBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(require_typegpu.data_exports.u32, pointCount).$usage("uniform"), "pairCountBuffer");
+	const kBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(require_typegpu.data_exports.u32, k).$usage("uniform"), "kBuffer");
+	const bindGroup = root.createBindGroup(KMeansAssignLayout, {
+		points: pointsBuffer,
+		centroids: centroidsBuffer,
+		assignments: assignmentsBuffer,
+		distances: distancesBuffer,
+		pointCount: pairCountBuffer,
+		k: kBuffer
+	});
+	pipeline.with(bindGroup).dispatchThreads(pointCount);
+}
+//#endregion
+exports.dispatchKMeansAssign = dispatchKMeansAssign;
+
+//# sourceMappingURL=kernel-CXeGBH3s.cjs.map

package/dist/kernel-CXeGBH3s.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel-CXeGBH3s.cjs","names":[],"sources":["../src/gpu/kernels/kmeans/kernel.ts"],"sourcesContent":["/**\n * TypeGPU compute kernel for K-means assignment step.\n *\n * Assigns each point to its nearest centroid in parallel.\n * This is the most parallelizable operation in K-means clustering.\n *\n * @module gpu/kernels/kmeans/kernel\n */\n\nimport tgpu, { d } from \"typegpu\";\nimport type { GraphwiseGPURoot } from \"../../root\";\n\n/**\n * K-means assignment kernel buffers.\n *\n * Buffer types are complex TypeGPU types that are difficult to express in TypeScript.\n * Using `any` here is intentional to avoid verbose generic constraints.\n */\nexport interface KMeansAssignBuffers {\n\t/** Points buffer (3D vectors) */\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\treadonly pointsBuffer: any;\n\t/** Centroids buffer (3D vectors) */\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\treadonly centroidsBuffer: any;\n\t/** Assignments output buffer (cluster indices) */\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\treadonly assignmentsBuffer: any;\n\t/** Distances output buffer (distances to assigned centroid) */\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\treadonly distancesBuffer: any;\n}\n\n/**\n * Bind group layout for K-means assignment kernel.\n */\nconst KMeansAssignLayout = tgpu.bindGroupLayout({\n\tpoints: { storage: d.arrayOf(d.arrayOf(d.f32, 3)) }, // 3D points for GRASP\n\tcentroids: { storage: d.arrayOf(d.arrayOf(d.f32, 3)) },\n\tassignments: { storage: d.arrayOf(d.u32), access: \"mutable\" },\n\tdistances: { storage: d.arrayOf(d.f32), access: \"mutable\" },\n\tpointCount: { uniform: d.u32 },\n\tk: { uniform: d.u32 },\n});\n\n/**\n * K-means assignment compute pipeline: one thread per point.\n *\n * For each point:\n *   - Compute distance to all centroids\n *   - Assign to nearest centroid\n *   - Store squared distance\n */\nconst kmeansAssignPipeline = (pointIdx: number): void => {\n\t\"use gpu\";\n\n\tif (pointIdx >= KMeansAssignLayout.$.pointCount) return;\n\n\t// Load point coordinates\n\tconst point = KMeansAssignLayout.$.points[pointIdx];\n\tif (point === undefined) {\n\t\tKMeansAssignLayout.$.assignments[pointIdx] = 0;\n\t\tKMeansAssignLayout.$.distances[pointIdx] = 0;\n\t\treturn;\n\t}\n\n\tconst px = point[0] ?? 0;\n\tconst py = point[1] ?? 0;\n\tconst pz = point[2] ?? 0;\n\n\t// Find nearest centroid\n\tlet minDist = 1000000000;\n\tlet minIdx = 0;\n\n\tfor (let c = 0; c < KMeansAssignLayout.$.k; c = c + 1) {\n\t\tconst centroid = KMeansAssignLayout.$.centroids[c];\n\t\tif (centroid === undefined) continue;\n\n\t\tconst cx = centroid[0] ?? 0;\n\t\tconst cy = centroid[1] ?? 0;\n\t\tconst cz = centroid[2] ?? 0;\n\n\t\tconst dx = px - cx;\n\t\tconst dy = py - cy;\n\t\tconst dz = pz - cz;\n\t\tconst distSq = dx * dx + dy * dy + dz * dz;\n\n\t\tif (distSq < minDist) {\n\t\t\tminDist = distSq;\n\t\t\tminIdx = c;\n\t\t}\n\t}\n\n\tKMeansAssignLayout.$.assignments[pointIdx] = minIdx;\n\tKMeansAssignLayout.$.distances[pointIdx] = minDist;\n};\n\n/**\n * Dispatch K-means assignment on GPU.\n *\n * @param root - TypeGPU root\n * @param pointsBuffer - Buffer of 3D points\n * @param centroidsBuffer - Buffer of centroids\n * @param assignmentsBuffer - Output buffer for assignments\n * @param distancesBuffer - Output buffer for distances\n * @param pointCount - Number of points\n * @param k - Number of centroids\n */\nexport function dispatchKMeansAssign(\n\troot: GraphwiseGPURoot,\n\t// TypeGPU buffer types are complex and not easily expressible in TypeScript\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\tpointsBuffer: any,\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\tcentroidsBuffer: any,\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\tassignmentsBuffer: any,\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\tdistancesBuffer: any,\n\tpointCount: number,\n\tk: number,\n): void {\n\t// TypeGPU kernel function with \"use gpu\" directive\n\n\tconst pipeline = root.createGuardedComputePipeline(\n\t\t// eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any\n\t\tkmeansAssignPipeline as any,\n\t);\n\n\tconst pairCountBuffer = root\n\t\t.createBuffer(d.u32, pointCount)\n\t\t.$usage(\"uniform\");\n\tconst kBuffer = root.createBuffer(d.u32, k).$usage(\"uniform\");\n\n\tconst bindGroup = root.createBindGroup(KMeansAssignLayout, {\n\t\tpoints: pointsBuffer,\n\t\tcentroids: centroidsBuffer,\n\t\tassignments: assignmentsBuffer,\n\t\tdistances: distancesBuffer,\n\t\tpointCount: pairCountBuffer,\n\t\tk: kBuffer,\n\t});\n\n\tpipeline.with(bindGroup).dispatchThreads(pointCount);\n}\n\n/**\n * Create buffers for K-means assignment.\n */\nexport function createKMeansAssignBuffers(\n\troot: GraphwiseGPURoot,\n\tpoints: readonly (readonly [number, number, number])[],\n\tcentroids: readonly (readonly [number, number, number])[],\n): KMeansAssignBuffers {\n\tconst pointCount = points.length;\n\tconst k = centroids.length;\n\n\t// Convert readonly arrays to mutable for TypeGPU buffer creation\n\n\tconst pointsBuffer = root\n\t\t.createBuffer(\n\t\t\td.arrayOf(d.vec3f, pointCount),\n\t\t\t// TypeGPU type constraints are complex; TypedArrays are compatible with buffer initialization\n\t\t\t// eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any\n\t\t\tArray.from(points) as any,\n\t\t)\n\t\t.$usage(\"storage\");\n\n\tconst centroidsBuffer = root\n\t\t.createBuffer(\n\t\t\td.arrayOf(d.vec3f, k),\n\t\t\t// eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any\n\t\t\tArray.from(centroids) as any,\n\t\t)\n\t\t.$usage(\"storage\");\n\n\tconst assignmentsBuffer = root\n\t\t.createBuffer(d.arrayOf(d.u32, pointCount))\n\t\t.$usage(\"storage\");\n\n\tconst distancesBuffer = root\n\t\t.createBuffer(d.arrayOf(d.f32, pointCount))\n\t\t.$usage(\"storage\");\n\n\treturn {\n\t\tpointsBuffer,\n\t\tcentroidsBuffer,\n\t\tassignmentsBuffer,\n\t\tdistancesBuffer,\n\t};\n}\n"],"mappings":"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"}