graphwise 1.0.0 → 1.1.0

package/dist/extraction/motif.d.ts

@@ -0,0 +1,50 @@
+import { NodeId, NodeData, EdgeData, ReadableGraph } from '../graph';
+/**
+ * Result of a motif census operation.
+ */
+export interface MotifCensus {
+    /** Map from motif type identifier to count */
+    readonly counts: ReadonlyMap<string, number>;
+    /** Optional map from motif type to node instances */
+    readonly instances?: ReadonlyMap<string, readonly NodeId[][]>;
+}
+/**
+ * Enumerate motifs of a given size in the graph.
+ *
+ * This function counts all occurrences of each distinct motif type
+ * (isomorphism class) in the graph. For graphs with many nodes,
+ * 4-motif enumeration can be expensive (O(n^4) worst case).
+ *
+ * @param graph - The source graph
+ * @param size - Motif size (3 or 4 nodes)
+ * @returns Motif census with counts per motif type
+ *
+ * @example
+ * ```typescript
+ * // Count all triangles and other 3-node patterns
+ * const census3 = enumerateMotifs(graph, 3);
+ * console.log(`Triangles: ${census3.counts.get('0-1,0-2,1-2')}`);
+ *
+ * // Count 4-node patterns
+ * const census4 = enumerateMotifs(graph, 4);
+ * ```
+ */
+export declare function enumerateMotifs<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, size: 3 | 4): MotifCensus;
+/**
+ * Enumerate motifs with optional instance tracking.
+ *
+ * @param graph - The source graph
+ * @param size - Motif size (3 or 4 nodes)
+ * @param includeInstances - Whether to include node instances
+ * @returns Motif census with counts and optionally instances
+ */
+export declare function enumerateMotifsWithInstances<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, size: 3 | 4, includeInstances: boolean): MotifCensus;
+/**
+ * Get a human-readable name for a motif pattern.
+ *
+ * @param pattern - The canonical pattern string
+ * @param size - Motif size (3 or 4 nodes)
+ * @returns A human-readable name, or the pattern itself if unknown
+ */
+export declare function getMotifName(pattern: string, size: 3 | 4): string;
+//# sourceMappingURL=motif.d.ts.map

package/dist/extraction/motif.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motif.d.ts","sourceRoot":"","sources":["../../src/extraction/motif.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE1E;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,qDAAqD;IACrD,QAAQ,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,CAAC;CAC9D;AA6QD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACrE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,IAAI,EAAE,CAAC,GAAG,CAAC,GACT,WAAW,CAKb;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC3C,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,QAAQ,EAElB,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,IAAI,EAAE,CAAC,GAAG,CAAC,EACX,gBAAgB,EAAE,OAAO,GACvB,WAAW,CAIb;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,MAAM,CAGjE"}

package/dist/extraction/motif.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for motif enumeration.
+ */
+export {};
+//# sourceMappingURL=motif.unit.test.d.ts.map

package/dist/extraction/motif.unit.test.d.ts.map

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

package/dist/extraction/node-filter.d.ts

@@ -0,0 +1,35 @@
+import { NodeData, EdgeData, ReadableGraph } from '../graph';
+import { AdjacencyMapGraph } from '../graph/adjacency-map';
+/**
+ * Options for filtering a subgraph.
+ */
+export interface FilterOptions<N extends NodeData, E extends EdgeData> {
+    /** Predicate to filter nodes. Return true to include the node. */
+    readonly nodePredicate?: (node: N) => boolean;
+    /** Predicate to filter edges. Return true to include the edge. */
+    readonly edgePredicate?: (edge: E) => boolean;
+    /** Whether to remove nodes that become isolated after edge filtering. Default: false. */
+    readonly removeIsolated?: boolean;
+}
+/**
+ * Extract a filtered subgraph based on node and edge predicates.
+ *
+ * Nodes are first filtered by the node predicate (if provided).
+ * Edges are then filtered by the edge predicate (if provided), and only
+ * retained if both endpoints pass the node predicate.
+ *
+ * @param graph - The source graph
+ * @param options - Filter options specifying node/edge predicates
+ * @returns A new graph containing only nodes and edges that pass the predicates
+ *
+ * @example
+ * ```typescript
+ * // Extract subgraph of high-weight nodes
+ * const filtered = filterSubgraph(graph, {
+ *   nodePredicate: (node) => (node.weight ?? 0) > 0.5,
+ *   removeIsolated: true
+ * });
+ * ```
+ */
+export declare function filterSubgraph<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, options?: FilterOptions<N, E>): AdjacencyMapGraph<N, E>;
+//# sourceMappingURL=node-filter.d.ts.map

package/dist/extraction/node-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-filter.d.ts","sourceRoot":"","sources":["../../src/extraction/node-filter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAU,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ;IACpE,kEAAkE;IAClE,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IAC9C,kEAAkE;IAClE,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IAC9C,yFAAyF;IACzF,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACpE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,OAAO,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GAC3B,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,CAiDzB"}

package/dist/extraction/node-filter.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for filtered subgraph extraction.
+ */
+export {};
+//# sourceMappingURL=node-filter.unit.test.d.ts.map

package/dist/extraction/node-filter.unit.test.d.ts.map

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

package/dist/extraction/truss.d.ts

@@ -0,0 +1,41 @@
+import { NodeData, EdgeData, ReadableGraph } from '../graph';
+import { AdjacencyMapGraph } from '../graph/adjacency-map';
+/**
+ * Extract the k-truss of a graph.
+ *
+ * The k-truss is the maximal subgraph where every edge participates in
+ * at least k-2 triangles. This is computed by iteratively removing edges
+ * with fewer than k-2 triangles, then removing isolated nodes.
+ *
+ * Note: K-truss is typically defined for undirected graphs. For directed
+ * graphs, this treats the graph as undirected for triangle counting.
+ *
+ * @param graph - The source graph
+ * @param k - The minimum triangle count threshold (edge must be in >= k-2 triangles)
+ * @returns A new graph containing the k-truss (may be empty)
+ *
+ * @example
+ * ```typescript
+ * // Extract the 3-truss (edges in at least 1 triangle)
+ * const truss3 = extractKTruss(graph, 3);
+ * ```
+ */
+export declare function extractKTruss<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, k: number): AdjacencyMapGraph<N, E>;
+/**
+ * Compute the truss number for each edge.
+ *
+ * The truss number of an edge is the largest k such that the edge
+ * belongs to the k-truss.
+ *
+ * @param graph - The source graph
+ * @returns Map from edge key (canonical "u::v") to truss number
+ *
+ * @example
+ * ```typescript
+ * const trussNumbers = computeTrussNumbers(graph);
+ * const edgeKey = 'A::B'; // where A < B lexicographically
+ * console.log(`Edge A-B is in the ${trussNumbers.get(edgeKey)}-truss`);
+ * ```
+ */
+export declare function computeTrussNumbers<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>): Map<string, number>;
+//# sourceMappingURL=truss.d.ts.map

package/dist/extraction/truss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"truss.d.ts","sourceRoot":"","sources":["../../src/extraction/truss.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAU,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AA8B3D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACnE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,MAAM,GACP,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,CAoIzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACzE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GACxB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAyGrB"}

package/dist/extraction/truss.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for k-truss decomposition.
+ */
+export {};
+//# sourceMappingURL=truss.unit.test.d.ts.map

package/dist/extraction/truss.unit.test.d.ts.map

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

package/dist/gpu/context.d.ts

@@ -0,0 +1,118 @@
+/**
+ * GPU context management for WebGPU compute operations.
+ *
+ * Provides device acquisition, buffer pooling, and shader compilation
+ * with caching for efficient GPU resource management.
+ */
+/**
+ * Options for creating a GPUContext.
+ */
+export interface GPUContextOptions {
+    /** Power preference for GPU adapter */
+    readonly powerPreference?: "low-power" | "high-performance";
+    /** Force create new context even if one exists */
+    readonly forceNew?: boolean;
+}
+/**
+ * Manages GPU device, buffers, and compiled shaders.
+ *
+ * Use the singleton pattern via getGPUContext() for most use cases,
+ * or create separate contexts for isolated GPU resource pools.
+ */
+export declare class GPUContext {
+    private device;
+    private readonly shaderCache;
+    private readonly bufferPool;
+    private readonly destroyedBuffers;
+    /**
+     * Check if this context has an acquired GPU device.
+     */
+    get isReady(): boolean;
+    /**
+     * Get the GPU device, throwing if not acquired.
+     */
+    getDevice(): GPUDevice;
+    /**
+     * Acquire a GPU device from the adapter.
+     *
+     * @param options - Context creation options
+     * @returns true if device was acquired successfully
+     * @throws Error if WebGPU is unavailable or device request fails
+     */
+    acquireDevice(options?: GPUContextOptions): Promise<boolean>;
+    /**
+     * Compile a WGSL shader, using cache if available.
+     *
+     * @param code - WGSL shader code
+     * @param key - Optional cache key (defaults to code hash)
+     * @returns Compiled shader module
+     */
+    compileShader(code: string, key?: string): GPUShaderModule;
+    /**
+     * Create a GPU buffer, optionally reusing from pool.
+     *
+     * @param size - Buffer size in bytes
+     * @param usage - Buffer usage flags
+     * @returns GPU buffer
+     */
+    createBuffer(size: number, usage: GPUBufferUsageFlags): GPUBuffer;
+    /**
+     * Return a buffer to the pool for reuse.
+     *
+     * @param buffer - Buffer to recycle
+     */
+    recycleBuffer(buffer: GPUBuffer): void;
+    /**
+     * Mark a buffer as destroyed (call before GPUBuffer.destroy()).
+     *
+     * @param buffer - Buffer to mark as destroyed
+     */
+    markDestroyed(buffer: GPUBuffer): void;
+    /**
+     * Create a compute pipeline from shader code.
+     *
+     * @param code - WGSL compute shader code
+     * @param entryPoint - Entry point function name
+     * @returns Compute pipeline
+     */
+    createComputePipeline(code: string, entryPoint?: string): GPUComputePipeline;
+    /**
+     * Create a compute pipeline asynchronously (preferred for performance).
+     *
+     * @param code - WGSL compute shader code
+     * @param entryPoint - Entry point function name
+     * @returns Promise resolving to compute pipeline
+     */
+    createComputePipelineAsync(code: string, entryPoint?: string): Promise<GPUComputePipeline>;
+    /**
+     * Clear all cached resources.
+     */
+    clearCache(): void;
+    /**
+     * Destroy the context and release all resources.
+     */
+    destroy(): void;
+    /**
+     * Simple string hash for cache keys.
+     */
+    private hashCode;
+}
+/**
+ * Get or create the default GPU context.
+ *
+ * This is a lazy singleton - the device is not acquired until
+ * acquireDevice() is called.
+ *
+ * @param options - Context creation options
+ * @returns GPU context instance
+ */
+export declare function getGPUContext(options?: GPUContextOptions): GPUContext;
+/**
+ * Create a new isolated GPU context.
+ *
+ * Use this when you need separate resource pools or device management.
+ *
+ * @returns New GPU context instance
+ */
+export declare function createGPUContext(): GPUContext;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/gpu/context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAuBH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,uCAAuC;IACvC,QAAQ,CAAC,eAAe,CAAC,EAAE,WAAW,GAAG,kBAAkB,CAAC;IAC5D,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC5B;AAUD;;;;;GAKG;AACH,qBAAa,UAAU;IACtB,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmC;IAC/D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmB;IAC9C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA4B;IAE7D;;OAEG;IACH,IAAW,OAAO,IAAI,OAAO,CAE5B;IAED;;OAEG;IACI,SAAS,IAAI,SAAS;IAS7B;;;;;;OAMG;IACU,aAAa,CACzB,OAAO,GAAE,iBAAsB,GAC7B,OAAO,CAAC,OAAO,CAAC;IAqDnB;;;;;;OAMG;IACI,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,eAAe;IAejE;;;;;;OAMG;IACI,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,GAAG,SAAS;IAoBxE;;;;OAIG;IACI,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IAO7C;;;;OAIG;IACI,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IAI7C;;;;;;OAMG;IACI,qBAAqB,CAC3B,IAAI,EAAE,MAAM,EACZ,UAAU,SAAS,GACjB,kBAAkB;IAarB;;;;;;OAMG;IACU,0BAA0B,CACtC,IAAI,EAAE,MAAM,EACZ,UAAU,SAAS,GACjB,OAAO,CAAC,kBAAkB,CAAC;IAa9B;;OAEG;IACI,UAAU,IAAI,IAAI;IAQzB;;OAEG;IACI,OAAO,IAAI,IAAI;IAQtB;;OAEG;IACH,OAAO,CAAC,QAAQ;CAQhB;AAKD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,UAAU,CAKrE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,IAAI,UAAU,CAE7C"}

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

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

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

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

package/dist/gpu/csr.d.ts

@@ -0,0 +1,97 @@
+import { NodeId, Direction, NodeData, EdgeData } from '../graph/types';
+import { ReadableGraph } from '../graph';
+/**
+ * CSR matrix representation of a graph adjacency structure.
+ *
+ * The rowOffsets array has length nodeCount + 1, where rowOffsets[i]
+ * gives the start index in colIndices for node i's neighbours.
+ * The neighbours of node i are colIndices[rowOffsets[i] : rowOffsets[i+1]].
+ */
+export interface CSRMatrix {
+    /** Row offsets array (length: nodeCount + 1) */
+    readonly rowOffsets: Uint32Array;
+    /** Column indices array (length: edgeCount for directed, 2*edgeCount for undirected) */
+    readonly colIndices: Uint32Array;
+    /** Optional edge weights aligned with colIndices */
+    readonly values?: Float32Array;
+    /** Number of nodes in the graph */
+    readonly nodeCount: number;
+    /** Number of directed edges (undirected edges counted once) */
+    readonly edgeCount: number;
+}
+/**
+ * Mapping from node IDs to CSR indices.
+ *
+ * Required because CSR uses dense integer indices while graphs
+ * may use arbitrary string identifiers.
+ */
+export interface CSRIndexMap {
+    /** Map from NodeId to CSR row index */
+    readonly nodeToIndex: ReadonlyMap<NodeId, number>;
+    /** Map from CSR row index to NodeId */
+    readonly indexToNode: readonly NodeId[];
+}
+/**
+ * Combined CSR matrix with index mapping.
+ */
+export interface CSRGraph {
+    readonly csr: CSRMatrix;
+    readonly indexMap: CSRIndexMap;
+}
+/**
+ * Group of GPU buffers holding a CSR matrix.
+ *
+ * Each buffer is created with appropriate usage flags for compute operations.
+ */
+export interface GPUBufferGroup {
+    /** Buffer containing rowOffsets data */
+    readonly rowOffsets: GPUBuffer;
+    /** Buffer containing colIndices data */
+    readonly colIndices: GPUBuffer;
+    /** Buffer containing values data (optional) */
+    readonly values?: GPUBuffer;
+    /** Number of nodes */
+    readonly nodeCount: number;
+    /** Number of edges */
+    readonly edgeCount: number;
+}
+/**
+ * Convert a ReadableGraph to CSR format.
+ *
+ * For undirected graphs, each edge is stored twice (once in each direction).
+ * For directed graphs, edges are stored in the out-direction by default.
+ *
+ * @param graph - The graph to convert
+ * @param direction - Edge direction to include (default: 'out' for directed, 'both' for undirected)
+ * @returns CSR representation with index mapping
+ */
+export declare function graphToCSR<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, direction?: Direction): CSRGraph;
+/**
+ * Create GPU buffers from a CSR matrix.
+ *
+ * Buffers are created with:
+ * - rowOffsets/colIndices: STORAGE | COPY_DST
+ * - values: STORAGE | COPY_DST (if present)
+ *
+ * @param device - GPU device to create buffers on
+ * @param csr - CSR matrix to upload
+ * @returns GPU buffer group
+ */
+export declare function csrToGPUBuffers(device: GPUDevice, csr: CSRMatrix): GPUBufferGroup;
+/**
+ * Create a result buffer for reading compute output.
+ *
+ * @param device - GPU device
+ * @param byteLength - Size of the buffer in bytes
+ * @returns GPU buffer configured for map reading
+ */
+export declare function createResultBuffer(device: GPUDevice, byteLength: number): GPUBuffer;
+/**
+ * Read data from a GPU buffer to CPU.
+ *
+ * @param device - GPU device
+ * @param buffer - Buffer to read from
+ * @returns ArrayBuffer containing the buffer data
+ */
+export declare function readBufferToCPU(device: GPUDevice, buffer: GPUBuffer): Promise<ArrayBuffer>;
+//# sourceMappingURL=csr.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"csr.d.ts","sourceRoot":"","sources":["../../src/gpu/csr.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACzB,gDAAgD;IAChD,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;IACjC,wFAAwF;IACxF,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;IACjC,oDAAoD;IACpD,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B,mCAAmC;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC3B,uCAAuC;IACvC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,uCAAuC;IACvC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;CAC/B;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC9B,wCAAwC;IACxC,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,wCAAwC;IACxC,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;IAC5B,sBAAsB;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,sBAAsB;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAChE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,SAAS,GAAE,SAA2C,GACpD,QAAQ,CA0EV;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,SAAS,EACjB,GAAG,EAAE,SAAS,GACZ,cAAc,CAmChB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,GAChB,SAAS,CAQX;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CACpC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,SAAS,GACf,OAAO,CAAC,WAAW,CAAC,CAKtB"}

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

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

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

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

package/dist/gpu/detect.d.ts

@@ -0,0 +1,25 @@
+import { GPUDetectionResult } from './types';
+/**
+ * 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
+ */
+export declare function detectWebGPU(): GPUDetectionResult;
+/**
+ * Check if WebGPU is available (convenience function).
+ *
+ * @returns true if WebGPU is available, false otherwise
+ */
+export declare function isWebGPUAvailable(): boolean;
+/**
+ * Assert that WebGPU is available, throwing an error if not.
+ *
+ * @throws Error if WebGPU is not available
+ */
+export declare function assertWebGPUAvailable(): void;
+//# sourceMappingURL=detect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../src/gpu/detect.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,IAAI,kBAAkB,CA4BjD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAO5C"}

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

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

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

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

package/dist/gpu/index.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_gpu = require("../gpu-BJRVYBjx.cjs");
+exports.GPUContext = require_gpu.GPUContext;
+exports.csrToGPUBuffers = require_gpu.csrToGPUBuffers;
+exports.detectWebGPU = require_gpu.detectWebGPU;
+exports.graphToCSR = require_gpu.graphToCSR;

package/dist/gpu/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WebGPU compute backend for graph algorithms.
+ *
+ * @module gpu - WebGPU compute utilities
+ */
+export type { ComputeBackend, GPUNotAvailableError, ComputeResult, GPUDetectionResult, } from './types';
+export type { CSRMatrix, GPUBufferGroup } from './csr';
+export { detectWebGPU } from './detect';
+export { GPUContext } from './context';
+export { graphToCSR, csrToGPUBuffers } from './csr';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gpu/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACX,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,kBAAkB,GAClB,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC"}

package/dist/gpu/index.js

@@ -0,0 +1,2 @@
+import { i as detectWebGPU, n as graphToCSR, r as GPUContext, t as csrToGPUBuffers } from "../gpu-BveuXugy.js";
+export { GPUContext, csrToGPUBuffers, detectWebGPU, graphToCSR };

package/dist/gpu/types.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Type definitions for the WebGPU compute backend.
+ *
+ * These types define the backend selection options and result types
+ * for GPU-accelerated graph operations.
+ */
+/**
+ * Backend selection for compute operations.
+ *
+ * - 'cpu': Synchronous CPU implementation (default, always available)
+ * - 'gpu': Async GPU implementation (throws if WebGPU unavailable)
+ * - 'auto': Async, detect WebGPU at runtime, fall back to CPU silently
+ */
+export type ComputeBackend = "auto" | "gpu" | "cpu";
+/**
+ * Result of WebGPU availability detection.
+ */
+export interface GPUDetectionResult {
+    /** Whether WebGPU is available in the current environment */
+    readonly available: boolean;
+    /** Human-readable reason if unavailable */
+    readonly reason?: string;
+}
+/**
+ * Error thrown when GPU backend is requested but unavailable.
+ */
+export declare class GPUNotAvailableError extends Error {
+    constructor(reason: string);
+}
+/**
+ * Result wrapper for GPU operations that may fall back to CPU.
+ */
+export interface ComputeResult<T> {
+    /** The computed result value */
+    readonly value: T;
+    /** Which backend was actually used */
+    readonly backend: "gpu" | "cpu";
+    /** Time taken in milliseconds (optional, for profiling) */
+    readonly elapsedMs?: number;
+}
+/**
+ * Configuration options for GPU compute operations.
+ */
+export interface GPUComputeOptions {
+    /** Backend selection: 'auto', 'gpu', or 'cpu' */
+    readonly backend?: ComputeBackend;
+    /** Optional GPU device to reuse (avoids device acquisition overhead) */
+    readonly device?: GPUDevice;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +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"}