nano-pow 1.2.3 → 2.0.0

package/dist/classes/gl.d.ts

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,232 @@
+// 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

@@ -0,0 +1,24 @@
+/**
+* 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

@@ -0,0 +1,236 @@
+// 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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,23 @@
+// 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

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

package/dist/global.js

@@ -0,0 +1,6 @@
+// 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;