nano-pow 1.2.2 → 1.2.4

package/dist/global.min.js

@@ -606,7 +606,7 @@ var NanoPowGpu = class _NanoPowGpu {
     do {
       const random = Math.floor(Math.random() * 4294967295);
       const seed = BigInt(random) << 32n | BigInt(random);
-      const data = await this.#dispatch(seed, hash, threshold, 255);
+      const data = await this.#dispatch(seed, hash, threshold, 1024);
       nonce = data.getBigUint64(0, true);
       this.#busy = !data.getUint32(8);
     } while (this.#busy);
@@ -668,7 +668,7 @@ try {
 }
 var NanoPow = isGpuSupported ? NanoPowGpu : isGlSupported ? NanoPowGl : null;
 
-// dist/global.js
+// src/global.ts
 globalThis.NanoPow ??= NanoPow;
 globalThis.NanoPowGl ??= NanoPowGl;
 globalThis.NanoPowGpu ??= NanoPowGpu;

package/dist/main.min.js

@@ -606,7 +606,7 @@ var NanoPowGpu = class _NanoPowGpu {
     do {
       const random = Math.floor(Math.random() * 4294967295);
       const seed = BigInt(random) << 32n | BigInt(random);
-      const data = await this.#dispatch(seed, hash, threshold, 255);
+      const data = await this.#dispatch(seed, hash, threshold, 1024);
       nonce = data.getBigUint64(0, true);
       this.#busy = !data.getUint32(8);
     } while (this.#busy);
@@ -668,7 +668,7 @@ try {
 }
 var NanoPow = isGpuSupported ? NanoPowGpu : isGlSupported ? NanoPowGl : null;
 
-// dist/main.js
+// src/main.ts
 var main_default = NanoPow;
 export {
   NanoPow,

package/dist/types.d.ts

@@ -0,0 +1,53 @@
+import "@webgpu/types"
+
+export declare const NanoPowGlFragmentShader: string
+export declare const NanoPowGlVertexShader: string
+export declare const NanoPowGpuComputeShader: any
+
+declare const NanoPow: typeof NanoPowGl | typeof NanoPowGpu | null
+
+export declare class NanoPowGl {
+	#private
+	/** Compile */
+	static init (): Promise<void>
+	/**
+	* Finds a nonce that satisfies the Nano proof-of-work requirements.
+	*
+	* @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
+	* @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
+	*/
+	static search (hash: string, threshold?: number): Promise<string>
+	/**
+	* Validates that a nonce satisfies Nano proof-of-work requirements.
+	*
+	* @param {string} work - Hexadecimal proof-of-work value to validate
+	* @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
+	* @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
+	*/
+	static validate (work: string, hash: string, threshold?: number): Promise<boolean>
+}
+
+/**
+* Nano proof-of-work using WebGPU.
+*/
+export declare class NanoPowGpu {
+	#private
+	static init (): Promise<void>
+	static setup (): void
+	static reset (): void
+	/**
+	* Finds a nonce that satisfies the Nano proof-of-work requirements.
+	*
+	* @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
+	* @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
+	*/
+	static search (hash: string, threshold?: number): Promise<string>
+	/**
+	* Validates that a nonce satisfies Nano proof-of-work requirements.
+	*
+	* @param {string} work - Hexadecimal proof-of-work value to validate
+	* @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
+	* @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
+	*/
+	static validate (work: string, hash: string, threshold?: number): Promise<boolean>
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nano-pow",
-	"version": "1.2.2",
+	"version": "1.2.4",
 	"description": "Proof-of-work generation and validation with WebGPU/WebGL for Nano cryptocurrency.",
 	"keywords": [
 		"nemo",
@@ -40,11 +40,7 @@
 		"url": "git+https://zoso.dev/nano-pow.git"
 	},
 	"scripts": {
-		"build": "rm -rf dist && tsc && node esbuild.mjs"
-	},
-	"imports": {
-		"#classes": "./src/classes/index.js",
-		"#shaders": "./src/shaders/index.js"
+		"build": "rm -rf types && tsc && node esbuild.mjs && cp types.d.ts dist"
 	},
 	"devDependencies": {
 		"@types/node": "^22.10.5",
@@ -55,7 +51,10 @@
 		"typescript": "^5.7.3"
 	},
 	"type": "module",
-	"exports": "./dist/main.js",
-	"types": "dist/main.d.ts",
+	"exports": [
+		"./dist/main.min.js",
+		"./dist/types.d.ts"
+	],
+	"types": "dist/types.d.ts",
 	"unpkg": "dist/main.min.js"
 }

package/dist/classes/gl.d.ts

@@ -1,20 +0,0 @@
-export declare class NanoPowGl {
-    #private;
-    /** Compile */
-    static init(): Promise<void>;
-    /**
-    * Finds a nonce that satisfies the Nano proof-of-work requirements.
-    *
-    * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-    * @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
-    */
-    static search(hash: string, threshold?: number): Promise<string>;
-    /**
-    * Validates that a nonce satisfies Nano proof-of-work requirements.
-    *
-    * @param {string} work - Hexadecimal proof-of-work value to validate
-    * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-    * @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
-    */
-    static validate(work: string, hash: string, threshold?: number): Promise<boolean>;
-}

package/dist/classes/gl.js

@@ -1,232 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-FileContributor: Ben Green <ben@latenightsketches.com>
-// SPDX-License-Identifier: GPL-3.0-or-later AND MIT
-import { NanoPowGlFragmentShader, NanoPowGlVertexShader } from '#shaders';
-export class NanoPowGl {
-    /** Used to set canvas size. Must be a multiple of 256. */
-    static #WORKLOAD = 256 * Math.max(1, Math.floor(navigator.hardwareConcurrency));
-    static #hexify(arr) {
-        let out = '';
-        for (let i = arr.length - 1; i >= 0; i--) {
-            out += arr[i].toString(16).padStart(2, '0');
-        }
-        return out;
-    }
-    static #gl;
-    static #program;
-    static #vertexShader;
-    static #fragmentShader;
-    static #positionBuffer;
-    static #uvBuffer;
-    static #uboBuffer;
-    static #workBuffer;
-    static #query;
-    static #pixels;
-    /**Vertex Positions, 2 triangles */
-    static #positions = new Float32Array([
-        -1, -1, 0, -1, 1, 0, 1, 1, 0,
-        1, -1, 0, 1, 1, 0, -1, -1, 0
-    ]);
-    /** Texture Positions */
-    static #uvPosArray = new Float32Array([
-        1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1
-    ]);
-    /** Compile */
-    static async init() {
-        this.#gl = new OffscreenCanvas(this.#WORKLOAD, this.#WORKLOAD).getContext('webgl2');
-        if (this.#gl == null)
-            throw new Error('WebGL 2 is required');
-        this.#gl.clearColor(0, 0, 0, 1);
-        this.#program = this.#gl.createProgram();
-        if (this.#program == null)
-            throw new Error('Failed to create shader program');
-        this.#vertexShader = this.#gl.createShader(this.#gl.VERTEX_SHADER);
-        if (this.#vertexShader == null)
-            throw new Error('Failed to create vertex shader');
-        this.#gl.shaderSource(this.#vertexShader, NanoPowGlVertexShader);
-        this.#gl.compileShader(this.#vertexShader);
-        if (!this.#gl.getShaderParameter(this.#vertexShader, this.#gl.COMPILE_STATUS))
-            throw new Error(this.#gl.getShaderInfoLog(this.#vertexShader) ?? `Failed to compile vertex shader`);
-        this.#fragmentShader = this.#gl.createShader(this.#gl.FRAGMENT_SHADER);
-        if (this.#fragmentShader == null)
-            throw new Error('Failed to create fragment shader');
-        this.#gl.shaderSource(this.#fragmentShader, NanoPowGlFragmentShader);
-        this.#gl.compileShader(this.#fragmentShader);
-        if (!this.#gl.getShaderParameter(this.#fragmentShader, this.#gl.COMPILE_STATUS))
-            throw new Error(this.#gl.getShaderInfoLog(this.#fragmentShader) ?? `Failed to compile fragment shader`);
-        this.#gl.attachShader(this.#program, this.#vertexShader);
-        this.#gl.attachShader(this.#program, this.#fragmentShader);
-        this.#gl.linkProgram(this.#program);
-        if (!this.#gl.getProgramParameter(this.#program, this.#gl.LINK_STATUS))
-            throw new Error(this.#gl.getProgramInfoLog(this.#program) ?? `Failed to link program`);
-        /** Construct simple 2D geometry */
-        this.#gl.useProgram(this.#program);
-        const triangleArray = this.#gl.createVertexArray();
-        this.#gl.bindVertexArray(triangleArray);
-        this.#positionBuffer = this.#gl.createBuffer();
-        this.#gl.bindBuffer(this.#gl.ARRAY_BUFFER, this.#positionBuffer);
-        this.#gl.bufferData(this.#gl.ARRAY_BUFFER, this.#positions, this.#gl.STATIC_DRAW);
-        this.#gl.vertexAttribPointer(0, 3, this.#gl.FLOAT, false, 0, 0);
-        this.#gl.enableVertexAttribArray(0);
-        this.#uvBuffer = this.#gl.createBuffer();
-        this.#gl.bindBuffer(this.#gl.ARRAY_BUFFER, this.#uvBuffer);
-        this.#gl.bufferData(this.#gl.ARRAY_BUFFER, this.#uvPosArray, this.#gl.STATIC_DRAW);
-        this.#gl.vertexAttribPointer(1, 2, this.#gl.FLOAT, false, 0, 0);
-        this.#gl.enableVertexAttribArray(1);
-        this.#uboBuffer = this.#gl.createBuffer();
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, this.#uboBuffer);
-        this.#gl.bufferData(this.#gl.UNIFORM_BUFFER, 144, this.#gl.DYNAMIC_DRAW);
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, null);
-        this.#gl.bindBufferBase(this.#gl.UNIFORM_BUFFER, 0, this.#uboBuffer);
-        this.#gl.uniformBlockBinding(this.#program, this.#gl.getUniformBlockIndex(this.#program, 'UBO'), 0);
-        this.#workBuffer = this.#gl.createBuffer();
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, this.#workBuffer);
-        this.#gl.bufferData(this.#gl.UNIFORM_BUFFER, 32, this.#gl.STREAM_DRAW);
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, null);
-        this.#gl.bindBufferBase(this.#gl.UNIFORM_BUFFER, 1, this.#workBuffer);
-        this.#gl.uniformBlockBinding(this.#program, this.#gl.getUniformBlockIndex(this.#program, 'WORK'), 1);
-        this.#pixels = new Uint8Array(this.#gl.drawingBufferWidth * this.#gl.drawingBufferHeight * 4);
-        this.#query = this.#gl.createQuery();
-    }
-    static #draw(work) {
-        if (this.#gl == null || this.#query == null)
-            throw new Error('WebGL 2 is required to draw and query pixels');
-        if (this.#workBuffer == null)
-            throw new Error('Work buffer is required to draw');
-        this.#gl.clear(this.#gl.COLOR_BUFFER_BIT);
-        /** Upload work buffer */
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, this.#workBuffer);
-        this.#gl.bufferSubData(this.#gl.UNIFORM_BUFFER, 0, Uint32Array.from(work));
-        this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, null);
-        this.#gl.beginQuery(this.#gl.ANY_SAMPLES_PASSED_CONSERVATIVE, this.#query);
-        this.#gl.drawArrays(this.#gl.TRIANGLES, 0, 6);
-        this.#gl.endQuery(this.#gl.ANY_SAMPLES_PASSED_CONSERVATIVE);
-    }
-    static async #checkQueryResult() {
-        if (this.#gl == null || this.#query == null)
-            throw new Error('WebGL 2 is required to check query results');
-        if (this.#gl.getQueryParameter(this.#query, this.#gl.QUERY_RESULT_AVAILABLE)) {
-            return !!(this.#gl.getQueryParameter(this.#query, this.#gl.QUERY_RESULT));
-        }
-        /** Query result not yet available, check again in the next frame */
-        return new Promise((resolve, reject) => {
-            try {
-                requestAnimationFrame(async () => {
-                    const result = await NanoPowGl.#checkQueryResult();
-                    resolve(result);
-                });
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
-    }
-    /**
-    * Reads pixels into the work buffer, checks every 4th pixel for the 'found'
-    * byte, converts the subsequent 3 pixels with the nonce byte values to a hex
-    * string, and returns the result.
-    *
-    * @param work - Buffer with the original random nonce value
-    * @returns Nonce as an 8-byte (16-char) hexadecimal string
-    */
-    static #readResult(work) {
-        if (this.#gl == null)
-            throw new Error('WebGL 2 is required to read pixels');
-        this.#gl.readPixels(0, 0, this.#gl.drawingBufferWidth, this.#gl.drawingBufferHeight, this.#gl.RGBA, this.#gl.UNSIGNED_BYTE, this.#pixels);
-        for (let i = 0; i < this.#pixels.length; i += 4) {
-            if (this.#pixels[i] !== 0) {
-                /** Return the work value with the custom bits */
-                const hex = this.#hexify(work.subarray(4, 8)) + this.#hexify([
-                    this.#pixels[i + 2],
-                    this.#pixels[i + 3],
-                    work[2] ^ (this.#pixels[i] - 1),
-                    work[3] ^ (this.#pixels[i + 1] - 1)
-                ]);
-                return hex;
-            }
-        }
-        throw new Error('Query reported result but nonce value not found');
-    }
-    /**
-    * Finds a nonce that satisfies the Nano proof-of-work requirements.
-    *
-    * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-    * @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
-    */
-    static async search(hash, threshold = 0xfffffff8) {
-        if (NanoPowGl.#gl == null)
-            throw new Error('WebGL 2 is required');
-        if (!/^[A-Fa-f0-9]{64}$/.test(hash))
-            throw new Error(`Invalid hash ${hash}`);
-        if (typeof threshold !== 'number')
-            throw new TypeError(`Invalid threshold ${threshold}`);
-        if (this.#gl == null)
-            throw new Error('WebGL 2 is required');
-        /** Set up uniform buffer object */
-        const uboView = new DataView(new ArrayBuffer(144));
-        for (let i = 0; i < 64; i += 8) {
-            const uint32 = hash.slice(i, i + 8);
-            uboView.setUint32(i * 2, parseInt(uint32, 16));
-        }
-        uboView.setUint32(128, threshold, true);
-        uboView.setFloat32(132, NanoPowGl.#WORKLOAD - 1, true);
-        NanoPowGl.#gl.bindBuffer(NanoPowGl.#gl.UNIFORM_BUFFER, NanoPowGl.#uboBuffer);
-        NanoPowGl.#gl.bufferSubData(NanoPowGl.#gl.UNIFORM_BUFFER, 0, uboView);
-        NanoPowGl.#gl.bindBuffer(NanoPowGl.#gl.UNIFORM_BUFFER, null);
-        /** Start drawing to calculate one nonce per pixel */
-        let nonce = null;
-        const seed = new Uint8Array(8);
-        while (nonce == null) {
-            crypto.getRandomValues(seed);
-            this.#draw(seed);
-            const found = await this.#checkQueryResult();
-            if (found) {
-                nonce = this.#readResult(seed);
-            }
-        }
-        return nonce;
-    }
-    /**
-    * Validates that a nonce satisfies Nano proof-of-work requirements.
-    *
-    * @param {string} work - Hexadecimal proof-of-work value to validate
-    * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-    * @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
-    */
-    static async validate(work, hash, threshold = 0xfffffff8) {
-        if (NanoPowGl.#gl == null)
-            throw new Error('WebGL 2 is required');
-        if (!/^[A-Fa-f0-9]{16}$/.test(work))
-            throw new Error(`Invalid work ${work}`);
-        if (!/^[A-Fa-f0-9]{64}$/.test(hash))
-            throw new Error(`Invalid hash ${hash}`);
-        if (typeof threshold !== 'number')
-            throw new TypeError(`Invalid threshold ${threshold}`);
-        if (this.#gl == null)
-            throw new Error('WebGL 2 is required');
-        /** Set up uniform buffer object */
-        const uboView = new DataView(new ArrayBuffer(144));
-        for (let i = 0; i < 64; i += 8) {
-            const uint32 = hash.slice(i, i + 8);
-            uboView.setUint32(i * 2, parseInt(uint32, 16));
-        }
-        uboView.setUint32(128, threshold, true);
-        uboView.setFloat32(132, NanoPowGl.#WORKLOAD - 1, true);
-        NanoPowGl.#gl.bindBuffer(NanoPowGl.#gl.UNIFORM_BUFFER, NanoPowGl.#uboBuffer);
-        NanoPowGl.#gl.bufferSubData(NanoPowGl.#gl.UNIFORM_BUFFER, 0, uboView);
-        NanoPowGl.#gl.bindBuffer(NanoPowGl.#gl.UNIFORM_BUFFER, null);
-        /** Start drawing to calculate one nonce per pixel */
-        let nonce = null;
-        const data = new DataView(new ArrayBuffer(8));
-        data.setBigUint64(0, BigInt(`0x${work}`), true);
-        const seed = new Uint8Array(data.buffer);
-        this.#draw(seed);
-        const found = await this.#checkQueryResult();
-        if (found) {
-            nonce = this.#readResult(seed);
-        }
-        if (found && nonce !== work)
-            throw new Error(`Nonce found but does not match work`);
-        return found;
-    }
-}

package/dist/classes/gpu.d.ts

@@ -1,24 +0,0 @@
-/**
-* Nano proof-of-work using WebGPU.
-*/
-export declare class NanoPowGpu {
-    #private;
-    static init(): Promise<void>;
-    static setup(): void;
-    static reset(): void;
-    /**
-    * Finds a nonce that satisfies the Nano proof-of-work requirements.
-    *
-    * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-    * @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
-    */
-    static search(hash: string, threshold?: number): Promise<string>;
-    /**
-    * Validates that a nonce satisfies Nano proof-of-work requirements.
-    *
-    * @param {string} work - Hexadecimal proof-of-work value to validate
-    * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-    * @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
-    */
-    static validate(work: string, hash: string, threshold?: number): Promise<boolean>;
-}

package/dist/classes/gpu.js

@@ -1,236 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-/// <reference types="@webgpu/types" />
-import { NanoPowGpuComputeShader } from '#shaders';
-/**
-* Nano proof-of-work using WebGPU.
-*/
-export class NanoPowGpu {
-    // Initialize WebGPU
-    static #busy = false;
-    static #device = null;
-    static #uboBuffer;
-    static #gpuBuffer;
-    static #cpuBuffer;
-    static #bindGroupLayout;
-    static #pipeline;
-    // Initialize WebGPU
-    static async init() {
-        if (this.#busy)
-            return;
-        this.#busy = true;
-        // Request device and adapter
-        if (navigator.gpu == null)
-            throw new Error('WebGPU is not supported in this browser.');
-        try {
-            const adapter = await navigator.gpu.requestAdapter();
-            if (adapter == null)
-                throw new Error('WebGPU adapter refused by browser.');
-            const device = await adapter.requestDevice();
-            if (!(device instanceof GPUDevice))
-                throw new Error('WebGPU device failed to load.');
-            device.lost.then(this.reset);
-            this.#device = device;
-            this.setup();
-        }
-        catch (err) {
-            throw new Error(`WebGPU initialization failed. ${err}`);
-        }
-        finally {
-            this.#busy = false;
-        }
-    }
-    static setup() {
-        if (this.#device == null)
-            throw new Error(`WebGPU device failed to load.`);
-        // Create buffers for writing GPU calculations and reading from Javascript
-        this.#uboBuffer = this.#device.createBuffer({
-            size: 48,
-            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
-        });
-        this.#gpuBuffer = this.#device.createBuffer({
-            size: 16,
-            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
-        });
-        this.#cpuBuffer = this.#device.createBuffer({
-            size: 16,
-            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-        });
-        // Create binding group data structure and use it later once UBO is known
-        this.#bindGroupLayout = this.#device.createBindGroupLayout({
-            entries: [
-                {
-                    binding: 0,
-                    visibility: GPUShaderStage.COMPUTE,
-                    buffer: { type: 'uniform' },
-                },
-                {
-                    binding: 1,
-                    visibility: GPUShaderStage.COMPUTE,
-                    buffer: { type: 'storage' },
-                }
-            ]
-        });
-        // Create pipeline to connect compute shader to binding layout
-        this.#pipeline = this.#device.createComputePipeline({
-            layout: this.#device.createPipelineLayout({
-                bindGroupLayouts: [this.#bindGroupLayout]
-            }),
-            compute: {
-                entryPoint: 'main',
-                module: this.#device.createShaderModule({
-                    code: NanoPowGpuComputeShader
-                })
-            }
-        });
-    }
-    static reset() {
-        console.warn(`GPU device lost. Reinitializing...`);
-        NanoPowGpu.#cpuBuffer?.destroy();
-        NanoPowGpu.#gpuBuffer?.destroy();
-        NanoPowGpu.#uboBuffer?.destroy();
-        NanoPowGpu.#busy = false;
-        NanoPowGpu.init();
-    }
-    static async #dispatch(seed, hash, threshold, passes) {
-        if (this.#device == null)
-            throw new Error(`WebGPU device failed to load.`);
-        // Set up uniform buffer object
-        // Note: u32 size is 4, but total alignment must be multiple of 16
-        const uboView = new DataView(new ArrayBuffer(48));
-        for (let i = 0; i < 64; i += 8) {
-            const uint32 = hash.slice(i, i + 8);
-            uboView.setUint32(i / 2, parseInt(uint32, 16));
-        }
-        uboView.setBigUint64(32, seed, true);
-        uboView.setUint32(40, threshold, true);
-        this.#device.queue.writeBuffer(this.#uboBuffer, 0, uboView);
-        // Reset `nonce` and `found` to 0u in WORK before each calculation
-        this.#device.queue.writeBuffer(this.#gpuBuffer, 0, new Uint32Array([0, 0, 0]));
-        // Bind UBO read and GPU write buffers
-        const bindGroup = this.#device.createBindGroup({
-            layout: this.#bindGroupLayout,
-            entries: [
-                {
-                    binding: 0,
-                    resource: {
-                        buffer: this.#uboBuffer
-                    },
-                },
-                {
-                    binding: 1,
-                    resource: {
-                        buffer: this.#gpuBuffer
-                    },
-                },
-            ],
-        });
-        // Create command encoder to issue commands to GPU and initiate computation
-        const commandEncoder = this.#device.createCommandEncoder();
-        const passEncoder = commandEncoder.beginComputePass();
-        // Issue commands and end compute pass structure
-        passEncoder.setPipeline(this.#pipeline);
-        passEncoder.setBindGroup(0, bindGroup);
-        passEncoder.dispatchWorkgroups(passes, passes);
-        passEncoder.end();
-        // Copy 8-byte nonce and 4-byte found flag from GPU to CPU for reading
-        commandEncoder.copyBufferToBuffer(this.#gpuBuffer, 0, this.#cpuBuffer, 0, 12);
-        // End computation by passing array of command buffers to command queue for execution
-        this.#device.queue.submit([commandEncoder.finish()]);
-        // Read results back to Javascript and then unmap buffer after reading
-        let data = null;
-        try {
-            await this.#cpuBuffer.mapAsync(GPUMapMode.READ);
-            await this.#device.queue.onSubmittedWorkDone();
-            data = new DataView(this.#cpuBuffer.getMappedRange().slice(0));
-            this.#cpuBuffer.unmap();
-        }
-        catch (err) {
-            console.warn(`Error getting data from GPU. ${err}`);
-            return this.#dispatch(seed, hash, threshold, passes);
-        }
-        if (data == null)
-            throw new Error(`Failed to get data from buffer.`);
-        return data;
-    }
-    /**
-    * Finds a nonce that satisfies the Nano proof-of-work requirements.
-    *
-    * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-    * @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
-    */
-    static async search(hash, threshold = 0xfffffff8) {
-        if (this.#busy) {
-            return new Promise(resolve => {
-                setTimeout(async () => {
-                    const result = this.search(hash, threshold);
-                    resolve(result);
-                }, 100);
-            });
-        }
-        this.#busy = true;
-        if (!/^[A-Fa-f0-9]{64}$/.test(hash))
-            throw new TypeError(`Invalid hash ${hash}`);
-        if (typeof threshold !== 'number')
-            throw new TypeError(`Invalid threshold ${threshold}`);
-        // Ensure WebGPU is initialized before calculating
-        let loads = 0;
-        while (this.#device == null && loads < 20) {
-            await new Promise(resolve => {
-                setTimeout(resolve, 500);
-            });
-        }
-        if (this.#device == null)
-            throw new Error(`WebGPU device failed to load.`);
-        let nonce = 0n;
-        do {
-            const random = Math.floor(Math.random() * 0xffffffff);
-            const seed = (BigInt(random) << 32n) | BigInt(random);
-            const data = await this.#dispatch(seed, hash, threshold, 0xff);
-            nonce = data.getBigUint64(0, true);
-            this.#busy = !data.getUint32(8);
-        } while (this.#busy);
-        return nonce.toString(16).padStart(16, '0');
-    }
-    /**
-    * Validates that a nonce satisfies Nano proof-of-work requirements.
-    *
-    * @param {string} work - Hexadecimal proof-of-work value to validate
-    * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
-    * @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
-    */
-    static async validate(work, hash, threshold = 0xfffffff8) {
-        if (this.#busy) {
-            return new Promise(resolve => {
-                setTimeout(async () => {
-                    const result = this.validate(work, hash, threshold);
-                    resolve(result);
-                }, 100);
-            });
-        }
-        this.#busy = true;
-        if (!/^[A-Fa-f0-9]{16}$/.test(work))
-            throw new TypeError(`Invalid work ${work}`);
-        if (!/^[A-Fa-f0-9]{64}$/.test(hash))
-            throw new TypeError(`Invalid hash ${hash}`);
-        if (typeof threshold !== 'number')
-            throw new TypeError(`Invalid threshold ${threshold}`);
-        // Ensure WebGPU is initialized before calculating
-        let loads = 0;
-        while (this.#device == null && loads < 20) {
-            await new Promise(resolve => {
-                setTimeout(resolve, 500);
-            });
-        }
-        if (this.#device == null)
-            throw new Error(`WebGPU device failed to load.`);
-        const seed = BigInt(`0x${work}`);
-        const data = await this.#dispatch(seed, hash, threshold, 1);
-        const nonce = data.getBigUint64(0, true).toString(16).padStart(16, '0');
-        const found = !!data.getUint32(8);
-        this.#busy = false;
-        if (found && work !== nonce)
-            throw new Error(`Nonce found but does not match work`);
-        return found;
-    }
-}

package/dist/classes/index.d.ts

@@ -1,4 +0,0 @@
-import { NanoPowGl } from "./gl.js";
-import { NanoPowGpu } from "./gpu.js";
-declare const NanoPow: typeof NanoPowGl | null;
-export { NanoPow, NanoPowGl, NanoPowGpu };

package/dist/classes/index.js

@@ -1,23 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-import { NanoPowGl } from "./gl.js";
-import { NanoPowGpu } from "./gpu.js";
-let isGlSupported, isGpuSupported = false;
-try {
-    await NanoPowGl.init();
-    isGlSupported = true;
-}
-catch (err) {
-    console.warn(`WebGL is not supported in this environment.`);
-    isGlSupported = false;
-}
-try {
-    await NanoPowGpu.init();
-    isGpuSupported = true;
-}
-catch (err) {
-    console.warn(`WebGPU is not supported in this environment.`);
-    isGpuSupported = false;
-}
-const NanoPow = isGpuSupported ? NanoPowGpu : isGlSupported ? NanoPowGl : null;
-export { NanoPow, NanoPowGl, NanoPowGpu };

package/dist/global.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/global.js

@@ -1,6 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-import { NanoPow as np, NanoPowGl as gl, NanoPowGpu as gpu } from './main.js';
-globalThis.NanoPow ??= np;
-globalThis.NanoPowGl ??= gl;
-globalThis.NanoPowGpu ??= gpu;

package/dist/main.d.ts

@@ -1,3 +0,0 @@
-import { NanoPow, NanoPowGl, NanoPowGpu } from "#classes";
-export { NanoPow, NanoPowGl, NanoPowGpu };
-export default NanoPow;

package/dist/main.js

@@ -1,5 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-import { NanoPow, NanoPowGl, NanoPowGpu } from "#classes";
-export { NanoPow, NanoPowGl, NanoPowGpu };
-export default NanoPow;

package/dist/shaders/gl-fragment.d.ts

@@ -1 +0,0 @@
-export declare const NanoPowGlFragmentShader = "#version 300 es\n#pragma vscode_glsllint_stage: frag\nprecision highp float;\nprecision highp int;\n\nin vec2 uv_pos;\nout vec4 fragColor;\n\n// blockhash - array of precalculated block hash components\n// threshold - 0xfffffff8 for send/change blocks, 0xfffffe00 for all else\n// workload - Defines canvas size\nlayout(std140) uniform UBO {\n\tuint blockhash[8];\n\tuint threshold;\n\tfloat workload;\n};\n\n// Random work values\n// First 2 bytes will be overwritten by texture pixel position\n// Second 2 bytes will be modified if the canvas size is greater than 256x256\n// Last 4 bytes remain as generated externally\nlayout(std140) uniform WORK {\n\tuvec4 work[2];\n};\n\n// Defined separately from uint v[32] below as the original value is required\n// to calculate the second uint32 of the digest for threshold comparison\nconst uint BLAKE2B_IV32_1 = 0x6A09E667u;\n\n// Both buffers represent 16 uint64s as 32 uint32s\n// because that's what GLSL offers, just like Javascript\n\n// Compression buffer, intialized to 2 instances of the initialization vector\n// The following values have been modified from the BLAKE2B_IV:\n// OUTLEN is constant 8 bytes\n// v[0] ^= 0x01010000u ^ uint(OUTLEN);\n// INLEN is constant 40 bytes: work value (8) + block hash (32)\n// v[24] ^= uint(INLEN);\n// It's always the \"last\" compression at this INLEN\n// v[28] = ~v[28];\n// v[29] = ~v[29];\nuint v[32] = uint[32](\n\t0xF2BDC900u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,\n\t0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,\n\t0xADE682D1u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,\n\t0xFB41BD6Bu, 0x1F83D9ABu, 0x137E2179u, 0x5BE0CD19u,\n\t0xF3BCC908u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,\n\t0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,\n\t0xADE682F9u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,\n\t0x04BE4294u, 0xE07C2654u, 0x137E2179u, 0x5BE0CD19u\n);\n// Input data buffer\nuint m[32];\n\n// These are offsets into the input data buffer for each mixing step.\n// They are multiplied by 2 from the original SIGMA values in\n// the C reference implementation, which refered to uint64s.\nconst uint SIGMA82[192] = uint[192](\n\t0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,\n\t28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u,\n\t22u,16u,24u,0u,10u,4u,30u,26u,20u,28u,6u,12u,14u,2u,18u,8u,\n\t14u,18u,6u,2u,26u,24u,22u,28u,4u,12u,10u,20u,8u,0u,30u,16u,\n\t18u,0u,10u,14u,4u,8u,20u,30u,28u,2u,22u,24u,12u,16u,6u,26u,\n\t4u,24u,12u,20u,0u,22u,16u,6u,8u,26u,14u,10u,30u,28u,2u,18u,\n\t24u,10u,2u,30u,28u,26u,8u,20u,0u,14u,12u,6u,18u,4u,16u,22u,\n\t26u,22u,14u,28u,24u,2u,6u,18u,10u,0u,30u,8u,16u,12u,4u,20u,\n\t12u,30u,28u,18u,22u,6u,0u,16u,24u,4u,26u,14u,2u,8u,20u,10u,\n\t20u,4u,16u,8u,14u,12u,2u,10u,30u,22u,18u,28u,6u,24u,26u,0u,\n\t0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,\n\t28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u\n);\n\n// G mixing function\nvoid G (uint ix, uint iy, uint a, uint b, uint c, uint d) {\n\tbool carry;\n\tuint o0;\n\tuint o1;\n\tuint xor0;\n\tuint xor1;\n\n\t// a = a + b;\n\to0 = v[a] + v[b];\n\to1 = v[a+1u] + v[b+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// a = a + m[sigma[r][2*i+0]];\n\to0 = v[a] + m[ix];\n\to1 = v[a+1u] + m[ix+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// d = rotr64(d ^ a, 32);\n\txor0 = v[d] ^ v[a];\n\txor1 = v[d+1u] ^ v[a+1u];\n\tv[d] = xor1;\n\tv[d+1u] = xor0;\n\n\t// c = c + d;\n\to0 = v[c] + v[d];\n\to1 = v[c+1u] + v[d+1u];\n\tcarry = o0 < v[c];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[c] = o0;\n\tv[c+1u] = o1;\n\n\t// b = rotr64(b ^ c, 24);\n\txor0 = v[b] ^ v[c];\n\txor1 = v[b+1u] ^ v[c+1u];\n\tv[b] = (xor0 >> 24u) ^ (xor1 << 8u);\n\tv[b+1u] = (xor1 >> 24u) ^ (xor0 << 8u);\n\n\t// a = a + b;\n\to0 = v[a] + v[b];\n\to1 = v[a+1u] + v[b+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// a = a + m[sigma[r][2*i+1]];\n\to0 = v[a] + m[iy];\n\to1 = v[a+1u] + m[iy+1u];\n\tcarry = o0 < v[a];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[a] = o0;\n\tv[a+1u] = o1;\n\n\t// d = rotr64(d ^ a, 16)\n\txor0 = v[d] ^ v[a];\n\txor1 = v[d+1u] ^ v[a+1u];\n\tv[d] = (xor0 >> 16u) ^ (xor1 << 16u);\n\tv[d+1u] = (xor1 >> 16u) ^ (xor0 << 16u);\n\n\t// c = c + d;\n\to0 = v[c] + v[d];\n\to1 = v[c+1u] + v[d+1u];\n\tcarry = o0 < v[c];\n\to1 = o1 + uint(mix(0.0, 1.0, float(carry)));\n\tv[c] = o0;\n\tv[c+1u] = o1;\n\n\t// b = rotr64(b ^ c, 63)\n\txor0 = v[b] ^ v[c];\n\txor1 = v[b+1u] ^ v[c+1u];\n\tv[b] = (xor1 >> 31u) ^ (xor0 << 1u);\n\tv[b+1u] = (xor0 >> 31u) ^ (xor1 << 1u);\n}\n\nvoid main() {\n\tint i;\n\tuvec4 u_work0 = work[0u];\n\tuvec4 u_work1 = work[1u];\n\tuint uv_x = uint(uv_pos.x * workload);\n\tuint uv_y = uint(uv_pos.y * workload);\n\tuint x_pos = uv_x % 256u;\n\tuint y_pos = uv_y % 256u;\n\tuint x_index = (uv_x - x_pos) / 256u;\n\tuint y_index = (uv_y - y_pos) / 256u;\n\n\t// First 2 work bytes are the x,y pos within the 256x256 area, the next\n\t// two bytes are modified from the random generated value, XOR'd with\n\t// the x,y area index of where this pixel is located\n\tm[0u] = (x_pos ^ (y_pos << 8u) ^ ((u_work0.b ^ x_index) << 16u) ^ ((u_work0.a ^ y_index) << 24u));\n\n\t// Remaining bytes are un-modified from the random generated value\n\tm[1u] = (u_work1.r ^ (u_work1.g << 8u) ^ (u_work1.b << 16u) ^ (u_work1.a << 24u));\n\n\t// Block hash\n\tfor (uint i = 0u; i < 8u; i = i + 1u) {\n\t\tm[i+2u] = blockhash[i];\n\t}\n\n\t// twelve rounds of mixing\n\tfor(uint i = 0u; i < 12u; i = i + 1u) {\n\t\tG(SIGMA82[i * 16u + 0u], SIGMA82[i * 16u + 1u], 0u, 8u, 16u, 24u);\n\t\tG(SIGMA82[i * 16u + 2u], SIGMA82[i * 16u + 3u], 2u, 10u, 18u, 26u);\n\t\tG(SIGMA82[i * 16u + 4u], SIGMA82[i * 16u + 5u], 4u, 12u, 20u, 28u);\n\t\tG(SIGMA82[i * 16u + 6u], SIGMA82[i * 16u + 7u], 6u, 14u, 22u, 30u);\n\t\tG(SIGMA82[i * 16u + 8u], SIGMA82[i * 16u + 9u], 0u, 10u, 20u, 30u);\n\t\tG(SIGMA82[i * 16u + 10u], SIGMA82[i * 16u + 11u], 2u, 12u, 22u, 24u);\n\t\tG(SIGMA82[i * 16u + 12u], SIGMA82[i * 16u + 13u], 4u, 14u, 16u, 26u);\n\t\tG(SIGMA82[i * 16u + 14u], SIGMA82[i * 16u + 15u], 6u, 8u, 18u, 28u);\n\t}\n\n\t// Pixel data is multipled by threshold test result (0 or 1)\n\t// First 4 bytes insignificant, only calculate digest of second 4 bytes\n\tif ((BLAKE2B_IV32_1 ^ v[1u] ^ v[17u]) > threshold) {\n\t\tfragColor = vec4(\n\t\t\tfloat(x_index + 1u)/255.0, // +1 to distinguish from 0 (unsuccessful) pixels\n\t\t\tfloat(y_index + 1u)/255.0, // Same as previous\n\t\t\tfloat(x_pos)/255.0, // Return the 2 custom bytes used in work value\n\t\t\tfloat(y_pos)/255.0  // Second custom byte\n\t\t);\n\t} else {\n \t\tdiscard;\n\t}\n}\n";

package/dist/shaders/gl-fragment.js

@@ -1,206 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-FileContributor: Ben Green <ben@latenightsketches.com>
-// SPDX-License-Identifier: GPL-3.0-or-later AND MIT
-export const NanoPowGlFragmentShader = `#version 300 es
-#pragma vscode_glsllint_stage: frag
-precision highp float;
-precision highp int;
-
-in vec2 uv_pos;
-out vec4 fragColor;
-
-// blockhash - array of precalculated block hash components
-// threshold - 0xfffffff8 for send/change blocks, 0xfffffe00 for all else
-// workload - Defines canvas size
-layout(std140) uniform UBO {
-	uint blockhash[8];
-	uint threshold;
-	float workload;
-};
-
-// Random work values
-// First 2 bytes will be overwritten by texture pixel position
-// Second 2 bytes will be modified if the canvas size is greater than 256x256
-// Last 4 bytes remain as generated externally
-layout(std140) uniform WORK {
-	uvec4 work[2];
-};
-
-// Defined separately from uint v[32] below as the original value is required
-// to calculate the second uint32 of the digest for threshold comparison
-const uint BLAKE2B_IV32_1 = 0x6A09E667u;
-
-// Both buffers represent 16 uint64s as 32 uint32s
-// because that's what GLSL offers, just like Javascript
-
-// Compression buffer, intialized to 2 instances of the initialization vector
-// The following values have been modified from the BLAKE2B_IV:
-// OUTLEN is constant 8 bytes
-// v[0] ^= 0x01010000u ^ uint(OUTLEN);
-// INLEN is constant 40 bytes: work value (8) + block hash (32)
-// v[24] ^= uint(INLEN);
-// It's always the "last" compression at this INLEN
-// v[28] = ~v[28];
-// v[29] = ~v[29];
-uint v[32] = uint[32](
-	0xF2BDC900u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,
-	0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,
-	0xADE682D1u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,
-	0xFB41BD6Bu, 0x1F83D9ABu, 0x137E2179u, 0x5BE0CD19u,
-	0xF3BCC908u, 0x6A09E667u, 0x84CAA73Bu, 0xBB67AE85u,
-	0xFE94F82Bu, 0x3C6EF372u, 0x5F1D36F1u, 0xA54FF53Au,
-	0xADE682F9u, 0x510E527Fu, 0x2B3E6C1Fu, 0x9B05688Cu,
-	0x04BE4294u, 0xE07C2654u, 0x137E2179u, 0x5BE0CD19u
-);
-// Input data buffer
-uint m[32];
-
-// These are offsets into the input data buffer for each mixing step.
-// They are multiplied by 2 from the original SIGMA values in
-// the C reference implementation, which refered to uint64s.
-const uint SIGMA82[192] = uint[192](
-	0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,
-	28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u,
-	22u,16u,24u,0u,10u,4u,30u,26u,20u,28u,6u,12u,14u,2u,18u,8u,
-	14u,18u,6u,2u,26u,24u,22u,28u,4u,12u,10u,20u,8u,0u,30u,16u,
-	18u,0u,10u,14u,4u,8u,20u,30u,28u,2u,22u,24u,12u,16u,6u,26u,
-	4u,24u,12u,20u,0u,22u,16u,6u,8u,26u,14u,10u,30u,28u,2u,18u,
-	24u,10u,2u,30u,28u,26u,8u,20u,0u,14u,12u,6u,18u,4u,16u,22u,
-	26u,22u,14u,28u,24u,2u,6u,18u,10u,0u,30u,8u,16u,12u,4u,20u,
-	12u,30u,28u,18u,22u,6u,0u,16u,24u,4u,26u,14u,2u,8u,20u,10u,
-	20u,4u,16u,8u,14u,12u,2u,10u,30u,22u,18u,28u,6u,24u,26u,0u,
-	0u,2u,4u,6u,8u,10u,12u,14u,16u,18u,20u,22u,24u,26u,28u,30u,
-	28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u
-);
-
-// G mixing function
-void G (uint ix, uint iy, uint a, uint b, uint c, uint d) {
-	bool carry;
-	uint o0;
-	uint o1;
-	uint xor0;
-	uint xor1;
-
-	// a = a + b;
-	o0 = v[a] + v[b];
-	o1 = v[a+1u] + v[b+1u];
-	carry = o0 < v[a];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[a] = o0;
-	v[a+1u] = o1;
-
-	// a = a + m[sigma[r][2*i+0]];
-	o0 = v[a] + m[ix];
-	o1 = v[a+1u] + m[ix+1u];
-	carry = o0 < v[a];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[a] = o0;
-	v[a+1u] = o1;
-
-	// d = rotr64(d ^ a, 32);
-	xor0 = v[d] ^ v[a];
-	xor1 = v[d+1u] ^ v[a+1u];
-	v[d] = xor1;
-	v[d+1u] = xor0;
-
-	// c = c + d;
-	o0 = v[c] + v[d];
-	o1 = v[c+1u] + v[d+1u];
-	carry = o0 < v[c];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[c] = o0;
-	v[c+1u] = o1;
-
-	// b = rotr64(b ^ c, 24);
-	xor0 = v[b] ^ v[c];
-	xor1 = v[b+1u] ^ v[c+1u];
-	v[b] = (xor0 >> 24u) ^ (xor1 << 8u);
-	v[b+1u] = (xor1 >> 24u) ^ (xor0 << 8u);
-
-	// a = a + b;
-	o0 = v[a] + v[b];
-	o1 = v[a+1u] + v[b+1u];
-	carry = o0 < v[a];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[a] = o0;
-	v[a+1u] = o1;
-
-	// a = a + m[sigma[r][2*i+1]];
-	o0 = v[a] + m[iy];
-	o1 = v[a+1u] + m[iy+1u];
-	carry = o0 < v[a];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[a] = o0;
-	v[a+1u] = o1;
-
-	// d = rotr64(d ^ a, 16)
-	xor0 = v[d] ^ v[a];
-	xor1 = v[d+1u] ^ v[a+1u];
-	v[d] = (xor0 >> 16u) ^ (xor1 << 16u);
-	v[d+1u] = (xor1 >> 16u) ^ (xor0 << 16u);
-
-	// c = c + d;
-	o0 = v[c] + v[d];
-	o1 = v[c+1u] + v[d+1u];
-	carry = o0 < v[c];
-	o1 = o1 + uint(mix(0.0, 1.0, float(carry)));
-	v[c] = o0;
-	v[c+1u] = o1;
-
-	// b = rotr64(b ^ c, 63)
-	xor0 = v[b] ^ v[c];
-	xor1 = v[b+1u] ^ v[c+1u];
-	v[b] = (xor1 >> 31u) ^ (xor0 << 1u);
-	v[b+1u] = (xor0 >> 31u) ^ (xor1 << 1u);
-}
-
-void main() {
-	int i;
-	uvec4 u_work0 = work[0u];
-	uvec4 u_work1 = work[1u];
-	uint uv_x = uint(uv_pos.x * workload);
-	uint uv_y = uint(uv_pos.y * workload);
-	uint x_pos = uv_x % 256u;
-	uint y_pos = uv_y % 256u;
-	uint x_index = (uv_x - x_pos) / 256u;
-	uint y_index = (uv_y - y_pos) / 256u;
-
-	// First 2 work bytes are the x,y pos within the 256x256 area, the next
-	// two bytes are modified from the random generated value, XOR'd with
-	// the x,y area index of where this pixel is located
-	m[0u] = (x_pos ^ (y_pos << 8u) ^ ((u_work0.b ^ x_index) << 16u) ^ ((u_work0.a ^ y_index) << 24u));
-
-	// Remaining bytes are un-modified from the random generated value
-	m[1u] = (u_work1.r ^ (u_work1.g << 8u) ^ (u_work1.b << 16u) ^ (u_work1.a << 24u));
-
-	// Block hash
-	for (uint i = 0u; i < 8u; i = i + 1u) {
-		m[i+2u] = blockhash[i];
-	}
-
-	// twelve rounds of mixing
-	for(uint i = 0u; i < 12u; i = i + 1u) {
-		G(SIGMA82[i * 16u + 0u], SIGMA82[i * 16u + 1u], 0u, 8u, 16u, 24u);
-		G(SIGMA82[i * 16u + 2u], SIGMA82[i * 16u + 3u], 2u, 10u, 18u, 26u);
-		G(SIGMA82[i * 16u + 4u], SIGMA82[i * 16u + 5u], 4u, 12u, 20u, 28u);
-		G(SIGMA82[i * 16u + 6u], SIGMA82[i * 16u + 7u], 6u, 14u, 22u, 30u);
-		G(SIGMA82[i * 16u + 8u], SIGMA82[i * 16u + 9u], 0u, 10u, 20u, 30u);
-		G(SIGMA82[i * 16u + 10u], SIGMA82[i * 16u + 11u], 2u, 12u, 22u, 24u);
-		G(SIGMA82[i * 16u + 12u], SIGMA82[i * 16u + 13u], 4u, 14u, 16u, 26u);
-		G(SIGMA82[i * 16u + 14u], SIGMA82[i * 16u + 15u], 6u, 8u, 18u, 28u);
-	}
-
-	// Pixel data is multipled by threshold test result (0 or 1)
-	// First 4 bytes insignificant, only calculate digest of second 4 bytes
-	if ((BLAKE2B_IV32_1 ^ v[1u] ^ v[17u]) > threshold) {
-		fragColor = vec4(
-			float(x_index + 1u)/255.0, // +1 to distinguish from 0 (unsuccessful) pixels
-			float(y_index + 1u)/255.0, // Same as previous
-			float(x_pos)/255.0, // Return the 2 custom bytes used in work value
-			float(y_pos)/255.0  // Second custom byte
-		);
-	} else {
- 		discard;
-	}
-}
-`;

package/dist/shaders/gl-vertex.d.ts

@@ -1 +0,0 @@
-export declare const NanoPowGlVertexShader = "#version 300 es\n#pragma vscode_glsllint_stage: vert\nprecision highp float;\nlayout (location=0) in vec4 position;\nlayout (location=1) in vec2 uv;\n\nout vec2 uv_pos;\n\nvoid main() {\n\tuv_pos = uv;\n\tgl_Position = position;\n}\n";

package/dist/shaders/gl-vertex.js

@@ -1,16 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-FileContributor: Ben Green <ben@latenightsketches.com>
-// SPDX-License-Identifier: GPL-3.0-or-later AND MIT
-export const NanoPowGlVertexShader = `#version 300 es
-#pragma vscode_glsllint_stage: vert
-precision highp float;
-layout (location=0) in vec4 position;
-layout (location=1) in vec2 uv;
-
-out vec2 uv_pos;
-
-void main() {
-	uv_pos = uv;
-	gl_Position = position;
-}
-`;

package/dist/shaders/index.d.ts

@@ -1,4 +0,0 @@
-import { default as NanoPowGpuComputeShader } from "./compute.wgsl";
-import { NanoPowGlFragmentShader } from "./gl-fragment.js";
-import { NanoPowGlVertexShader } from "./gl-vertex.js";
-export { NanoPowGpuComputeShader, NanoPowGlFragmentShader, NanoPowGlVertexShader };

package/dist/shaders/index.js

@@ -1,6 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Chris Duncan <chris@zoso.dev>
-// SPDX-License-Identifier: GPL-3.0-or-later
-import { default as NanoPowGpuComputeShader } from "./compute.wgsl";
-import { NanoPowGlFragmentShader } from "./gl-fragment.js";
-import { NanoPowGlVertexShader } from "./gl-vertex.js";
-export { NanoPowGpuComputeShader, NanoPowGlFragmentShader, NanoPowGlVertexShader };