@spirobel/monero-wallet-api 0.3.18 → 0.4.1

package/dist/node-interaction/jsonEndpoints.js

@@ -1,51 +1,95 @@
-import { z } from "zod";
-export const GetInfoResponseSchema = z.object({
-    id: z.string(),
-    jsonrpc: z.literal("2.0"),
-    result: z.object({
-        adjusted_time: z.number(),
-        alt_blocks_count: z.number(),
-        block_size_limit: z.number(),
-        block_size_median: z.number(),
-        block_weight_limit: z.number(),
-        block_weight_median: z.number(),
-        bootstrap_daemon_address: z.string(),
-        busy_syncing: z.boolean(),
-        credits: z.number(),
-        cumulative_difficulty: z.number(),
-        cumulative_difficulty_top64: z.number(),
-        database_size: z.number(),
-        difficulty: z.number(),
-        difficulty_top64: z.number(),
-        free_space: z.number(),
-        grey_peerlist_size: z.number(),
-        height: z.number(),
-        height_without_bootstrap: z.number(),
-        incoming_connections_count: z.number(),
-        mainnet: z.boolean(),
-        nettype: z.string(),
-        offline: z.boolean(),
-        outgoing_connections_count: z.number(),
-        restricted: z.boolean(),
-        rpc_connections_count: z.number(),
-        stagenet: z.boolean(),
-        start_time: z.number(),
-        status: z.string(),
-        synchronized: z.boolean(),
-        target: z.number(),
-        target_height: z.number(),
-        testnet: z.boolean(),
-        top_block_hash: z.string(),
-        top_hash: z.string(),
-        tx_count: z.number(),
-        tx_pool_size: z.number(),
-        untrusted: z.boolean(),
-        update_available: z.boolean(),
-        version: z.string(),
-        was_bootstrap_ever_used: z.boolean(),
-        white_peerlist_size: z.number(),
-        wide_cumulative_difficulty: z.string(),
-        wide_difficulty: z.string(),
+function obj(s) {
+    function p(d) {
+        if (typeof d !== "object" || d === null)
+            throw 0;
+        const r = {};
+        for (const k in s)
+            r[k] = s[k](d[k]);
+        return r;
+    }
+    p.safeParse = (d) => {
+        try {
+            return { success: true, data: p(d) };
+        }
+        catch {
+            return { success: false, error: new Error() };
+        }
+    };
+    return p;
+}
+const str = (x) => {
+    if (typeof x !== "string")
+        throw 0;
+    return x;
+};
+const num = (x) => {
+    if (typeof x !== "number")
+        throw 0;
+    return x;
+};
+const bool = (x) => {
+    if (typeof x !== "boolean")
+        throw 0;
+    return x;
+};
+const lit = (v) => (x) => {
+    if (x !== v)
+        throw 0;
+    return v;
+};
+const arr = (f) => (x) => {
+    if (!Array.isArray(x))
+        throw 0;
+    return x.map(f);
+};
+const opt = (f) => (x) => x === undefined ? undefined : f(x);
+export const GetInfoResponseSchema = obj({
+    id: str,
+    jsonrpc: lit("2.0"),
+    result: obj({
+        adjusted_time: num,
+        alt_blocks_count: num,
+        block_size_limit: num,
+        block_size_median: num,
+        block_weight_limit: num,
+        block_weight_median: num,
+        bootstrap_daemon_address: str,
+        busy_syncing: bool,
+        credits: num,
+        cumulative_difficulty: num,
+        cumulative_difficulty_top64: num,
+        database_size: num,
+        difficulty: num,
+        difficulty_top64: num,
+        free_space: num,
+        grey_peerlist_size: num,
+        height: num,
+        height_without_bootstrap: num,
+        incoming_connections_count: num,
+        mainnet: bool,
+        nettype: str,
+        offline: bool,
+        outgoing_connections_count: num,
+        restricted: bool,
+        rpc_connections_count: num,
+        stagenet: bool,
+        start_time: num,
+        status: str,
+        synchronized: bool,
+        target: num,
+        target_height: num,
+        testnet: bool,
+        top_block_hash: str,
+        top_hash: str,
+        tx_count: num,
+        tx_pool_size: num,
+        untrusted: bool,
+        update_available: bool,
+        version: str,
+        was_bootstrap_ever_used: bool,
+        white_peerlist_size: num,
+        wide_cumulative_difficulty: str,
+        wide_difficulty: str,
     }),
 });
 /**
@@ -61,17 +105,17 @@ export const GetInfoResponseSchema = z.object({
  *     - start_height:  unsigned int; Note that this is not necessarily equal to from_height, especially for amount=0 where start_height will be no less than the height of the v4 hardfork.
  *   - status: string; General RPC error code. "OK" means everything looks good.
  */
-export const GetOutputDistributionResponseSchema = z.object({
-    id: z.string(),
-    jsonrpc: z.literal("2.0"),
-    result: z.object({
-        distributions: z.array(z.object({
-            amount: z.number(),
-            base: z.number(),
-            distribution: z.array(z.number()),
-            start_height: z.number(),
+export const GetOutputDistributionResponseSchema = obj({
+    id: str,
+    jsonrpc: lit("2.0"),
+    result: obj({
+        distributions: arr(obj({
+            amount: num,
+            base: num,
+            distribution: arr(num),
+            start_height: num,
         })),
-        status: z.string(),
+        status: str,
     }),
 });
 export function parseGetOutputDistributionResponse(data) {
@@ -154,14 +198,14 @@ export async function get_output_distribution(NODE_URL, params = {
  *   - fees: (Optional) Array of unsigned int; Fee estimates for priorities 1–4.
  *   - quantization_mask: unsigned int; Mask used for fee rounding.
  */
-export const GetFeeEstimateResponseSchema = z.object({
-    id: z.string(),
-    jsonrpc: z.literal("2.0"),
-    result: z.object({
-        status: z.string(),
-        fee: z.number(),
-        fees: z.array(z.number()).optional(),
-        quantization_mask: z.number(),
+export const GetFeeEstimateResponseSchema = obj({
+    id: str,
+    jsonrpc: lit("2.0"),
+    result: obj({
+        status: str,
+        fee: num,
+        fees: opt(arr(num)),
+        quantization_mask: num,
     }),
 });
 export function parseGetFeeEstimateResponse(data) {
@@ -199,19 +243,19 @@ export async function get_fee_estimate(NODE_URL) {
     }
     return parsedResult.result;
 }
-export const SendRawTransactionResponseSchema = z.object({
-    double_spend: z.boolean(), // double_spend - boolean; Transaction is a double spend (true) or not (false).
-    fee_too_low: z.boolean(), // fee_too_low - boolean; Fee is too low (true) or OK (false).
-    invalid_input: z.boolean(), // invalid_input - boolean; Input is invalid (true) or valid (false).
-    invalid_output: z.boolean(), // invalid_output - boolean; Output is invalid (true) or valid (false).
-    low_mixin: z.boolean(), // low_mixin - boolean; Mixin count is too low (true) or OK (false).
-    not_rct: z.boolean().optional(), // not_rct - boolean; Transaction is a standard ring transaction (true) or a ring confidential transaction (false).
-    not_relayed: z.boolean(), // not_relayed - boolean; Transaction was not relayed (true) or relayed (false).
-    overspend: z.boolean(), // overspend - boolean; Transaction uses more money than available (true) or not (false).
-    reason: z.string(), // reason - string; Additional information. Currently empty or "Not relayed" if transaction was accepted but not relayed.
-    status: z.string(), // status - string; General RPC error code. "OK" means everything looks good. Any other value means that something went wrong.
-    too_big: z.boolean(), // too_big - boolean; Transaction size is too big (true) or OK (false).
-    untrusted: z.boolean(), // untrusted - boolean; States if the result is obtained using the bootstrap mode, and is therefore not trusted (true), or when the daemon is fully synced and thus handles the RPC locally (false)
+export const SendRawTransactionResponseSchema = obj({
+    double_spend: bool, // double_spend - boolean; Transaction is a double spend (true) or not (false).
+    fee_too_low: bool, // fee_too_low - boolean; Fee is too low (true) or OK (false).
+    invalid_input: bool, // invalid_input - boolean; Input is invalid (true) or valid (false).
+    invalid_output: bool, // invalid_output - boolean; Output is invalid (true) or valid (false).
+    low_mixin: bool, // low_mixin - boolean; Mixin count is too low (true) or OK (false).
+    not_rct: opt(bool), // not_rct - boolean; Transaction is a standard ring transaction (true) or a ring confidential transaction (false).
+    not_relayed: bool, // not_relayed - boolean; Transaction was not relayed (true) or relayed (false).
+    overspend: bool, // overspend - boolean; Transaction uses more money than available (true) or not (false).
+    reason: str, // reason - string; Additional information. Currently empty or "Not relayed" if transaction was accepted but not relayed.
+    status: str, // status - string; General RPC error code. "OK" means everything looks good. Any other value means that something went wrong.
+    too_big: bool, // too_big - boolean; Transaction size is too big (true) or OK (false).
+    untrusted: bool, // untrusted - boolean; States if the result is obtained using the bootstrap mode, and is therefore not trusted (true), or when the daemon is fully synced and thus handles the RPC locally (false)
 });
 export function parseSendRawTransactionResponse(data) {
     const result = SendRawTransactionResponseSchema.safeParse(data);
@@ -279,47 +323,43 @@ do_not_relay = false) {
  * - code: int; Error code.
  * - message: string; Error message.
  */
-export const GetBlockHeadersRangeResponseSchema = z.object({
-    id: z.string(),
-    jsonrpc: z.literal("2.0"),
-    result: z
-        .object({
-        credits: z.number(),
-        headers: z.array(z.object({
-            block_size: z.number(),
-            block_weight: z.number(),
-            cumulative_difficulty: z.number(),
-            cumulative_difficulty_top64: z.number(),
-            depth: z.number(),
-            difficulty: z.number(),
-            difficulty_top64: z.number(),
-            hash: z.string(),
-            height: z.number(),
-            long_term_weight: z.number(),
-            major_version: z.number(),
-            miner_tx_hash: z.string(),
-            minor_version: z.number(),
-            nonce: z.number(),
-            num_txes: z.number(),
-            orphan_status: z.boolean(),
-            pow_hash: z.string(),
-            prev_hash: z.string(),
-            reward: z.number(),
-            timestamp: z.number(),
-            wide_cumulative_difficulty: z.string(),
-            wide_difficulty: z.string(),
+export const GetBlockHeadersRangeResponseSchema = obj({
+    id: str,
+    jsonrpc: lit("2.0"),
+    result: opt(obj({
+        credits: num,
+        headers: arr(obj({
+            block_size: num,
+            block_weight: num,
+            cumulative_difficulty: num,
+            cumulative_difficulty_top64: num,
+            depth: num,
+            difficulty: num,
+            difficulty_top64: num,
+            hash: str,
+            height: num,
+            long_term_weight: num,
+            major_version: num,
+            miner_tx_hash: str,
+            minor_version: num,
+            nonce: num,
+            num_txes: num,
+            orphan_status: bool,
+            pow_hash: str,
+            prev_hash: str,
+            reward: num,
+            timestamp: num,
+            wide_cumulative_difficulty: str,
+            wide_difficulty: str,
         })),
-        status: z.string(),
-        top_hash: z.string(),
-        untrusted: z.boolean(),
-    })
-        .optional(),
-    error: z
-        .object({
-        code: z.number(),
-        message: z.string(),
-    })
-        .optional(),
+        status: str,
+        top_hash: str,
+        untrusted: bool,
+    })),
+    error: opt(obj({
+        code: num,
+        message: str,
+    })),
 });
 export function parseGetBlockHeadersRangeResponse(data) {
     const result = GetBlockHeadersRangeResponseSchema.safeParse(data);

package/dist/node-interaction/nodeUrl.d.ts

@@ -1,5 +1,6 @@
-import { type GetBlocksBinRequest, type Output, type GetOutsBinRequest } from "./binaryEndpoints";
+import { type Output, type GetBlocksBinRequest, type GetBlocksResultMeta, type GetOutsBinRequest } from "./binaryEndpoints";
 import { type FeeEstimateResponse, type GetBlockHeadersRangeParams, type GetOutputDistributionParams, type SendRawTransactionResult } from "./jsonEndpoints";
+export type NETWORKS = "mainnet" | "stagenet" | "testnet";
 import { type SignedTransaction, type Input } from "../send-functionality/transactionBuilding";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
 /**
@@ -11,14 +12,27 @@ import { WasmProcessor } from "../wasm-processing/wasmProcessor";
 export declare class NodeUrl extends WasmProcessor {
     node_url: string;
     protected constructor(node_url: string);
+    private _network;
+    get network(): NETWORKS;
+    private _genesis_hash;
+    get genesis_hash(): string;
     static create(node_url?: string): Promise<NodeUrl>;
     /**
-     * This request helps making requests to the get_blocks.bin endpoint of the Monerod nodes.
-     *  @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
-     * @param params params that will be turned into epee (moner lib that does binary serialization)
-     * @returns after the request is made it will return epee serialized objects that are then parsed into json.
+     * Executes a get_blocks.bin request and returns the raw binary response buffer.
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
+     * @param params params for the get_blocks.bin request
+     * @param stopSync optional AbortSignal
+     * @returns the raw binary response buffer
+     */
+    getBlocksBinExecuteRequest(params: GetBlocksBinRequest, stopSync?: AbortSignal): Promise<Uint8Array<ArrayBufferLike>>;
+    /**
+     * Loads a getBlocks.bin response into the WASM module.
+     * Unlike getBlocksBinExecuteRequest, this does not make a request, it parses an already fetched
+     * binary response and stores it in WASM memory. Subsequent calls overwrite the stored response.
+     * @param getBlocksBinResponseBuffer the raw binary response from the get_blocks.bin endpoint
+     * @returns metadata about the loaded blocks (new_height, daemon_height, status, block_infos)
      */
-    getBlocksBin(params: GetBlocksBinRequest): Promise<import("./binaryEndpoints").GetBlocksBinResponse | import("./binaryEndpoints").ErrorResponse>;
+    loadGetBlocksBinResponse(getBlocksBinResponseBuffer: Uint8Array): Promise<GetBlocksResultMeta>;
     /**
      * This request helps making requests to the get_outs.bin endpoint of the Monerod nodes.
      *  @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_outsbin
@@ -125,5 +139,6 @@ export declare class NodeUrl extends WasmProcessor {
         wide_cumulative_difficulty: string;
         wide_difficulty: string;
     }>;
+    addGenesisHashToBlockIds(params: GetBlocksBinRequest): Promise<GetBlocksBinRequest>;
 }
 export declare const LOCAL_NODE_DEFAULT_URL = "http://127.0.0.1:18081";

package/dist/node-interaction/nodeUrl.js

@@ -1,4 +1,4 @@
-import { getBlocksBinJson, getOutsBinJson, getOutsBinExecuteRequest, } from "./binaryEndpoints";
+import { getBlocksBinExecuteRequest, loadGetBlocksBinResponse, getOutsBinJson, getOutsBinExecuteRequest, MAINNET_GENESIS_BLOCK_HASH, STAGENET_GENESIS_BLOCK_HASH, } from "./binaryEndpoints";
 import { get_block_headers_range, get_fee_estimate, get_info, get_output_distribution, send_raw_transaction, } from "./jsonEndpoints";
 import { makeInput, sampleDecoys, } from "../send-functionality/transactionBuilding";
 import { WasmProcessor } from "../wasm-processing/wasmProcessor";
@@ -14,19 +14,41 @@ export class NodeUrl extends WasmProcessor {
         super();
         this.node_url = node_url;
     }
+    _network;
+    get network() {
+        return this._network; // we set this in ViewPair.create()
+    }
+    _genesis_hash;
+    get genesis_hash() {
+        if (!this._genesis_hash) {
+            throw new Error("Genesis hash not set. Node not connected?");
+        }
+        return this._genesis_hash; // set in first call to ViewPair.getBlocksBin, if params.block_ids is supplied
+    }
     static async create(node_url) {
         const nodeUrl = new NodeUrl(node_url || LOCAL_NODE_DEFAULT_URL);
         await nodeUrl.initWasmModule();
         return nodeUrl;
     }
     /**
-     * This request helps making requests to the get_blocks.bin endpoint of the Monerod nodes.
-     *  @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
-     * @param params params that will be turned into epee (moner lib that does binary serialization)
-     * @returns after the request is made it will return epee serialized objects that are then parsed into json.
+     * Executes a get_blocks.bin request and returns the raw binary response buffer.
+     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
+     * @param params params for the get_blocks.bin request
+     * @param stopSync optional AbortSignal
+     * @returns the raw binary response buffer
      */
-    getBlocksBin(params) {
-        return getBlocksBinJson(this, params);
+    async getBlocksBinExecuteRequest(params, stopSync) {
+        return await getBlocksBinExecuteRequest(this, await this.addGenesisHashToBlockIds(params), stopSync);
+    }
+    /**
+     * Loads a getBlocks.bin response into the WASM module.
+     * Unlike getBlocksBinExecuteRequest, this does not make a request, it parses an already fetched
+     * binary response and stores it in WASM memory. Subsequent calls overwrite the stored response.
+     * @param getBlocksBinResponseBuffer the raw binary response from the get_blocks.bin endpoint
+     * @returns metadata about the loaded blocks (new_height, daemon_height, status, block_infos)
+     */
+    loadGetBlocksBinResponse(getBlocksBinResponseBuffer) {
+        return loadGetBlocksBinResponse(this, getBlocksBinResponseBuffer);
     }
     /**
      * This request helps making requests to the get_outs.bin endpoint of the Monerod nodes.
@@ -99,7 +121,7 @@ export class NodeUrl extends WasmProcessor {
      * @returns The result object with headers, status, etc. Throws if the range is invalid:(end_height > daemonheight)
      */
     async getBlockHeadersRange(params) {
-        return get_block_headers_range(this.node_url, params);
+        return await get_block_headers_range(this.node_url, params);
     }
     /**
      * Fetch general information about the Monero daemon.
@@ -109,5 +131,25 @@ export class NodeUrl extends WasmProcessor {
     async getInfo() {
         return get_info(this.node_url);
     }
+    async addGenesisHashToBlockIds(params) {
+        if (params.block_ids) {
+            if (!this._genesis_hash && this.network === "mainnet") {
+                this._genesis_hash = MAINNET_GENESIS_BLOCK_HASH;
+            }
+            if (!this._genesis_hash && this.network === "stagenet") {
+                this._genesis_hash = STAGENET_GENESIS_BLOCK_HASH;
+            }
+            if (!this._genesis_hash) {
+                // TESTNET
+                const range = await this.getBlockHeadersRange({
+                    start_height: 0,
+                    end_height: 0,
+                });
+                this._genesis_hash = range.headers[0].hash;
+            }
+            params.block_ids.push(this.genesis_hash);
+        }
+        return params;
+    }
 }
 export const LOCAL_NODE_DEFAULT_URL = "http://127.0.0.1:18081";

package/dist/scanning-syncing/backgroundWorker.d.ts

@@ -1,6 +1,10 @@
-import { type CacheChangedCallback, type CacheChangedCallbackParameters } from "./scanresult/scanCache";
-export declare function scanWallets(cacheChanged?: CacheChangedCallback, stopSync?: AbortSignal, scan_settings_path?: string, pathPrefix?: string): Promise<void>;
-export declare function createWebworker(handle_result?: (result: CacheChangedCallbackParameters) => void, scan_settings_path?: string, pathPrefix?: string, handle_error?: (error: unknown) => void): Promise<Worker | undefined>;
-export declare function makeWebworkerScript(scan_settings_path?: string, pathPrefix?: string): string;
-export declare function startWebworker(worker_script: string, handle_result?: (result: unknown) => void, handle_error?: (error: unknown) => void): Worker;
-export declare const WW_ERROR_FORWARDING_SNIPPET = "\n\nself.onerror = (e) => self.postMessage({ type: 'ERROR', payload: e });\nself.addEventListener('unhandledrejection', (e) => \n  self.postMessage({ type: 'ERROR', payload: e.reason })\n); \n";
+import { type CacheChangedCallbackParameters } from "./scanresult/scanCache";
+export declare const CPU_POOL_SIZE = 4;
+export type WorkerSet = {
+    fetchWorker: Worker;
+    cpuWorkers: Worker[];
+    terminate: () => void;
+};
+export declare function createWebworker(handle_result?: (result: CacheChangedCallbackParameters) => void, scan_settings_path?: string, pathPrefix?: string, handle_error?: (error: unknown) => void): Promise<WorkerSet | undefined>;
+export declare function makeWebworkerScript(): string;
+export declare function startWebworker(handle_result?: (result: unknown) => void, handle_error?: (error: unknown) => void): Worker;

package/dist/scanning-syncing/backgroundWorker.js

@@ -1,66 +1,115 @@
-import { get_info, ViewPair } from "../api";
 import { LOCAL_NODE_DEFAULT_URL } from "../node-interaction/nodeUrl";
 import {} from "./scanresult/scanCache";
-import { openNonHaltedWallets, readNodeUrlFromScanSettings, walletSettingsPlusKeys, } from "./scanSettings";
+import { openScanSettingsFile, SCAN_SETTINGS_STORE_NAME_DEFAULT, } from "./scanSettings";
+import { log, setupLoggingPath } from "../io/logging";
 import { workerMainCode } from "./worker-entrypoints/worker";
-export async function scanWallets(cacheChanged = (params) => console.log(params), stopSync, scan_settings_path, pathPrefix) {
-    const nonHaltedWallets = await openNonHaltedWallets(scan_settings_path);
-    const masterWalletSettings = nonHaltedWallets[0];
-    if (!masterWalletSettings)
-        return;
-    const masterWithKeys = await walletSettingsPlusKeys(masterWalletSettings);
-    const masterViewPair = await ViewPair.create(masterWalletSettings.primary_address, masterWithKeys.secret_view_key, masterWalletSettings.subaddress_index, masterWalletSettings.node_url);
-    await masterViewPair.scan(cacheChanged, stopSync, scan_settings_path, pathPrefix);
-}
+export const CPU_POOL_SIZE = 4;
 export async function createWebworker(handle_result, scan_settings_path, pathPrefix, handle_error) {
     try {
-        const node_url = (await readNodeUrlFromScanSettings(scan_settings_path)) ||
-            LOCAL_NODE_DEFAULT_URL;
-        // check if the node connection works before starting the sync worker
-        const getInfo = await get_info(node_url);
-        const worker_script = makeWebworkerScript(scan_settings_path, pathPrefix);
-        return startWebworker(worker_script, handle_result, handle_error);
+        const resolvedPath = scan_settings_path || SCAN_SETTINGS_STORE_NAME_DEFAULT;
+        const scanSettings = await openScanSettingsFile(resolvedPath);
+        await setupLoggingPath(resolvedPath, pathPrefix ?? "", "mainthread");
+        const node_url = scanSettings?.node_url || LOCAL_NODE_DEFAULT_URL;
+        const cpu_worker_count = typeof scanSettings?.cpu_worker_count !== "undefined"
+            ? scanSettings?.cpu_worker_count
+            : CPU_POOL_SIZE;
+        // spawn CPU workers
+        const cpuWorkers = [];
+        const cpuPorts = [];
+        for (let i = 0; i < cpu_worker_count; i++) {
+            const channel = new MessageChannel();
+            const cpuWorker = await startWebworkerReady();
+            cpuWorker.postMessage({
+                type: "setup",
+                role: "cpubound",
+                cpu_worker_id: i,
+                scan_settings_path: resolvedPath,
+                pathPrefix,
+            }, [channel.port1]);
+            cpuWorker.onerror = (e) => {
+                if (handle_error)
+                    handle_error("cpu worker " + i + " error: " + (e.message ?? String(e)));
+            };
+            cpuWorkers.push(cpuWorker);
+            cpuPorts.push(channel.port2);
+        }
+        const coordinationWorker = await startWebworkerReady();
+        coordinationWorker.postMessage({
+            type: "setup",
+            scan_settings_path: resolvedPath,
+            pathPrefix,
+            role: "coordinator",
+            node_url,
+            start_height: 0,
+        }, cpuPorts); // transfer CPU port2s to coordination worker
+        log("createWebworker", [
+            "coordinator worker started, node_url=" + node_url,
+            ", cpuPorts=" + cpuPorts.length,
+        ]);
+        coordinationWorker.onmessage = (event) => {
+            if (event.data.type === "ERROR") {
+                if (handle_error)
+                    handle_error(event.data.payload);
+            }
+            else if (event.data.type === "SCAN_RESULT") {
+                if (handle_result)
+                    handle_result(event.data.payload);
+            }
+        };
+        return {
+            fetchWorker: coordinationWorker,
+            cpuWorkers,
+            terminate: () => {
+                coordinationWorker.terminate();
+                for (const w of cpuWorkers)
+                    w.terminate();
+            },
+        };
     }
     catch (error) {
         handle_error?.(error);
     }
 }
-export function makeWebworkerScript(scan_settings_path, pathPrefix) {
-    const settingsPathLine = scan_settings_path
-        ? `const scan_settings_path = '${scan_settings_path}';`
-        : "const scan_settings_path = undefined;";
-    const pathPrefixLine = pathPrefix
-        ? `const pathPrefix = '${pathPrefix}';`
-        : "const pathPrefix = undefined;";
-    return `\n
-      ${settingsPathLine}
-      ${pathPrefixLine}
-      ${workerMainCode}
-      `;
+export function makeWebworkerScript() {
+    return workerMainCode;
 }
-export function startWebworker(worker_script, handle_result, handle_error) {
-    const blob = new Blob([WW_ERROR_FORWARDING_SNIPPET + worker_script], {
+export function startWebworker(handle_result, handle_error) {
+    const blob = new Blob([workerMainCode], {
         type: "text/javascript",
     });
     const url = URL.createObjectURL(blob);
     const worker = new Worker(url, { type: "module" });
     worker.onmessage = (event) => {
         switch (event.data.type) {
-            case "RESULT": // Handle normal messages
+            case "RESULT":
                 if (handle_result)
                     handle_result(event.data.payload);
                 break;
             case "ERROR":
+            case "scan_error":
                 if (handle_error)
-                    handle_error(event.data.payload);
+                    handle_error(event.data.payload ?? event.data.error);
+                break;
+            case "DEBUG":
+                log("startWebworker", ["worker debug:", event.data.payload]);
                 break;
         }
     };
     return worker;
 }
-// Autoforward ALL errors with error type (global handlers)
-export const WW_ERROR_FORWARDING_SNIPPET = `\n
-self.onerror = (e) => self.postMessage({ type: 'ERROR', payload: e });
-self.addEventListener('unhandledrejection', (e) => 
-  self.postMessage({ type: 'ERROR', payload: e.reason })
-); \n`;
+// creates a worker via startWebworker, then waits for it to signal
+// WORKER_READY (meaning self.onmessage = handleMessage has executed).
+// after that, postMessage is safe, no race between worker startup
+// and message delivery.
+function startWebworkerReady() {
+    const worker = startWebworker();
+    return new Promise((resolve) => {
+        const onReady = (e) => {
+            if (e.data?.type === "WORKER_READY") {
+                worker.removeEventListener("message", onReady);
+                resolve(worker);
+            }
+        };
+        worker.addEventListener("message", onReady);
+    });
+}