@spirobel/monero-wallet-api 0.5.4 → 0.6.0

package/dist/actionlog/idbBackend.js

@@ -0,0 +1,98 @@
+import { OpenInvocationMaps } from "./openMaps";
+const DB_NAME_DEFAULT = "monero-actionlog";
+const STORE_EVENTS = "events";
+export class ActionLogIdbBackend {
+    db;
+    open = new OpenInvocationMaps();
+    constructor(db) {
+        this.db = db;
+    }
+    static async open(dbName = DB_NAME_DEFAULT) {
+        if (typeof indexedDB === "undefined") {
+            throw new Error("IndexedDB not available");
+        }
+        const db = await openDb(dbName);
+        const backend = new ActionLogIdbBackend(db);
+        await backend.rebuildOpenMaps();
+        return backend;
+    }
+    async rebuildOpenMaps() {
+        this.open.clear();
+        const events = await this.getAllEventsOrdered();
+        for (const event of events)
+            this.open.apply(event);
+    }
+    getAllEventsOrdered() {
+        return new Promise((resolve, reject) => {
+            const tx = this.db.transaction(STORE_EVENTS, "readonly");
+            const store = tx.objectStore(STORE_EVENTS);
+            const req = store.getAll();
+            req.onerror = () => reject(req.error);
+            req.onsuccess = () => {
+                const rows = req.result ?? [];
+                rows.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+                resolve(rows);
+            };
+        });
+    }
+    async append(event) {
+        await new Promise((resolve, reject) => {
+            const tx = this.db.transaction(STORE_EVENTS, "readwrite");
+            const store = tx.objectStore(STORE_EVENTS);
+            const req = store.put(event);
+            req.onerror = () => reject(req.error);
+            req.onsuccess = () => resolve();
+        });
+        this.open.apply(event);
+    }
+    async getBranch(invocationId) {
+        return new Promise((resolve, reject) => {
+            const tx = this.db.transaction(STORE_EVENTS, "readonly");
+            const store = tx.objectStore(STORE_EVENTS);
+            const index = store.index("invocationId");
+            const req = index.getAll(invocationId);
+            req.onerror = () => reject(req.error);
+            req.onsuccess = () => {
+                const rows = req.result ?? [];
+                rows.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+                resolve(rows);
+            };
+        });
+    }
+    async getTip(invocationId) {
+        const branch = await this.getBranch(invocationId);
+        return branch.length ? branch[branch.length - 1] : null;
+    }
+    async getOpenByToolId(toolId) {
+        return this.open.getOpenByToolId(toolId);
+    }
+    async getOpenInvocations() {
+        return this.open.getOpenInvocations();
+    }
+    async feed(events) {
+        for (const event of events)
+            await this.append(event);
+    }
+    async reload() {
+        await this.rebuildOpenMaps();
+    }
+    async close() {
+        this.db.close();
+    }
+}
+function openDb(name) {
+    return new Promise((resolve, reject) => {
+        const req = indexedDB.open(name, 1);
+        req.onerror = () => reject(req.error);
+        req.onupgradeneeded = () => {
+            const db = req.result;
+            if (!db.objectStoreNames.contains(STORE_EVENTS)) {
+                const store = db.createObjectStore(STORE_EVENTS, { keyPath: "id" });
+                store.createIndex("invocationId", "invocationId", { unique: false });
+                store.createIndex("toolId", "toolId", { unique: false });
+                store.createIndex("timestamp", "timestamp", { unique: false });
+            }
+        };
+        req.onsuccess = () => resolve(req.result);
+    });
+}

package/dist/actionlog/jsonlBackend.d.ts

@@ -0,0 +1,19 @@
+import type { ActionLogBackend } from "./backend";
+import type { ActionLogEvent, OpenInvocationState } from "./types";
+import type { ToolId } from "../tools/monero-tools";
+export declare class ActionLogJsonlBackend implements ActionLogBackend {
+    private readonly path;
+    private events;
+    private open;
+    constructor(path: string);
+    static open(path: string): Promise<ActionLogJsonlBackend>;
+    private load;
+    private persist;
+    append(event: ActionLogEvent): Promise<void>;
+    getBranch(invocationId: string): Promise<ActionLogEvent[]>;
+    getTip(invocationId: string): Promise<ActionLogEvent | null>;
+    getOpenByToolId(toolId: ToolId): Promise<OpenInvocationState | null>;
+    getOpenInvocations(): Promise<OpenInvocationState[]>;
+    feed(events: ActionLogEvent[]): Promise<void>;
+    reload(): Promise<void>;
+}

package/dist/actionlog/jsonlBackend.js

@@ -0,0 +1,75 @@
+import { atomicWrite } from "../io/atomicWrite";
+import { OpenInvocationMaps } from "./openMaps";
+export class ActionLogJsonlBackend {
+    path;
+    events = [];
+    open = new OpenInvocationMaps();
+    constructor(path) {
+        this.path = path;
+    }
+    static async open(path) {
+        const backend = new ActionLogJsonlBackend(path);
+        await backend.load();
+        return backend;
+    }
+    async load() {
+        const text = await Bun.file(this.path)
+            .text()
+            .catch(() => "");
+        this.events = [];
+        this.open.clear();
+        if (!text.trim())
+            return;
+        for (const line of text.split("\n")) {
+            const t = line.trim();
+            if (!t)
+                continue;
+            try {
+                const event = JSON.parse(t);
+                this.events.push(event);
+                this.open.apply(event);
+            }
+            catch {
+                // skip bad line
+            }
+        }
+    }
+    async persist() {
+        const body = this.events.map((e) => JSON.stringify(e)).join("\n") +
+            (this.events.length ? "\n" : "");
+        await atomicWrite(this.path, body);
+    }
+    async append(event) {
+        this.events.push(event);
+        this.open.apply(event);
+        await this.persist();
+    }
+    async getBranch(invocationId) {
+        return this.events.filter((e) => e.invocationId === invocationId);
+    }
+    async getTip(invocationId) {
+        for (let i = this.events.length - 1; i >= 0; i--) {
+            if (this.events[i].invocationId === invocationId)
+                return this.events[i];
+        }
+        return null;
+    }
+    async getOpenByToolId(toolId) {
+        return this.open.getOpenByToolId(toolId);
+    }
+    async getOpenInvocations() {
+        return this.open.getOpenInvocations();
+    }
+    async feed(events) {
+        for (const event of events) {
+            if (this.events.some((e) => e.id === event.id))
+                continue;
+            this.events.push(event);
+            this.open.apply(event);
+        }
+        await this.persist();
+    }
+    async reload() {
+        await this.load();
+    }
+}

package/dist/actionlog/memoryBackend.d.ts

@@ -0,0 +1,14 @@
+import type { ActionLogBackend } from "./backend";
+import type { ActionLogEvent, OpenInvocationState } from "./types";
+import type { ToolId } from "../tools/monero-tools";
+export declare class ActionLogMemoryBackend implements ActionLogBackend {
+    private events;
+    private open;
+    append(event: ActionLogEvent): Promise<void>;
+    getBranch(invocationId: string): Promise<ActionLogEvent[]>;
+    getTip(invocationId: string): Promise<ActionLogEvent | null>;
+    getOpenByToolId(toolId: ToolId): Promise<OpenInvocationState | null>;
+    getOpenInvocations(): Promise<OpenInvocationState[]>;
+    feed(events: ActionLogEvent[]): Promise<void>;
+    reload(): Promise<void>;
+}

package/dist/actionlog/memoryBackend.js

@@ -0,0 +1,38 @@
+import { OpenInvocationMaps } from "./openMaps";
+export class ActionLogMemoryBackend {
+    events = [];
+    open = new OpenInvocationMaps();
+    async append(event) {
+        this.events.push(event);
+        this.open.apply(event);
+    }
+    async getBranch(invocationId) {
+        return this.events.filter((e) => e.invocationId === invocationId);
+    }
+    async getTip(invocationId) {
+        for (let i = this.events.length - 1; i >= 0; i--) {
+            if (this.events[i].invocationId === invocationId)
+                return this.events[i];
+        }
+        return null;
+    }
+    async getOpenByToolId(toolId) {
+        return this.open.getOpenByToolId(toolId);
+    }
+    async getOpenInvocations() {
+        return this.open.getOpenInvocations();
+    }
+    async feed(events) {
+        for (const event of events) {
+            if (this.events.some((e) => e.id === event.id))
+                continue;
+            this.events.push(event);
+            this.open.apply(event);
+        }
+    }
+    async reload() {
+        this.open.clear();
+        for (const event of this.events)
+            this.open.apply(event);
+    }
+}

package/dist/actionlog/openMaps.d.ts

@@ -0,0 +1,11 @@
+import type { ToolId } from "../tools/monero-tools";
+import { type ActionLogEvent, type OpenInvocationState } from "./types";
+/** shared open-invocation maps for backends without a native secondary index */
+export declare class OpenInvocationMaps {
+    byInvocation: Map<string, OpenInvocationState>;
+    byTool: Map<"001" | "002", string>;
+    apply(event: ActionLogEvent): void;
+    clear(): void;
+    getOpenByToolId(toolId: ToolId): OpenInvocationState | null;
+    getOpenInvocations(): OpenInvocationState[];
+}

package/dist/actionlog/openMaps.js

@@ -0,0 +1,32 @@
+import { applyEventToState, isTerminalEventType, } from "./types";
+/** shared open-invocation maps for backends without a native secondary index */
+export class OpenInvocationMaps {
+    byInvocation = new Map();
+    byTool = new Map();
+    apply(event) {
+        const prev = this.byInvocation.get(event.invocationId) ?? null;
+        const next = applyEventToState(prev, event);
+        if (isTerminalEventType(event.type)) {
+            this.byInvocation.delete(event.invocationId);
+            if (this.byTool.get(event.toolId) === event.invocationId) {
+                this.byTool.delete(event.toolId);
+            }
+            return;
+        }
+        this.byInvocation.set(event.invocationId, next);
+        this.byTool.set(event.toolId, event.invocationId);
+    }
+    clear() {
+        this.byInvocation.clear();
+        this.byTool.clear();
+    }
+    getOpenByToolId(toolId) {
+        const id = this.byTool.get(toolId);
+        if (!id)
+            return null;
+        return this.byInvocation.get(id) ?? null;
+    }
+    getOpenInvocations() {
+        return [...this.byInvocation.values()];
+    }
+}

package/dist/actionlog/sqliteBackend.d.ts

@@ -0,0 +1,18 @@
+import type { ActionLogBackend } from "./backend";
+import type { ActionLogEvent, OpenInvocationState } from "./types";
+import type { ToolId } from "../tools/monero-tools";
+/** bun-only sqlite backend. do not import from browser worker graphs. */
+export declare class ActionLogSqliteBackend implements ActionLogBackend {
+    private open;
+    private sql;
+    private constructor();
+    static open(filename: string): Promise<ActionLogSqliteBackend>;
+    private rebuildOpenMaps;
+    append(event: ActionLogEvent): Promise<void>;
+    getBranch(invocationId: string): Promise<ActionLogEvent[]>;
+    getTip(invocationId: string): Promise<ActionLogEvent | null>;
+    getOpenByToolId(toolId: ToolId): Promise<OpenInvocationState | null>;
+    getOpenInvocations(): Promise<OpenInvocationState[]>;
+    feed(events: ActionLogEvent[]): Promise<void>;
+    reload(): Promise<void>;
+}

package/dist/actionlog/sqliteBackend.js

@@ -0,0 +1,105 @@
+import { OpenInvocationMaps } from "./openMaps";
+/** bun-only sqlite backend. do not import from browser worker graphs. */
+export class ActionLogSqliteBackend {
+    open = new OpenInvocationMaps();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sql;
+    constructor(sql) {
+        this.sql = sql;
+    }
+    static async open(filename) {
+        const { SQL } = await import("bun");
+        const sql = new SQL({
+            adapter: "sqlite",
+            filename,
+            create: true,
+        });
+        await sql `PRAGMA journal_mode = WAL`;
+        await sql `
+      CREATE TABLE IF NOT EXISTS actionlog_events (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        invocationId TEXT NOT NULL,
+        stage TEXT NOT NULL,
+        type TEXT NOT NULL,
+        toolId TEXT NOT NULL,
+        body TEXT NOT NULL
+      )
+    `;
+        await sql `
+      CREATE INDEX IF NOT EXISTS idx_actionlog_invocation
+      ON actionlog_events (invocationId)
+    `;
+        await sql `
+      CREATE INDEX IF NOT EXISTS idx_actionlog_tool
+      ON actionlog_events (toolId)
+    `;
+        await sql `
+      CREATE INDEX IF NOT EXISTS idx_actionlog_invocation_ts
+      ON actionlog_events (invocationId, timestamp)
+    `;
+        const backend = new ActionLogSqliteBackend(sql);
+        await backend.rebuildOpenMaps();
+        return backend;
+    }
+    async rebuildOpenMaps() {
+        this.open.clear();
+        const rows = (await this.sql `
+      SELECT body FROM actionlog_events ORDER BY rowid ASC
+    `);
+        if (!Array.isArray(rows))
+            return;
+        for (const row of rows) {
+            this.open.apply(JSON.parse(row.body));
+        }
+    }
+    async append(event) {
+        const body = JSON.stringify(event);
+        await this.sql `
+      INSERT INTO actionlog_events (id, timestamp, invocationId, stage, type, toolId, body)
+      VALUES (
+        ${event.id},
+        ${event.timestamp},
+        ${event.invocationId},
+        ${event.stage},
+        ${event.type},
+        ${event.toolId},
+        ${body}
+      )
+    `;
+        this.open.apply(event);
+    }
+    async getBranch(invocationId) {
+        const rows = (await this.sql `
+      SELECT body FROM actionlog_events
+      WHERE invocationId = ${invocationId}
+      ORDER BY rowid ASC
+    `);
+        if (!Array.isArray(rows))
+            return [];
+        return rows.map((r) => JSON.parse(r.body));
+    }
+    async getTip(invocationId) {
+        const branch = await this.getBranch(invocationId);
+        return branch.length ? branch[branch.length - 1] : null;
+    }
+    async getOpenByToolId(toolId) {
+        return this.open.getOpenByToolId(toolId);
+    }
+    async getOpenInvocations() {
+        return this.open.getOpenInvocations();
+    }
+    async feed(events) {
+        for (const event of events) {
+            try {
+                await this.append(event);
+            }
+            catch {
+                // skip duplicate
+            }
+        }
+    }
+    async reload() {
+        await this.rebuildOpenMaps();
+    }
+}

package/dist/actionlog/toolContext.d.ts

@@ -0,0 +1,36 @@
+import type { ActionLogEvent, ActionLogOpened } from "./actionLogOpened";
+import type { ToolPermission } from "./types";
+/** durable plate notice — title/message are tool-owned STE text */
+export type ToolNotice = {
+    id: string;
+    permission: ToolPermission;
+    /** short STE title for the notice plate hole */
+    title: string;
+    /** full STE body for the notice plate hole */
+    message: string;
+    context_domain?: string;
+    context_href?: string;
+    wallet_slot?: number;
+    timestamp?: number | string;
+};
+/** static STE strings for open-invocation plate holes */
+export type ToolUiCopy = {
+    openTitle: string;
+    acceptLabel?: string;
+    dismissLabel?: string;
+};
+/**
+ * context ActionLog passes into per-tool actionlog writers.
+ * lives next to ActionLog — tools import this, not the other way around for placement.
+ */
+export type ToolActionLogContext = {
+    log: ActionLogOpened;
+    getWallets?: () => unknown;
+    /** host reopens wallets after tool changes scan settings */
+    reloadWallets?: () => void | Promise<void>;
+    getPort: (invocationId: string) => {
+        postMessage: (msg: unknown) => void;
+    } | undefined;
+    postToPort: (invocationId: string, msg: unknown) => void;
+    broadcast: (events: ActionLogEvent[]) => void;
+};

package/dist/actionlog/toolContext.js

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

package/dist/actionlog/types.d.ts

@@ -0,0 +1,62 @@
+import type { ToolId } from "../tools/monero-tools";
+import type { ExtensionPort, ToolInvocationValidity, ToolPermission } from "../tools/globals";
+import type { ActionLogOpened } from "./actionLogOpened";
+export type { ToolPermission };
+export type ActionLogEventType = "session_start" | "validate_start" | "validate_result" | "accept" | "dismiss" | "execute_start" | "execute_error" | "execute_result" | "aborted";
+export type ActionLogStage = "recognized" | "invoked" | "validated" | "accepted" | "executed";
+export type ActionLogEvent = {
+    type: ActionLogEventType;
+    id: string;
+    timestamp: string;
+    invocationId: string;
+    stage: ActionLogStage;
+    toolId: ToolId;
+    valid?: ToolInvocationValidity;
+    amount?: string;
+    address?: string;
+    no_check?: boolean;
+    wallet_slot?: number;
+    context_domain?: string;
+    destination_domain?: string;
+    context_href?: string;
+    found_in?: "link" | "linkText";
+    link?: string;
+    linkText?: string;
+    wallet_to_send_from_pa?: string;
+    ok?: boolean;
+    error?: string;
+    [key: string]: unknown;
+};
+export type OpenInvocationState = {
+    invocationId: string;
+    toolId: ToolId;
+    stage: ActionLogStage;
+    lastType: ActionLogEventType;
+    valid?: ToolInvocationValidity;
+    amount?: string;
+    address?: string;
+    no_check?: boolean;
+    wallet_slot?: number;
+    context_domain?: string;
+    destination_domain?: string;
+    context_href?: string;
+    found_in?: "link" | "linkText";
+    link?: string;
+    linkText?: string;
+    timestamp?: string;
+    wallet_to_send_from_pa?: string;
+    ok?: boolean;
+    error?: string;
+};
+export declare const TERMINAL_EVENT_TYPES: ReadonlySet<ActionLogEventType>;
+export declare function isTerminalEventType(type: ActionLogEventType): boolean;
+export declare function newEventId(): string;
+export declare function nowTimestamp(): string;
+export type ToolWorkerContext = {
+    log: ActionLogOpened;
+    getWallets?: () => unknown;
+    reloadWallets?: () => void | Promise<void>;
+    getPort: (invocationId: string) => ExtensionPort | undefined;
+};
+export declare function applyEventToState(prev: OpenInvocationState | null, event: ActionLogEvent): OpenInvocationState;
+export declare function isOpenState(state: OpenInvocationState): boolean;

package/dist/actionlog/types.js

@@ -0,0 +1,62 @@
+export const TERMINAL_EVENT_TYPES = new Set([
+    "dismiss",
+    "execute_result",
+    "aborted",
+]);
+export function isTerminalEventType(type) {
+    return TERMINAL_EVENT_TYPES.has(type);
+}
+export function newEventId() {
+    return crypto.randomUUID();
+}
+export function nowTimestamp() {
+    return new Date().toISOString();
+}
+export function applyEventToState(prev, event) {
+    const base = prev ?? {
+        invocationId: event.invocationId,
+        toolId: event.toolId,
+        stage: event.stage,
+        lastType: event.type,
+    };
+    const next = {
+        ...base,
+        invocationId: event.invocationId,
+        toolId: event.toolId,
+        stage: event.stage,
+        lastType: event.type,
+        timestamp: event.timestamp,
+    };
+    if (event.valid !== undefined)
+        next.valid = event.valid;
+    if (event.amount !== undefined)
+        next.amount = event.amount;
+    if (event.address !== undefined)
+        next.address = event.address;
+    if (event.no_check !== undefined)
+        next.no_check = event.no_check;
+    if (event.wallet_slot !== undefined)
+        next.wallet_slot = event.wallet_slot;
+    if (event.context_domain !== undefined)
+        next.context_domain = event.context_domain;
+    if (event.destination_domain !== undefined)
+        next.destination_domain = event.destination_domain;
+    if (event.context_href !== undefined)
+        next.context_href = event.context_href;
+    if (event.found_in !== undefined)
+        next.found_in = event.found_in;
+    if (event.link !== undefined)
+        next.link = event.link;
+    if (event.linkText !== undefined)
+        next.linkText = event.linkText;
+    if (event.wallet_to_send_from_pa !== undefined)
+        next.wallet_to_send_from_pa = event.wallet_to_send_from_pa;
+    if (event.ok !== undefined)
+        next.ok = event.ok;
+    if (event.error !== undefined)
+        next.error = event.error;
+    return next;
+}
+export function isOpenState(state) {
+    return !isTerminalEventType(state.lastType);
+}

package/dist/api.d.ts

@@ -8,6 +8,7 @@ export * from "./node-interaction/jsonEndpoints";
 export * from "./io/readDir";
 export * from "./io/atomicWrite";
 export * from "./io/sleep";
+export { LOGGING_FUNCTIONS, type PossibleLogs, type LogSetting, } from "./io/logging";
 export { signTransaction, parseAddress, type ParsedAddress, type ParseAddressError, } from "./send-functionality/transactionBuilding";
 export { computeKeyImage } from "./scanning-syncing/scanresult/computeKeyImage";
 export * from "./multisig/multisig";
@@ -21,6 +22,7 @@ export * from "./scanning-syncing/blocksbuffer/blocksBufferFetchLoop";
 export * from "./scanning-syncing/blocksbuffer/blocksbufferCoordination";
 export * from "./scanning-syncing/connectionStatus";
 export { ConnectionStatusOpened } from "./scanning-syncing/connectionStatusOpened";
+export { ActionLogOpened, type ActionLogOpenedCreateOptions, type ActionLogBackendKind, type ActionLogEvent, type ActionLogEventType, type ActionLogStage, Invocation, type InvocationDisplayStatus, type InvocationState, type ToolPermission, type ToolNotice, type ToolUiCopy, type ToolWorkerContext, } from "./actionlog/actionLogOpened";
 export * from "./scansettings/scanSettings";
 export { ScanSettingsOpened } from "./scansettings/scanSettingsOpened";
 export * from "./scanning-syncing/scanresult/scanResult";
@@ -33,3 +35,5 @@ export * from "./keypairs-seeds/keypairs";
 export * from "./send-functionality/conversion";
 export * from "./send-functionality/inputSelection";
 export * from "./tools/monero-tools";
+export type { ToolArm, ToolContentZone, ToolCounterpartyZone, ToolWorkerZone, ToolInvocationForValidate, } from "./tools/globals";
+export { sendToBackground } from "./tools/globals";

package/dist/api.js

@@ -7,6 +7,7 @@ export * from "./node-interaction/jsonEndpoints";
 export * from "./io/readDir";
 export * from "./io/atomicWrite";
 export * from "./io/sleep";
+export { LOGGING_FUNCTIONS, } from "./io/logging";
 export { signTransaction, parseAddress, } from "./send-functionality/transactionBuilding";
 export { computeKeyImage } from "./scanning-syncing/scanresult/computeKeyImage";
 export * from "./multisig/multisig";
@@ -20,6 +21,7 @@ export * from "./scanning-syncing/blocksbuffer/blocksBufferFetchLoop";
 export * from "./scanning-syncing/blocksbuffer/blocksbufferCoordination";
 export * from "./scanning-syncing/connectionStatus";
 export { ConnectionStatusOpened } from "./scanning-syncing/connectionStatusOpened";
+export { ActionLogOpened, Invocation, } from "./actionlog/actionLogOpened";
 export * from "./scansettings/scanSettings";
 export { ScanSettingsOpened } from "./scansettings/scanSettingsOpened";
 export * from "./scanning-syncing/scanresult/scanResult";
@@ -32,3 +34,4 @@ export * from "./keypairs-seeds/keypairs";
 export * from "./send-functionality/conversion";
 export * from "./send-functionality/inputSelection";
 export * from "./tools/monero-tools";
+export { sendToBackground } from "./tools/globals";

package/dist/io/sleep.d.ts

@@ -1 +1 @@
-export declare const sleep: (ms: number) => Promise<unknown>;
+export declare const sleep: (ms: number, signal?: AbortSignal) => Promise<void>;

package/dist/io/sleep.js

@@ -1 +1,16 @@
-export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export const sleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+        reject(signal.reason ?? new DOMException("aborted", "AbortError"));
+        return;
+    }
+    const onAbort = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        reject(signal?.reason ?? new DOMException("aborted", "AbortError"));
+    };
+    const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+});

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

@@ -3,7 +3,9 @@ export declare const CPU_POOL_SIZE = 4;
 export type WorkerSet = {
     fetchWorker: Worker;
     cpuWorkers: Worker[];
+    shutdown: (timeoutMs?: number) => Promise<void>;
     terminate: () => void;
+    dumpHeaps: (dir?: string) => Promise<string[]>;
 };
 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;