fireEvent (eventName, payload = '') {
    // ...
    this.eventQueue.push({
        eventName: eventName,
        payload: payload,
        firedAt: new Date().toISOString()
    });
}

async processBatchEvents () {
    if (this.eventQueue.length === 0) return;

    // キューから全イベントを取り出す
    const events = this.eventQueue.splice(0);
    log.info(`Mesh V2: Processing ${events.length} queued events for sending`);
    // ...
}

// フレームごとに1つのブロードキャストのみ実行
const {event, offsetMs} = eventsToProcess[0];
this.broadcastEvent(event);

// constructorに定数と統計変数を追加
constructor (blocks, meshId, domain) {
    // ... 既存のコード ...

    this.eventQueue = [];
    this.eventBatchInterval = 250;
    this.eventBatchTimer = null;

    // Event queue limits
    this.MAX_EVENT_QUEUE_SIZE = 100;  // 最大100イベント
    this.eventQueueStats = {
        duplicatesSkipped: 0,
        dropped: 0,
        lastReportTime: Date.now()
    };

    // ... 残りのコード ...
}

// fireEvent()を修正
fireEvent (eventName, payload = '') {
    if (!this.groupId || !this.client) {
        log.warn(`Mesh V2: Cannot fire event ${eventName} - groupId: ${this.groupId}, client: ${!!this.client}`);
        return;
    }

    // ステップ1: 重複チェック
    const isDuplicate = this.eventQueue.some(item =>
        item.eventName === eventName && item.payload === payload
    );

    if (isDuplicate) {
        this.eventQueueStats.duplicatesSkipped++;
        this.reportEventStatsIfNeeded();

        log.debug(`Mesh V2: Event already in queue, skipping: ${eventName}`);
        return;
    }

    // ステップ2: サイズ制限チェック（保険）
    if (this.eventQueue.length >= this.MAX_EVENT_QUEUE_SIZE) {
        const dropped = this.eventQueue.shift();  // 古いイベントを破棄（FIFO）
        this.eventQueueStats.dropped++;

        if (this.eventQueueStats.dropped % 10 === 1) {  // 10イベントごとに警告
            log.warn(`Mesh V2: Event queue full (${this.MAX_EVENT_QUEUE_SIZE}). ` +
                `Dropped ${this.eventQueueStats.dropped} events. ` +
                `Latest: ${dropped.eventName}`);
        }
    }

    log.debug(`Mesh V2: Queuing event for sending: ${eventName} ` +
        `(queue size: ${this.eventQueue.length})`);

    this.eventQueue.push({
        eventName: eventName,
        payload: payload,
        firedAt: new Date().toISOString()
    });
}

// 統計情報レポート（10秒ごと）
reportEventStatsIfNeeded () {
    const now = Date.now();
    const elapsed = now - this.eventQueueStats.lastReportTime;

    if (elapsed >= 10000 &&
        (this.eventQueueStats.duplicatesSkipped > 0 || this.eventQueueStats.dropped > 0)) {
        log.info(`Mesh V2: Event Queue Stats (last ${(elapsed / 1000).toFixed(1)}s): ` +
            `duplicates skipped=${this.eventQueueStats.duplicatesSkipped}, ` +
            `dropped=${this.eventQueueStats.dropped}, ` +
            `current queue size=${this.eventQueue.length}`);

        this.eventQueueStats.duplicatesSkipped = 0;
        this.eventQueueStats.dropped = 0;
        this.eventQueueStats.lastReportTime = now;
    }
}

// cleanup()に統計情報出力を追加
cleanup () {
    // 統計情報を出力
    if (this.eventQueueStats &&
        (this.eventQueueStats.duplicatesSkipped > 0 || this.eventQueueStats.dropped > 0)) {
        log.info(`Mesh V2: Final Event Queue Stats: ` +
            `duplicates skipped=${this.eventQueueStats.duplicatesSkipped}, ` +
            `dropped=${this.eventQueueStats.dropped}`);
    }

    // キューをクリア
    this.pendingBroadcasts = [];
    this.batchStartTime = null;
    this.lastBroadcastOffset = 0;

    // ... 既存のクリーンアップコード ...
}

/**
 * Process pending broadcast events that should fire based on elapsed real time.
 * Called once per frame via BEFORE_STEP event.
 *
 * Strategy:
 * - Process all events whose timing has arrived (offsetMs <= elapsedMs)
 * - Execute them in order (maintains event sequence)
 * - Different event types don't cause RESTART (different handlers)
 */
processNextBroadcast () {
    if (!this.groupId) {
        // 切断されている場合はなにもしない
        return;
    }

    if (this.pendingBroadcasts.length === 0) {
        // キューが空になったらリセット
        this.batchStartTime = null;
        this.lastBroadcastOffset = 0;
        return;
    }

    const now = Date.now();
    const elapsedMs = this.batchStartTime ? now - this.batchStartTime : 0;

    // 処理すべきイベントを収集（タイミングが来ているもの）
    const eventsToProcess = [];

    while (this.pendingBroadcasts.length > 0) {
        const {event, offsetMs} = this.pendingBroadcasts[0];

        // まだタイミングが来ていない場合は待機
        if (offsetMs > elapsedMs) {
            log.debug(`Mesh V2: Waiting for event ${event.name} ` +
                `(needs ${offsetMs}ms, elapsed ${elapsedMs}ms)`);
            break;
        }

        // タイミングが来たイベントをキューから取り出し
        const item = this.pendingBroadcasts.shift();
        eventsToProcess.push(item);
    }

    // 収集したイベントをすべて処理
    if (eventsToProcess.length > 0) {
        log.info(`Mesh V2: Broadcasting ${eventsToProcess.length} events ` +
            `(${this.pendingBroadcasts.length} remaining in queue)`);

        eventsToProcess.forEach(({event, offsetMs}) => {
            log.info(`Mesh V2: Broadcasting event: ${event.name} ` +
                `(offset: ${offsetMs}ms, elapsed: ${elapsedMs}ms)`);

            this.broadcastEvent(event);
            this.lastBroadcastOffset = offsetMs;
        });
    }
}

ずっと
  [メッセージ1] を送る
  [メッセージ2] を送る
  [メッセージ3] を送る
end

// 150種類の異なるイベントを発火
for (let i = 0; i < 150; i++) {
    this.meshService.fireEvent(`message${i}`);
}

[メッセージ1] を送る
[メッセージ2] を送る
[メッセージ3] を送る

[メッセージ1] を受け取ったとき
  (変数1) を (1) にする

[メッセージ2] を受け取ったとき
  (変数2) を (1) にする

[メッセージ3] を受け取ったとき
  (変数3) を (1) にする