@nitpicker/core 0.4.1

package/lib/utils.d.ts

@@ -0,0 +1,36 @@
+type SequentialEachChunkCallback<R, T> = (item: T, i: number) => Promise<R>;
+/**
+ * Sequential processing each chunk
+ *
+ * 1. Split an array
+ *  ┌───────── array ────────┐
+ *   chunk1 │ chunk2 | chunk3
+ *   ├item    ├item    ├item
+ *   ├item    ├item    ├item
+ *   └item    └item    └item
+ *
+ * 2. Runs parallel and sequential
+ * chunk1 ┬ callback(item) ┐
+ * │      ├ callback(item) │ Promise.all
+ * │      └ callback(item) ┘
+ * │
+ * (Sequential)
+ * │
+ * chunk2 ┬ callback(item) ┐
+ * │      ├ callback(item) │ Promise.all
+ * │      └ callback(item) ┘
+ * │
+ * (Sequential)
+ * │
+ * chunk3 ┬ callback(item) ┐
+ * │      ├ callback(item) │ Promise.all
+ * │      └ callback(item) ┘
+ * │
+ * (Done)
+ * @param array
+ * @param split
+ * @param callback
+ * @returns
+ */
+export declare function sequentialEachChunk<R, T>(array: T[], split: number, callback: SequentialEachChunkCallback<R, T>): Promise<R[]>;
+export {};

package/lib/utils.js

@@ -0,0 +1,43 @@
+/**
+ * Sequential processing each chunk
+ *
+ * 1. Split an array
+ *  ┌───────── array ────────┐
+ *   chunk1 │ chunk2 | chunk3
+ *   ├item    ├item    ├item
+ *   ├item    ├item    ├item
+ *   └item    └item    └item
+ *
+ * 2. Runs parallel and sequential
+ * chunk1 ┬ callback(item) ┐
+ * │      ├ callback(item) │ Promise.all
+ * │      └ callback(item) ┘
+ * │
+ * (Sequential)
+ * │
+ * chunk2 ┬ callback(item) ┐
+ * │      ├ callback(item) │ Promise.all
+ * │      └ callback(item) ┘
+ * │
+ * (Sequential)
+ * │
+ * chunk3 ┬ callback(item) ┐
+ * │      ├ callback(item) │ Promise.all
+ * │      └ callback(item) ┘
+ * │
+ * (Done)
+ * @param array
+ * @param split
+ * @param callback
+ * @returns
+ */
+export async function sequentialEachChunk(array, split, callback) {
+    array = [...array];
+    const result = [];
+    do {
+        const chunk = array.splice(0, split);
+        const segRes = await Promise.all(chunk.map((item, i) => callback(item, i + result.length)));
+        result.push(...segRes);
+    } while (array.length > 0);
+    return result;
+}

package/lib/worker/run-in-worker.d.ts

@@ -0,0 +1,51 @@
+import type { UrlEventBus } from '../url-event-bus.js';
+/**
+ * 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 declare function runInWorker<I extends Record<string, unknown>, R>(params: RunInWorkerParams<I>): Promise<R>;

package/lib/worker/run-in-worker.js

@@ -0,0 +1,120 @@
+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;
+/**
+ * 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(params) {
+    const { filePath, num, total, emitter, initialData } = params;
+    if (useWorker) {
+        const worker = new Worker(workerPath, {
+            workerData: {
+                filePath,
+                num,
+                total,
+                ...initialData,
+            },
+        });
+        return new Promise((resolve, reject) => {
+            const killWorker = async (sig) => {
+                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({
+        filePath,
+        num,
+        total,
+        ...initialData,
+    }, emitter);
+}

package/lib/worker/runner.d.ts

@@ -0,0 +1,25 @@
+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 declare function runner<I extends Record<string, unknown>, R>(data: WorkerData<I>, emitter: UrlEventBus): Promise<R>;

package/lib/worker/runner.js

@@ -0,0 +1,31 @@
+/**
+ * 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(data, emitter) {
+    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;
+}

package/lib/worker/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Data payload passed to a Worker thread via `workerData`.
+ *
+ * This type merges the worker infrastructure fields (`filePath`, `num`, `total`)
+ * with the caller-supplied initial data (`I`). The `filePath` points to the
+ * module whose default export will be invoked by the {@link ../runner.ts!runner}.
+ * @template I - Shape of the additional data the caller provides
+ *   (e.g. {@link ../../page-analysis-worker.ts!PageAnalysisWorkerData}).
+ * @see {@link ../run-in-worker.ts!runInWorker} for where this payload is constructed
+ * @see {@link ../runner.ts!runner} for where it is consumed
+ */
+export type WorkerData<I extends Record<string, unknown>> = {
+    /**
+     * Absolute path to the compiled JS module to `import()` and execute.
+     * The module must export a default function matching the
+     * `(data, emitter, num, total) => Promise<R>` signature.
+     */
+    filePath: string;
+    /** Zero-based index of the current item in the batch (for progress tracking). */
+    num: number;
+    /** Total number of items in the batch (for progress tracking). */
+    total: number;
+} & I;

package/lib/worker/types.js

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

package/lib/worker/worker.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Worker thread entry point for plugin execution.
+ *
+ * This module runs inside a `new Worker(...)` created by {@link ./run-in-worker.ts!runInWorker}.
+ * It uses a message-based protocol to communicate with the main thread:
+ *
+ * ## Message protocol (Worker -> Main)
+ *
+ * | `type`     | Payload          | Description                                    |
+ * |------------|------------------|------------------------------------------------|
+ * | `'url'`    | `{ url: string }` | A URL was discovered during analysis           |
+ * | `'finish'` | `{ result: R }`  | Analysis complete, carries the plugin result   |
+ *
+ * ## Lifecycle
+ *
+ * 1. Reads `workerData` containing the module path + plugin data
+ * 2. Creates a local {@link ../url-event-bus.ts!UrlEventBus} that forwards `'url'`
+ *    events to the main thread via `parentPort.postMessage`
+ * 3. Delegates to {@link ./runner.ts!runner} for dynamic import and execution
+ * 4. Posts the `'finish'` message with the result
+ *
+ * The main thread terminates this Worker after receiving `'finish'`.
+ * @see {@link ./run-in-worker.ts!runInWorker} for the main-thread counterpart
+ * @see {@link ./runner.ts!runner} for the actual module loading logic
+ * @module
+ */
+export {};

package/lib/worker/worker.js

@@ -0,0 +1,53 @@
+/**
+ * Worker thread entry point for plugin execution.
+ *
+ * This module runs inside a `new Worker(...)` created by {@link ./run-in-worker.ts!runInWorker}.
+ * It uses a message-based protocol to communicate with the main thread:
+ *
+ * ## Message protocol (Worker -> Main)
+ *
+ * | `type`     | Payload          | Description                                    |
+ * |------------|------------------|------------------------------------------------|
+ * | `'url'`    | `{ url: string }` | A URL was discovered during analysis           |
+ * | `'finish'` | `{ result: R }`  | Analysis complete, carries the plugin result   |
+ *
+ * ## Lifecycle
+ *
+ * 1. Reads `workerData` containing the module path + plugin data
+ * 2. Creates a local {@link ../url-event-bus.ts!UrlEventBus} that forwards `'url'`
+ *    events to the main thread via `parentPort.postMessage`
+ * 3. Delegates to {@link ./runner.ts!runner} for dynamic import and execution
+ * 4. Posts the `'finish'` message with the result
+ *
+ * The main thread terminates this Worker after receiving `'finish'`.
+ * @see {@link ./run-in-worker.ts!runInWorker} for the main-thread counterpart
+ * @see {@link ./runner.ts!runner} for the actual module loading logic
+ * @module
+ */
+import { parentPort, workerData } from 'node:worker_threads';
+import { UrlEventBus } from '../url-event-bus.js';
+import { runner } from './runner.js';
+const data = workerData;
+const emitter = new UrlEventBus();
+/**
+ * Forward URL discovery events from the plugin to the main thread.
+ * The main thread's {@link ../url-event-bus.ts!UrlEventBus} re-emits these
+ * so that the orchestrator can track discovered URLs.
+ */
+emitter.on('url', (url) => {
+    if (!parentPort) {
+        throw new Error('Use in worker thread');
+    }
+    parentPort.postMessage({
+        type: 'url',
+        url,
+    });
+});
+const result = await runner(data, emitter);
+if (!parentPort) {
+    throw new Error('Use in worker thread');
+}
+parentPort.postMessage({
+    type: 'finish',
+    result,
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+	"name": "@nitpicker/core",
+	"version": "0.4.1",
+	"description": "Plugin-based page analysis engine for Nitpicker",
+	"author": "D-ZERO",
+	"license": "Apache-2.0",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/d-zero-dev/nitpicker.git",
+		"directory": "packages/@nitpicker/core"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./lib/index.js",
+			"types": "./lib/index.d.ts"
+		}
+	},
+	"scripts": {
+		"build": "tsc",
+		"clean": "tsc --build --clean"
+	},
+	"dependencies": {
+		"@d-zero/dealer": "1.6.3",
+		"@d-zero/shared": "0.20.0",
+		"@nitpicker/crawler": "0.4.1",
+		"@nitpicker/types": "0.4.1",
+		"ansi-colors": "4.1.3",
+		"cosmiconfig": "9.0.0",
+		"jsdom": "28.1.0"
+	},
+	"gitHead": "32b83ee38eba7dfd237adb1b41f69e049e8d4ceb"
+}

package/src/discover-analyze-plugins.spec.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+
+import { discoverAnalyzePlugins } from './discover-analyze-plugins.js';
+
+describe('discoverAnalyzePlugins', () => {
+	it('returns all standard analyze plugins', () => {
+		const plugins = discoverAnalyzePlugins();
+		expect(plugins.length).toBeGreaterThanOrEqual(6);
+		expect(plugins.map((p) => p.name)).toContain('@nitpicker/analyze-axe');
+		expect(plugins.map((p) => p.name)).toContain('@nitpicker/analyze-textlint');
+	});
+
+	it('returns plugins with empty default settings', () => {
+		const plugins = discoverAnalyzePlugins();
+		for (const plugin of plugins) {
+			expect(plugin.module).toBe(plugin.name);
+			expect(plugin.configFilePath).toBe('');
+			expect(plugin.settings).toEqual({});
+		}
+	});
+});

package/src/discover-analyze-plugins.ts

@@ -0,0 +1,37 @@
+import type { Plugin } from './types.js';
+
+/**
+ * Standard analyze plugin module names bundled with the Nitpicker CLI.
+ *
+ * These are treated as built-in plugins and always available without
+ * explicit configuration.
+ */
+const STANDARD_ANALYZE_PLUGINS = [
+	'@nitpicker/analyze-axe',
+	'@nitpicker/analyze-lighthouse',
+	'@nitpicker/analyze-main-contents',
+	'@nitpicker/analyze-markuplint',
+	'@nitpicker/analyze-search',
+	'@nitpicker/analyze-textlint',
+] as const;
+
+/**
+ * Returns the standard set of `@nitpicker/analyze-*` plugins
+ * as {@link Plugin} entries with default (empty) settings.
+ *
+ * This is used as a fallback when no configuration file is found,
+ * allowing `nitpicker analyze` to work out of the box without
+ * requiring a `.nitpickerrc` file.
+ *
+ * All analyze plugins are treated as standard packages bundled
+ * with the CLI, so no filesystem scanning is necessary.
+ * @returns Array of standard analyze plugins with empty settings.
+ */
+export function discoverAnalyzePlugins(): Plugin[] {
+	return STANDARD_ANALYZE_PLUGINS.map((moduleName) => ({
+		name: moduleName,
+		module: moduleName,
+		configFilePath: '',
+		settings: {},
+	}));
+}

package/src/hooks/define-plugin.spec.ts

@@ -0,0 +1,38 @@
+import type { PluginFactory } from '../types.js';
+
+import { describe, it, expect } from 'vitest';
+
+import { definePlugin } from './define-plugin.js';
+
+describe('definePlugin', () => {
+	it('returns the exact same function passed in', () => {
+		const factory: PluginFactory<{ lang: string }> = (options) => {
+			return {
+				headers: { score: `Score (${options.lang})` },
+			};
+		};
+
+		const result = definePlugin(factory);
+
+		expect(result).toBe(factory);
+	});
+
+	it('preserves type inference for sync factories', () => {
+		const factory = definePlugin((() => ({
+			headers: { found: 'Found' },
+		})) as PluginFactory<{ keywords: string[] }>);
+
+		expect(typeof factory).toBe('function');
+	});
+
+	it('preserves label in the returned AnalyzePlugin', () => {
+		const factory = definePlugin((() => ({
+			label: 'テスト用プラグイン',
+			headers: { score: 'Score' },
+		})) as PluginFactory<Record<string, never>>);
+
+		const plugin = factory({} as never, '');
+
+		expect(plugin).toHaveProperty('label', 'テスト用プラグイン');
+	});
+});

package/src/hooks/define-plugin.ts

@@ -0,0 +1,73 @@
+import type { PluginFactory } from '../types.js';
+
+/**
+ * Identity function that provides full type inference for analyze plugin definitions.
+ *
+ * This function does **nothing at runtime** - it returns its argument unchanged.
+ * Its sole purpose is to give TypeScript enough context to infer the generic
+ * parameters `O` (options type) and `T` (column key union) from the plugin
+ * implementation, without requiring explicit type annotations at the call site.
+ *
+ * ## Why an identity function?
+ *
+ * Without this wrapper, plugin authors would need to manually annotate the
+ * `PluginFactory` type with both generic parameters:
+ *
+ * ```ts
+ * // Without definePlugin - verbose and error-prone
+ * const factory: PluginFactory<{ lang: string }, 'score' | 'details'> = (options) => { ... };
+ * export default factory;
+ * ```
+ *
+ * With `definePlugin`, TypeScript infers everything from the function body:
+ *
+ * ```ts
+ * // With definePlugin - concise and type-safe
+ * export default definePlugin(async (options: { lang: string }) => {
+ *   return {
+ *     label: 'Custom Analysis',
+ *     headers: { score: 'Score', details: 'Details' },
+ *     async eachPage({ window }) {
+ *       return { page: { score: { value: 100 }, details: { value: 'OK' } } };
+ *     },
+ *   };
+ * });
+ * ```
+ *
+ * This pattern is sometimes called a "satisfies helper" or "builder pattern"
+ * and is common in TypeScript libraries that need generic inference from
+ * function arguments (cf. Zod's `z.object()`, tRPC's `router()`).
+ * @template O - Shape of the plugin's settings/options from the config file.
+ * @template T - String literal union of column keys contributed by this plugin.
+ * @param factory - The plugin factory function to pass through.
+ * @returns The same function, unchanged.
+ * @example
+ * ```ts
+ * import { definePlugin } from '@nitpicker/core';
+ *
+ * type Options = { keywords: string[] };
+ *
+ * export default definePlugin(async (options: Options) => {
+ *   return {
+ *     label: 'キーワード検索',
+ *     headers: { found: 'Keywords Found', count: 'Match Count' },
+ *     async eachPage({ html }) {
+ *       const matches = options.keywords.filter(k => html.includes(k));
+ *       return {
+ *         page: {
+ *           found: { value: matches.join(', ') },
+ *           count: { value: matches.length },
+ *         },
+ *       };
+ *     },
+ *   };
+ * });
+ * ```
+ * @see {@link ../types.ts!PluginFactory} for the function signature being wrapped
+ * @see {@link ../types.ts!AnalyzePlugin} for the returned plugin interface
+ */
+export function definePlugin<O, T extends string = string>(
+	factory: PluginFactory<O, T>,
+): PluginFactory<O, T> {
+	return factory;
+}

package/src/hooks/index.ts

@@ -0,0 +1 @@
+export { definePlugin } from './define-plugin.js';