@midra/webext 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Midra
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -9,7 +9,7 @@ Chrome / Firefox の WebExtensions API を共通のインターフェースで
 - **サイドパネル**：`webext.side` で Chrome / Firefox の操作を共通化。
 - **タブ取得・ポップアウト**：コンテンツスクリプト自身のタブ取得と、タブに関連付けた別ウィンドウの作成。
 - **ストレージ**：不足メソッドの補完、値の取得・保存、変更監視。
-- **型付きメッセージング**：チャンネルごとのリクエスト・レスポンスの型定義。
+- **型付きメッセージング**：チャンネルごとのリクエスト・レスポンスの型定義。MAIN worldとの双方向通信にも対応。
 - **メニュー**：`menus` で Firefox の `menus` / Chrome の `contextMenus` の差異を吸収。
 
 グローバルの `chrome` / `browser` は変更しません。WXT、ビルド時のブラウザ指定、追加のランタイム依存は不要です。
@@ -218,6 +218,76 @@ const result = await channel.send('greet', { name: 'Midra' })
 - 型は実行時検証ではありません。受信値やsenderの追加検証は必要に応じてhandler内で行ってください。
 - `stop()` / `channel.dispose()` / `webext.dispose()` でリスナーを解除。
 
+### MAIN worldとの通信
+
+MAIN worldでは拡張APIを使えないため、`createMainWorldMessaging()` を使用します。同じフレームのISOLATED worldコンテンツスクリプトで、中継を登録してください。既存の `channel().send()/handle()` とスキーマを共有できます。
+
+```ts
+// 共通の型
+interface WorldMessages {
+  greet: { request: string; response: string }
+}
+```
+
+```ts
+// ISOLATED worldのコンテンツスクリプト
+import { webext } from '@midra/webext'
+
+const stopBridge = webext.messaging.bridgeMainWorld({
+  namespace: 'my-extension/world',
+  channels: ['app/world'], // 中継を許可するチャンネルだけ指定
+})
+const channel = webext.messaging.channel<WorldMessages>('app/world')
+channel.handle('greet', (name) => `Content: ${name}`)
+
+const reply = await channel.send('greet', 'Midra', { target: 'main-world' })
+```
+
+```ts
+// MAIN worldのスクリプト
+import { createMainWorldMessaging } from '@midra/webext'
+
+const messaging = createMainWorldMessaging({ namespace: 'my-extension/world' })
+const channel = messaging.channel<WorldMessages>('app/world')
+channel.handle('greet', (name) => `MAIN: ${name}`)
+
+const backgroundReply = await channel.send('greet', 'Midra')
+const contentReply = await channel.send('greet', 'Midra', {
+  target: 'content-script',
+})
+```
+
+```ts
+// background（トップレベルで登録）
+import { webext } from '@midra/webext'
+
+const channel = webext.messaging.channel<WorldMessages>('app/world')
+channel.handle('greet', (name, sender) => {
+  console.log(sender.world, sender.tab?.id) // MAIN由来ならworldは 'MAIN'
+  return `Background: ${name}`
+})
+
+// 任意のタイミングで、対象タブ・フレームのMAIN worldへ送る
+const reply = await channel.send('greet', 'Midra', {
+  target: 'main-world', tabId: 123, frameId: 0,
+})
+```
+
+| 送信元 → 送信先 | `send()` の指定 |
+| --- | --- |
+| MAIN → background | 指定なし（または `target: 'background'`） |
+| MAIN → 同じフレームのcontent script | `target: 'content-script'` |
+| content script → 同じフレームのMAIN | `target: 'main-world'` |
+| background / 拡張ページ → MAIN | `target: 'main-world', tabId`。必要なら `frameId` / `documentId` |
+
+- 中継はコンテンツスクリプトのインスタンスにつき1つ。送信前に両worldのスクリプト・受信ハンドラー・中継を登録してください。MAIN worldのスクリプトの注入は利用側で行います。
+- 中継に指定していないチャンネルは公開しません。通常のruntime/tabs通信は従来どおり動作します。`target: 'background'` は `runtime.sendMessage()` を使うため、該当する拡張内ハンドラーは1つにしてください。
+- MAIN由来の要求には `sender.world: 'MAIN'` を付けます。backgroundにはネイティブの実際のタブ・フレーム情報を渡します。content script内のハンドラーにはページURLを渡し、拡張ID・タブIDは付けません。
+- 通信は同じWindow・origin・namespaceに限定しますが、**ページのスクリプトも内容を読み書きできます**。namespace・`sender.world` は認証に使えません。公開する処理と要求値を検証し、機密情報をこの通信に載せないでください。
+- JSON制約・`RemoteError`・タイムアウト・`AbortSignal` は既存の通信と同じです。タイムアウト／中止時にはDOM応答の待機も解除します。
+- `stopBridge()` / `webext.dispose()` は中継を解除します。`messaging.dispose()` はMAIN側を解除します。これらの破棄は未完了のDOM応答待機を拒否します。受信済みの処理は継続します。
+- 通常のHTTP(S)ページが対象です。`data:` やsandbox iframeなど、originが `null` のドキュメントは非対応です。
+
 ## ネイティブ API と移行
 
 ブラウザ固有の操作には `webext.native` を使用できます。`webext.sidePanel` / `webext.sidebarAction` もネイティブのままです。
@@ -273,7 +343,7 @@ bun run build
 - `src/disposables.ts` / `src/facade.ts`：解除処理の管理、ネイティブAPIを変更しないラッパー。
 - `demo/src/operations.ts`：ユーザー操作を維持した実行と、ボタンごとの実行中状態の管理。
 
-メッセージの受信リスナーは `createWebExt()` のインスタンスごとに1つを共有し、handlerが存在する間だけ登録します。ストレージの監視とactionクリックの解除関数は、繰り返し呼んでも解除処理を重複実行しません。
+ネイティブメッセージの受信リスナーは `createWebExt()` のインスタンスごとに1つを共有し、handlerまたはMAIN world中継が存在する間だけ登録します。ストレージの監視とactionクリックの解除関数は、繰り返し呼んでも解除処理を重複実行しません。
 
 ### 検証範囲
 

package/dist/index.d.ts

@@ -78,12 +78,19 @@ type MessageSchema = Record<string, MessageDefinition>;
  *
  * @remarks
  * `tabId` がなければ自拡張への `runtime.sendMessage()`、あれば `tabs.sendMessage()` を使用します。
- * 外部拡張・Webページ宛ての送信は提供しません。対象フレーム・ドキュメントの存在と各オプションへの
+ * MAIN world宛ては明示登録したコンテンツスクリプト中継を使います。外部拡張への送信は提供しません。
+ * 対象フレーム・ドキュメントの存在と各オプションへの
  * 対応はネイティブAPIに従い、未対応の指定を代替しません。
  * @see https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendMessage
  * @see https://developer.chrome.com/docs/extensions/reference/api/tabs#method-sendMessage
  */
 interface SendOptions {
+  /**
+   * 送信先のworld。省略時は従来のruntime/tabs送信、MAIN world側ではbackground宛て。
+   * `content-script` はMAIN worldから同じフレームへの送信で使用します。
+   * `main-world` はコンテンツスクリプトから同じフレーム、background等からは `tabId` と併用します。
+   */
+  target?: 'background' | 'content-script' | 'main-world';
   /**
    * 送信先コンテンツスクリプトを含むタブID。非負の安全な整数が必要です。
    * @remarks ネイティブの `tabs.sendMessage()` が使えるコンテキストと、対象タブの受信ハンドラーが必要です。
@@ -120,8 +127,10 @@ interface SendOptions {
  *
  * @typeParam Schema - メッセージ名ごとの要求型・応答型。実行時スキーマ検証は行いません。
  * @remarks
- * ファクトリーごとに単一の `runtime.onMessage` ルーターを共有し、ハンドラーがある間だけ登録します。
- * 受信は `sender.id === runtime.id` の内部メッセージに限定し、未登録のチャンネル・メッセージは扱いません。
+ * 拡張側は単一の `runtime.onMessage` ルーターを共有し、ハンドラーまたは中継がある間だけ登録します。
+ * ネイティブ受信は `sender.id === runtime.id` の内部メッセージに限定します。
+ * MAIN worldとのDOM通信はページも読み書きできます。中継の許可チャンネルは明示登録してください。
+ * 未登録のチャンネル・メッセージは扱いません。
  * この確認は要求内容や送信元URLの信頼性を保証しません。必要な検証はハンドラーで行ってください。
  * 1つの要求に応答するコンテキストは1つにしてください。複数の受信先が応答する場合の順序は保証しません。
  * @see https://developer.chrome.com/docs/extensions/reference/api/runtime#type-MessageSender
@@ -143,8 +152,10 @@ interface MessageChannel<Schema extends { [K in keyof Schema]: MessageDefinition
    * @throws 破棄済みチャンネル・非互換の応答・ネイティブ通信エラー・シグナル中止理由。
    * @remarks
    * 上記の失敗はすべて戻り値のPromiseの拒否です（同期例外ではありません）。受信先がない場合も成功扱いにしません。
-   * `tabId` なしの送信は送信元自身を除く拡張コンテキスト宛てで、コンテンツスクリプト宛てではありません。
-   * コンテンツスクリプトへは `tabId` を指定してください。待機の中止は受信処理を停止しません。
+   * 通常の `tabId` なしの送信は送信元自身を除く拡張コンテキスト宛てです。
+   * 拡張側からコンテンツスクリプトへは `tabId` を指定してください。
+   * MAIN world側の `target: 'content-script'` は同じフレームへ送り、タブ指定はできません。
+   * `target: 'main-world'` は明示登録した中継を使います。待機の中止は受信処理を停止しません。
    * @see https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendMessage
    * @see https://developer.chrome.com/docs/extensions/reference/api/tabs#method-sendMessage
    * @see https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage
@@ -155,9 +166,9 @@ interface MessageChannel<Schema extends { [K in keyof Schema]: MessageDefinition
    *
    * @typeParam K - スキーマ内のメッセージ名。
    * @param type - 処理するメッセージ名。同じチャンネル内で重複登録はできません。
-   * @param handler - 要求値とネイティブのMessageSenderを受け取り、JSON互換の応答値またはそのPromiseを返す関数。
+   * @param handler - 要求値とMessageSenderを受け取り、JSON互換の応答値またはそのPromiseを返す関数。
    * @returns この登録だけを解除する関数。繰り返し呼んでも一度だけ解除し、後続の再登録は解除しません。
-   * @throws {UnsupportedOperationError} `runtime.onMessage` が利用できない場合に同期的に送出します。
+   * @throws {UnsupportedOperationError} 拡張側で `runtime.onMessage` が利用できない場合に同期的に送出します。
    * @throws 破棄済みチャンネル・同じメッセージ名の重複登録は同期例外です。
    * @remarks
    * 受信イベント内でハンドラーを同期的に呼び、その結果をawaitしてcallbackで応答します。
@@ -175,7 +186,7 @@ interface MessageChannel<Schema extends { [K in keyof Schema]: MessageDefinition
    * @see https://developer.chrome.com/docs/extensions/reference/api/runtime#type-MessageSender
    * @see https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage
    */
-  handle<K extends keyof Schema & string>(type: K, handler: (request: Schema[K]['request'], sender: Browser.Runtime.MessageSender) => Schema[K]['response'] | Promise<Schema[K]['response']>): () => void;
+  handle<K extends keyof Schema & string>(type: K, handler: (request: Schema[K]['request'], sender: MessageSender) => Schema[K]['response'] | Promise<Schema[K]['response']>): () => void;
   /**
    * このチャンネルの全ハンドラーを解除し、このオブジェクトを終端的に破棄します。
    *
@@ -183,12 +194,20 @@ interface MessageChannel<Schema extends { [K in keyof Schema]: MessageDefinition
    * @remarks
    * 以後の `send()` はPromiseの拒否、`handle()` は同期例外になります。
    * ファクトリーが未破棄なら `messaging.channel(name)` で同名の新しいチャンネルを作れます。
-   * 既に実行中のハンドラーや送信側の待機はキャンセルしません。
+   * 既に実行中のハンドラーや送信側の待機はキャンセルしません。DOMの待機はファクトリー／中継の破棄で拒否します。
    */
   dispose(): void;
 }
 /** 名前付きチャンネルを管理する、WebExtインスタンスごとのメッセージングファクトリー。 */
 interface Messaging {
+  /**
+   * 同じフレームのMAIN worldとの中継を登録し、解除関数を返します。
+   * コンテンツスクリプトで呼び、両worldで同じnamespaceを指定してください。
+   * 許可したチャンネルだけを中継します。ページも通信を読み書きできるため、
+   * namespaceは認証情報ではありません。入力・送信元はhandlerで検証してください。
+   * 1インスタンスにつき1つ登録でき、disposeでも解除します。
+   */
+  bridgeMainWorld(options: MainWorldBridgeOptions): () => void;
   /**
    * 名前に対応するチャンネルを取得・作成します。
    *
@@ -212,10 +231,37 @@ interface Messaging {
    * @remarks
    * `webext.dispose()` でも呼ばれます。破棄後は `channel()` を呼べません。
    * 再利用には `createWebExt()` で新しいインスタンスを作成してください。
-   * 送信済みの待機や実行中の受信処理をキャンセルするものではありません。
+   * DOMの応答待機は拒否します。ネイティブ送信の待機や実行中の受信処理は継続します。
    */
   dispose(): void;
 }
+/** ネイティブの送信元情報。MAIN world由来の要求には `world: 'MAIN'` を付けます。 */
+type MessageSender = Browser.Runtime.MessageSender & {
+  world?: 'MAIN';
+};
+/** MAIN worldとコンテンツスクリプトで共有するDOM通信の設定。 */
+interface MainWorldOptions {
+  /** 拡張ごとに固有の名前。同じフレームで両worldが同じ値を使います。認証には使えません。 */
+  namespace: string;
+  /** 通信に使う同じフレームのWindow。省略時はglobalThis.window。テスト用に注入できます。 */
+  window?: Window;
+}
+/** コンテンツスクリプト側でMAIN worldに公開するチャンネル。 */
+interface MainWorldBridgeOptions extends MainWorldOptions {
+  /** 中継を許可するチャンネル名。内部タブ取得など、未指定のチャンネルは公開しません。 */
+  channels: readonly string[];
+}
+/** 拡張APIがないMAIN worldで使うチャンネル管理API。 */
+type MainWorldMessaging = Pick<Messaging, 'channel' | 'dispose'>;
+//#endregion
+//#region src/messaging/index.d.ts
+/**
+ * 拡張APIがないMAIN worldで、同じ型付きchannel APIを作成します。
+ * 同じフレームのコンテンツスクリプトでbridgeMainWorldを登録してください。
+ * sendの既定宛先はbackground、target: 'content-script'で同じフレームへ送れます。
+ * ページは通信を読み書きでき、namespaceやsenderは認証に使えません。
+ */
+export declare function createMainWorldMessaging(options: MainWorldOptions): MainWorldMessaging;
 //#endregion
 //#region src/popout.d.ts
 /**
@@ -855,7 +901,7 @@ type WebExt = Omit<Browser.Browser, 'tabs' | 'action' | 'storage' | 'menus' | 's
    *
    * @remarks
    * 繰り返し呼べます。保存値・パネル・ネイティブ設定・直接登録されたリスナーは変更しません。
-   * 送信済みの待機や実行中の受信処理はキャンセルしません。
+   * MAIN world中継のDOM応答待機は拒否します。ネイティブ送信の待機や実行中の受信処理は継続します。
    * メッセージングは終端的に破棄されるため、再利用には `createWebExt()` で新しいインスタンスを作成してください。
    */
   dispose(): void;
@@ -896,4 +942,4 @@ export declare function createWebExt(options?: CreateWebExtOptions): WebExt;
  */
 export declare const webext: WebExt;
 //#endregion
-export type { CreateWebExtOptions, MessageChannel, MessageDefinition, MessageSchema, Messaging, PopoutOptions, SendOptions, Side, SideCapabilities, SidePathTarget, SideTarget, StorageArea, StorageHelpers, WebExt, WebExtContext, WebExtStorage, WebExtTabs };
+export type { CreateWebExtOptions, MainWorldBridgeOptions, MainWorldMessaging, MainWorldOptions, MessageChannel, MessageDefinition, MessageSchema, MessageSender, Messaging, PopoutOptions, SendOptions, Side, SideCapabilities, SidePathTarget, SideTarget, StorageArea, StorageHelpers, WebExt, WebExtContext, WebExtStorage, WebExtTabs };

package/dist/index.js

@@ -236,20 +236,37 @@ function normalizeError(error) {
 //#endregion
 //#region src/messaging/transport.ts
 const MAX_TIMEOUT_MS = 2147483647;
-async function sendMessage(api, name, type, request, options = {}) {
+async function sendMessage(api, name, type, request, options = {}, transport) {
 	const timeoutMs = options.timeoutMs ?? 1e4;
 	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMEOUT_MS) throw new TypeError(`timeoutMs must be positive, finite and at most ${MAX_TIMEOUT_MS}`);
 	if (options.signal?.aborted) throw options.signal.reason ?? new DOMException("Aborted", "AbortError");
 	if (options.tabId !== void 0) assertTabId(options.tabId);
 	if (options.tabId === void 0 && (options.frameId !== void 0 || options.documentId !== void 0)) throw new TypeError("frameId/documentId requires tabId");
+	if (options.target !== void 0 && ![
+		"background",
+		"content-script",
+		"main-world"
+	].includes(options.target)) throw new TypeError("Invalid message target");
+	if (options.target === "background" && options.tabId !== void 0) throw new TypeError("background target cannot be combined with tabId");
 	const message = {
 		__webext_rpc__: 1,
 		channel: name,
 		type,
 		payload: encode(request),
-		empty: request === void 0
+		empty: request === void 0,
+		...options.target === "main-world" ? {
+			target: "main-world",
+			timeoutMs
+		} : {}
 	};
+	let pending;
 	const send = () => {
+		if (transport) {
+			pending = transport(message);
+			return pending.response;
+		}
+		if (!api) throw new UnsupportedOperationError("messaging.send");
+		if (options.target === "content-script" && options.tabId === void 0) throw new TypeError("content-script target requires tabId");
 		if (options.tabId === void 0) return api.runtime.sendMessage(message);
 		if (!api.tabs?.sendMessage) throw new UnsupportedOperationError("messaging.send to tab");
 		const target = {
@@ -273,21 +290,135 @@ async function sendMessage(api, name, type, request, options = {}) {
 		if (!response.ok) throw new RemoteError(response.error?.message ?? "Remote handler failed", response.error?.name ?? "Error");
 		return response.empty ? void 0 : response.value;
 	} finally {
+		pending?.dispose();
 		if (timer !== void 0) clearTimeout(timer);
 		if (onAbort) options.signal?.removeEventListener("abort", onAbort);
 	}
 }
 //#endregion
+//#region src/messaging/window.ts
+function errorResponse(error) {
+	return {
+		__webext_rpc__: 1,
+		ok: false,
+		error: normalizeError(error)
+	};
+}
+/** 同じフレームのDOM通信。namespace・送信元worldはページから偽装でき、認証には使えません。 */
+function createWindowTransport(options, side, receive) {
+	if (typeof options.namespace !== "string" || !options.namespace.trim()) throw new TypeError("MAIN world namespace must not be empty");
+	const namespace = options.namespace;
+	const window = options.window ?? globalThis.window;
+	if (!window?.postMessage || !window.addEventListener) throw new UnsupportedOperationError("MAIN world messaging");
+	const origin = window.location.origin;
+	if (origin === "null") throw new UnsupportedOperationError("MAIN world messaging on opaque origins");
+	const peer = side === "main" ? "content" : "main";
+	const pending = /* @__PURE__ */ new Map();
+	let disposed = false;
+	const post = (body) => {
+		if (disposed) return;
+		window.postMessage({
+			...body,
+			__webext_window_rpc__: 1,
+			namespace,
+			from: side
+		}, origin);
+	};
+	const listener = (event) => {
+		if (event.source !== window || event.origin !== origin) return;
+		const data = event.data;
+		if (!data || typeof data !== "object" || data.__webext_window_rpc__ !== 1 || data.namespace !== namespace || data.from !== peer || typeof data.id !== "string") return;
+		if (data.kind === "response") {
+			const entry = pending.get(data.id);
+			if (!entry) return;
+			pending.delete(data.id);
+			try {
+				entry.resolve(encode(data.response));
+			} catch (error) {
+				entry.reject(error);
+			}
+			return;
+		}
+		if (data.kind !== "request") return;
+		const message = data.message;
+		if (!message || typeof message !== "object" || message.__webext_rpc__ !== 1 || typeof message.channel !== "string" || typeof message.type !== "string" || typeof message.empty !== "boolean") return;
+		const respond = (response) => post({
+			kind: "response",
+			id: data.id,
+			response
+		});
+		try {
+			const snapshot = encode(message);
+			if (side === "main" && (!data.sender || typeof data.sender !== "object" || Array.isArray(data.sender))) throw new TypeError("Invalid MAIN world message sender");
+			receive(snapshot, side === "content" ? {
+				url: window.location.href,
+				world: "MAIN"
+			} : encode(data.sender), data.target, respond);
+		} catch (error) {
+			respond(errorResponse(error));
+		}
+	};
+	window.addEventListener("message", listener);
+	return {
+		window,
+		send(message, sender, target) {
+			if (disposed) throw new Error("MAIN world messaging is disposed");
+			const id = Array.from(globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(4)), (value) => value.toString(16)).join("-");
+			return {
+				response: new Promise((resolve, reject) => {
+					pending.set(id, {
+						resolve,
+						reject
+					});
+					try {
+						post({
+							kind: "request",
+							id,
+							message,
+							sender: encode(sender),
+							target
+						});
+					} catch (error) {
+						pending.delete(id);
+						reject(error);
+					}
+				}),
+				dispose: () => {
+					pending.delete(id);
+				}
+			};
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			window.removeEventListener("message", listener);
+			for (const entry of pending.values()) entry.reject(/* @__PURE__ */ new Error("MAIN world messaging is disposed"));
+			pending.clear();
+		}
+	};
+}
+//#endregion
 //#region src/messaging/index.ts
-function createMessaging(api) {
+function createMessaging(api, context) {
+	return createFactory(api, context);
+}
+/**
+* 拡張APIがないMAIN worldで、同じ型付きchannel APIを作成します。
+* 同じフレームのコンテンツスクリプトでbridgeMainWorldを登録してください。
+* sendの既定宛先はbackground、target: 'content-script'で同じフレームへ送れます。
+* ページは通信を読み書きでき、namespaceやsenderは認証に使えません。
+*/
+function createMainWorldMessaging(options) {
+	return createFactory(void 0, "main-world", options);
+}
+function createFactory(api, context, mainOptions) {
 	const channels = /* @__PURE__ */ new Map();
 	const routes = /* @__PURE__ */ new Map();
 	let listening = false;
 	let factoryDisposed = false;
-	const listener = (message, sender, sendResponse) => {
-		if (!sendResponse || !message || typeof message !== "object") return false;
-		const envelope = message;
-		if (envelope.__webext_rpc__ !== 1 || typeof envelope.channel !== "string" || typeof envelope.type !== "string" || sender.id !== api.runtime.id) return false;
+	let bridge;
+	let allowedChannels = /* @__PURE__ */ new Set();
+	const route = (envelope, sender, sendResponse) => {
 		const handler = routes.get(envelope.channel)?.get(envelope.type);
 		if (!handler) return false;
 		(async () => {
@@ -309,15 +440,99 @@ function createMessaging(api) {
 		})();
 		return true;
 	};
+	const main = mainOptions && createWindowTransport(mainOptions, "main", (message, sender, _target, respond) => {
+		if (!route(message, sender, respond)) respond(errorResponse(/* @__PURE__ */ new Error(`No receiver for ${message.channel}:${message.type}`)));
+	});
+	const listener = (message, sender, sendResponse) => {
+		if (!api || !sendResponse || !message || typeof message !== "object") return false;
+		const envelope = message;
+		if (envelope.__webext_rpc__ !== 1 || typeof envelope.channel !== "string" || typeof envelope.type !== "string" || sender.id !== api.runtime.id) return false;
+		if (envelope.target === "main-world") {
+			if (!bridge || !allowedChannels.has(envelope.channel)) return false;
+			relayToMain(envelope, sender, sendResponse);
+			return true;
+		}
+		return route(envelope, envelope.__webext_main_world__ === 1 ? {
+			...sender,
+			world: "MAIN"
+		} : sender, sendResponse);
+	};
+	const syncListener = () => {
+		if (!api?.runtime.onMessage) return;
+		const needed = routes.size > 0 || !!bridge;
+		if (needed === listening) return;
+		if (needed) api.runtime.onMessage.addListener(listener);
+		else api.runtime.onMessage.removeListener(listener);
+		listening = needed;
+	};
+	const relayToMain = (envelope, sender, respond) => {
+		const endpoint = bridge;
+		(async () => {
+			try {
+				const value = await sendMessage(void 0, envelope.channel, envelope.type, envelope.empty === true ? void 0 : envelope.payload, { timeoutMs: envelope.timeoutMs }, (message) => endpoint.send(message, sender));
+				respond({
+					__webext_rpc__: 1,
+					ok: true,
+					value: encode(value),
+					empty: value === void 0
+				});
+			} catch (error) {
+				const response = errorResponse(error);
+				if (error instanceof RemoteError) response.error.name = error.remoteName;
+				respond(response);
+			}
+		})();
+	};
 	const removeRoute = (name, handlers) => {
 		if (routes.get(name) !== handlers) return;
 		routes.delete(name);
-		if (!routes.size && listening) {
-			api.runtime.onMessage.removeListener(listener);
-			listening = false;
-		}
+		syncListener();
 	};
 	return {
+		bridgeMainWorld(options) {
+			if (factoryDisposed) throw new Error("Messaging is disposed");
+			if (!api || context !== "content-script") throw new UnsupportedOperationError("messaging.bridgeMainWorld outside content-script");
+			if (bridge) throw new Error("A MAIN world bridge is already registered");
+			if (!Array.isArray(options.channels) || options.channels.some((name) => typeof name !== "string" || !name.trim())) throw new TypeError("MAIN world bridge channels must be non-empty names");
+			if (!api.runtime.onMessage) throw new UnsupportedOperationError("messaging.bridgeMainWorld");
+			allowedChannels = new Set(options.channels);
+			const endpoint = createWindowTransport(options, "content", (message, sender, target, respond) => {
+				if (!allowedChannels.has(message.channel)) {
+					respond(errorResponse(/* @__PURE__ */ new Error("MAIN world channel is not allowed")));
+					return;
+				}
+				if (target === "content-script") {
+					if (!route(message, sender, respond)) respond(errorResponse(/* @__PURE__ */ new Error(`No receiver for ${message.channel}:${message.type}`)));
+				} else if (target === "background") (async () => {
+					try {
+						respond(await api.runtime.sendMessage({
+							__webext_rpc__: 1,
+							__webext_main_world__: 1,
+							channel: message.channel,
+							type: message.type,
+							payload: message.payload,
+							empty: message.empty
+						}));
+					} catch (error) {
+						respond(errorResponse(error));
+					}
+				})();
+				else respond(errorResponse(/* @__PURE__ */ new TypeError("Invalid MAIN world message target")));
+			});
+			bridge = endpoint;
+			syncListener();
+			let stopped = false;
+			return () => {
+				if (stopped) return;
+				stopped = true;
+				endpoint.dispose();
+				if (bridge === endpoint) {
+					bridge = void 0;
+					allowedChannels.clear();
+					syncListener();
+				}
+			};
+		},
 		channel(name) {
 			if (factoryDisposed) throw new Error("Messaging is disposed");
 			if (!name.trim()) throw new TypeError("Message channel name must not be empty");
@@ -328,18 +543,25 @@ function createMessaging(api) {
 			const channel = {
 				send(type, request, options = {}) {
 					if (disposed) return Promise.reject(/* @__PURE__ */ new Error("Message channel is disposed"));
-					return sendMessage(api, name, type, request, options);
+					return sendMessage(api, name, type, request, options, main ? (message) => {
+						if (options.tabId !== void 0) throw new TypeError("MAIN world cannot select another tab");
+						if (options.target === "main-world") throw new TypeError("MAIN world cannot send to itself");
+						return main.send(message, {}, options.target ?? "background");
+					} : options.target === "main-world" && options.tabId === void 0 ? (message) => {
+						if (!bridge || !allowedChannels.has(name)) throw new UnsupportedOperationError("messaging.send to MAIN world");
+						return bridge.send(message, {
+							id: api?.runtime.id,
+							url: bridge.window.location.href
+						});
+					} : void 0);
 				},
 				handle(type, handler) {
 					if (disposed) throw new Error("Message channel is disposed");
 					if (handlers.has(type)) throw new Error(`A handler for ${name}:${type} is already registered`);
-					if (!api.runtime.onMessage) throw new UnsupportedOperationError("messaging.handle");
+					if (!main && !api?.runtime.onMessage) throw new UnsupportedOperationError("messaging.handle");
 					handlers.set(type, handler);
 					routes.set(name, handlers);
-					if (!listening) {
-						api.runtime.onMessage.addListener(listener);
-						listening = true;
-					}
+					syncListener();
 					let stopped = false;
 					return () => {
 						if (stopped) return;
@@ -362,7 +584,12 @@ function createMessaging(api) {
 		dispose() {
 			if (factoryDisposed) return;
 			factoryDisposed = true;
+			main?.dispose();
+			bridge?.dispose();
+			bridge = void 0;
+			allowedChannels.clear();
 			for (const channel of channels.values()) channel.dispose();
+			syncListener();
 		}
 	};
 }
@@ -681,7 +908,7 @@ function createWebExt(options = {}) {
 	if (!api?.runtime?.getManifest) throw new Error("webext requires a WebExtension context or an injected API");
 	const extensionUrl = new URL(api.runtime.getURL("/"));
 	const context = createContext(api, extensionUrl, options);
-	const messaging = createMessaging(api);
+	const messaging = createMessaging(api, context.type ?? void 0);
 	const { tabs, initialize } = createTabs(api, context, messaging);
 	const { resolveTabId, openPopout } = createPopout(api, extensionUrl, () => tabs.getTargetId());
 	const action = api.action && facade(api.action, { async openPopout(options = {}) {
@@ -735,4 +962,4 @@ function createWebExt(options = {}) {
 */
 const webext = lazyFacade(() => createWebExt());
 //#endregion
-export { MessageTimeoutError, RemoteError, UnsupportedOperationError, createWebExt, webext };
+export { MessageTimeoutError, RemoteError, UnsupportedOperationError, createMainWorldMessaging, createWebExt, webext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midra/webext",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "ブラウザ拡張機能の開発用ライブラリ",
   "author": "Midra <me@midra.me> (https://github.com/Midra429)",
   "license": "MIT",