@d-zero/dealer 1.6.5 → 1.7.0

package/README.md

@@ -38,6 +38,31 @@ await deal(
 );
 ```
 
+### キャンセル
+
+`AbortSignal`を渡すことで、処理を途中で中断できます。実行中のワーカーは完了まで待機し、新しいワーカーの起動のみが停止されます。
+
+```ts
+const controller = new AbortController();
+
+// 外部イベント（タイムアウトなど）でキャンセル
+setTimeout(() => controller.abort(), 30_000);
+
+await deal(
+	items,
+	(item, update, index) => {
+		return async () => {
+			update(`Processing item ${index}...`);
+			await item.process();
+		};
+	},
+	{
+		limit: 10,
+		signal: controller.signal,
+	},
+);
+```
+
 ### deal関数
 
 コレクションを並列処理し、ログを順次出力します。
@@ -80,23 +105,6 @@ async function deal<T extends WeakKey>(
      - これはアイテム開始**後**、最初の出力の**前**に発生
    - 実際の処理が始まる(ユーザーコードからの最初の `update()` 呼び出し)
 
-#### エラーハンドリング
-
-ワーカー（`start()`関数）がエラーを投げた場合、残りのワーカーの処理は継続されます。すべてのワーカーが完了（成功または失敗）した後、1つ以上のエラーがあれば`AggregateError`でrejectされます。
-
-```ts
-try {
-	await deal(items, setup, options);
-} catch (error) {
-	if (error instanceof AggregateError) {
-		console.error(`${error.errors.length} workers failed:`);
-		for (const e of error.errors) {
-			console.error(e);
-		}
-	}
-}
-```
-
 ### DealOptions型
 
 ```ts
@@ -112,13 +120,14 @@ type DealOptions<T = unknown> = DealerOptions<T> &
 
 - `limit?: number`: 同時実行数の制限(デフォルト: 10)
 - `onPush?: (item: T) => boolean`: `push()`時のフィルタ関数。`false`を返すとそのアイテムは拒否される(例: 重複排除)
+- `signal?: AbortSignal`: 処理のキャンセルに使用する`AbortSignal`。シグナルがabortされると新しいワーカーの起動を停止し、実行中のワーカーの完了を待ってから終了する
 - `header?: DealHeader`: 進捗ヘッダーを生成する関数
 - `debug?: boolean`: デバッグログを表示するかどうか
 - `interval?: number | DelayOptions`: 各処理の間隔(ミリ秒またはDelayOptions)
 - `animations?: Animations`: アニメーション定義
 - `fps?: FPS`: フレームレート(12, 24, 30, 60)
 - `indent?: string`: ログのインデント文字列
-- `sort?: (a: readonly [number, string], b: readonly [number, string]) => number`: ログのソート関数
+- `sort?: (a: [number, string], b: [number, string]) => number`: ログのソート関数
 - `verbose?: boolean`: 詳細ログモード
 
 ### DealHeader型
@@ -137,7 +146,7 @@ type DealHeader = (
 #### パラメータ
 
 - `progress`: 進捗率(0〜1)
-- `done`: 処理済みアイテム数（エラーで失敗したアイテムを含む）
+- `done`: 完了したアイテム数
 - `total`: 総アイテム数
 - `limit`: 同時実行数制限
 
@@ -158,19 +167,7 @@ constructor(items: readonly T[], options?: DealerOptions<T>)
 - `items`: 処理対象のアイテム
 - `options.limit`: 同時実行数の制限(デフォルト: 10)
 - `options.onPush`: `push()`時のフィルタ関数
-
-#### プロパティ
-
-##### get errors(): ReadonlyArray<{ item: T; error: unknown }>
-
-ワーカーの実行中に発生したエラーの一覧を返します。各エントリにはエラーを起こしたアイテムとエラーオブジェクトが含まれます。
-
-```ts
-await runDealer(dealer);
-for (const { item, error } of dealer.errors) {
-	console.error('Failed item:', item, error);
-}
-```
+- `options.signal`: 処理のキャンセルに使用する`AbortSignal`
 
 #### メソッド
 
@@ -214,7 +211,7 @@ dealer.progress((progress, done, total, limit) => {
 
 ##### async push(...items: T[])
 
-実行中にアイテムをキューに追加します。追加されたアイテムには`setup()`で設定した初期化関数が自動適用されます。完了後の呼び出しは無視されます。
+実行中にアイテムをキューに追加します。追加されたアイテムには`setup()`で設定した初期化関数が自動適用されます。処理完了後または`signal`がabort済みの場合、呼び出しは無視されます。
 
 ```ts
 await dealer.push(newItem1, newItem2);

package/dist/deal.d.ts

@@ -2,26 +2,24 @@ import type { DealerOptions } from './dealer.js';
 import type { LanesOptions } from './lanes.js';
 import type { DelayOptions } from '@d-zero/shared/delay';
 /**
- * Configuration options for the {@link deal} function.
- * Combines {@link DealerOptions} (concurrency), {@link LanesOptions} (display),
- * and deal-specific options (header, debug, interval).
- * @template T - The type of items being processed
+ * {@link deal} 関数のオプション。
+ * {@link DealerOptions} と {@link LanesOptions} を合成し、
+ * ヘッダー・デバッグ・インターバルの設定を追加したもの。
+ * @template T - 処理対象アイテムの型
  */
 export type DealOptions<T = unknown> = DealerOptions<T> & LanesOptions & {
-    /** Function to generate the progress header string */
     readonly header?: DealHeader;
-    /** Whether to display debug log output */
     readonly debug?: boolean;
-    /** Delay between each worker start, in milliseconds or as a DelayOptions object */
     readonly interval?: number | DelayOptions;
 };
 /**
- * Function type that converts progress information into a header string for display.
- * @param progress - Progress ratio from 0 to 1
- * @param done - Number of processed items (including errors)
- * @param total - Total number of items
- * @param limit - Concurrency limit
- * @returns Header string to display. May include animation variables like `%earth%`, `%dots%`.
+ * 進捗情報をヘッダー文字列に変換するコールバック型。
+ * 返却文字列にはアニメーション変数（`%earth%`, `%dots%` など）を含めることができる。
+ * @param progress - 進捗率（0〜1）
+ * @param done - 完了したアイテム数
+ * @param total - 総アイテム数
+ * @param limit - 同時実行数制限
+ * @returns ヘッダーとして表示する文字列
  */
 export type DealHeader = (progress: number, done: number, total: number, limit: number) => string;
 /**
@@ -53,16 +51,20 @@ export type DealHeader = (progress: number, done: number, total: number, limit:
  * - All wait logs (including interval delay) are output via `delay()` callback
  * - This ensures the determined interval (even for random delays) is used for countdown
  * - The `%countdown()` function displays remaining time based on the actual delay duration
- * @template T - The type of items to process, must extend WeakKey
- * @param items - Collection of items to process
- * @param setup - Function that initializes each item and returns a start function.
- *   Receives the item, an update callback for logging, the item index,
- *   a setLineHeader callback for log prefixes, and a push callback to add items dynamically.
- *   Must return a start function that performs the actual work.
- * @param options - Configuration options including concurrency limit, interval delay, and display settings
- * @returns Promise that resolves when all items are processed successfully
- * @throws {AggregateError} When one or more workers throw errors. All workers run to
- *   completion regardless of individual failures. The AggregateError.errors array
- *   contains the original errors from each failed worker.
+ *
+ * ### Cancellation via AbortSignal
+ * - Pass `signal` option with an `AbortSignal` to enable cancellation
+ * - When the signal is aborted:
+ *   1. No new workers will be launched
+ *   2. Currently running workers will continue until they complete
+ *   3. `push()` calls after abort are silently ignored
+ *   4. The returned Promise resolves after all running workers finish
+ * - If the signal is already aborted before `play()`, the Promise resolves immediately
+ *   without processing any items
+ * @template T - 処理対象アイテムの型（WeakKey 制約）
+ * @param items - 処理対象のアイテムのコレクション
+ * @param setup - 各アイテムを初期化し、開始関数を返すコールバック
+ * @param options - 並列処理・ログ出力・インターバルの設定オプション
+ * @returns 全アイテムの処理完了またはキャンセル完了時に解決する Promise
  */
 export declare function deal<T extends WeakKey>(items: readonly T[], setup: (process: T, update: (log: string) => void, index: number, setLineHeader: (lineHeader: string) => void, push: (...items: T[]) => Promise<void>) => Promise<() => void | Promise<void>> | (() => void | Promise<void>), options?: DealOptions<T>): Promise<void>;

package/dist/deal.js

@@ -31,17 +31,21 @@ const DEBUG_ID = Number.MIN_SAFE_INTEGER;
  * - All wait logs (including interval delay) are output via `delay()` callback
  * - This ensures the determined interval (even for random delays) is used for countdown
  * - The `%countdown()` function displays remaining time based on the actual delay duration
- * @template T - The type of items to process, must extend WeakKey
- * @param items - Collection of items to process
- * @param setup - Function that initializes each item and returns a start function.
- *   Receives the item, an update callback for logging, the item index,
- *   a setLineHeader callback for log prefixes, and a push callback to add items dynamically.
- *   Must return a start function that performs the actual work.
- * @param options - Configuration options including concurrency limit, interval delay, and display settings
- * @returns Promise that resolves when all items are processed successfully
- * @throws {AggregateError} When one or more workers throw errors. All workers run to
- *   completion regardless of individual failures. The AggregateError.errors array
- *   contains the original errors from each failed worker.
+ *
+ * ### Cancellation via AbortSignal
+ * - Pass `signal` option with an `AbortSignal` to enable cancellation
+ * - When the signal is aborted:
+ *   1. No new workers will be launched
+ *   2. Currently running workers will continue until they complete
+ *   3. `push()` calls after abort are silently ignored
+ *   4. The returned Promise resolves after all running workers finish
+ * - If the signal is already aborted before `play()`, the Promise resolves immediately
+ *   without processing any items
+ * @template T - 処理対象アイテムの型（WeakKey 制約）
+ * @param items - 処理対象のアイテムのコレクション
+ * @param setup - 各アイテムを初期化し、開始関数を返すコールバック
+ * @param options - 並列処理・ログ出力・インターバルの設定オプション
+ * @returns 全アイテムの処理完了またはキャンセル完了時に解決する Promise
  */
 export async function deal(items, setup, options) {
     const dealer = new Dealer(items, options);
@@ -63,12 +67,8 @@ export async function deal(items, setup, options) {
             await delay(options?.interval ?? 0, (determinedInterval) => {
                 update(`Waiting interval: %countdown(${determinedInterval},${index}_interval)%ms`);
             });
-            try {
-                await start();
-            }
-            finally {
-                lanes.delete(index);
-            }
+            await start();
+            lanes.delete(index);
         };
     });
     if (options?.debug) {
@@ -76,15 +76,10 @@ export async function deal(items, setup, options) {
             lanes.update(DEBUG_ID, `[DEBUG]: ${log}`);
         });
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
         dealer.finish(() => {
             lanes.close();
-            if (dealer.errors.length > 0) {
-                reject(new AggregateError(dealer.errors.map((e) => e.error), `${dealer.errors.length} worker(s) failed`));
-            }
-            else {
-                resolve();
-            }
+            resolve();
         });
         dealer.play();
     });

package/dist/dealer.d.ts

@@ -1,67 +1,67 @@
 import type { ProcessInitializer } from './types.js';
 /**
- * Configuration options for the {@link Dealer} class.
- * @template T - The type of items being processed
+ * {@link Dealer} のコンストラクタオプション。
+ * @template T - 処理対象アイテムの型
  */
 export interface DealerOptions<T = unknown> {
-    /** Maximum number of concurrent workers (default: 10) */
+    /** 同時実行ワーカー数の上限。デフォルトは `10`。 */
     limit?: number;
-    /** Filter function called when items are added via {@link Dealer.push}. Return `false` to reject the item. */
+    /**
+     * {@link Dealer.push} 時に呼ばれるフィルタ関数。
+     * `false` を返すとそのアイテムはキューに追加されない。
+     * @param item - push されたアイテム
+     * @returns アイテムを受け入れる場合は `true`
+     */
     onPush?: (item: T) => boolean;
+    /**
+     * 処理のキャンセルに使用する `AbortSignal`。
+     * シグナルが abort されると新しいワーカーの起動を停止し、
+     * 実行中のワーカーの完了を待ってから終了する。
+     */
+    signal?: AbortSignal;
 }
 /**
- * Manages parallel processing of items with configurable concurrency limits.
+ * アイテムを並列処理するワーカープールマネージャー。
  *
- * Items are dispatched to workers up to the configured limit. When a worker
- * completes (successfully or with error), the next pending item is dispatched.
- * Errors are collected and accessible via the `errors` property.
- * @template T - The type of items to process, must extend WeakKey
+ * 典型的な使用順序: {@link setup} → {@link finish} / {@link progress} → {@link play}。
+ * 処理中に {@link push} で動的にアイテムを追加できる。
+ * @template T - 処理対象アイテムの型（WeakKey 制約）
  */
 export declare class Dealer<T extends WeakKey> {
     #private;
-    /**
-     * Errors collected from failed workers during processing.
-     * @returns Array of objects containing the failed item and its error
-     */
-    get errors(): ReadonlyArray<{
-        item: T;
-        error: unknown;
-    }>;
-    /**
-     * @param items - Collection of items to process
-     * @param options - Configuration options
-     */
     constructor(items: readonly T[], options?: DealerOptions<T>);
     /**
-     * Sets a listener for debug log messages.
-     * @param listener - Callback invoked with debug log strings
+     * デバッグログのリスナーを設定する。
+     * @param listener - デバッグメッセージを受け取るコールバック
      */
     debug(listener: (log: string) => void): void;
     /**
-     * Sets a listener called when all items have been processed (including failures).
-     * @param listener - Callback invoked on completion
+     * 全アイテムの処理完了（またはキャンセル完了）時に呼ばれるリスナーを設定する。
+     * @param listener - 完了時に呼ばれるコールバック
      */
     finish(listener: () => void): void;
     /**
-     * Starts dispatching items to workers.
+     * 並列処理を開始する。
+     * {@link setup} を先に呼び出す必要がある。
      */
     play(): void;
     /**
-     * Sets a listener for progress updates, called each time a worker completes.
-     * @param listener - Callback receiving progress ratio (0–1), done count (including errors), total count, and concurrency limit
+     * 進捗更新のリスナーを設定する。
+     * アイテムが完了するたびに呼び出される。
+     * @param listener - 進捗情報を受け取るコールバック
      */
     progress(listener: (progress: number, done: number, total: number, limit: number) => void): void;
     /**
-     * Adds items to the processing queue during execution.
-     * Added items are initialized using the same initializer set via {@link setup}.
-     * Calls after all processing has finished are silently ignored.
-     * @param items - Items to add. If `onPush` is configured, items returning `false` are skipped.
+     * 実行中にアイテムをキューに追加する。
+     * 追加されたアイテムには {@link setup} で設定した初期化関数が自動適用される。
+     * 処理完了後または signal が abort 済みの場合、呼び出しは無視される。
+     * @param items - 追加するアイテム
      */
     push(...items: T[]): Promise<void>;
     /**
-     * Registers the initializer function and prepares all items for processing.
-     * Must be called before {@link play}.
-     * @param initializer - Function that receives each item and its index, returning a start function
+     * 各アイテムの初期化関数を設定する。
+     * {@link play} を呼ぶ前に必ず呼び出すこと。
+     * @param initializer - 各アイテムを初期化し、実行関数を返すコールバック
      */
     setup(initializer: ProcessInitializer<T>): Promise<void>;
 }

package/dist/dealer.js

@@ -1,16 +1,14 @@
 /**
- * Manages parallel processing of items with configurable concurrency limits.
+ * アイテムを並列処理するワーカープールマネージャー。
  *
- * Items are dispatched to workers up to the configured limit. When a worker
- * completes (successfully or with error), the next pending item is dispatched.
- * Errors are collected and accessible via the `errors` property.
- * @template T - The type of items to process, must extend WeakKey
+ * 典型的な使用順序: {@link setup} → {@link finish} / {@link progress} → {@link play}。
+ * 処理中に {@link push} で動的にアイテムを追加できる。
+ * @template T - 処理対象アイテムの型（WeakKey 制約）
  */
 export class Dealer {
     #debug = () => { };
     #done = new WeakSet();
     #doneCount = 0;
-    #errors = [];
     #finish = () => { };
     #finished = false;
     #initializer = null;
@@ -20,59 +18,52 @@ export class Dealer {
     #onPush;
     #pendingInitCount = 0;
     #progress = () => { };
+    #signal;
     #starts = new WeakMap();
     #workers = new Set();
-    /**
-     * Errors collected from failed workers during processing.
-     * @returns Array of objects containing the failed item and its error
-     */
-    get errors() {
-        return this.#errors;
-    }
-    /**
-     * @param items - Collection of items to process
-     * @param options - Configuration options
-     */
     constructor(items, options) {
         this.#items = [...items];
         this.#limit = options?.limit ?? 10;
         this.#onPush = options?.onPush;
+        this.#signal = options?.signal;
     }
     /**
-     * Sets a listener for debug log messages.
-     * @param listener - Callback invoked with debug log strings
+     * デバッグログのリスナーを設定する。
+     * @param listener - デバッグメッセージを受け取るコールバック
      */
     debug(listener) {
         this.#debug = listener;
     }
     /**
-     * Sets a listener called when all items have been processed (including failures).
-     * @param listener - Callback invoked on completion
+     * 全アイテムの処理完了（またはキャンセル完了）時に呼ばれるリスナーを設定する。
+     * @param listener - 完了時に呼ばれるコールバック
      */
     finish(listener) {
         this.#finish = listener;
     }
     /**
-     * Starts dispatching items to workers.
+     * 並列処理を開始する。
+     * {@link setup} を先に呼び出す必要がある。
      */
     play() {
         this.#deal();
     }
     /**
-     * Sets a listener for progress updates, called each time a worker completes.
-     * @param listener - Callback receiving progress ratio (0–1), done count (including errors), total count, and concurrency limit
+     * 進捗更新のリスナーを設定する。
+     * アイテムが完了するたびに呼び出される。
+     * @param listener - 進捗情報を受け取るコールバック
      */
     progress(listener) {
         this.#progress = listener;
     }
     /**
-     * Adds items to the processing queue during execution.
-     * Added items are initialized using the same initializer set via {@link setup}.
-     * Calls after all processing has finished are silently ignored.
-     * @param items - Items to add. If `onPush` is configured, items returning `false` are skipped.
+     * 実行中にアイテムをキューに追加する。
+     * 追加されたアイテムには {@link setup} で設定した初期化関数が自動適用される。
+     * 処理完了後または signal が abort 済みの場合、呼び出しは無視される。
+     * @param items - 追加するアイテム
      */
     async push(...items) {
-        if (this.#finished) {
+        if (this.#finished || this.#signal?.aborted) {
             return;
         }
         for (const item of items) {
@@ -84,9 +75,9 @@ export class Dealer {
         }
     }
     /**
-     * Registers the initializer function and prepares all items for processing.
-     * Must be called before {@link play}.
-     * @param initializer - Function that receives each item and its index, returning a start function
+     * 各アイテムの初期化関数を設定する。
+     * {@link play} を呼ぶ前に必ず呼び出すこと。
+     * @param initializer - 各アイテムを初期化し、実行関数を返すコールバック
      */
     async setup(initializer) {
         this.#initializer = initializer;
@@ -97,13 +88,10 @@ export class Dealer {
         const total = this.#items.length;
         this.#progress(total === 0 ? 0 : this.#doneCount / total, this.#doneCount, total, this.#limit);
     }
-    #completeWorker(worker) {
-        this.#workers.delete(worker);
-        this.#done.add(worker);
-        this.#doneCount++;
-        this.#deal();
-    }
     #deal() {
+        if (this.#finished) {
+            return;
+        }
         const total = this.#items.length;
         this.#debug(`Done: ${this.#doneCount}/${total} (Limit: ${this.#limit})`);
         this.#progress(total === 0 ? 0 : this.#doneCount / total, this.#doneCount, total, this.#limit);
@@ -112,6 +100,13 @@ export class Dealer {
             this.#finish();
             return;
         }
+        if (this.#signal?.aborted) {
+            if (this.#workers.size === 0) {
+                this.#finished = true;
+                this.#finish();
+            }
+            return;
+        }
         while (this.#workers.size < this.#limit) {
             const worker = this.#draw();
             if (!worker) {
@@ -122,13 +117,11 @@ export class Dealer {
             if (!start) {
                 throw new Error(`Didn't have a starting function`);
             }
-            void start()
-                .then(() => {
-                this.#completeWorker(worker);
-            })
-                .catch((error) => {
-                this.#errors.push({ item: worker, error });
-                this.#completeWorker(worker);
+            void start().then(() => {
+                this.#workers.delete(worker);
+                this.#done.add(worker);
+                this.#doneCount++;
+                this.#deal();
             });
         }
     }
@@ -149,9 +142,13 @@ export class Dealer {
             throw new Error('setup() must be called before push()');
         }
         const start = await this.#initializer(item, this.#nextIndex++);
+        this.#pendingInitCount--;
+        if (this.#signal?.aborted) {
+            this.#deal();
+            return;
+        }
         this.#starts.set(item, async () => await start());
         this.#items.push(item);
-        this.#pendingInitCount--;
         this.#deal();
     }
 }

package/dist/lanes.d.ts

@@ -1,60 +1,55 @@
 import type { Animations, FPS } from './types.js';
 type Log = readonly [id: number, message: string];
 type SortFunc = (a: Log, b: Log) => number;
-/** Configuration options for the {@link Lanes} display manager. */
+/**
+ * {@link Lanes} のコンストラクタオプション。
+ */
 export type LanesOptions = {
-    /** Custom animation definitions to override or extend built-in presets */
     readonly animations?: Animations;
-    /** Frame rate for display rendering */
     readonly fps?: FPS;
-    /** Indent string prepended to each log line */
     readonly indent?: string;
-    /** Sort function for ordering log entries by their ID */
     readonly sort?: SortFunc;
-    /** When true, logs are appended line-by-line to stdout instead of being redrawn in-place */
     readonly verbose?: boolean;
 };
 /**
- * Manages multiple concurrent log lines with ordered display output.
- * Each log line is identified by a numeric ID and can be independently updated or deleted.
+ * 複数のログラインを管理し、順序付きでターミナルに表示するクラス。
+ * verbose モードでは上書き表示ではなく追記出力を行う。
  */
 export declare class Lanes {
     #private;
-    /**
-     * @param options - Display configuration options
-     */
     constructor(options?: LanesOptions);
     /**
-     * Clears all log entries. No-op in verbose mode.
-     * @param options - Pass `{ header: true }` to also clear the header
+     * すべてのログをクリアする。verbose モードでは何もしない。
+     * @param options - クリアオプション
      * @param options.header
      */
     clear(options?: {
         header?: boolean;
     }): void;
     /**
-     * Closes the underlying display and releases resources.
+     * ディスプレイを閉じ、リソースを解放する。
      */
     close(): void;
     /**
-     * Removes the log entry with the given ID. No-op in verbose mode.
-     * @param id - The log entry ID to remove
+     * 指定した ID のログを削除する。verbose モードでは何もしない。
+     * @param id - 削除するログの ID
      */
     delete(id: number): void;
     /**
-     * Sets the header text displayed above all log lines.
-     * @param text - Header text to display
+     * ヘッダーテキストを設定する。
+     * @param text - ヘッダーとして表示する文字列
      */
     header(text: string): void;
     /**
-     * Updates the log entry for the given ID. In verbose mode, immediately writes the header and log to stdout.
-     * @param id - The log entry ID
-     * @param log - The log message
+     * 指定した ID のログを更新する。
+     * verbose モードではヘッダーとログを連結して即時出力する。
+     * @param id - 更新するログの ID
+     * @param log - ログメッセージ
      */
     update(id: number, log: string): void;
     /**
-     * Renders all current log entries to the display. No-op in verbose mode.
-     * Entries are sorted by the configured sort function before rendering.
+     * 現在のログをソートしてターミナルに表示する。
+     * verbose モードでは何もしない。
      */
     write(): void;
 }

package/dist/lanes.js

@@ -1,8 +1,8 @@
 import { Display } from './display.js';
 const RESET = '\u001B[0m';
 /**
- * Manages multiple concurrent log lines with ordered display output.
- * Each log line is identified by a numeric ID and can be independently updated or deleted.
+ * 複数のログラインを管理し、順序付きでターミナルに表示するクラス。
+ * verbose モードでは上書き表示ではなく追記出力を行う。
  */
 export class Lanes {
     #display;
@@ -11,9 +11,6 @@ export class Lanes {
     #logs = new Map();
     #sort = ([a], [b]) => a - b;
     #verbose;
-    /**
-     * @param options - Display configuration options
-     */
     constructor(options) {
         this.#display = new Display({
             animations: options?.animations,
@@ -25,8 +22,8 @@ export class Lanes {
         this.#verbose = options?.verbose ?? false;
     }
     /**
-     * Clears all log entries. No-op in verbose mode.
-     * @param options - Pass `{ header: true }` to also clear the header
+     * すべてのログをクリアする。verbose モードでは何もしない。
+     * @param options - クリアオプション
      * @param options.header
      */
     clear(options) {
@@ -40,14 +37,14 @@ export class Lanes {
         this.write();
     }
     /**
-     * Closes the underlying display and releases resources.
+     * ディスプレイを閉じ、リソースを解放する。
      */
     close() {
         this.#display.close();
     }
     /**
-     * Removes the log entry with the given ID. No-op in verbose mode.
-     * @param id - The log entry ID to remove
+     * 指定した ID のログを削除する。verbose モードでは何もしない。
+     * @param id - 削除するログの ID
      */
     delete(id) {
         if (this.#verbose) {
@@ -57,8 +54,8 @@ export class Lanes {
         this.write();
     }
     /**
-     * Sets the header text displayed above all log lines.
-     * @param text - Header text to display
+     * ヘッダーテキストを設定する。
+     * @param text - ヘッダーとして表示する文字列
      */
     header(text) {
         this.#header = text;
@@ -68,9 +65,10 @@ export class Lanes {
         this.write();
     }
     /**
-     * Updates the log entry for the given ID. In verbose mode, immediately writes the header and log to stdout.
-     * @param id - The log entry ID
-     * @param log - The log message
+     * 指定した ID のログを更新する。
+     * verbose モードではヘッダーとログを連結して即時出力する。
+     * @param id - 更新するログの ID
+     * @param log - ログメッセージ
      */
     update(id, log) {
         if (this.#verbose) {
@@ -81,8 +79,8 @@ export class Lanes {
         this.write();
     }
     /**
-     * Renders all current log entries to the display. No-op in verbose mode.
-     * Entries are sorted by the configured sort function before rendering.
+     * 現在のログをソートしてターミナルに表示する。
+     * verbose モードでは何もしない。
      */
     write() {
         if (this.#verbose) {

package/dist/types.d.ts

@@ -1,13 +1,19 @@
-/** Mapping of animation names to their frame rate and sprite sequences. */
+/**
+ * アニメーション定義のマップ。
+ * キーはアニメーション名（`%name%` 形式でログ中に埋め込み可能）、
+ * 値は先頭が FPS、残りがスプライトフレームのタプル。
+ */
 export type Animations = Record<string, [fps: number, ...sprites: string[]]>;
-/** Supported frame rates for display rendering. */
+/**
+ * サポートされるフレームレート。
+ */
 export type FPS = 12 | 24 | 30 | 60;
 /**
- * Function that initializes an item and returns its start function.
- * @template T - The type of item being initialized
- * @param process - The item to initialize
- * @param index - The sequential index assigned to the item
- * @returns A start function that performs the actual processing
+ * 各アイテムを初期化し、実行関数を返すコールバック。
+ * @template T - 処理対象アイテムの型
+ * @param process - 初期化対象のアイテム
+ * @param index - アイテムのインデックス（0始まり）
+ * @returns 処理を開始する関数を返す Promise
  */
 export interface ProcessInitializer<T> {
     (process: T, index: number): Promise<() => Promise<void> | void>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@d-zero/dealer",
-	"version": "1.6.5",
+	"version": "1.7.0",
 	"description": "A tool that provides an API and CLI for parallel processing of collections and sequential logging to standard output",
 	"author": "D-ZERO",
 	"license": "MIT",
@@ -26,5 +26,5 @@
 		"@d-zero/shared": "0.20.1",
 		"ansi-colors": "4.1.3"
 	},
-	"gitHead": "31410767ae6beff5c5dbe21a824406a4e6716868"
+	"gitHead": "866364294ddacc3095f65a9f8b488d40c4ccb904"
 }