From: Chris Duncan <chris@codecow.com>
Date: Sun, 12 Jul 2026 07:23:31 +0000 (-0700)
Subject: Remove droppable logging labels.
X-Git-Url: https://git.codecow.com/?a=commitdiff_plain;h=d04049e44fc78121030e1e984070dc08fa5df941;p=nano-pow.git

Remove droppable logging labels.
---

diff --git a/scripts/build.mjs b/scripts/build.mjs
index 082ce3e..927055f 100644
--- a/scripts/build.mjs
+++ b/scripts/build.mjs
@@ -15,7 +15,6 @@ const sharedOptions = {
 	legalComments: 'inline',
 	outbase: 'src',
 	outdir: 'dist',
-	dropLabels: process.env.NODE_ENV === 'development' ? [] : ['LOG'],
 	sourcemap: 'linked',
 	plugins: [
 		glsl({
diff --git a/src/bin/server.ts b/src/bin/server.ts
index f6b6c02..081a22f 100755
--- a/src/bin/server.ts
+++ b/src/bin/server.ts
@@ -82,16 +82,16 @@ async function loadConfig (): Promise<void> {
 	CONFIG.EFFORT = +(process.env.NANO_POW_EFFORT ?? '') || CONFIG.EFFORT
 	CONFIG.PORT = process.send ? 0 : +(process.env.NANO_POW_PORT ?? '') || CONFIG.PORT
 	logger.isEnabled = CONFIG.DEBUG
-	if (configFile.length === 0) LOG: logger.log('config file not found')
-	LOG: logger.log(`config set: ${JSON.stringify(CONFIG)}`)
+	if (configFile.length === 0) logger.log('config file not found')
+	logger.log(`config set: ${JSON.stringify(CONFIG)}`)
 }
 
 await loadConfig()
 
 // Initialize puppeteer
-LOG: logger.log('starting work server')
+logger.log('starting work server')
 const NanoPow = await readFile(new URL('../index.js', import.meta.url), 'utf-8')
-LOG: logger.log('launching puppeteer browser')
+logger.log('launching puppeteer browser')
 const browser = await launch({
 	handleSIGHUP: false,
 	handleSIGINT: false,
@@ -104,7 +104,7 @@ const browser = await launch({
 		'--enable-unsafe-webgpu'
 	]
 })
-LOG: logger.log('creating puppeteer page')
+logger.log('creating puppeteer page')
 const page = await browser.newPage()
 
 const src = `${NanoPow};window.NanoPow=NanoPow;`
@@ -116,7 +116,7 @@ const body = `
 	<script type="module">${src}</script>
 `
 
-LOG: logger.log('setting puppeteer request interception')
+logger.log('setting puppeteer request interception')
 await page.setRequestInterception(true)
 page.on('request', req => {
 	if (req.isInterceptResolutionHandled()) return
@@ -127,16 +127,16 @@ page.on('request', req => {
 	}
 })
 page.on('console', msg => logger.log(msg.text()))
-LOG: logger.log('navigating to https://nanopow.invalid/ to be intercepted')
+logger.log('navigating to https://nanopow.invalid/ to be intercepted')
 await page.goto('https://nanopow.invalid/')
 
-LOG: logger.log('loading NanoPow handle')
+logger.log('loading NanoPow handle')
 let NanoPowHandle = await page.waitForFunction(async () => {
 	await window.navigator.gpu.requestAdapter()
 	return window.NanoPow
 })
 
-LOG: logger.log('puppeteer initialized')
+logger.log('puppeteer initialized')
 
 // Track requests by IP address, and let them fall off over time
 const requests = new Map<string, { time: number, tokens: number }>()
@@ -153,33 +153,33 @@ setInterval(() => {
 async function work (data: unknown): Promise<string> {
 	let resBody = 'request failed'
 	if (data == null || typeof data !== 'object') {
-		LOG: logger.log('Failed to parse request')
+		logger.log('Failed to parse request')
 		throw new Error(resBody)
 	}
 	if (Object.getPrototypeOf(data) !== Object.prototype) {
-		LOG: logger.log('Data corrupted.')
+		logger.log('Data corrupted.')
 		throw new Error(resBody)
 	}
 	const dataParsed = data as Record<string, unknown>
 
 	let { action, hash, work, difficulty } = dataParsed
 	if (action !== 'work_generate' && action !== 'work_validate') {
-		LOG: logger.log('Action must be work_generate or work_validate.')
+		logger.log('Action must be work_generate or work_validate.')
 		throw new Error(resBody)
 	}
 	resBody = `${action} failed`
 
 	if (!isHex32(hash)) {
-		LOG: logger.log('Hash must be hex char(64)')
+		logger.log('Hash must be hex char(64)')
 		throw new Error(resBody)
 	}
 	if (difficulty !== undefined && !isHex8(difficulty)) {
-		LOG: logger.log('Difficulty must be hex char(16).')
+		logger.log('Difficulty must be hex char(16).')
 		throw new Error(resBody)
 	}
 	if (action === 'work_validate') {
 		if (!isHex8(work)) {
-			LOG: logger.log('Work must be hex char(16).')
+			logger.log('Work must be hex char(16).')
 			throw new Error(resBody)
 		}
 	} else {
@@ -206,7 +206,7 @@ async function work (data: unknown): Promise<string> {
 		resBody = JSON.stringify(result)
 		return resBody
 	} catch (err) {
-		LOG: logger.log(err)
+		logger.log(err)
 		throw new Error(resBody)
 	}
 }
@@ -276,7 +276,7 @@ function isRateLimited (ip: string): boolean {
 	}
 	const client = requests.get(ip)
 	if (client && client.tokens-- <= 0) {
-		LOG: logger.log(`====    Potential Abuse: ${ip}    ====`)
+		logger.log(`====    Potential Abuse: ${ip}    ====`)
 		return true
 	}
 	if (Date.now() - MAX_REQUEST_TIME > (client?.time ?? 0)) {
@@ -307,19 +307,19 @@ function listen (): void {
 				}
 			}
 		})
-		LOG: logger.log(`server listening on ipc`)
+		logger.log(`server listening on ipc`)
 		process.send?.({ type: 'listening', data: 'ipc' })
 	} else {
 		server.listen(CONFIG.PORT, '127.0.0.1', () => {
 			const address = server.address()
 			if (address == null) {
-				LOG: logger.log(`server closed`)
+				logger.log(`server closed`)
 			} else if (typeof address === 'string') {
-				LOG: logger.log(`server listening on ${address}`)
+				logger.log(`server listening on ${address}`)
 				process.send?.({ type: 'listening', data: address })
 			} else {
 				CONFIG.PORT = address.port
-				LOG: logger.log(`server listening on port ${address.port}`)
+				logger.log(`server listening on port ${address.port}`)
 				process.send?.({ type: 'listening', data: address.port })
 			}
 		})
@@ -394,11 +394,11 @@ server.on('connection', s => {
 })
 
 server.on('error', serverErr => {
-	LOG: logger.log('server error', serverErr)
+	logger.log('server error', serverErr)
 	try {
 		shutdown()
 	} catch (shutdownErr) {
-		LOG: logger.log('server failed to shut down', shutdownErr)
+		logger.log('server failed to shut down', shutdownErr)
 		process.exit(1)
 	}
 })
@@ -408,15 +408,15 @@ server.on('error', serverErr => {
 * does not respond within 10 seconds.
 */
 function shutdown (): void {
-	LOG: logger.log('shutdown signal received')
+	logger.log('shutdown signal received')
 	const kill = setTimeout((): never => {
-		LOG: logger.log('server unresponsive, forcefully stopped')
+		logger.log('server unresponsive, forcefully stopped')
 		process.exit(1)
 	}, 10_000)
 	server.close(async (): Promise<never> => {
 		await browser.close()
 		clearTimeout(kill)
-		LOG: logger.log('server stopped')
+		logger.log('server stopped')
 		process.exit(0)
 	})
 }
@@ -425,7 +425,7 @@ process.on('SIGINT', shutdown)
 process.on('SIGTERM', shutdown)
 
 process.on('SIGHUP', async () => {
-	LOG: logger.log('reloading configuration')
+	logger.log('reloading configuration')
 	server.close(async () => {
 		await loadConfig()
 		await page.reload()
diff --git a/src/lib/generate/cpu/index.ts b/src/lib/generate/cpu/index.ts
index 8d22251..d65f58c 100644
--- a/src/lib/generate/cpu/index.ts
+++ b/src/lib/generate/cpu/index.ts
@@ -9,19 +9,19 @@ const logger = new Logger()
 
 export async function generate (hash: bigint, difficulty: bigint, debug: boolean): Promise<WorkGenerateResponse> {
 	logger.isEnabled = debug
-	LOG: logger.groupStart('NanoPow CPU work_generate')
+	logger.groupStart('NanoPow CPU work_generate')
 	return new Promise((resolve, reject) => {
 		const check = () => {
 			try {
 				const seed = new BigUint64Array(1)
-				LOG: logger.log('check 0x8000 nonces')
+				logger.log('check 0x8000 nonces')
 				let result = NanoPowValidate(crypto.getRandomValues(seed)[0], hash, difficulty, false)
 				for (let i = 0; i < 0x8000; i++) {
 					if (result.valid === '1') break
 					result = NanoPowValidate(crypto.getRandomValues(seed)[0], hash, difficulty, false)
 				}
 				if (result.valid === '1') {
-					LOG: logger.groupEnd('NanoPow CPU work_generate')
+					logger.groupEnd('NanoPow CPU work_generate')
 					resolve({
 						hash: result.hash,
 						work: result.work,
diff --git a/src/lib/generate/wasm/index.ts b/src/lib/generate/wasm/index.ts
index a08f717..a71e82c 100644
--- a/src/lib/generate/wasm/index.ts
+++ b/src/lib/generate/wasm/index.ts
@@ -20,7 +20,7 @@ function setup (): void {
 	try {
 		url = URL.createObjectURL(new Blob([NanoPowWasmWorker], { type: 'text/javascript' }))
 		workers = []
-		LOG: logger.log(`NanoPow CPU initialized.`)
+		logger.log(`NanoPow CPU initialized.`)
 		isReady = true
 	} catch (err) {
 		isReady = false
@@ -49,7 +49,7 @@ async function init (hash: bigint, difficulty: bigint, effort: number): Promise<
 	}
 	try {
 		await workersStarted()
-		LOG: logger.log('Workers ready')
+		logger.log('Workers ready')
 	} catch (err: any) {
 		throw new Error('Error loading workers')
 	}
@@ -86,11 +86,11 @@ async function dispatch (): Promise<bigint> {
 				w.onmessage = (msg) => {
 					const { data } = msg
 					if (data.url === url) {
-						LOG: logger.log(`received result ${typeof data.result} "${data.result}" from worker ${i}`)
+						logger.log(`received result ${typeof data.result} "${data.result}" from worker ${i}`)
 						found(data.result)
 					}
 				}
-				LOG: logger.log(`sending data to worker ${i}`, { ...data, url })
+				logger.log(`sending data to worker ${i}`, { ...data, url })
 				w.postMessage({ ...data, url })
 			}))
 		}
@@ -141,8 +141,8 @@ async function workersStopped (): Promise<boolean> {
 */
 export async function generate (hash: bigint, difficulty: bigint, effort: number, debug: boolean): Promise<WorkGenerateResponse> {
 	logger.isEnabled = debug
-	LOG: logger.groupStart('NanoPow WASM work_generate')
-	LOG: logger.log('generating')
+	logger.groupStart('NanoPow WASM work_generate')
+	logger.log('generating')
 	if (isReady === false) setup()
 	await init(hash, difficulty, effort)
 
@@ -152,16 +152,16 @@ export async function generate (hash: bigint, difficulty: bigint, effort: number
 		work = await dispatch()
 		result = (await NanoPowValidate(work, hash, difficulty, debug)).difficulty
 	} catch (err) {
-		LOG: logger.log(err)
+		logger.log(err)
 	} finally {
 		const isStopped = await workersStopped()
 		if (isStopped) {
-			LOG: logger.log('workers stopped')
+			logger.log('workers stopped')
 		} else {
 			reset()
-			LOG: logger.log('workers reset')
+			logger.log('workers reset')
 		}
-		LOG: logger.groupEnd('NanoPow WASM work_generate')
+		logger.groupEnd('NanoPow WASM work_generate')
 	}
 
 	return {
diff --git a/src/lib/generate/webgl/index.ts b/src/lib/generate/webgl/index.ts
index f4c13e6..1244977 100644
--- a/src/lib/generate/webgl/index.ts
+++ b/src/lib/generate/webgl/index.ts
@@ -2,7 +2,7 @@
 //! SPDX-FileContributor: Ben Green <ben@latenightsketches.com>
 //! SPDX-License-Identifier: GPL-3.0-or-later AND MIT
 
-import { bigHex, bigToU32, Logger } from '#utils'
+import { Logger, bigHex, bigToU32 } from '#utils'
 import { WorkGenerateResponse } from 'nano-pow'
 import { downsampleSource, drawSource, quadSource } from './shaders'
 
@@ -61,7 +61,7 @@ let raf: number = 0
 
 // Create persistent resizable canvas and get WebGL2 context
 function createCanvas (size: number): void {
-	LOG: logger.groupStart('NanoPow WebGL createCanvas')
+	logger.groupStart('NanoPow WebGL createCanvas')
 	if (canvas == null) {
 		canvas = new OffscreenCanvas(0, 0)
 		canvas.addEventListener('webglcontextlost', ev => {
@@ -70,12 +70,12 @@ function createCanvas (size: number): void {
 				throw new Error('NanoPow could not restore WebGL context.')
 			}, 10_000)
 			ev.preventDefault()
-			LOG: logger.log('NanoPow WebGL createCanvas', 'WebGL context lost. Waiting for it to be restored...')
+			logger.log('NanoPow WebGL createCanvas', 'WebGL context lost. Waiting for it to be restored...')
 		})
 		canvas.addEventListener('webglcontextrestored', ev => {
 			window.clearTimeout(isContextLost)
 			isContextLost = 0
-			LOG: logger.log('NanoPow WebGL createCanvas', 'WebGL context restored. Reinitializing...')
+			logger.log('NanoPow WebGL createCanvas', 'WebGL context restored. Reinitializing...')
 		})
 	}
 
@@ -92,21 +92,21 @@ function createCanvas (size: number): void {
 	gl = context
 
 	const MAX_VIEWPORT_DIMS = gl.getParameter(gl.MAX_VIEWPORT_DIMS) ?? [0x1000, 0x1000]
-	LOG: logger.log('NanoPow WebGL createCanvas', 'requested size', size)
-	LOG: logger.log('NanoPow WebGL createCanvas', 'MAX_VIEWPORT_DIMS', MAX_VIEWPORT_DIMS)
+	logger.log('NanoPow WebGL createCanvas', 'requested size', size)
+	logger.log('NanoPow WebGL createCanvas', 'MAX_VIEWPORT_DIMS', MAX_VIEWPORT_DIMS)
 	size = Math.min(size, ...MAX_VIEWPORT_DIMS)
 	size = (size >>> 8) << 8
 	canvas.height = canvas.width = size
-	LOG: logger.log('NanoPow WebGL createCanvas', 'canvas size', canvas.height, canvas.width)
-	LOG: logger.log('NanoPow WebGL createCanvas', 'drawingBuffer size', gl.drawingBufferHeight, gl.drawingBufferWidth)
+	logger.log('NanoPow WebGL createCanvas', 'canvas size', canvas.height, canvas.width)
+	logger.log('NanoPow WebGL createCanvas', 'drawingBuffer size', gl.drawingBufferHeight, gl.drawingBufferWidth)
 	if (canvas.height !== gl.drawingBufferHeight
 		|| canvas.width !== gl.drawingBufferWidth
 	) {
 		size = ((gl.drawingBufferHeight < gl.drawingBufferWidth ? gl.drawingBufferHeight : gl.drawingBufferWidth) >>> 8) << 8
 		canvas.height = canvas.width = size
 	}
-	LOG: logger.log('NanoPow WebGL createCanvas', 'final size', size)
-	LOG: logger.groupEnd('NanoPow WebGL createCanvas')
+	logger.log('NanoPow WebGL createCanvas', 'final size', size)
+	logger.groupEnd('NanoPow WebGL createCanvas')
 }
 
 function compile (): void {
@@ -219,7 +219,7 @@ function compile (): void {
 		// Finalize configuration
 		pixels = new Uint32Array(finalFbo.size.x * finalFbo.size.y * 4)
 		isReady = true
-		LOG: logger.log(`NanoPow WebGL initialized at ${gl.drawingBufferWidth}x${gl.drawingBufferHeight}. Maximum nonces checked per frame: ${gl.drawingBufferWidth * gl.drawingBufferHeight}`)
+		logger.log(`NanoPow WebGL initialized at ${gl.drawingBufferWidth}x${gl.drawingBufferHeight}. Maximum nonces checked per frame: ${gl.drawingBufferWidth * gl.drawingBufferHeight}`)
 	} catch (err) {
 		throw new Error('WebGL compilation failed.', { cause: err })
 	}
@@ -275,7 +275,7 @@ function reset (): void {
 	vertexShader = null
 	gl?.deleteProgram(drawProgram)
 	drawProgram = null
-	LOG: logger.log('reset done')
+	logger.log('reset done')
 }
 
 function init (hash: Uint32Array, difficulty: bigint): void {
@@ -298,7 +298,7 @@ function init (hash: Uint32Array, difficulty: bigint): void {
 		inputHashView.setUint32(i * 16, hash[i])
 	}
 	inputDifficultyView.setBigUint64(0, difficulty, true)
-	LOG: logger.log('INPUT', inputArray.buffer.slice(0))
+	logger.log('INPUT', inputArray.buffer.slice(0))
 	gl.bindBuffer(gl.UNIFORM_BUFFER, inputBuffer)
 	gl.bufferSubData(gl.UNIFORM_BUFFER, 0, inputView)
 	gl.bindBuffer(gl.UNIFORM_BUFFER, null)
@@ -311,11 +311,11 @@ function draw (seed: bigint, drawFbo: FBO, query: WebGLQuery): void {
 	if (gl == null) throw new Error('WebGL 2 is required to draw')
 	if (drawFbo == null) throw new Error('FBO is required to draw')
 	if (query == null) throw new Error('Query is required to draw')
-	LOG: logger.log(bigHex(seed, 16))
+	logger.log(bigHex(seed, 16))
 
 	// Upload work seed buffer
 	inputSeedView.setBigUint64(0, seed, true)
-	LOG: logger.log('INPUT', inputView.buffer.slice(0))
+	logger.log('INPUT', inputView.buffer.slice(0))
 	gl.bindBuffer(gl.UNIFORM_BUFFER, inputBuffer)
 	gl.bufferSubData(gl.UNIFORM_BUFFER, 136, inputSeedView)
 	gl.bindBuffer(gl.UNIFORM_BUFFER, null)
@@ -387,7 +387,7 @@ function read (drawFbo: FBO): { work: bigint, difficulty: bigint } {
 	// Loop pixels to find one with values
 	for (let i = 0; i < pixels.length; i += 4) {
 		if (pixels[i] || pixels[i + 1] || pixels[i + 2] || pixels[i + 3]) {
-			LOG: logger.log(`rgba(${pixels[i]}, ${pixels[i + 1]}, ${pixels[i + 2]}, ${pixels[i + 3]})`)
+			logger.log(`rgba(${pixels[i]}, ${pixels[i + 1]}, ${pixels[i + 2]}, ${pixels[i + 3]})`)
 			resultView.setUint32(0, pixels[i], true)
 			resultView.setUint32(4, pixels[i + 1], true)
 			resultView.setUint32(8, pixels[i + 2], true)
@@ -398,7 +398,7 @@ function read (drawFbo: FBO): { work: bigint, difficulty: bigint } {
 			}
 		}
 	}
-	LOG: logger.log(`pixels[${pixels.length}]`, pixels)
+	logger.log(`pixels[${pixels.length}]`, pixels)
 	throw new Error('Query reported result but nonce value not found')
 }
 
@@ -411,10 +411,10 @@ export async function generate (hash: bigint, difficulty: bigint, effort: number
 	let timeout = false
 	const kill = setTimeout(() => {
 		timeout = true
-		LOG: logger.log('timed out')
+		logger.log('timed out')
 	}, 60_000)
-	LOG: logger.groupStart('NanoPow WebGL work_generate')
-	LOG: logger.log(`generate('${bigHex(hash, 16)}', '${bigHex(difficulty, 16)}', ${effort}, ${debug})`)
+	logger.groupStart('NanoPow WebGL work_generate')
+	logger.log(`generate('${bigHex(hash, 16)}', '${bigHex(difficulty, 16)}', ${effort}, ${debug})`)
 
 	// Start drawing to calculate one nonce per pixel
 	const seed = new BigUint64Array(4)
@@ -429,7 +429,7 @@ export async function generate (hash: bigint, difficulty: bigint, effort: number
 				}
 				init(bigToU32(hash, 8), difficulty)
 				crypto.getRandomValues(seed)
-				LOG: logger.log('drawing frame 0')
+				logger.log('drawing frame 0')
 				draw(seed[0], drawFbos[0], queries[0])
 				draw(seed[1], drawFbos[1], queries[1])
 				draw(seed[2], drawFbos[2], queries[2])
@@ -444,7 +444,7 @@ export async function generate (hash: bigint, difficulty: bigint, effort: number
 				isFirstRetry = false
 			} catch (err) {
 				isFirstRetry = !isFirstRetry
-				LOG: logger.log(err)
+				logger.log(err)
 				if (!isFirstRetry) {
 					throw new Error('failed to restore context', { cause: err })
 				}
@@ -455,7 +455,7 @@ export async function generate (hash: bigint, difficulty: bigint, effort: number
 		clearTimeout(kill)
 		cancelAnimationFrame(raf)
 		raf = 0
-		LOG: logger.groupEnd('NanoPow WebGL work_generate')
+		logger.groupEnd('NanoPow WebGL work_generate')
 		if (!found) throw new Error(timeout ? 'timed out' : 'work not found for unknown reason')
 	}
 
diff --git a/src/lib/generate/webgpu/index.ts b/src/lib/generate/webgpu/index.ts
index e4894de..881b423 100644
--- a/src/lib/generate/webgpu/index.ts
+++ b/src/lib/generate/webgpu/index.ts
@@ -33,16 +33,16 @@ let resultBuffers: GPUBuffer[]
 // Initialize WebGPU
 async function start (): Promise<void> {
 	if (status === 'Idle') {
-		LOG: logger.log('starting')
+		logger.log('starting')
 		status = 'Starting'
 		await getDevice()
 		try {
 			await compile()
-			LOG: logger.log('ready')
+			logger.log('ready')
 			status = 'Ready'
 		} catch (err) {
 			status = 'Crashed'
-			LOG: logger.log(err)
+			logger.log(err)
 			throw new Error('failed to compile', { cause: err })
 		}
 	}
@@ -64,7 +64,7 @@ async function getDevice () {
 		throw new Error('failed to get device from gpu adapter')
 	}
 	device.lost?.then(async (deviceLostInfo) => {
-		LOG: logger.log('device lost', deviceLostInfo)
+		logger.log('device lost', deviceLostInfo)
 		// Set up 30s timeout to prevent long-running calls
 		isContextLost = window.setTimeout(() => {
 			throw new Error('failed to restore device', { cause: deviceLostInfo })
@@ -154,7 +154,7 @@ async function compile () {
 }
 
 async function restore (): Promise<void> {
-	LOG: logger.log('restoring')
+	logger.log('restoring')
 	try {
 		status = 'Restoring'
 		for (let i = 0; i < 2; i++) {
@@ -169,7 +169,7 @@ async function restore (): Promise<void> {
 		await compile()
 		window.clearTimeout(isContextLost)
 		isContextLost = 0
-		LOG: logger.log('ready')
+		logger.log('ready')
 		status = 'Ready'
 	} catch (err) {
 		status = 'Crashed'
@@ -178,7 +178,7 @@ async function restore (): Promise<void> {
 }
 
 async function init (hash: bigint, difficulty: bigint): Promise<void> {
-	LOG: logger.log('variables initializing')
+	logger.log('variables initializing')
 	try {
 		// Save hash data for normal usage and potential recovery efforts
 		hashData.set(bigToU64(hash, 4))
@@ -197,19 +197,19 @@ async function init (hash: bigint, difficulty: bigint): Promise<void> {
 		device.queue.writeBuffer(outputBuffers[0], 0, bufferReset)
 		device.queue.writeBuffer(outputBuffers[1], 0, bufferReset)
 	} catch (err) {
-		LOG: logger.log(err)
+		logger.log(err)
 		throw new Error('failed to initialize', { cause: err })
 	}
 }
 
 async function dispatch (dispatchIndex: number, seed: bigint, effort: number): Promise<void> {
-	LOG: logger.log('dispatching compute pass')
+	logger.log('dispatching compute pass')
 	try {
-		LOG: logger.log('seed', bigHex(seed, 16))
+		logger.log('seed', bigHex(seed, 16))
 
 		// Copy seed into INPUT buffer
 		inputDataView.setBigUint64(40, seed, true)
-		LOG: logger.log('INPUT', inputDataView)
+		logger.log('INPUT', inputDataView)
 		device.queue.writeBuffer(inputBuffers[dispatchIndex], 40, inputDataView, 40)
 
 		// Create command encoder to issue commands to GPU and initiate computation
@@ -229,23 +229,23 @@ async function dispatch (dispatchIndex: number, seed: bigint, effort: number): P
 		// End computation by passing array of command buffers to command queue for execution
 		device.queue.submit([commandEncoder.finish()])
 	} catch (err) {
-		LOG: logger.log(err)
+		logger.log(err)
 		throw new Error('failed to dispatch compute pass', { cause: err })
 	}
 }
 
 async function check (dispatchIndex: number): Promise<boolean> {
-	LOG: logger.log('checking results from compute pass')
+	logger.log('checking results from compute pass')
 	try {
 		await resultBuffers[dispatchIndex].mapAsync(GPUMapMode.READ)
 		resultViews[dispatchIndex] = new DataView(resultBuffers[dispatchIndex].getMappedRange().slice(0))
 		resultBuffers[dispatchIndex].unmap()
-		LOG: logger.log('OUTPUT', resultViews[dispatchIndex])
+		logger.log('OUTPUT', resultViews[dispatchIndex])
 		if (resultViews[dispatchIndex] == null) throw new Error('failed to get data from resultBuffer.')
 		return !!resultViews[dispatchIndex].getUint32(0, true)
 
 	} catch (err) {
-		LOG: logger.log(err)
+		logger.log(err)
 		throw new Error('failed to read results from compute pass', { cause: err })
 	}
 }
@@ -254,7 +254,7 @@ async function check (dispatchIndex: number): Promise<boolean> {
 * Map CPU buffer to GPU, read results to static result object, and unmap.
 */
 function read (dispatchIndex: number): { work: bigint, difficulty: bigint } {
-	LOG: logger.log('reading results from compute pass')
+	logger.log('reading results from compute pass')
 	try {
 		if (resultViews[dispatchIndex] == null) throw new Error('failed to get data from result view')
 		return {
@@ -262,7 +262,7 @@ function read (dispatchIndex: number): { work: bigint, difficulty: bigint } {
 			difficulty: resultViews[dispatchIndex].getBigUint64(16, true)
 		}
 	} catch (err) {
-		LOG: logger.log(err)
+		logger.log(err)
 		throw new Error('failed to read results from compute pass', { cause: err })
 	}
 }
@@ -278,8 +278,8 @@ export async function generate (hash: bigint, difficulty: bigint, effort: number
 		timeout = true
 		throw new Error('timed out')
 	}, 60_000)
-	LOG: logger.groupStart('NanoPow WebGPU work_generate')
-	LOG: logger.log('generating')
+	logger.groupStart('NanoPow WebGPU work_generate')
+	logger.log('generating')
 	const seed = new BigUint64Array(2)
 	let found = false
 	let result: Record<string, bigint> = {}
@@ -314,7 +314,7 @@ export async function generate (hash: bigint, difficulty: bigint, effort: number
 				}
 				// Only retry once here, allow errors to propagate out to the consumer
 				isFirstRetry = !isFirstRetry
-				LOG: logger.log(err)
+				logger.log(err)
 				if (!isFirstRetry) {
 					throw new Error('failed to restore device', { cause: err })
 				}
@@ -323,7 +323,7 @@ export async function generate (hash: bigint, difficulty: bigint, effort: number
 		} while (isFirstRetry)
 	} finally {
 		clearTimeout(kill)
-		LOG: logger.groupEnd('NanoPow WebGPU work_generate')
+		logger.groupEnd('NanoPow WebGPU work_generate')
 		if (!found && timeout) throw new Error('timed out')
 	}
 
diff --git a/src/lib/index.ts b/src/lib/index.ts
index 994494a..d08bc5c 100644
--- a/src/lib/index.ts
+++ b/src/lib/index.ts
@@ -4,7 +4,7 @@
 import { NanoPowConfig } from '#lib/config'
 import { NanoPowCpu, NanoPowWasm, NanoPowWebgl, NanoPowWebgpu } from '#lib/generate'
 import { NanoPowValidate } from '#lib/validate'
-import { big, Cache, Logger, MAX_HASH, Queue } from '#utils'
+import { Cache, Logger, MAX_HASH, Queue, big } from '#utils'
 import { WorkErrorResponse, WorkGenerateResponse, WorkValidateResponse } from 'nano-pow'
 
 const logger = new Logger()
@@ -14,10 +14,10 @@ export async function generate (blockhash: unknown, options?: unknown): Promise<
 	const { api, debug, difficulty, effort } = await NanoPowConfig(options)
 	const hash = big(blockhash)
 	if (hash < 0 || hash > MAX_HASH) throw RangeError('invalid block hash', { cause: blockhash })
-	LOG: logger.isEnabled = debug
+	logger.isEnabled = debug
 	const cached = Cache.search(hash, difficulty)
 	if (cached) {
-		LOG: logger.log('found work in cache')
+		logger.log('found work in cache')
 		const { valid } = NanoPowValidate(big(cached.work), big(cached.hash), difficulty, debug)
 		if (valid === '1') {
 			return cached
@@ -25,7 +25,7 @@ export async function generate (blockhash: unknown, options?: unknown): Promise<
 			try {
 				Cache.delete(hash)
 			} catch (err) {
-				LOG: logger.log('error deleting invalid work from cache, continuing with generate', err)
+				logger.log('error deleting invalid work from cache, continuing with generate', err)
 			}
 		}
 	}
diff --git a/src/lib/validate/index.ts b/src/lib/validate/index.ts
index cf99606..60f8d25 100644
--- a/src/lib/validate/index.ts
+++ b/src/lib/validate/index.ts
@@ -94,12 +94,12 @@ function blake2b (work: bigint, hash: bigint): void {
 }
 
 function log (work: bigint, hash: bigint, difficulty: bigint): void {
-	LOG: logger.groupStart('NanoPow CPU work_validate')
-	LOG: logger.log('NanoPow CPU work_validate', 'work', bigHex(work, 16))
-	LOG: logger.log('NanoPow CPU work_validate', 'hash', bigHex(hash, 64))
-	LOG: logger.log('NanoPow CPU work_validate', 'difficulty', bigHex(difficulty, 16))
-	LOG: logger.log('NanoPow CPU work_validate', 'result', bigHex(result, 16))
-	LOG: logger.groupEnd('NanoPow CPU work_validate')
+	logger.groupStart('NanoPow CPU work_validate')
+	logger.log('NanoPow CPU work_validate', 'work', bigHex(work, 16))
+	logger.log('NanoPow CPU work_validate', 'hash', bigHex(hash, 64))
+	logger.log('NanoPow CPU work_validate', 'difficulty', bigHex(difficulty, 16))
+	logger.log('NanoPow CPU work_validate', 'result', bigHex(result, 16))
+	logger.groupEnd('NanoPow CPU work_validate')
 }
 
 function validate (work: bigint, hash: bigint, difficulty: bigint, debug: boolean): WorkValidateResponse {