graphwise 1.8.1 → 1.9.0

package/dist/gpu/kernels/jaccard/logic.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Pure CPU implementation of batch Jaccard similarity.
+ *
+ * Computes Jaccard coefficient for multiple node pairs in parallel:
+ *   J(u, v) = |N(u) ∩ N(v)| / |N(u) ∪ N(v)|
+ *
+ * This is the CPU reference implementation extracted from the WGSL kernel.
+ * Uses binary search optimisation: iterate smaller neighbourhood, search in larger.
+ *
+ * @module gpu/kernels/jaccard/logic
+ */
+/**
+ * Binary search in a sorted subarray of colIndices.
+ *
+ * @param colIndices - CSR column indices array (must be sorted per row)
+ * @param start - Start index (inclusive)
+ * @param end - End index (exclusive)
+ * @param target - Value to search for
+ * @returns true if target is found between colIndices[start] and colIndices[end-1]
+ */
+export declare function binarySearch(colIndices: Uint32Array, start: number, end: number, target: number): boolean;
+/**
+ * Compute Jaccard similarity for a single pair of nodes in CSR format.
+ *
+ * Neighbours must be sorted (CSR guarantees this from graphToCSR).
+ *
+ * @param rowOffsets - CSR row offset array
+ * @param colIndices - CSR column indices array
+ * @param u - First node index
+ * @param v - Second node index
+ * @returns Jaccard coefficient in [0, 1]
+ */
+export declare function jaccardPair(rowOffsets: Uint32Array, colIndices: Uint32Array, u: number, v: number): number;
+/**
+ * Batch Jaccard similarity for multiple node pairs.
+ *
+ * @param rowOffsets - CSR row offset array
+ * @param colIndices - CSR column indices array
+ * @param pairs - Array of [u, v] node index pairs
+ * @returns Float32Array of Jaccard coefficients, one per pair
+ */
+export declare function jaccardBatch(rowOffsets: Uint32Array, colIndices: Uint32Array, pairs: readonly (readonly [number, number])[]): Float32Array;
+//# sourceMappingURL=logic.d.ts.map

package/dist/gpu/kernels/jaccard/logic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/jaccard/logic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC3B,UAAU,EAAE,WAAW,EACvB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GACZ,OAAO,CAkBT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAC1B,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACP,MAAM,CAsCR;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC3B,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,KAAK,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,GAC3C,YAAY,CAYd"}

package/dist/gpu/kernels/jaccard/logic.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logic.unit.test.d.ts.map

package/dist/gpu/kernels/jaccard/logic.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.unit.test.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/jaccard/logic.unit.test.ts"],"names":[],"mappings":""}

package/dist/gpu/kernels/pagerank/kernel.d.ts

@@ -0,0 +1,44 @@
+import { d, StorageFlag, TgpuBuffer } from 'typegpu';
+import { TypedBufferGroup } from '../../csr';
+import { GraphwiseGPURoot } from '../../root';
+/**
+ * Bind group layout for PageRank kernel.
+ */
+declare const PageRankLayout: import('typegpu').TgpuBindGroupLayout<{
+    rowOffsets: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    colIndices: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    ranks: {
+        storage: (elementCount: number) => d.WgslArray<d.F32>;
+    };
+    outDegrees: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    newRanks: {
+        storage: (elementCount: number) => d.WgslArray<d.F32>;
+        access: "mutable";
+    };
+    nodeCount: {
+        uniform: d.U32;
+    };
+    damping: {
+        uniform: d.F32;
+    };
+}>;
+/**
+ * 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)
+ */
+export declare function dispatchPagerank(root: GraphwiseGPURoot, csrBuffers: TypedBufferGroup, ranks: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.f32>>> & StorageFlag, outDegrees: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag, newRanks: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.f32>>> & StorageFlag, nodeCount: number, damping: number): void;
+export { PageRankLayout };
+//# sourceMappingURL=kernel.d.ts.map

package/dist/gpu/kernels/pagerank/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/pagerank/kernel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAa,EAAE,CAAC,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;GAEG;AACH,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;EAQlB,CAAC;AA8BH;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,WAAW,EAC3E,UAAU,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GACjE,WAAW,EACZ,QAAQ,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAC/D,WAAW,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACb,IAAI,CAiBN;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/gpu/kernels/pagerank/logic.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pure CPU implementation of PageRank power iteration.
+ *
+ * Computes one iteration of PageRank:
+ *   r(v) = (1 - d)/N + d * sum(r(u) / deg_out(u)) for u -> v
+ *
+ * This is the CPU reference implementation extracted from the WGSL kernel.
+ * The CSR stores the transpose graph (in-edges as rows).
+ *
+ * @module gpu/kernels/pagerank/logic
+ */
+/**
+ * Compute one node's PageRank contribution from its incoming neighbours.
+ *
+ * @param rowOffsets - CSR row offset array (transpose graph: in-edges)
+ * @param colIndices - CSR column indices array
+ * @param ranks - Current rank values
+ * @param outDegrees - Out-degree for each node
+ * @param node - Node index to compute
+ * @param damping - Damping factor (typically 0.85)
+ * @param n - Total number of nodes
+ * @returns New rank for this node
+ */
+export declare function pagerankNode(rowOffsets: Uint32Array, colIndices: Uint32Array, ranks: Float32Array, outDegrees: Uint32Array, node: number, damping: number, n: number): number;
+/**
+ * Full PageRank power iteration: compute new ranks from current ranks.
+ *
+ * @param rowOffsets - CSR row offset array (transpose graph)
+ * @param colIndices - CSR column indices array
+ * @param ranks - Current rank values (will be read, not modified)
+ * @param outDegrees - Out-degree for each node
+ * @param damping - Damping factor (typically 0.85)
+ * @param n - Total number of nodes
+ * @returns New rank values after one iteration
+ */
+export declare function pagerankIteration(rowOffsets: Uint32Array, colIndices: Uint32Array, ranks: Float32Array, outDegrees: Uint32Array, damping: number, n: number): Float32Array;
+/**
+ * Run multiple PageRank iterations until convergence or maxIterations.
+ *
+ * @param rowOffsets - CSR row offset array (transpose graph)
+ * @param colIndices - CSR column indices array
+ * @param outDegrees - Out-degree for each node
+ * @param n - Total number of nodes
+ * @param damping - Damping factor (default: 0.85)
+ * @param maxIterations - Maximum iterations (default: 100)
+ * @param tolerance - Convergence tolerance (default: 1e-6)
+ * @returns Final rank values
+ */
+export declare function pagerank(rowOffsets: Uint32Array, colIndices: Uint32Array, outDegrees: Uint32Array, n: number, damping?: number, maxIterations?: number, tolerance?: number): Float32Array;
+//# sourceMappingURL=logic.d.ts.map

package/dist/gpu/kernels/pagerank/logic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/pagerank/logic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAWH;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC3B,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,KAAK,EAAE,YAAY,EACnB,UAAU,EAAE,WAAW,EACvB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,CAAC,EAAE,MAAM,GACP,MAAM,CAgBR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAChC,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,KAAK,EAAE,YAAY,EACnB,UAAU,EAAE,WAAW,EACvB,OAAO,EAAE,MAAM,EACf,CAAC,EAAE,MAAM,GACP,YAAY,CAgBd;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CACvB,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,CAAC,EAAE,MAAM,EACT,OAAO,GAAE,MAAwB,EACjC,aAAa,GAAE,MAA+B,EAC9C,SAAS,GAAE,MAA0B,GACnC,YAAY,CA4Bd"}

package/dist/gpu/kernels/pagerank/logic.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logic.unit.test.d.ts.map

package/dist/gpu/kernels/pagerank/logic.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.unit.test.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/pagerank/logic.unit.test.ts"],"names":[],"mappings":""}

package/dist/gpu/kernels/spmv/kernel.d.ts

@@ -0,0 +1,43 @@
+import { d, StorageFlag, TgpuBuffer } from 'typegpu';
+import { TypedBufferGroup } from '../../csr';
+import { GraphwiseGPURoot } from '../../root';
+/**
+ * Bind group layout for SpMV kernel.
+ */
+declare const SpMVLayout: import('typegpu').TgpuBindGroupLayout<{
+    rowOffsets: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    colIndices: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    values: {
+        storage: (elementCount: number) => d.WgslArray<d.F32>;
+    };
+    x: {
+        storage: (elementCount: number) => d.WgslArray<d.F32>;
+    };
+    y: {
+        storage: (elementCount: number) => d.WgslArray<d.F32>;
+        access: "mutable";
+    };
+    nodeCount: {
+        uniform: d.U32;
+    };
+    hasValues: {
+        uniform: d.U32;
+    };
+}>;
+/**
+ * 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
+ */
+export declare function dispatchSpmv(root: GraphwiseGPURoot, csrBuffers: TypedBufferGroup, x: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.f32>>> & StorageFlag, y: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.f32>>> & StorageFlag, nodeCount: number, hasValues: boolean): void;
+export { SpMVLayout };
+//# sourceMappingURL=kernel.d.ts.map

package/dist/gpu/kernels/spmv/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/spmv/kernel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAa,EAAE,CAAC,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;GAEG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;EAQd,CAAC;AAyBH;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC3B,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,gBAAgB,EAC5B,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,WAAW,EACvE,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,WAAW,EACvE,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,OAAO,GAChB,IAAI,CA8BN;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/gpu/kernels/spmv/logic.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pure CPU implementation of Sparse Matrix-Vector Multiplication (SpMV).
+ *
+ * Computes y = A * x where A is a sparse matrix in CSR format.
+ * This is the CPU reference implementation extracted from the WGSL kernel.
+ *
+ * @module gpu/kernels/spmv/logic
+ */
+/**
+ * Compute one row of SpMV: dot product of CSR row with vector x.
+ *
+ * @param rowOffsets - CSR row offset array
+ * @param colIndices - CSR column indices array
+ * @param values - Optional edge weights (undefined for unweighted)
+ * @param x - Input vector
+ * @param row - Row index to compute
+ * @returns Dot product for this row
+ */
+export declare function spmvRow(rowOffsets: Uint32Array, colIndices: Uint32Array, values: Float32Array | undefined, x: Float32Array, row: number): number;
+/**
+ * Full SpMV: y = A * x where A is in CSR format.
+ *
+ * @param rowOffsets - CSR row offset array (length: nodeCount + 1)
+ * @param colIndices - CSR column indices array
+ * @param values - Optional edge weights (undefined for unweighted)
+ * @param x - Input vector (length: nodeCount)
+ * @param nodeCount - Number of nodes/rows
+ * @returns Output vector y (length: nodeCount)
+ */
+export declare function spmv(rowOffsets: Uint32Array, colIndices: Uint32Array, values: Float32Array | undefined, x: Float32Array, nodeCount: number): Float32Array;
+//# sourceMappingURL=logic.d.ts.map

package/dist/gpu/kernels/spmv/logic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/spmv/logic.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CACtB,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,CAAC,EAAE,YAAY,EACf,GAAG,EAAE,MAAM,GACT,MAAM,CAaR;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CACnB,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,CAAC,EAAE,YAAY,EACf,SAAS,EAAE,MAAM,GACf,YAAY,CAQd"}

package/dist/gpu/kernels/spmv/logic.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logic.unit.test.d.ts.map

package/dist/gpu/kernels/spmv/logic.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.unit.test.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/spmv/logic.unit.test.ts"],"names":[],"mappings":""}

package/dist/gpu/operations.d.ts

@@ -0,0 +1,76 @@
+import { NodeData, EdgeData, NodeId, ReadableGraph } from '../graph';
+import { ComputeResult, GPUComputeOptions } from './types';
+/**
+ * Degree statistics from histogram computation.
+ */
+export interface DegreeStats {
+    /** Minimum degree in the graph */
+    readonly min: number;
+    /** Maximum degree in the graph */
+    readonly max: number;
+    /** Average degree */
+    readonly mean: number;
+    /** Histogram of degree frequencies (index = degree, value = count) */
+    readonly histogram: readonly number[];
+}
+/**
+ * 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
+ */
+export declare function gpuSpmv<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, x: Float32Array, options?: GPUComputeOptions & {
+    signal?: AbortSignal;
+}): Promise<ComputeResult<Float32Array>>;
+/**
+ * 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
+ */
+export declare function gpuPageRank<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, options?: GPUComputeOptions & {
+    damping?: number;
+    iterations?: number;
+    signal?: AbortSignal;
+}): Promise<ComputeResult<Float32Array>>;
+/**
+ * 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
+ */
+export declare function gpuJaccardBatch<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, pairs: readonly [NodeId, NodeId][], options?: GPUComputeOptions & {
+    signal?: AbortSignal;
+}): Promise<ComputeResult<Float32Array>>;
+/**
+ * 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)
+ */
+export declare function gpuBfsLevels<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, source: NodeId, options?: GPUComputeOptions & {
+    signal?: AbortSignal;
+}): Promise<ComputeResult<Int32Array>>;
+/**
+ * Degree histogram and statistics on GPU.
+ *
+ * @param graph - Input graph
+ * @param options - Compute options
+ * @returns Degree statistics with histogram
+ */
+export declare function gpuDegreeHistogram<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, options?: GPUComputeOptions & {
+    signal?: AbortSignal;
+}): Promise<ComputeResult<DegreeStats>>;
+//# sourceMappingURL=operations.d.ts.map

package/dist/gpu/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../src/gpu/operations.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAUhE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,kCAAkC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,kCAAkC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qBAAqB;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED;;;;;;;;;GASG;AACH,wBAAsB,OAAO,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACnE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,YAAY,EACf,OAAO,CAAC,EAAE,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACpD,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CA8DtC;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACvE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GAAG;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB,GACC,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CA+FtC;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC3E,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAClC,OAAO,CAAC,EAAE,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACpD,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CA8FtC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,YAAY,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACxE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACpD,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAsDpC;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACvC,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,QAAQ,EAElB,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACpD,OAAO,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CA+ErC"}

package/dist/gpu/operations.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for GPU operations.
+ */
+export {};
+//# sourceMappingURL=operations.unit.test.d.ts.map

package/dist/gpu/operations.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.unit.test.d.ts","sourceRoot":"","sources":["../../src/gpu/operations.unit.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/gpu/root.d.ts

@@ -0,0 +1,53 @@
+import { tgpu } from 'typegpu';
+/**
+ * Options for initialising the GPU root.
+ */
+export interface InitGPUOptions {
+    /** Power preference for GPU adapter */
+    readonly powerPreference?: "low-power" | "high-performance";
+}
+/**
+ * The TypeGPU root instance used for GPU operations.
+ * Re-exports TgpuRoot from TypeGPU for convenience.
+ */
+export type GraphwiseGPURoot = Awaited<ReturnType<typeof tgpu.init>>;
+/**
+ * Initialise a TypeGPU root for GPU compute operations.
+ *
+ * This wraps tgpu.init() with WebGPU availability checking and
+ * simplified options.
+ *
+ * @param options - Initialisation options
+ * @returns Promise resolving to a TypeGPU root instance
+ * @throws Error if WebGPU is unavailable or device request fails
+ *
+ * @example
+ * ```typescript
+ * import { initGPU } from "graphwise/gpu";
+ *
+ * const root = await initGPU();
+ * // Use root for GPU operations...
+ * root.destroy();
+ * ```
+ */
+export declare function initGPU(options?: InitGPUOptions): Promise<GraphwiseGPURoot>;
+/**
+ * Create a TypeGPU root from an existing GPU device.
+ *
+ * Use this when you already have a GPUDevice and want to wrap it
+ * with TypeGPU functionality.
+ *
+ * @param device - Existing GPU device
+ * @returns TypeGPU root instance
+ *
+ * @example
+ * ```typescript
+ * import { initGPUFromDevice } from "graphwise/gpu";
+ *
+ * const adapter = await navigator.gpu.requestAdapter();
+ * const device = await adapter.requestDevice();
+ * const root = initGPUFromDevice(device);
+ * ```
+ */
+export declare function initGPUFromDevice(device: GPUDevice): GraphwiseGPURoot;
+//# sourceMappingURL=root.d.ts.map

package/dist/gpu/root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../src/gpu/root.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAG/B;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,uCAAuC;IACvC,QAAQ,CAAC,eAAe,CAAC,EAAE,WAAW,GAAG,kBAAkB,CAAC;CAC5D;AAED;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;AAErE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,OAAO,CAC5B,OAAO,GAAE,cAAmB,GAC1B,OAAO,CAAC,gBAAgB,CAAC,CAe3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,gBAAgB,CAErE"}

package/dist/gpu/root.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=root.unit.test.d.ts.map

package/dist/gpu/root.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.unit.test.d.ts","sourceRoot":"","sources":["../../src/gpu/root.unit.test.ts"],"names":[],"mappings":""}

package/dist/gpu/types.d.ts

@@ -1,9 +1,4 @@
-/**
- * Type definitions for the WebGPU compute backend.
- *
- * These types define the backend selection options and result types
- * for GPU-accelerated graph operations.
- */
+import { GraphwiseGPURoot } from './root';
 /**
  * Backend selection for compute operations.
  *
@@ -44,7 +39,7 @@ export interface ComputeResult<T> {
 export interface GPUComputeOptions {
     /** Backend selection: 'auto', 'gpu', or 'cpu' */
     readonly backend?: ComputeBackend;
-    /** Optional GPU device to reuse (avoids device acquisition overhead) */
-    readonly device?: GPUDevice;
+    /** Optional TypeGPU root to reuse (avoids device acquisition overhead) */
+    readonly root?: GraphwiseGPURoot;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/gpu/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/gpu/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;gBAC3B,MAAM,EAAE,MAAM;CAIjC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC;IAC/B,gCAAgC;IAChC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,sCAAsC;IACtC,QAAQ,CAAC,OAAO,EAAE,KAAK,GAAG,KAAK,CAAC;IAChC,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,iDAAiD;IACjD,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAClC,wEAAwE;IACxE,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;CAC5B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/gpu/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;gBAC3B,MAAM,EAAE,MAAM;CAIjC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC;IAC/B,gCAAgC;IAChC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,sCAAsC;IACtC,QAAQ,CAAC,OAAO,EAAE,KAAK,GAAG,KAAK,CAAC;IAChC,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,iDAAiD;IACjD,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAClC,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC;CACjC"}