@rimori/playwright-testing 0.3.35-next.0 → 0.3.35

package/README.md

@@ -367,6 +367,46 @@ await env.event.triggerOnMainPanelAction({
 });
 ```
 
+### Worker Testing (`env.worker`)
+
+Drives the plugin's web worker (`public/web-worker.js`) through the **real** worker handshake — the
+same `rimori:hello` → `rimori:init` → `rimori:acknowledged` flow `rimori-main` uses — inside the
+Playwright page. The worker's `client.event.respond(...)` / `.on(...)` listeners run for real, and its
+AI/Supabase calls are served by the **same route mocks** as the UI (`page.route` intercepts
+dedicated-worker requests), so worker logic is tested deterministically without a real stack.
+
+Requires the worker bundle to be built — add `pnpm build:worker` to your scenario `webServer.command`
+(e.g. `pnpm build:scenario && pnpm build:worker && pnpm dev:standalone`).
+
+| Method | Description |
+| --- | --- |
+| `start()` | Spawn the worker and complete the handshake. Idempotent. Mock any routes the worker hits **during init** first. |
+| `request<T>(topic, data?, sender?)` | Send a request, resolve with the worker's response data. |
+| `emit(topic, data?, sender?)` | Fire-and-forget event into the worker. |
+| `on(topic, handler)` | Observe events the worker emits. Returns an `off()` function. |
+| `mockRequest(topic, responder)` | Auto-respond to a request the worker itself makes over the event bus. |
+| `stop()` | Terminate the worker (call from `afterEach`). |
+
+**Topics are fully qualified** on the wire (`<pluginId>.<area>.<action>`), exactly as another plugin
+or `rimori-main` would send them — a worker `respond('deck.requestOpenToday', …)` is reached via
+`request('<pluginId>.deck.requestOpenToday', …)`.
+
+```typescript
+await env.setup();
+
+// Mock everything the worker touches during init AND when answering the request.
+env.db.mockFrom('decks', decks, { method: 'GET' });
+
+await env.worker.start();
+
+const result = await env.worker.request(`${pluginId}.deck.requestOpenToday`, {});
+expect(result).toHaveLength(2);
+
+// afterEach: await env.worker.stop();
+```
+
+See `plugins/flashcards/test/scenario/worker-integration.test.ts` for a complete example.
+
 ### Mock Options
 
 All mock methods accept an optional `MockOptions` parameter:

package/dist/core/MessageChannelSimulator.d.ts

@@ -60,6 +60,18 @@ export declare class MessageChannelSimulator {
      * @returns A function to manually remove the responder before it's used
      */
     respondOnce(topic: string, responder: AutoResponder | unknown): () => void;
+    /**
+     * Registers a responder for a streaming request (`client.event.requestStream`). When the
+     * plugin emits the request (carrying a `__streamId`), the provided items are streamed back
+     * as `item` chunks on the derived chunk topic followed by a `done` chunk.
+     *
+     * @param topic - The streaming request topic (e.g. `pl123.lookup.requestBulkStream`).
+     * @param items - The items to stream, or a function receiving the request event that returns them.
+     * @returns A function to remove the responder.
+     */
+    respondStream(topic: string, items: unknown[] | ((event: EventBusMessage) => unknown[] | Promise<unknown[]>)): () => void;
+    /** Mirrors EventModule.deriveStreamTopics — chunk flows on the requester's namespace. */
+    private static deriveChunkTopic;
     /**
      * Overrides the user info.
      */

package/dist/core/MessageChannelSimulator.js

@@ -195,6 +195,38 @@ class MessageChannelSimulator {
             }
         };
     }
+    /**
+     * Registers a responder for a streaming request (`client.event.requestStream`). When the
+     * plugin emits the request (carrying a `__streamId`), the provided items are streamed back
+     * as `item` chunks on the derived chunk topic followed by a `done` chunk.
+     *
+     * @param topic - The streaming request topic (e.g. `pl123.lookup.requestBulkStream`).
+     * @param items - The items to stream, or a function receiving the request event that returns them.
+     * @returns A function to remove the responder.
+     */
+    respondStream(topic, items) {
+        return this.on(topic, async (event) => {
+            const streamId = event.data?.__streamId;
+            if (streamId === undefined)
+                return;
+            // Chunks flow on the REQUESTER's namespace (the plugin under test, i.e. event.sender)
+            // so the plugin's requestStream receives them — mirrors EventModule routing.
+            const chunkTopic = MessageChannelSimulator.deriveChunkTopic(topic, event.sender);
+            const list = typeof items === 'function' ? await items(event) : items;
+            for (const payload of list) {
+                await this.emit(chunkTopic, { __streamId: streamId, type: 'item', payload }, 'rimori-main');
+            }
+            await this.emit(chunkTopic, { __streamId: streamId, type: 'done' }, 'rimori-main');
+        });
+    }
+    /** Mirrors EventModule.deriveStreamTopics — chunk flows on the requester's namespace. */
+    static deriveChunkTopic(requestTopic, requesterId) {
+        const [, area, action] = requestTopic.split('.');
+        const base = action.startsWith('request')
+            ? action.slice('request'.length)
+            : action.charAt(0).toUpperCase() + action.slice(1);
+        return `${requesterId}.${area}.trigger${base}Chunk`;
+    }
     /**
      * Overrides the user info.
      */

package/dist/core/RimoriTestEnvironment.d.ts

@@ -2,7 +2,7 @@ import { Page, Request } from '@playwright/test';
 import { UserInfo } from '@rimori/client';
 import { MainPanelAction, Plugin, SidebarAction } from '@rimori/client';
 import { PluginSettings } from './SettingsStateManager';
-import { EventPayload } from '@rimori/client';
+import { EventPayload, EventBusMessage } from '@rimori/client';
 import { LanguageLevel } from '@rimori/client';
 interface RimoriTestEnvironmentOptions {
     page: Page;
@@ -46,6 +46,7 @@ export declare class RimoriTestEnvironment {
     private backendRoutes;
     private supabaseRoutes;
     private messageChannelSimulator;
+    private workerSimulator;
     private settingsManager;
     constructor(options: RimoriTestEnvironmentOptions);
     /**
@@ -200,6 +201,25 @@ export declare class RimoriTestEnvironment {
          * @returns A function to manually remove the responder
          */
         mockRequest: (topic: string, response: unknown | ((event: unknown) => unknown)) => () => void;
+        /**
+         * Registers a responder for a streaming request (`client.event.requestStream`), e.g. the
+         * translator's `lookup.requestBulkStream` used by flashcard deck generation. The items are
+         * streamed back as `item` chunks then a `done`. Pass a function to derive items from the
+         * request event (e.g. one item per `event.data.words` entry).
+         *
+         * ```ts
+         * env.event.mockRequestStream('pl7720512027.lookup.requestBulkStream', (event) =>
+         *   (event.data.words as { id: string; word: string }[]).map((w) => ({
+         *     id: w.id, word: w.word, translation: {...}, formatted: { front: '...', back: w.word },
+         *   })),
+         * );
+         * ```
+         *
+         * @param topic - The streaming request topic.
+         * @param items - The items to stream, or a function receiving the request event that returns them.
+         * @returns A function to remove the responder.
+         */
+        mockRequestStream: (topic: string, items: unknown[] | ((event: EventBusMessage) => unknown[] | Promise<unknown[]>)) => () => void;
         /**
          * Listen for events emitted by the plugin.
          * @param topic - The event topic to listen for (e.g., 'global.accomplishment.triggerMicro')
@@ -243,6 +263,35 @@ export declare class RimoriTestEnvironment {
          */
         triggerOnMainPanelAction: (payload: MainPanelAction) => Promise<void>;
     };
+    private getWorkerSimulator;
+    /**
+     * Drives the plugin's web worker (`public/web-worker.js`) through the real worker handshake,
+     * with AI/DB calls served by the same route mocks as the UI. Mock any routes the worker hits
+     * during init (e.g. flashcards' study-deck rotation) before calling `start()`.
+     *
+     * ```ts
+     * await env.setup();
+     * env.db.mockFrom('decks', [{ id: 'd1', name: 'Deck', state: 'active', created_at: '...' }]);
+     * await env.worker.start();
+     * const decks = await env.worker.request('deck.requestOpenToday', {});
+     * ```
+     */
+    readonly worker: {
+        /** Spawn the worker and complete the hello/init/ack handshake. Idempotent. */
+        start: () => Promise<void>;
+        /** Fire-and-forget event into the worker. */
+        emit: (topic: string, data?: EventPayload, sender?: string) => Promise<void>;
+        /** Send a request and resolve with the worker's response data. */
+        request: <T = unknown>(topic: string, data?: EventPayload, sender?: string) => Promise<T>;
+        /** Drive a streaming request (`respondStream`); resolves with all pushed items on done. */
+        requestStream: <TItem = unknown>(topic: string, data?: EventPayload, onItem?: (item: TItem) => void, sender?: string) => Promise<TItem[]>;
+        /** Observe events the worker emits. Returns an off() function. */
+        on: (topic: string, handler: (data: unknown, event: EventBusMessage) => void | Promise<void>) => (() => void);
+        /** Auto-respond to a request the worker itself makes over the event bus. */
+        mockRequest: (topic: string, responder: unknown) => (() => void);
+        /** Terminate the worker. Call from afterEach to avoid cross-test leaks. */
+        stop: () => Promise<void>;
+    };
     readonly ai: {
         /**
          * Mocks a text response from the LLM endpoint.

package/dist/core/RimoriTestEnvironment.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RimoriTestEnvironment = void 0;
 const default_user_info_1 = require("../fixtures/default-user-info");
 const MessageChannelSimulator_1 = require("./MessageChannelSimulator");
+const WorkerSimulator_1 = require("./WorkerSimulator");
 const SettingsStateManager_1 = require("./SettingsStateManager");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -50,6 +51,7 @@ class RimoriTestEnvironment {
         this.backendRoutes = {};
         this.supabaseRoutes = {};
         this.messageChannelSimulator = null;
+        this.workerSimulator = null;
         this.plugin = {
             /**
              * Manually set the settings state (useful for test setup).
@@ -164,6 +166,30 @@ class RimoriTestEnvironment {
                 }
                 return this.messageChannelSimulator.respond(topic, response);
             },
+            /**
+             * Registers a responder for a streaming request (`client.event.requestStream`), e.g. the
+             * translator's `lookup.requestBulkStream` used by flashcard deck generation. The items are
+             * streamed back as `item` chunks then a `done`. Pass a function to derive items from the
+             * request event (e.g. one item per `event.data.words` entry).
+             *
+             * ```ts
+             * env.event.mockRequestStream('pl7720512027.lookup.requestBulkStream', (event) =>
+             *   (event.data.words as { id: string; word: string }[]).map((w) => ({
+             *     id: w.id, word: w.word, translation: {...}, formatted: { front: '...', back: w.word },
+             *   })),
+             * );
+             * ```
+             *
+             * @param topic - The streaming request topic.
+             * @param items - The items to stream, or a function receiving the request event that returns them.
+             * @returns A function to remove the responder.
+             */
+            mockRequestStream: (topic, items) => {
+                if (!this.messageChannelSimulator) {
+                    throw new Error('MessageChannelSimulator not initialized. Call setup() first.');
+                }
+                return this.messageChannelSimulator.respondStream(topic, items);
+            },
             /**
              * Listen for events emitted by the plugin.
              * @param topic - The event topic to listen for (e.g., 'global.accomplishment.triggerMicro')
@@ -239,6 +265,34 @@ class RimoriTestEnvironment {
                 });
             },
         };
+        /**
+         * Drives the plugin's web worker (`public/web-worker.js`) through the real worker handshake,
+         * with AI/DB calls served by the same route mocks as the UI. Mock any routes the worker hits
+         * during init (e.g. flashcards' study-deck rotation) before calling `start()`.
+         *
+         * ```ts
+         * await env.setup();
+         * env.db.mockFrom('decks', [{ id: 'd1', name: 'Deck', state: 'active', created_at: '...' }]);
+         * await env.worker.start();
+         * const decks = await env.worker.request('deck.requestOpenToday', {});
+         * ```
+         */
+        this.worker = {
+            /** Spawn the worker and complete the hello/init/ack handshake. Idempotent. */
+            start: () => this.getWorkerSimulator().start(),
+            /** Fire-and-forget event into the worker. */
+            emit: (topic, data = {}, sender = 'rimori-main') => this.getWorkerSimulator().emit(topic, data, sender),
+            /** Send a request and resolve with the worker's response data. */
+            request: (topic, data = {}, sender = 'rimori-main') => this.getWorkerSimulator().request(topic, data, sender),
+            /** Drive a streaming request (`respondStream`); resolves with all pushed items on done. */
+            requestStream: (topic, data = {}, onItem, sender = 'rimori-main') => this.getWorkerSimulator().requestStream(topic, data, onItem, sender),
+            /** Observe events the worker emits. Returns an off() function. */
+            on: (topic, handler) => this.getWorkerSimulator().on(topic, handler),
+            /** Auto-respond to a request the worker itself makes over the event bus. */
+            mockRequest: (topic, responder) => this.getWorkerSimulator().mockRequest(topic, responder),
+            /** Terminate the worker. Call from afterEach to avoid cross-test leaks. */
+            stop: () => (this.workerSimulator ? this.workerSimulator.stop() : Promise.resolve()),
+        };
         this.ai = {
             /**
              * Mocks a text response from the LLM endpoint.
@@ -712,6 +766,15 @@ class RimoriTestEnvironment {
                 await route.fulfill({ status: 500, headers: { 'Content-Type': 'text/plain' }, body: String(error?.message ?? error) });
             }
         });
+        // Minimal same-origin page used by WorkerSimulator to host the worker. Being on the
+        // plugin dev-server origin makes the in-page `fetch('/web-worker.js')` same-origin.
+        this.page.route(`${pluginUrl}/__rimori_worker_harness__.html`, async (route) => {
+            await route.fulfill({
+                status: 200,
+                headers: { 'Content-Type': 'text/html; charset=utf-8' },
+                body: '<!doctype html><html><head><meta charset="utf-8"><title>Rimori Worker Harness</title></head><body></body></html>',
+            });
+        });
         // Intercept all /locales requests and fetch from the dev server
         this.page.route(`${pluginUrl}/locales/**`, async (route) => {
             const request = route.request();
@@ -1132,5 +1195,18 @@ class RimoriTestEnvironment {
             isStreaming: isStreaming ?? false,
         });
     }
+    getWorkerSimulator() {
+        if (!this.workerSimulator) {
+            this.workerSimulator = new WorkerSimulator_1.WorkerSimulator({
+                page: this.page,
+                pluginId: this.pluginId,
+                workerUrl: `${this.pluginUrl}/web-worker.js`,
+                // Same RimoriInfo object the UI bridge uses, so mockGetUserInfo() updates are reflected
+                // as long as they run before worker.start() (the worker snapshots it at init).
+                rimoriInfo: this.rimoriInfo,
+            });
+        }
+        return this.workerSimulator;
+    }
 }
 exports.RimoriTestEnvironment = RimoriTestEnvironment;

package/dist/core/WorkerSimulator.d.ts

@@ -0,0 +1,80 @@
+import type { Page } from '@playwright/test';
+import { RimoriInfo, EventBusMessage, EventPayload } from '@rimori/client';
+type EventListener = (data: unknown, event: EventBusMessage) => void | Promise<void>;
+type AutoResponder = (event: EventBusMessage) => unknown | Promise<unknown>;
+interface WorkerSimulatorArgs {
+    page: Page;
+    pluginId: string;
+    workerUrl: string;
+    rimoriInfo: RimoriInfo;
+    /** Default timeout (ms) for `request()` before rejecting. */
+    requestTimeout?: number;
+}
+/**
+ * Drives a plugin's web worker (`public/web-worker.js`) inside the Playwright page,
+ * playing the host (rimori-main) role of the worker handshake exactly like
+ * `apps/rimori-main/src/hooks/useWorkerHandler.ts`:
+ *
+ *   worker → host: `rimori:hello`
+ *   host   → worker: `rimori:init` (+ transferred MessagePort + rimoriInfo)
+ *   worker → host: `rimori:acknowledged`
+ *
+ * After the handshake all EventBus traffic is bridged across the port, so the same
+ * Playwright route mocks (AI `/ai/llm`, Supabase `/rest/v1/*`) that the UI uses also
+ * cover the worker's fetches — `page.route` intercepts dedicated-worker requests.
+ */
+export declare class WorkerSimulator {
+    private readonly page;
+    private readonly pluginId;
+    private readonly workerUrl;
+    private readonly rimoriInfo;
+    private readonly requestTimeout;
+    private readonly listeners;
+    private readonly autoResponders;
+    private readonly pending;
+    private bindingReady;
+    private started;
+    constructor({ page, pluginId, workerUrl, rimoriInfo, requestTimeout }: WorkerSimulatorArgs);
+    /**
+     * Spawns the worker and completes the handshake. Idempotent — a second call is a no-op.
+     * Mock any backend/Supabase routes the worker touches *during init* (e.g. flashcards'
+     * study-deck rotation queries the `decks` table) before calling this.
+     */
+    start(): Promise<void>;
+    /**
+     * Emits a fire-and-forget event into the worker (no response awaited).
+     * @param sender - Defaults to 'rimori-main'; must NOT be the plugin id or the worker's
+     *   respond() listeners ignore it (they blacklist their own sender for non-self topics).
+     */
+    emit(topic: string, data?: EventPayload, sender?: string): Promise<void>;
+    /**
+     * Emits a request into the worker and resolves with the worker's response data.
+     * The worker's `client.event.respond(topic, …)` handler answers with the same eventId.
+     */
+    request<T = unknown>(topic: string, data?: EventPayload, sender?: string): Promise<T>;
+    /**
+     * Drives a streaming request (`client.event.respondStream`) into the worker: emits the
+     * request carrying a generated `__streamId`, collects the chunk events the worker pushes on
+     * the derived chunk topic, and resolves with all items on `done` (rejects on `error`/timeout).
+     */
+    requestStream<TItem = unknown>(topic: string, data?: EventPayload, onItem?: (item: TItem) => void, sender?: string): Promise<TItem[]>;
+    /** Mirrors EventModule.deriveStreamTopics — chunk flows on the requester's namespace. */
+    private static deriveChunkTopic;
+    /** Observe events the worker emits (e.g. accomplishments, triggerUpdate). Returns an off() fn. */
+    on(topic: string, handler: EventListener): () => void;
+    /**
+     * Auto-respond to a request the *worker* makes over the event bus (e.g. an inter-plugin
+     * `client.event.request(...)`). The value (or function result) is returned to the worker.
+     */
+    mockRequest(topic: string, responder: AutoResponder | unknown): () => void;
+    /** Terminate the worker and clear pending state. Call from afterEach to avoid leaks. */
+    stop(): Promise<void>;
+    private ensureBinding;
+    private buildEvent;
+    private handlePortMessage;
+    private buildEventWithId;
+    private resolvePending;
+    private rejectPending;
+    private send;
+}
+export {};

package/dist/core/WorkerSimulator.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerSimulator = void 0;
+/**
+ * Drives a plugin's web worker (`public/web-worker.js`) inside the Playwright page,
+ * playing the host (rimori-main) role of the worker handshake exactly like
+ * `apps/rimori-main/src/hooks/useWorkerHandler.ts`:
+ *
+ *   worker → host: `rimori:hello`
+ *   host   → worker: `rimori:init` (+ transferred MessagePort + rimoriInfo)
+ *   worker → host: `rimori:acknowledged`
+ *
+ * After the handshake all EventBus traffic is bridged across the port, so the same
+ * Playwright route mocks (AI `/ai/llm`, Supabase `/rest/v1/*`) that the UI uses also
+ * cover the worker's fetches — `page.route` intercepts dedicated-worker requests.
+ */
+class WorkerSimulator {
+    constructor({ page, pluginId, workerUrl, rimoriInfo, requestTimeout }) {
+        this.listeners = new Map();
+        this.autoResponders = new Map();
+        this.pending = new Map();
+        this.bindingReady = false;
+        this.started = false;
+        this.page = page;
+        this.pluginId = pluginId;
+        this.workerUrl = workerUrl;
+        this.rimoriInfo = rimoriInfo;
+        this.requestTimeout = requestTimeout ?? 10000;
+        // Host-side responders the worker may need during init / runtime. The worker already
+        // receives rimoriInfo via the init handshake, so these are fallbacks for any plugin
+        // that explicitly re-requests access or user info over the event bus.
+        this.autoResponders.set('global.supabase.requestAccess', () => this.rimoriInfo);
+        this.autoResponders.set('global.profile.requestUserInfo', () => this.rimoriInfo.profile);
+        this.autoResponders.set('global.profile.getUserInfo', () => this.rimoriInfo.profile);
+    }
+    /**
+     * Spawns the worker and completes the handshake. Idempotent — a second call is a no-op.
+     * Mock any backend/Supabase routes the worker touches *during init* (e.g. flashcards'
+     * study-deck rotation queries the `decks` table) before calling this.
+     */
+    async start() {
+        if (this.started)
+            return;
+        await this.ensureBinding();
+        // Navigate to a minimal, same-origin page on the plugin dev server so the in-page
+        // `fetch(workerUrl)` is same-origin (web-worker.js is served from the plugin's public/).
+        await this.page.goto(`${this.workerUrl.replace(/\/web-worker\.js$/, '')}/__rimori_worker_harness__.html`);
+        await this.page.evaluate(async ({ pluginId, workerUrl, rimoriInfo }) => {
+            const res = await fetch(workerUrl);
+            const code = await res.text();
+            const blob = new Blob([code], { type: 'application/javascript' });
+            const worker = new Worker(URL.createObjectURL(blob), { type: 'module' });
+            const channel = new MessageChannel();
+            // Bridge worker → Node. The worker posts EventBus traffic on the transferred port.
+            channel.port1.onmessage = ({ data }) => {
+                // @ts-expect-error binding injected via exposeBinding
+                window.__rimoriWorker_onMessage(data);
+            };
+            window.__rimoriWorker_send = (payload) => channel.port1.postMessage(payload);
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => reject(new Error('[WorkerSimulator] handshake timed out after 10s')), 10000);
+                worker.onerror = (e) => {
+                    clearTimeout(timeout);
+                    reject(new Error('[WorkerSimulator] worker error: ' + (e.message || 'unknown')));
+                };
+                // hello / acknowledged arrive on the main worker channel (self.postMessage), not the port.
+                worker.onmessage = ({ data }) => {
+                    if (data?.type === 'rimori:hello') {
+                        worker.postMessage({ type: 'rimori:init', pluginId, queryParams: {}, rimoriInfo }, [channel.port2]);
+                    }
+                    else if (data?.type === 'rimori:acknowledged') {
+                        clearTimeout(timeout);
+                        resolve();
+                    }
+                };
+            });
+        }, { pluginId: this.pluginId, workerUrl: this.workerUrl, rimoriInfo: this.rimoriInfo });
+        this.started = true;
+    }
+    /**
+     * Emits a fire-and-forget event into the worker (no response awaited).
+     * @param sender - Defaults to 'rimori-main'; must NOT be the plugin id or the worker's
+     *   respond() listeners ignore it (they blacklist their own sender for non-self topics).
+     */
+    async emit(topic, data = {}, sender = 'rimori-main') {
+        await this.send({ event: this.buildEvent(topic, data, sender) });
+    }
+    /**
+     * Emits a request into the worker and resolves with the worker's response data.
+     * The worker's `client.event.respond(topic, …)` handler answers with the same eventId.
+     */
+    async request(topic, data = {}, sender = 'rimori-main') {
+        const event = this.buildEvent(topic, data, sender);
+        const eventId = event.eventId;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(eventId);
+                reject(new Error(`[WorkerSimulator] request '${topic}' timed out after ${this.requestTimeout}ms`));
+            }, this.requestTimeout);
+            this.pending.set(eventId, { resolve: resolve, reject, timer });
+            void this.send({ event });
+        });
+    }
+    /**
+     * Drives a streaming request (`client.event.respondStream`) into the worker: emits the
+     * request carrying a generated `__streamId`, collects the chunk events the worker pushes on
+     * the derived chunk topic, and resolves with all items on `done` (rejects on `error`/timeout).
+     */
+    async requestStream(topic, data = {}, onItem, sender = 'rimori-main') {
+        const streamId = Math.floor(Math.random() * 1000000000);
+        // The worker responder emits chunks on the REQUESTER's namespace (our `sender`).
+        const chunkTopic = WorkerSimulator.deriveChunkTopic(topic, sender);
+        const items = [];
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                off();
+                reject(new Error(`[WorkerSimulator] requestStream '${topic}' timed out after ${this.requestTimeout}ms`));
+            }, this.requestTimeout);
+            const off = this.on(chunkTopic, (chunkData) => {
+                const d = chunkData;
+                if (d.__streamId !== streamId)
+                    return;
+                if (d.type === 'item') {
+                    items.push(d.payload);
+                    onItem?.(d.payload);
+                }
+                else if (d.type === 'done') {
+                    clearTimeout(timer);
+                    off();
+                    resolve(items);
+                }
+                else if (d.type === 'error') {
+                    clearTimeout(timer);
+                    off();
+                    reject(new Error(d.error ?? 'stream error'));
+                }
+            });
+            void this.send({ event: this.buildEvent(topic, { __streamId: streamId, ...data }, sender) });
+        });
+    }
+    /** Mirrors EventModule.deriveStreamTopics — chunk flows on the requester's namespace. */
+    static deriveChunkTopic(requestTopic, requesterId) {
+        const [, area, action] = requestTopic.split('.');
+        const base = action.startsWith('request')
+            ? action.slice('request'.length)
+            : action.charAt(0).toUpperCase() + action.slice(1);
+        return `${requesterId}.${area}.trigger${base}Chunk`;
+    }
+    /** Observe events the worker emits (e.g. accomplishments, triggerUpdate). Returns an off() fn. */
+    on(topic, handler) {
+        const handlers = this.listeners.get(topic) ?? new Set();
+        handlers.add(handler);
+        this.listeners.set(topic, handlers);
+        return () => {
+            this.listeners.get(topic)?.delete(handler);
+        };
+    }
+    /**
+     * Auto-respond to a request the *worker* makes over the event bus (e.g. an inter-plugin
+     * `client.event.request(...)`). The value (or function result) is returned to the worker.
+     */
+    mockRequest(topic, responder) {
+        const wrapped = (event) => (typeof responder === 'function' ? responder(event) : responder);
+        this.autoResponders.set(topic, wrapped);
+        return () => {
+            this.autoResponders.delete(topic);
+        };
+    }
+    /** Terminate the worker and clear pending state. Call from afterEach to avoid leaks. */
+    async stop() {
+        for (const { reject, timer } of this.pending.values()) {
+            clearTimeout(timer);
+            reject(new Error('[WorkerSimulator] stopped before response'));
+        }
+        this.pending.clear();
+        if (!this.started)
+            return;
+        this.started = false;
+        await this.page
+            .evaluate(() => {
+            const w = window.__rimoriWorker;
+            w?.worker.terminate();
+        })
+            .catch(() => {
+            /* page may already be closed */
+        });
+    }
+    async ensureBinding() {
+        if (this.bindingReady)
+            return;
+        await this.page.exposeBinding('__rimoriWorker_onMessage', (_source, payload) => this.handlePortMessage(payload));
+        this.bindingReady = true;
+    }
+    buildEvent(topic, data, sender) {
+        return {
+            timestamp: new Date().toISOString(),
+            eventId: Math.floor(Math.random() * 1000000000),
+            sender,
+            topic,
+            data,
+            debug: false,
+        };
+    }
+    async handlePortMessage(payload) {
+        if (!payload)
+            return;
+        // Explicit response/error envelopes (not currently emitted by the worker, but handle them).
+        if (payload.type === 'response') {
+            this.resolvePending(payload.eventId, payload.response?.data);
+            return;
+        }
+        if (payload.type === 'error') {
+            this.rejectPending(payload.eventId, payload.error);
+            return;
+        }
+        const event = payload.event;
+        if (!event)
+            return;
+        // A response to one of our requests: same eventId, sender is the plugin id.
+        if (event.eventId && this.pending.has(event.eventId)) {
+            this.resolvePending(event.eventId, event.data);
+            return;
+        }
+        // A request originated by the worker that we know how to answer.
+        if (event.eventId && this.autoResponders.has(event.topic)) {
+            const responder = this.autoResponders.get(event.topic);
+            const data = (await responder(event));
+            // Reply with a non-plugin sender so the worker's request resolver picks it up.
+            await this.send({ event: this.buildEventWithId(event.topic, data, 'rimori-main', event.eventId) });
+            return;
+        }
+        // Otherwise it's a plain emitted event — notify observers.
+        const handlers = this.listeners.get(event.topic);
+        if (handlers?.size) {
+            for (const handler of handlers)
+                await handler(event.data, event);
+        }
+    }
+    buildEventWithId(topic, data, sender, eventId) {
+        return { timestamp: new Date().toISOString(), eventId, sender, topic, data, debug: false };
+    }
+    resolvePending(eventId, data) {
+        const pending = this.pending.get(eventId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pending.delete(eventId);
+        pending.resolve(data);
+    }
+    rejectPending(eventId, error) {
+        const pending = this.pending.get(eventId);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pending.delete(eventId);
+        pending.reject(error instanceof Error ? error : new Error(String(error)));
+    }
+    async send(payload) {
+        await this.page.evaluate((value) => {
+            const bridge = window.__rimoriWorker_send;
+            if (!bridge)
+                throw new Error('[WorkerSimulator] worker bridge unavailable — call start() first');
+            bridge(value);
+        }, payload);
+    }
+}
+exports.WorkerSimulator = WorkerSimulator;

package/dist/harness/__mfe_internal__rimori_mf_2_scenario_mf_2_host__loadShare___mf_0_rimori_mf_1_client__loadShare__.mjs.js

@@ -1 +1 @@
-var e=`modulepreload`,t=function(e){return`/__rimori_harness__/`+e},n={},r=function(r,i,a){let o=Promise.resolve();if(i&&i.length>0){let r=document.getElementsByTagName(`link`),s=document.querySelector(`meta[property=csp-nonce]`),c=s?.nonce||s?.getAttribute(`nonce`);function l(e){return Promise.all(e.map(e=>Promise.resolve(e).then(e=>({status:`fulfilled`,value:e}),e=>({status:`rejected`,reason:e}))))}o=l(i.map(i=>{if(i=t(i,a),i in n)return;n[i]=!0;let o=i.endsWith(`.css`),s=o?`[rel="stylesheet"]`:``;if(a)for(let e=r.length-1;e>=0;e--){let t=r[e];if(t.href===i&&(!o||t.rel===`stylesheet`))return}else if(document.querySelector(`link[href="${i}"]${s}`))return;let l=document.createElement(`link`);if(l.rel=o?`stylesheet`:e,o||(l.as=`script`),l.crossOrigin=``,l.href=i,c&&l.setAttribute(`nonce`,c),document.head.appendChild(l),o)return new Promise((e,t)=>{l.addEventListener(`load`,e),l.addEventListener(`error`,()=>t(Error(`Unable to preload CSS for ${i}`)))})}))}function s(e){let t=new Event(`vite:preloadError`,{cancelable:!0});if(t.payload=e,window.dispatchEvent(t),!t.defaultPrevented)throw e}return o.then(e=>{for(let t of e||[])t.status===`rejected`&&s(t.reason);return r().catch(s)})},i=`__mf_module_cache__`;globalThis[i]||={share:{},remote:{}},globalThis[i].share||={},globalThis[i].remote||={};var a=globalThis[i],o=a.share[`@rimori/client`];o===void 0&&(o=await r(()=>import(`./dist3.js`),[]),a.share[`@rimori/client`]=o),o.__esModule,o.default;var{setupWorker:s,AudioController:c,Translator:l,TIER_ORDER:u,ROLE_ORDER:d,StorageModule:f,AssetsModule:p,EventBusHandler:m,EventBus:h,RimoriClient:g,StandaloneClient:_,MessageSender:v,getDifficultyLevel:y,getDifficultyLabel:b,getNeighborDifficultyLevel:x,compareLanguageLevels:S,RimoriCommunicationHandler:C}=o;export{m as a,r as c,u as i,_ as n,h as o,v as r,g as s,c as t};
+var e=`modulepreload`,t=function(e){return`/__rimori_harness__/`+e},n={},r=function(r,i,a){let o=Promise.resolve();if(i&&i.length>0){let r=document.getElementsByTagName(`link`),s=document.querySelector(`meta[property=csp-nonce]`),c=s?.nonce||s?.getAttribute(`nonce`);function l(e){return Promise.all(e.map(e=>Promise.resolve(e).then(e=>({status:`fulfilled`,value:e}),e=>({status:`rejected`,reason:e}))))}o=l(i.map(i=>{if(i=t(i,a),i in n)return;n[i]=!0;let o=i.endsWith(`.css`),s=o?`[rel="stylesheet"]`:``;if(a)for(let e=r.length-1;e>=0;e--){let t=r[e];if(t.href===i&&(!o||t.rel===`stylesheet`))return}else if(document.querySelector(`link[href="${i}"]${s}`))return;let l=document.createElement(`link`);if(l.rel=o?`stylesheet`:e,o||(l.as=`script`),l.crossOrigin=``,l.href=i,c&&l.setAttribute(`nonce`,c),document.head.appendChild(l),o)return new Promise((e,t)=>{l.addEventListener(`load`,e),l.addEventListener(`error`,()=>t(Error(`Unable to preload CSS for ${i}`)))})}))}function s(e){let t=new Event(`vite:preloadError`,{cancelable:!0});if(t.payload=e,window.dispatchEvent(t),!t.defaultPrevented)throw e}return o.then(e=>{for(let t of e||[])t.status===`rejected`&&s(t.reason);return r().catch(s)})},i=`__mf_module_cache__`;globalThis[i]||={share:{},remote:{}},globalThis[i].share||={},globalThis[i].remote||={};var a=globalThis[i],o=a.share[`@rimori/client`];o===void 0&&(o=await r(()=>import(`./dist3.js`),[]),a.share[`@rimori/client`]=o),o.__esModule,o.default;var{setupWorker:s,AudioController:c,voiceDebug:l,Translator:u,TIER_ORDER:d,ROLE_ORDER:f,StorageModule:p,AssetsModule:m,EventBusHandler:h,EventBus:g,RimoriClient:_,StandaloneClient:v,MessageSender:y,getDifficultyLevel:b,getDifficultyLabel:x,getNeighborDifficultyLevel:S,compareLanguageLevels:C,RimoriCommunicationHandler:w}=o;export{l as a,g as c,y as i,r as l,_ as n,d as o,v as r,h as s,c as t};