@nitpicker/core 0.4.1 → 0.4.3

package/src/table.ts

@@ -1,149 +0,0 @@
-import type {
-	TableData,
-	TableHeaderMap,
-	TableHeaders,
-	TablePages,
-	TableRow,
-} from './types.js';
-import type { ExURL as URL } from '@d-zero/shared/parse-url';
-
-/**
- * In-memory accumulator for tabular report data.
- *
- * Table collects column headers from plugins and per-URL row data from
- * analysis results. It uses `Map` internally for efficient merge operations
- * (multiple plugins contribute columns to the same URL row), then serializes
- * to plain objects for JSON storage in the archive.
- *
- * ## Merge semantics
- *
- * When data is added for a URL that already has entries, the new columns are
- * shallow-merged with existing ones (later values overwrite earlier ones for
- * the same key). This allows multiple plugins to contribute different columns
- * to the same row without conflicts, as long as they use distinct column keys.
- * @template T - String literal union of all column keys across plugins.
- * @example
- * ```ts
- * const table = new Table<'title' | 'score'>();
- * table.addHeaders({ title: 'Page Title', score: 'Score' });
- * table.addDataToUrl(url, {
- *   title: { value: 'Home' },
- *   score: { value: 95 },
- * });
- * const json = table.toJSON();
- * // { headers: { title: 'Page Title', score: 'Score' }, data: { 'https://...': { ... } } }
- * ```
- * @see {@link ./types.ts} for the underlying type aliases
- */
-export class Table<T extends string> {
-	/** Per-URL row data. Key is the URL href string. */
-	#data: TableRow<T> = new Map();
-
-	/** Column header definitions accumulated from all plugins. */
-	#headers: TableHeaderMap<T> = new Map();
-
-	/**
-	 * Merges a batch of URL-keyed page data into the table.
-	 * Typically called with deserialized data from a Worker thread or cache.
-	 * @param data - Object where keys are URL strings and values are column data.
-	 */
-	addData(data: TablePages<T>) {
-		const entries = Object.entries(data);
-		for (const [k, v] of entries) {
-			this.#add(k, v);
-		}
-	}
-
-	/**
-	 * Adds or merges column data for a single URL.
-	 * @param url - The page URL to associate the data with.
-	 * @param data - Column values to store for this URL.
-	 */
-	addDataToUrl(url: URL, data: TableData<T>) {
-		this.#add(url.href, data);
-	}
-
-	/**
-	 * Registers column headers from a plugin.
-	 *
-	 * Multiple plugins can call this independently; headers are merged by key.
-	 * If two plugins declare the same key with different labels, the later
-	 * registration wins.
-	 * @param headers - Map of column keys to display labels.
-	 */
-	addHeaders(headers: TableHeaders<T>) {
-		const entries = Object.entries(headers);
-		for (const entry of entries) {
-			const [key, name] = entry as [T, string];
-			this.#headers.set(key, name);
-		}
-	}
-
-	/**
-	 * Returns all row data as a plain object (serializable to JSON).
-	 * @returns URL-keyed record of column data.
-	 */
-	getData(): TablePages<T> {
-		return mapToObject(this.#data);
-	}
-
-	/**
-	 * Retrieves column data for a specific URL, or `undefined` if not present.
-	 * @param url - The page URL to look up.
-	 * @returns Column data for the URL, or `undefined`.
-	 */
-	getDataByUrl(url: URL) {
-		return this.#data.get(url.href);
-	}
-
-	/**
-	 * Serializes the entire table (headers + data) to a JSON-compatible object.
-	 *
-	 * Used when storing the table in the archive via `archive.setData('analysis/table', ...)`.
-	 * @returns Plain object with `headers` and `data` properties.
-	 */
-	toJSON() {
-		return {
-			headers: mapToObject(this.#headers),
-			data: mapToObject(this.#data),
-		};
-	}
-
-	/**
-	 * Internal merge-or-insert for a single URL row.
-	 * If the URL already has data, the new values are shallow-merged.
-	 * @param k - URL href string used as the row key.
-	 * @param v - Column data to add or merge.
-	 */
-	#add(k: string, v: TableData<T>) {
-		const data = this.#data.get(k);
-		if (data) {
-			this.#data.set(k, {
-				...data,
-				...v,
-			});
-		} else {
-			this.#data.set(k, v);
-		}
-	}
-}
-
-/**
- * Converts a `Map<K, V>` to a plain `Record<K, V>` object.
- *
- * Used internally to serialize Map-based storage into JSON-compatible
- * objects for archive storage and Worker message passing.
- * @template K - String key type.
- * @template V - Value type.
- * @param map - The Map to convert.
- * @returns A plain object with the same key-value pairs.
- */
-function mapToObject<K extends string, V>(map: Map<K, V>) {
-	const entries = map.entries();
-	const object = {} as Record<K, V>;
-	for (const entry of entries) {
-		const [k, v] = entry;
-		object[k] = v;
-	}
-	return object;
-}

package/src/types.ts

@@ -1,289 +0,0 @@
-import type { Lanes } from '@d-zero/dealer';
-import type { ExURL as URL } from '@d-zero/shared/parse-url';
-import type { TableValue, Violation } from '@nitpicker/types';
-import type { DOMWindow } from 'jsdom';
-
-/**
- * Represents a single analyze plugin loaded from the user's configuration.
- *
- * Each plugin corresponds to an npm module that exports a {@link PluginFactory}
- * factory function as its default export. The `settings` object is passed
- * through to that factory at initialization time.
- * @see {@link ./load-plugin-settings.ts} for how plugins are discovered from cosmiconfig
- * @see {@link ./import-modules.ts} for how plugins are dynamically imported
- */
-export interface Plugin {
-	/**
-	 * Human-readable plugin name. Currently unused at runtime but kept
-	 * for backward compatibility with older config formats.
-	 * @deprecated Use `module` to identify plugins instead.
-	 */
-	name: string;
-
-	/**
-	 * The npm module specifier to `import()` (e.g. `"@nitpicker/analyze-axe"`).
-	 */
-	module: string;
-
-	/**
-	 * Absolute path to the configuration file where this plugin was declared.
-	 * Passed to the plugin so it can resolve relative paths in its own config.
-	 */
-	configFilePath: string;
-
-	/**
-	 * Plugin-specific settings object parsed from the config file.
-	 * The shape is determined by the plugin itself (e.g. `{ lang: "ja" }` for axe).
-	 */
-	settings?: unknown;
-}
-
-/**
- * Options for {@link ../nitpicker.ts!Nitpicker.analyze}.
- *
- * Allows callers to provide an external {@link https://www.npmjs.com/package/@d-zero/dealer | Lanes}
- * instance for rich progress display, and a verbose flag for non-TTY environments.
- */
-export interface AnalyzeOptions {
-	/** Lanes instance for per-plugin progress display. If omitted, no progress is shown. */
-	readonly lanes?: Lanes;
-
-	/** When `true`, outputs plain-text progress lines instead of animated Lanes. */
-	readonly verbose?: boolean;
-}
-
-/**
- * Internal configuration model used by {@link ../nitpicker.ts!Nitpicker}.
- *
- * Built by {@link ./load-plugin-settings.ts!loadPluginSettings} from the
- * user's cosmiconfig file (e.g. `.nitpickerrc.json`). The external config
- * format (`ConfigJSON` from `@nitpicker/types`) uses a `plugins.analyze`
- * object keyed by module name; this internal type normalizes it into an
- * ordered array of fully-resolved {@link Plugin} entries.
- */
-export interface Config {
-	/** Ordered list of analyze plugins to execute. */
-	analyze: Plugin[];
-}
-
-/**
- * The runtime interface that every analyze plugin must satisfy after
- * its factory function ({@link PluginFactory}) has been invoked.
- *
- * A plugin may implement one or both callback methods:
- *
- * - **`eachPage`** - Runs inside a Worker thread with full JSDOM access.
- *   Best for DOM-dependent analysis (markup validation, text linting,
- *   accessibility checks). Each invocation receives a parsed `DOMWindow`,
- *   so plugins can use standard DOM APIs without additional parsing.
- *
- * - **`eachUrl`** - Runs in the main thread, receives only the URL and
- *   external/internal flag. Suited for lightweight, network-based checks
- *   (e.g. link validation, SEO URL pattern checks).
- * @template T - String literal union of the column keys this plugin
- *   contributes to the report table (e.g. `'title' | 'description'`).
- * @see {@link ./page-analysis-worker.ts} for how `eachPage` is called inside the worker
- * @see {@link ./nitpicker.ts} for how `eachUrl` is called from the main thread
- */
-export interface AnalyzePlugin<T extends string = string> {
-	/**
-	 * Human-readable display label for interactive prompts.
-	 * Shown instead of the raw package name (e.g. `"axe: アクセシビリティチェック"`).
-	 */
-	label?: string;
-
-	/**
-	 * Column header definitions contributed by this plugin.
-	 * Keys are column identifiers (`T`), values are human-readable labels
-	 * shown in the report header row.
-	 */
-	headers?: TableHeaders<T>;
-
-	/**
-	 * Per-page analysis callback executed in a Worker thread.
-	 * @param page - Context for the current page, including the raw HTML,
-	 *   a live JSDOM window, the page URL, and progress counters.
-	 * @param page.url - Parsed URL of the page being analyzed.
-	 * @param page.html - Raw HTML string of the page.
-	 * @param page.window - JSDOM window with the page's DOM tree. Closed after the callback returns.
-	 * @param page.num - Zero-based index of the current page in the batch.
-	 * @param page.total - Total number of pages in the batch.
-	 * @returns Report data for this page, or `null` to skip.
-	 */
-	eachPage?(page: {
-		/** Parsed URL of the page being analyzed. */
-		url: URL;
-		/** Raw HTML string of the page. */
-		html: string;
-		/** JSDOM window with the page's DOM tree. Closed after the callback returns. */
-		window: DOMWindow;
-		/** Zero-based index of the current page in the batch. */
-		num: number;
-		/** Total number of pages in the batch. */
-		total: number;
-	}): Promise<ReportPage<T> | null> | ReportPage<T> | null;
-
-	/**
-	 * Per-URL analysis callback executed in the main thread.
-	 *
-	 * Unlike `eachPage`, this callback does **not** receive HTML or a DOM
-	 * window. It is designed for checks that depend only on URL metadata
-	 * (e.g. checking URL patterns, external link policies).
-	 * @param page - URL context including external/internal classification.
-	 * @param page.url - Parsed URL being analyzed.
-	 * @param page.isExternal - Whether this URL is external to the crawled site.
-	 * @returns Report data for this URL, or `null` to skip.
-	 */
-	eachUrl?(page: {
-		/** Parsed URL being analyzed. */
-		url: URL;
-		/** Whether this URL is external to the crawled site. */
-		isExternal: boolean;
-	}): Promise<ReportPage<T> | null> | ReportPage<T> | null;
-}
-
-/**
- * The return value of a single {@link AnalyzePlugin.eachPage} or {@link AnalyzePlugin.eachUrl}
- * invocation for one page/URL.
- *
- * A plugin can contribute tabular data (displayed in spreadsheet columns)
- * and/or violation records (displayed in a dedicated violations sheet).
- * @template T - Column key union matching the plugin's `headers`.
- */
-export interface ReportPage<T extends string> {
-	/** Column data for this page. Keys must be a subset of `T`. */
-	page?: TableData<T>;
-	/** Violations detected on this page (e.g. a11y issues, lint errors). */
-	violations?: Violation[];
-}
-
-/**
- * Aggregated report data from a Worker thread, keyed by page URL.
- *
- * This is the message payload returned from the Worker to the main thread
- * via the `'finish'` message. It aggregates results from all plugins that
- * ran `eachPage` for a single page.
- * @template T - Column key union.
- * @see {@link ./page-analysis-worker.ts} for the Worker entry point that produces this
- * @see {@link ./worker/run-in-worker.ts!runInWorker} for the main-thread consumer
- */
-export interface ReportPages<T extends string> {
-	/** Per-URL table data from all plugins. */
-	pages?: TablePages<T>;
-	/** Combined violations from all plugins. */
-	violations?: Violation[];
-}
-
-/**
- * Factory function signature that every analyze plugin module must
- * export as its default export.
- *
- * The factory receives the user's settings object (`O`) and returns
- * an {@link AnalyzePlugin} instance (or a Promise thereof). This two-phase
- * pattern allows plugins to perform async initialization (e.g.
- * loading locale files, compiling lint configs) once, then reuse
- * the resulting plugin for every page.
- *
- * Use {@link ./hooks/define-plugin.ts!definePlugin} to define a
- * plugin with full type inference.
- * @template O - Shape of the plugin's settings from the config file.
- * @template T - String literal union of column keys the plugin contributes.
- * @example
- * ```ts
- * // In @nitpicker/analyze-search/src/index.ts
- * import { definePlugin } from '@nitpicker/core';
- *
- * type Options = { keywords: string[] };
- *
- * export default definePlugin(async (options: Options) => {
- *   return {
- *     headers: { found: 'Keywords Found' },
- *     async eachPage({ html }) {
- *       const count = options.keywords.filter(k => html.includes(k)).length;
- *       return { page: { found: { value: count } } };
- *     },
- *   };
- * });
- * ```
- * @see {@link AnalyzePlugin} for the runtime interface
- * @see {@link ./hooks/define-plugin.ts!definePlugin} for the type-safe wrapper
- */
-export type PluginFactory<O, T extends string = string> = (
-	options: O,
-	configFilePath: string,
-) => Promise<AnalyzePlugin<T>> | AnalyzePlugin<T>;
-
-/**
- * Column header definitions: maps column key to display label.
- * @example
- * ```ts
- * const headers: TableHeaders<'title' | 'desc'> = {
- *   title: 'Page Title',
- *   desc: 'Meta Description',
- * };
- * ```
- */
-export type TableHeaders<K extends string> = Record<K, string>;
-
-/** Internal Map representation of {@link TableHeaders}, used by {@link ../table.ts!Table}. */
-export type TableHeaderMap<K extends string> = Map<K, string>;
-
-/** A single row of cell values keyed by column identifier. */
-export type TableData<K extends string> = Record<K, TableValue>;
-
-/**
- * Multiple rows of table data keyed by page URL.
- * This is the serialized form used in Worker message payloads and JSON output.
- */
-export type TablePages<K extends string> = Record<string, TableData<K>>;
-
-/**
- * Internal Map representation of page-keyed table data.
- * Used by {@link ../table.ts!Table} for efficient merge operations.
- */
-export type TableRow<K extends string> = Map<string, TableData<K>>;
-
-/**
- * Payload for starting an analyze action.
- * @internal
- */
-export interface PluginExecutionContext {
-	/** Human-readable name of the plugin module. */
-	pluginModuleName: string;
-	/** Resolved file system path to the plugin module. */
-	pluginModulePath: string;
-	/** Plugin-specific settings to pass to the hook factory. */
-	settings: unknown;
-	/** Path to the config file where this action was declared. */
-	configFilePath: string;
-	/** Temporary directory where the archive is extracted. */
-	archiveTempDir: string;
-	/** Full resolved configuration. */
-	config: Config;
-}
-
-/**
- * Event map for the {@link ../nitpicker.ts!Nitpicker} event emitter.
- *
- * Consumers can listen to these events via `nitpicker.on('writeFile', ...)`.
- * @see {@link ../nitpicker.ts!Nitpicker} which extends `TypedAwaitEventEmitter<NitpickerEvent>`
- */
-export interface NitpickerEvent {
-	/**
-	 * Emitted after the archive file has been successfully written to disk.
-	 */
-	writeFile: {
-		/** Absolute path to the written `.nitpicker` archive file. */
-		filePath: string;
-	};
-
-	/**
-	 * Emitted when a non-fatal error occurs during analysis.
-	 */
-	error: {
-		/** Human-readable error description. */
-		message: string;
-		/** Original Error object, or `null` if unavailable. */
-		error: Error | null;
-	};
-}

package/src/url-event-bus.spec.ts

@@ -1,28 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-
-import { UrlEventBus } from './url-event-bus.js';
-
-describe('UrlEventBus', () => {
-	it('emits and receives url events', async () => {
-		const emitter = new UrlEventBus();
-		const handler = vi.fn();
-
-		emitter.on('url', handler);
-		await emitter.emit('url', 'https://example.com/');
-
-		expect(handler).toHaveBeenCalledWith('https://example.com/');
-	});
-
-	it('supports multiple listeners', async () => {
-		const emitter = new UrlEventBus();
-		const handler1 = vi.fn();
-		const handler2 = vi.fn();
-
-		emitter.on('url', handler1);
-		emitter.on('url', handler2);
-		await emitter.emit('url', 'https://example.com/page');
-
-		expect(handler1).toHaveBeenCalledOnce();
-		expect(handler2).toHaveBeenCalledOnce();
-	});
-});

package/src/url-event-bus.ts

@@ -1,33 +0,0 @@
-import { TypedAwaitEventEmitter as EventEmitter } from '@d-zero/shared/typed-await-event-emitter';
-
-/**
- * Event map for {@link UrlEventBus}.
- *
- * Currently supports a single event type for URL discovery notifications.
- */
-export interface UrlEventBusEvent {
-	/**
-	 * Emitted when a URL is discovered or being processed.
-	 * The payload is the URL href string.
-	 */
-	url: string;
-}
-
-/**
- * Typed event bus for URL discovery notifications.
- *
- * Used as a communication channel between Worker threads and the main thread:
- *
- * - **Inside Workers**: The each-page worker emits `'url'` events on a local
- *   UrlEventBus. The Worker thread entry point ({@link ./worker/worker.ts})
- *   listens for these and forwards them to the main thread via `parentPort.postMessage`.
- *
- * - **In the main thread**: {@link ./worker/run-in-worker.ts!runInWorker} creates its own
- *   UrlEventBus and re-emits `'url'` messages received from the Worker.
- *
- * This indirection allows the same plugin code to work both in Worker threads
- * and in direct execution mode (when `useWorker` is `false`).
- * @see {@link ./worker/worker.ts} for Worker-side forwarding
- * @see {@link ./worker/run-in-worker.ts!runInWorker} for main-thread re-emission
- */
-export class UrlEventBus extends EventEmitter<UrlEventBusEvent> {}

package/src/worker/run-in-worker.ts

@@ -1,155 +0,0 @@
-import type { UrlEventBus } from '../url-event-bus.js';
-
-import path from 'node:path';
-import { Worker } from 'node:worker_threads';
-
-import { runner } from './runner.js';
-
-const __filename = new URL(import.meta.url).pathname;
-const __dirname = path.dirname(__filename);
-
-/** Resolved path to the compiled Worker thread entry point ({@link ./worker.ts}). */
-const workerPath = path.resolve(__dirname, 'worker.js');
-
-/**
- * Feature flag controlling whether plugin execution uses Worker threads.
- * When `true` (default), each plugin invocation runs in an isolated Worker,
- * providing memory isolation and crash protection. When `false`, the runner
- * executes directly in the main thread (useful for debugging).
- */
-const useWorker = true;
-
-/**
- * Parameters for {@link runInWorker}.
- * @template I - Shape of the additional data merged into `workerData`.
- */
-export interface RunInWorkerParams<I extends Record<string, unknown>> {
-	/** Absolute path to the module to execute in the Worker. */
-	readonly filePath: string;
-	/** Zero-based index of the current item (for progress display). */
-	readonly num: number;
-	/** Total number of items in the batch. */
-	readonly total: number;
-	/** URL event bus; `'url'` messages from the Worker are re-emitted here. */
-	readonly emitter: UrlEventBus;
-	/** Plugin-specific data to pass to the Worker module. */
-	readonly initialData: I;
-}
-
-/**
- * Spawns a Worker thread to execute a plugin module and returns its result.
- *
- * This is the bridge between the main thread's `deal()` parallelism and the
- * per-page Worker execution. Each call creates a new Worker, passes the
- * initial data via `workerData`, and listens for messages until the Worker
- * signals completion.
- *
- * ## Why Worker threads?
- *
- * DOM-heavy plugins (JSDOM + axe-core, markuplint, etc.) allocate significant
- * memory per page. Running them in Workers ensures:
- * - **Memory isolation**: JSDOM windows are fully GC'd when the Worker exits
- * - **Crash containment**: A plugin segfault/OOM kills only the Worker, not the process
- * - **Signal handling**: Graceful cleanup on SIGABRT, SIGQUIT, and other signals
- *
- * ## Message protocol
- *
- * The Worker sends two types of messages:
- * - `{ type: 'url', url: string }` - URL discovery notification, forwarded to the emitter
- * - `{ type: 'finish', result: R }` - Execution complete, resolves the Promise
- *
- * ## Fallback mode
- *
- * When `useWorker` is `false`, execution delegates directly to
- * {@link ./runner.ts!runner} in the main thread.
- * @template I - Shape of the additional data merged into `workerData`.
- * @template R - Return type expected from the Worker module.
- * @param params - Parameters containing file path, progress info, emitter, and data.
- * @returns The result produced by the Worker module's default export.
- * @see {@link ./worker.ts} for the Worker-side entry point
- * @see {@link ./runner.ts!runner} for the direct (non-Worker) execution path
- */
-export function runInWorker<I extends Record<string, unknown>, R>(
-	params: RunInWorkerParams<I>,
-) {
-	const { filePath, num, total, emitter, initialData } = params;
-	if (useWorker) {
-		const worker = new Worker(workerPath, {
-			workerData: {
-				filePath,
-				num,
-				total,
-				...initialData,
-			},
-		});
-		return new Promise<R>((resolve, reject) => {
-			const killWorker = async (sig: NodeJS.Signals) => {
-				await worker.terminate();
-				worker.unref();
-				worker.removeAllListeners();
-
-				process.removeListener('SIGABRT', killWorker);
-				process.removeListener('SIGLOST', killWorker);
-				process.removeListener('SIGQUIT', killWorker);
-				process.removeListener('disconnect', killWorker);
-				process.removeListener('exit', killWorker);
-				process.removeListener('uncaughtException', killWorker);
-				process.removeListener('uncaughtExceptionMonitor', killWorker);
-				process.removeListener('unhandledRejection', killWorker);
-
-				// eslint-disable-next-line no-console
-				console.log(`Kill Worker cause: %O`, sig);
-				reject(`SIG: ${sig}`);
-			};
-
-			// Changed from old issue
-			// @see https://github.com/nodejs/node-v0.x-archive/issues/6339
-			// process.once('SIGKILL', killWorker);
-			// process.once('SIGSTOP', killWorker);
-
-			process.once('SIGABRT', killWorker);
-			process.once('SIGLOST', killWorker);
-			process.once('SIGQUIT', killWorker);
-			process.once('disconnect', killWorker);
-			process.once('exit', killWorker);
-			process.once('uncaughtException', killWorker);
-			process.once('uncaughtExceptionMonitor', killWorker);
-			process.once('unhandledRejection', killWorker);
-			worker.once('error', killWorker);
-			worker.once('messageerror', killWorker);
-
-			worker.on('message', async (message) => {
-				if (!message) {
-					return;
-				}
-				if (message.type === 'url') {
-					void emitter.emit('url', message.url);
-				}
-				if (message.type === 'finish') {
-					await worker.terminate();
-					worker.removeAllListeners();
-					worker.unref();
-					process.removeListener('SIGABRT', killWorker);
-					process.removeListener('SIGLOST', killWorker);
-					process.removeListener('SIGQUIT', killWorker);
-					process.removeListener('disconnect', killWorker);
-					process.removeListener('exit', killWorker);
-					process.removeListener('uncaughtException', killWorker);
-					process.removeListener('uncaughtExceptionMonitor', killWorker);
-					process.removeListener('unhandledRejection', killWorker);
-					resolve(message.result);
-				}
-			});
-		});
-	}
-
-	return runner<I, R>(
-		{
-			filePath,
-			num,
-			total,
-			...initialData,
-		},
-		emitter,
-	);
-}

package/src/worker/runner.ts

@@ -1,38 +0,0 @@
-import type { WorkerData } from './types.js';
-import type { UrlEventBus } from '../url-event-bus.js';
-
-/**
- * Dynamically imports and executes a plugin worker module.
- *
- * This function is the final execution step in the worker pipeline:
- * 1. It `import()`s the module specified by `data.filePath`
- * 2. Calls the module's default export with the remaining data, emitter,
- *    and progress counters
- * 3. Returns the result
- *
- * The `filePath` field is deleted from `data` before passing it to the
- * module function, so the module only receives its own domain-specific data.
- *
- * This function is called both from the Worker thread ({@link ./worker.ts})
- * and as a direct fallback when `useWorker` is `false` in {@link ./run-in-worker.ts}.
- * @template I - Shape of the caller's initial data (minus the worker infrastructure fields).
- * @template R - Return type of the plugin module's default export.
- * @param data - Combined worker data containing the module path and plugin-specific payload.
- * @param emitter - Event emitter for URL discovery notifications (forwarded to the plugin).
- * @returns The result produced by the dynamically imported module.
- * @see {@link ./types.ts!WorkerData} for the data shape
- * @see {@link ../page-analysis-worker.ts} for a typical module loaded by this runner
- */
-export async function runner<I extends Record<string, unknown>, R>(
-	data: WorkerData<I>,
-	emitter: UrlEventBus,
-): Promise<R> {
-	const { filePath, num, total } = data;
-
-	const mod = await import(filePath);
-	const fn = mod.default;
-	// @ts-expect-error
-	delete data.filePath;
-	const result = await fn(data, emitter, num, total);
-	return result;
-}