electron-json-rpc 1.0.0

package/dist/preload.mjs

@@ -0,0 +1,417 @@
+import { STREAM_CHANNEL, createStreamChunk } from "./stream.mjs";
+import { EVENT_CHANNEL } from "./event.mjs";
+
+//#region src/preload.ts
+/**
+* 订阅指定事件到主进程
+*/
+function subscribeToEvent(ipcRenderer, eventName) {
+	ipcRenderer.send(EVENT_CHANNEL, {
+		type: "subscribe",
+		eventName
+	});
+}
+/**
+* 取消订阅指定事件
+*/
+function unsubscribeFromEvent(ipcRenderer, eventName) {
+	ipcRenderer.send(EVENT_CHANNEL, {
+		type: "unsubscribe",
+		eventName
+	});
+}
+/**
+* IPC channel name for JSON-RPC communication
+*/
+const RPC_CHANNEL = "json-rpc";
+/**
+* Module-level state (not exposed to renderer, so can contain unclonable objects)
+*/
+const state = {
+	eventHandlers: /* @__PURE__ */ new Map(),
+	activeStreams: /* @__PURE__ */ new Map(),
+	ipcRenderer: null,
+	requestIdCounter: 0
+};
+/**
+* Setup IPC listeners for streams and events (only these need preload state)
+*/
+function setupListeners(ipcRenderer) {
+	ipcRenderer.on(STREAM_CHANNEL, handleStreamChunk);
+	ipcRenderer.on(EVENT_CHANNEL, handleEventBusMessage);
+}
+/**
+* Handle incoming stream chunks
+*/
+function handleStreamChunk(_event, ...args) {
+	const { streamId, type, data, error } = args[0];
+	const streamKey = String(streamId);
+	const controller = state.activeStreams.get(streamKey);
+	if (!controller) return;
+	switch (type) {
+		case "chunk":
+			controller.enqueue(data);
+			break;
+		case "end":
+			state.activeStreams.delete(streamKey);
+			controller.close();
+			break;
+		case "error":
+			state.activeStreams.delete(streamKey);
+			const errorObj = new Error(error?.message ?? "Stream error");
+			controller.error(errorObj);
+			break;
+	}
+}
+/**
+* Handle incoming event bus messages from main
+*/
+function handleEventBusMessage(_event, ...args) {
+	const { type, eventName, data } = args[0];
+	if (type === "event") {
+		const handlers = state.eventHandlers.get(eventName);
+		if (handlers) for (const callback of handlers) try {
+			callback(data);
+		} catch (error) {
+			console.error(`Error in event handler for "${eventName}":`, error);
+		}
+	}
+}
+/**
+* Generate a unique request ID
+*/
+function generateRequestId() {
+	return `rpc_${++state.requestIdCounter}_${Date.now()}`;
+}
+/**
+* Create the API object to expose to renderer
+*
+* The API object functions only capture primitive values and use ipcRenderer
+* which is available in renderer, making the object clonable by contextBridge.
+*/
+function createApiObject(ipcRenderer) {
+	return {
+		call: (method, ...params) => {
+			const id = generateRequestId();
+			return new Promise((resolve, reject) => {
+				const timeout = setTimeout(() => {
+					ipcRenderer.removeListener(RPC_CHANNEL, listener);
+					reject(/* @__PURE__ */ new Error(`RPC timeout: ${method}`));
+				}, 3e4);
+				const listener = (_event, ...args) => {
+					const response = args[0];
+					if (response.id === id) {
+						clearTimeout(timeout);
+						ipcRenderer.removeListener(RPC_CHANNEL, listener);
+						if (response.error) {
+							const err = response.error;
+							reject(new Error(err.message));
+						} else resolve(response.result);
+					}
+				};
+				ipcRenderer.on(RPC_CHANNEL, listener);
+				ipcRenderer.send(RPC_CHANNEL, {
+					jsonrpc: "2.0",
+					id,
+					method,
+					params
+				});
+			});
+		},
+		notify: (method, ...params) => {
+			ipcRenderer.send(RPC_CHANNEL, {
+				jsonrpc: "2.0",
+				method,
+				params
+			});
+		},
+		stream: (method, ...params) => {
+			const callId = generateRequestId();
+			const ipc = state.ipcRenderer || ipcRenderer;
+			let streamKey = null;
+			return new ReadableStream({
+				start: async (controller) => {
+					try {
+						const streamId = await new Promise((resolve, reject) => {
+							const timeout = setTimeout(() => {
+								ipc.removeListener(RPC_CHANNEL, listener);
+								reject(/* @__PURE__ */ new Error("Stream timeout"));
+							}, 3e4);
+							const listener = (_event, ...args) => {
+								const response = args[0];
+								if (response.id === callId) {
+									clearTimeout(timeout);
+									ipc.removeListener(RPC_CHANNEL, listener);
+									if (response.result?.streamId) resolve(response.result.streamId);
+									else reject(/* @__PURE__ */ new Error("Not a stream method"));
+								}
+							};
+							ipc.on(RPC_CHANNEL, listener);
+							ipc.send(RPC_CHANNEL, {
+								jsonrpc: "2.0",
+								id: callId,
+								method,
+								params
+							});
+						});
+						streamKey = String(streamId);
+						state.activeStreams.set(streamKey, controller);
+						const originalClose = controller.close.bind(controller);
+						controller.close = () => {
+							state.activeStreams.delete(streamKey);
+							originalClose();
+						};
+					} catch (error) {
+						controller.error(error);
+					}
+				},
+				cancel: () => {
+					if (streamKey) {
+						state.activeStreams.delete(streamKey);
+						ipc.send(STREAM_CHANNEL, createStreamChunk(streamKey, "end"));
+					}
+				}
+			});
+		},
+		on: (eventName, callback) => {
+			const ipc = state.ipcRenderer || ipcRenderer;
+			if (!state.eventHandlers.has(eventName)) {
+				state.eventHandlers.set(eventName, /* @__PURE__ */ new Set());
+				subscribeToEvent(ipc, eventName);
+			}
+			state.eventHandlers.get(eventName).add(callback);
+			return () => {
+				const handlers = state.eventHandlers.get(eventName);
+				if (handlers) {
+					handlers.delete(callback);
+					if (handlers.size === 0) {
+						state.eventHandlers.delete(eventName);
+						unsubscribeFromEvent(ipc, eventName);
+					}
+				}
+			};
+		},
+		off: (eventName, callback) => {
+			const ipc = state.ipcRenderer || ipcRenderer;
+			const handlers = state.eventHandlers.get(eventName);
+			if (!handlers) return;
+			if (callback) {
+				handlers.delete(callback);
+				if (handlers.size === 0) {
+					state.eventHandlers.delete(eventName);
+					unsubscribeFromEvent(ipc, eventName);
+				}
+			} else {
+				state.eventHandlers.delete(eventName);
+				unsubscribeFromEvent(ipc, eventName);
+			}
+		},
+		once: (eventName, callback) => {
+			const ipc = state.ipcRenderer || ipcRenderer;
+			const wrappedCallback = (data) => {
+				try {
+					callback(data);
+				} finally {
+					const handlers = state.eventHandlers.get(eventName);
+					if (handlers) {
+						handlers.delete(wrappedCallback);
+						if (handlers.size === 0) {
+							state.eventHandlers.delete(eventName);
+							unsubscribeFromEvent(ipc, eventName);
+						}
+					}
+				}
+			};
+			if (!state.eventHandlers.has(eventName)) {
+				state.eventHandlers.set(eventName, /* @__PURE__ */ new Set());
+				subscribeToEvent(ipc, eventName);
+			}
+			state.eventHandlers.get(eventName).add(wrappedCallback);
+		}
+	};
+}
+/**
+* Create the API object for whitelist mode
+* Adds shortcut methods for whitelisted method names
+*/
+function createWhitelistApi(methods, ipcRenderer) {
+	const api = createApiObject(ipcRenderer);
+	for (const method of methods) Object.defineProperty(api, method, {
+		value: (...args) => {
+			const callFn = api.call;
+			return callFn(method, ...args);
+		},
+		writable: false,
+		enumerable: true
+	});
+	return api;
+}
+/**
+* Initialize the preload module
+*/
+function init(ipcRenderer) {
+	if (state.ipcRenderer) return;
+	state.ipcRenderer = ipcRenderer;
+	setupListeners(ipcRenderer);
+}
+/**
+* Expose an RPC API to the renderer process via contextBridge
+*/
+function exposeRpcApi(options) {
+	const { contextBridge, ipcRenderer, methods, apiName = "rpc" } = options;
+	init(ipcRenderer);
+	const api = methods && methods.length > 0 ? createWhitelistApi(methods, ipcRenderer) : createApiObject(ipcRenderer);
+	contextBridge.exposeInMainWorld(apiName, api);
+}
+/**
+* Create an RPC client for use in preload scripts
+* (without exposing to renderer)
+*/
+function createPreloadClient(ipcRenderer, timeout = 3e4) {
+	init(ipcRenderer);
+	return {
+		call: (method, ...params) => {
+			const id = generateRequestId();
+			return new Promise((resolve, reject) => {
+				const timeoutId = setTimeout(() => {
+					ipcRenderer.removeListener(RPC_CHANNEL, listener);
+					reject(/* @__PURE__ */ new Error(`RPC timeout: ${method}`));
+				}, timeout);
+				const listener = (_event, ...args) => {
+					const response = args[0];
+					if (response.id === id) {
+						clearTimeout(timeoutId);
+						ipcRenderer.removeListener(RPC_CHANNEL, listener);
+						if (response.error) {
+							const err = response.error;
+							reject(new Error(err.message));
+						} else resolve(response.result);
+					}
+				};
+				ipcRenderer.on(RPC_CHANNEL, listener);
+				ipcRenderer.send(RPC_CHANNEL, {
+					jsonrpc: "2.0",
+					id,
+					method,
+					params
+				});
+			});
+		},
+		notify: (method, ...params) => {
+			ipcRenderer.send(RPC_CHANNEL, {
+				jsonrpc: "2.0",
+				method,
+				params
+			});
+		},
+		stream: (method, ...params) => {
+			const callId = generateRequestId();
+			let streamKey = null;
+			return new ReadableStream({
+				start: async (controller) => {
+					try {
+						const streamId = await new Promise((resolve, reject) => {
+							const timeoutId = setTimeout(() => {
+								ipcRenderer.removeListener(RPC_CHANNEL, listener);
+								reject(/* @__PURE__ */ new Error("Stream timeout"));
+							}, timeout);
+							const listener = (_event, ...args) => {
+								const response = args[0];
+								if (response.id === callId) {
+									clearTimeout(timeoutId);
+									ipcRenderer.removeListener(RPC_CHANNEL, listener);
+									if (response.result?.streamId) resolve(response.result.streamId);
+									else reject(/* @__PURE__ */ new Error("Not a stream method"));
+								}
+							};
+							ipcRenderer.on(RPC_CHANNEL, listener);
+							ipcRenderer.send(RPC_CHANNEL, {
+								jsonrpc: "2.0",
+								id: callId,
+								method,
+								params
+							});
+						});
+						streamKey = String(streamId);
+						state.activeStreams.set(streamKey, controller);
+						const originalClose = controller.close.bind(controller);
+						controller.close = () => {
+							state.activeStreams.delete(streamKey);
+							originalClose();
+						};
+					} catch (error) {
+						controller.error(error);
+					}
+				},
+				cancel: () => {
+					if (streamKey) {
+						state.activeStreams.delete(streamKey);
+						ipcRenderer.send(STREAM_CHANNEL, createStreamChunk(streamKey, "end"));
+					}
+				}
+			});
+		},
+		on: (eventName, callback) => {
+			if (!state.eventHandlers.has(eventName)) {
+				state.eventHandlers.set(eventName, /* @__PURE__ */ new Set());
+				subscribeToEvent(ipcRenderer, eventName);
+			}
+			state.eventHandlers.get(eventName).add(callback);
+			return () => {
+				const handlers = state.eventHandlers.get(eventName);
+				if (handlers) {
+					handlers.delete(callback);
+					if (handlers.size === 0) {
+						state.eventHandlers.delete(eventName);
+						unsubscribeFromEvent(ipcRenderer, eventName);
+					}
+				}
+			};
+		},
+		off: (eventName, callback) => {
+			const handlers = state.eventHandlers.get(eventName);
+			if (!handlers) return;
+			if (callback) {
+				handlers.delete(callback);
+				if (handlers.size === 0) {
+					state.eventHandlers.delete(eventName);
+					unsubscribeFromEvent(ipcRenderer, eventName);
+				}
+			} else {
+				state.eventHandlers.delete(eventName);
+				unsubscribeFromEvent(ipcRenderer, eventName);
+			}
+		},
+		once: (eventName, callback) => {
+			const wrappedCallback = (data) => {
+				callback(data);
+				const handlers = state.eventHandlers.get(eventName);
+				if (handlers) {
+					handlers.delete(wrappedCallback);
+					if (handlers.size === 0) {
+						state.eventHandlers.delete(eventName);
+						unsubscribeFromEvent(ipcRenderer, eventName);
+					}
+				}
+			};
+			if (!state.eventHandlers.has(eventName)) {
+				state.eventHandlers.set(eventName, /* @__PURE__ */ new Set());
+				subscribeToEvent(ipcRenderer, eventName);
+			}
+			state.eventHandlers.get(eventName).add(wrappedCallback);
+		},
+		dispose: () => {
+			ipcRenderer.removeListener(STREAM_CHANNEL, handleStreamChunk);
+			ipcRenderer.removeListener(EVENT_CHANNEL, handleEventBusMessage);
+			for (const controller of state.activeStreams.values()) try {
+				controller.close();
+			} catch {}
+			state.activeStreams.clear();
+			state.eventHandlers.clear();
+		}
+	};
+}
+
+//#endregion
+export { createPreloadClient, exposeRpcApi };
+//# sourceMappingURL=preload.mjs.map

package/dist/preload.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"preload.mjs","names":[],"sources":["../src/preload.ts"],"sourcesContent":["/**\n * JSON-RPC Preload Script for Electron\n *\n * Exposes a secure RPC API to the renderer process via contextBridge\n *\n * Architecture:\n * - Regular RPC calls go directly from renderer to main (no preload overhead)\n * - Streams and events are handled in preload (require state management)\n */\n\nimport type { ExposeRpcApiOptions, EventHandler } from \"./types.js\";\nimport { STREAM_CHANNEL, createStreamChunk } from \"./stream.js\";\nimport { EVENT_CHANNEL, type EventMessage } from \"./event.js\";\n\n/**\n * 订阅指定事件到主进程\n */\nfunction subscribeToEvent(\n  ipcRenderer: ExposeRpcApiOptions[\"ipcRenderer\"],\n  eventName: string,\n): void {\n  ipcRenderer.send(EVENT_CHANNEL, {\n    type: \"subscribe\",\n    eventName,\n  } as EventMessage);\n}\n\n/**\n * 取消订阅指定事件\n */\nfunction unsubscribeFromEvent(\n  ipcRenderer: ExposeRpcApiOptions[\"ipcRenderer\"],\n  eventName: string,\n): void {\n  ipcRenderer.send(EVENT_CHANNEL, {\n    type: \"unsubscribe\",\n    eventName,\n  } as EventMessage);\n}\n\n/**\n * IPC channel name for JSON-RPC communication\n */\nconst RPC_CHANNEL = \"json-rpc\";\n\n/**\n * Module-level state (not exposed to renderer, so can contain unclonable objects)\n */\nconst state = {\n  /** Event handlers by event name (for exposed API and preload client) */\n  eventHandlers: new Map<string, Set<EventHandler>>(),\n  /** Active stream controllers */\n  activeStreams: new Map<string, ReadableStreamDefaultController>(),\n\n  /** The ipcRenderer instance (set during setup) */\n  ipcRenderer: null as ExposeRpcApiOptions[\"ipcRenderer\"] | null,\n  /** Request ID counter */\n  requestIdCounter: 0,\n};\n\n/**\n * Setup IPC listeners for streams and events (only these need preload state)\n */\nfunction setupListeners(ipcRenderer: ExposeRpcApiOptions[\"ipcRenderer\"]): void {\n  // Listen for stream chunks\n  ipcRenderer.on(STREAM_CHANNEL, handleStreamChunk as (event: unknown, ...args: unknown[]) => void);\n  // Listen for event bus messages from main process\n  ipcRenderer.on(\n    EVENT_CHANNEL,\n    handleEventBusMessage as (event: unknown, ...args: unknown[]) => void,\n  );\n}\n\n/**\n * Handle incoming stream chunks\n */\nfunction handleStreamChunk(_event: unknown, ...args: unknown[]): void {\n  const chunk = args[0] as {\n    streamId: string | number;\n    type: \"chunk\" | \"end\" | \"error\";\n    data?: unknown;\n    error?: { message?: string };\n  };\n  const { streamId, type, data, error } = chunk;\n  const streamKey = String(streamId);\n  const controller = state.activeStreams.get(streamKey);\n\n  if (!controller) {\n    return; // Stream not found or already closed\n  }\n\n  switch (type) {\n    case \"chunk\":\n      controller.enqueue(data);\n      break;\n    case \"end\":\n      state.activeStreams.delete(streamKey);\n      controller.close();\n      break;\n    case \"error\":\n      state.activeStreams.delete(streamKey);\n      const errorObj = new Error(error?.message ?? \"Stream error\");\n      controller.error(errorObj);\n      break;\n  }\n}\n\n/**\n * Handle incoming event bus messages from main\n */\nfunction handleEventBusMessage(_event: unknown, ...args: unknown[]): void {\n  const message = args[0] as { type: string; eventName: string; data?: unknown };\n  const { type, eventName, data } = message;\n\n  if (type === \"event\") {\n    // Handle callbacks from createPreloadClient and exposed API\n    const handlers = state.eventHandlers.get(eventName);\n    if (handlers) {\n      for (const callback of handlers) {\n        try {\n          callback(data);\n        } catch (error) {\n          console.error(`Error in event handler for \"${eventName}\":`, error);\n        }\n      }\n    }\n  }\n}\n\n/**\n * Generate a unique request ID\n */\nfunction generateRequestId(): string {\n  return `rpc_${++state.requestIdCounter}_${Date.now()}`;\n}\n\n/**\n * Create the API object to expose to renderer\n *\n * The API object functions only capture primitive values and use ipcRenderer\n * which is available in renderer, making the object clonable by contextBridge.\n */\nfunction createApiObject(ipcRenderer: ExposeRpcApiOptions[\"ipcRenderer\"]): Record<string, unknown> {\n  return {\n    /**\n     * Call a RPC method - direct IPC to main, no preload overhead\n     */\n    call: (method: string, ...params: unknown[]) => {\n      const id = generateRequestId();\n\n      return new Promise((resolve, reject) => {\n        const timeout = setTimeout(() => {\n          ipcRenderer.removeListener(RPC_CHANNEL, listener);\n          reject(new Error(`RPC timeout: ${method}`));\n        }, 30000);\n\n        const listener = (_event: unknown, ...args: unknown[]) => {\n          const response = args[0] as {\n            jsonrpc: \"2.0\";\n            id: string | number;\n            result?: unknown;\n            error?: unknown;\n          };\n          if (response.id === id) {\n            clearTimeout(timeout);\n            ipcRenderer.removeListener(RPC_CHANNEL, listener);\n            if (response.error) {\n              const err = response.error as { message: string };\n              reject(new Error(err.message));\n            } else {\n              resolve(response.result);\n            }\n          }\n        };\n\n        ipcRenderer.on(RPC_CHANNEL, listener);\n        ipcRenderer.send(RPC_CHANNEL, { jsonrpc: \"2.0\", id, method, params });\n      });\n    },\n\n    /**\n     * Send a notification (one-way, no response) - direct IPC\n     */\n    notify: (method: string, ...params: unknown[]) => {\n      ipcRenderer.send(RPC_CHANNEL, { jsonrpc: \"2.0\", method, params });\n    },\n\n    /**\n     * Create a stream from a RPC method\n     * Stream setup uses delegation, but chunks go direct via STREAM_CHANNEL\n     */\n    stream: (method: string, ...params: unknown[]) => {\n      const callId = generateRequestId();\n      const ipc = state.ipcRenderer || ipcRenderer;\n      let streamKey: string | null = null;\n\n      return new ReadableStream({\n        start: async (controller) => {\n          try {\n            // First call the method to get stream ID\n            const streamId = await new Promise<string>((resolve, reject) => {\n              const timeout = setTimeout(() => {\n                ipc.removeListener(RPC_CHANNEL, listener);\n                reject(new Error(\"Stream timeout\"));\n              }, 30000);\n\n              const listener = (_event: unknown, ...args: unknown[]) => {\n                const response = args[0] as {\n                  jsonrpc: \"2.0\";\n                  id: string;\n                  result?: { streamId?: string };\n                };\n                if (response.id === callId) {\n                  clearTimeout(timeout);\n                  ipc.removeListener(RPC_CHANNEL, listener);\n                  if (response.result?.streamId) {\n                    resolve(response.result.streamId);\n                  } else {\n                    reject(new Error(\"Not a stream method\"));\n                  }\n                }\n              };\n\n              ipc.on(RPC_CHANNEL, listener);\n              ipc.send(RPC_CHANNEL, { jsonrpc: \"2.0\", id: callId, method, params });\n            });\n\n            // Store controller for this stream\n            streamKey = String(streamId);\n            state.activeStreams.set(streamKey, controller);\n\n            // Set up cleanup when stream closes\n            const originalClose = controller.close.bind(controller);\n            controller.close = () => {\n              state.activeStreams.delete(streamKey!);\n              originalClose();\n            };\n          } catch (error) {\n            controller.error(error);\n          }\n        },\n        cancel: () => {\n          if (streamKey) {\n            state.activeStreams.delete(streamKey);\n            ipc.send(STREAM_CHANNEL, createStreamChunk(streamKey, \"end\"));\n          }\n        },\n      });\n    },\n\n    /**\n     * Subscribe to an event\n     * @returns Unsubscribe function\n     */\n    on: (eventName: string, callback: (data?: unknown) => void) => {\n      const ipc = state.ipcRenderer || ipcRenderer;\n\n      if (!state.eventHandlers.has(eventName)) {\n        state.eventHandlers.set(eventName, new Set());\n        subscribeToEvent(ipc, eventName);\n      }\n\n      state.eventHandlers.get(eventName)!.add(callback as EventHandler);\n\n      // Return unsubscribe function\n      return () => {\n        const handlers = state.eventHandlers.get(eventName);\n        if (handlers) {\n          handlers.delete(callback as EventHandler);\n          if (handlers.size === 0) {\n            state.eventHandlers.delete(eventName);\n            unsubscribeFromEvent(ipc, eventName);\n          }\n        }\n      };\n    },\n\n    /**\n     * Unsubscribe from an event\n     */\n    off: (eventName: string, callback?: (data?: unknown) => void) => {\n      const ipc = state.ipcRenderer || ipcRenderer;\n      const handlers = state.eventHandlers.get(eventName);\n      if (!handlers) {\n        return;\n      }\n\n      if (callback) {\n        handlers.delete(callback as EventHandler);\n        if (handlers.size === 0) {\n          state.eventHandlers.delete(eventName);\n          unsubscribeFromEvent(ipc, eventName);\n        }\n      } else {\n        state.eventHandlers.delete(eventName);\n        unsubscribeFromEvent(ipc, eventName);\n      }\n    },\n\n    /**\n     * Subscribe to an event once (auto-unsubscribe after first call)\n     */\n    once: (eventName: string, callback: (data?: unknown) => void) => {\n      const ipc = state.ipcRenderer || ipcRenderer;\n\n      const wrappedCallback: EventHandler = (data) => {\n        try {\n          callback(data);\n        } finally {\n          const handlers = state.eventHandlers.get(eventName);\n          if (handlers) {\n            handlers.delete(wrappedCallback);\n            if (handlers.size === 0) {\n              state.eventHandlers.delete(eventName);\n              unsubscribeFromEvent(ipc, eventName);\n            }\n          }\n        }\n      };\n\n      if (!state.eventHandlers.has(eventName)) {\n        state.eventHandlers.set(eventName, new Set());\n        subscribeToEvent(ipc, eventName);\n      }\n\n      state.eventHandlers.get(eventName)!.add(wrappedCallback);\n    },\n  };\n}\n\n/**\n * Create the API object for whitelist mode\n * Adds shortcut methods for whitelisted method names\n */\nfunction createWhitelistApi(\n  methods: string[],\n  ipcRenderer: ExposeRpcApiOptions[\"ipcRenderer\"],\n): Record<string, unknown> {\n  const api = createApiObject(ipcRenderer);\n\n  // Add method shortcuts for whitelisted methods\n  for (const method of methods) {\n    Object.defineProperty(api, method, {\n      value: (...args: unknown[]) => {\n        const callFn = api.call as (method: string, ...params: unknown[]) => Promise<unknown>;\n        return callFn(method, ...args);\n      },\n      writable: false,\n      enumerable: true,\n    });\n  }\n\n  return api;\n}\n\n/**\n * Initialize the preload module\n */\nfunction init(ipcRenderer: ExposeRpcApiOptions[\"ipcRenderer\"]): void {\n  if (state.ipcRenderer) {\n    return; // Already initialized\n  }\n\n  state.ipcRenderer = ipcRenderer;\n  setupListeners(ipcRenderer);\n}\n\n/**\n * Expose an RPC API to the renderer process via contextBridge\n */\nexport function exposeRpcApi(options: ExposeRpcApiOptions): void {\n  const { contextBridge, ipcRenderer, methods, apiName = \"rpc\" } = options;\n\n  // Initialize the module-level state\n  init(ipcRenderer);\n\n  // Build the API object to expose\n  const api =\n    methods && methods.length > 0\n      ? createWhitelistApi(methods, ipcRenderer)\n      : createApiObject(ipcRenderer);\n\n  // Expose to renderer via contextBridge\n  contextBridge.exposeInMainWorld(apiName, api);\n}\n\n/**\n * Create an RPC client for use in preload scripts\n * (without exposing to renderer)\n */\nexport function createPreloadClient(\n  ipcRenderer: ExposeRpcApiOptions[\"ipcRenderer\"],\n  timeout = 30000,\n): {\n  call: (method: string, ...params: unknown[]) => Promise<unknown>;\n  notify: (method: string, ...params: unknown[]) => void;\n  stream: (method: string, ...params: unknown[]) => ReadableStream;\n  on: (eventName: string, callback: (data?: unknown) => void) => () => void;\n  off: (eventName: string, callback?: (data?: unknown) => void) => void;\n  once: (eventName: string, callback: (data?: unknown) => void) => void;\n  dispose: () => void;\n} {\n  // Initialize the module-level state\n  init(ipcRenderer);\n\n  return {\n    call: (method: string, ...params: unknown[]) => {\n      const id = generateRequestId();\n      return new Promise((resolve, reject) => {\n        const timeoutId = setTimeout(() => {\n          ipcRenderer.removeListener(RPC_CHANNEL, listener);\n          reject(new Error(`RPC timeout: ${method}`));\n        }, timeout);\n\n        const listener = (_event: unknown, ...args: unknown[]) => {\n          const response = args[0] as {\n            jsonrpc: \"2.0\";\n            id: string | number;\n            result?: unknown;\n            error?: unknown;\n          };\n          if (response.id === id) {\n            clearTimeout(timeoutId);\n            ipcRenderer.removeListener(RPC_CHANNEL, listener);\n            if (response.error) {\n              const err = response.error as { message: string };\n              reject(new Error(err.message));\n            } else {\n              resolve(response.result);\n            }\n          }\n        };\n\n        ipcRenderer.on(RPC_CHANNEL, listener);\n        ipcRenderer.send(RPC_CHANNEL, { jsonrpc: \"2.0\", id, method, params });\n      });\n    },\n\n    notify: (method: string, ...params: unknown[]) => {\n      ipcRenderer.send(RPC_CHANNEL, { jsonrpc: \"2.0\", method, params });\n    },\n\n    stream: (method: string, ...params: unknown[]) => {\n      const callId = generateRequestId();\n      let streamKey: string | null = null;\n\n      return new ReadableStream({\n        start: async (controller) => {\n          try {\n            // First call the method to get stream ID\n            const streamId = await new Promise<string>((resolve, reject) => {\n              const timeoutId = setTimeout(() => {\n                ipcRenderer.removeListener(RPC_CHANNEL, listener);\n                reject(new Error(\"Stream timeout\"));\n              }, timeout);\n\n              const listener = (_event: unknown, ...args: unknown[]) => {\n                const response = args[0] as {\n                  jsonrpc: \"2.0\";\n                  id: string;\n                  result?: { streamId?: string };\n                };\n                if (response.id === callId) {\n                  clearTimeout(timeoutId);\n                  ipcRenderer.removeListener(RPC_CHANNEL, listener);\n                  if (response.result?.streamId) {\n                    resolve(response.result.streamId);\n                  } else {\n                    reject(new Error(\"Not a stream method\"));\n                  }\n                }\n              };\n\n              ipcRenderer.on(RPC_CHANNEL, listener);\n              ipcRenderer.send(RPC_CHANNEL, { jsonrpc: \"2.0\", id: callId, method, params });\n            });\n\n            // Store controller for this stream\n            streamKey = String(streamId);\n            state.activeStreams.set(streamKey, controller);\n\n            // Set up cleanup when stream closes\n            const originalClose = controller.close.bind(controller);\n            controller.close = () => {\n              state.activeStreams.delete(streamKey!);\n              originalClose();\n            };\n          } catch (error) {\n            controller.error(error);\n          }\n        },\n        cancel: () => {\n          if (streamKey) {\n            state.activeStreams.delete(streamKey);\n            ipcRenderer.send(STREAM_CHANNEL, createStreamChunk(streamKey, \"end\"));\n          }\n        },\n      });\n    },\n\n    on: (eventName: string, callback: EventHandler) => {\n      if (!state.eventHandlers.has(eventName)) {\n        state.eventHandlers.set(eventName, new Set());\n        // Send subscribe message to main process\n        subscribeToEvent(ipcRenderer, eventName);\n      }\n\n      state.eventHandlers.get(eventName)!.add(callback);\n\n      // Return unsubscribe function\n      return () => {\n        const handlers = state.eventHandlers.get(eventName);\n        if (handlers) {\n          handlers.delete(callback);\n          if (handlers.size === 0) {\n            state.eventHandlers.delete(eventName);\n            unsubscribeFromEvent(ipcRenderer, eventName);\n          }\n        }\n      };\n    },\n\n    off: (eventName: string, callback?: EventHandler) => {\n      const handlers = state.eventHandlers.get(eventName);\n      if (!handlers) {\n        return;\n      }\n\n      if (callback) {\n        handlers.delete(callback);\n        if (handlers.size === 0) {\n          state.eventHandlers.delete(eventName);\n          unsubscribeFromEvent(ipcRenderer, eventName);\n        }\n      } else {\n        state.eventHandlers.delete(eventName);\n        unsubscribeFromEvent(ipcRenderer, eventName);\n      }\n    },\n\n    once: (eventName: string, callback: EventHandler) => {\n      const wrappedCallback: EventHandler = (data) => {\n        callback(data);\n        const handlers = state.eventHandlers.get(eventName);\n        if (handlers) {\n          handlers.delete(wrappedCallback);\n          if (handlers.size === 0) {\n            state.eventHandlers.delete(eventName);\n            unsubscribeFromEvent(ipcRenderer, eventName);\n          }\n        }\n      };\n\n      if (!state.eventHandlers.has(eventName)) {\n        state.eventHandlers.set(eventName, new Set());\n        subscribeToEvent(ipcRenderer, eventName);\n      }\n\n      state.eventHandlers.get(eventName)!.add(wrappedCallback);\n    },\n\n    dispose: () => {\n      ipcRenderer.removeListener(STREAM_CHANNEL, handleStreamChunk as (...args: unknown[]) => void);\n      ipcRenderer.removeListener(\n        EVENT_CHANNEL,\n        handleEventBusMessage as (...args: unknown[]) => void,\n      );\n\n      // Close all active streams\n      for (const controller of state.activeStreams.values()) {\n        try {\n          controller.close();\n        } catch {\n          // Ignore errors during cleanup\n        }\n      }\n      state.activeStreams.clear();\n\n      // Clear all event handlers\n      state.eventHandlers.clear();\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/renderer/builder.d.mts

@@ -0,0 +1,64 @@
+import { d as RpcClientOptions, f as RpcDebugOptions } from "../types-BnGse9DF.mjs";
+
+//#region src/renderer/builder.d.ts
+/**
+ * RpcBuilder for fluent API definition
+ *
+ * Accumulates method definitions and builds a typed client.
+ */
+declare class RpcBuilder {
+  private methods;
+  private options;
+  private apiName;
+  constructor(options?: RpcClientOptions & RpcDebugOptions, apiName?: string);
+  /**
+       * Add a regular RPC method
+       *
+       * @param name - Method name
+       * @param _handler - Handler function for type inference only (not executed)
+       * @returns Builder with method added
+       */
+  add<K extends string, P extends any[], R>(name: K, _handler: (...args: P) => R): RpcBuilderWithMethod<K, P, R>;
+  /**
+       * Add a stream RPC method
+       *
+       * @param name - Method name
+       * @param _handler - Handler function for type inference only (not executed)
+       * @returns Builder with stream method added
+       */
+  stream<K extends string, P extends any[], R>(name: K, _handler: (...args: P) => R): RpcBuilderWithMethod<K, P, R>;
+  /**
+       * Build the final typed API client
+       *
+       * @returns Typed RPC client
+       */
+  build(): Record<string, (...args: any[]) => any>;
+}
+/**
+ * Builder type with one method added
+ * Provides fluent chaining for building the API
+ */
+type RpcBuilderWithMethod<K extends string, P extends any[], R> = { [M in K]: (...args: P) => R extends void ? void : Promise<Awaited<R>> } & Omit<RpcBuilderMethods, K>;
+/**
+ * Available methods on the builder
+ */
+type RpcBuilderMethods = {
+  add: <K extends string, P extends any[], R>(name: K, handler: (...args: P) => R) => RpcBuilderWithMethod<K, P, R>;
+  stream: <K extends string, P extends any[], R>(name: K, handler: (...args: P) => R) => RpcBuilderWithMethod<K, P, R>;
+  build: () => Record<string, (...args: any[]) => any>;
+};
+/**
+ * Create a fluent RPC API builder
+ *
+ * Build a typed RPC API by chaining method definitions.
+ * Types are inferred from the handler functions.
+ *
+ * @param options - Client options
+ * @returns Builder instance
+ */
+declare function createRpc(options?: RpcClientOptions & RpcDebugOptions): Omit<RpcBuilder, "build"> & {
+  build: () => Record<string, (...args: any[]) => any>;
+};
+//#endregion
+export { type RpcBuilder, type RpcBuilderMethods, type RpcBuilderWithMethod, createRpc };
+//# sourceMappingURL=builder.d.mts.map

package/dist/renderer/builder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.mts","names":[],"sources":["../../src/renderer/builder.ts"],"mappings":";;;;AAOqE;;;;cAU/D,UAAA;EAAA,QAAA,OAAA;EAAA,QAAA,OAAA;EAAA,QAAA,OAAA;EAAA,YAAA,OAAA,GAMO,gBAAA,GAAmB,eAAA,EAAA,OAAA;EAAA;;;;;;;EAAA,GAAA,sCAAA,CAAA,IAAA,EAetB,CAAA,EAAA,QAAA,MAAA,IAAA,EACc,CAAA,KAAM,CAAA,GACzB,oBAAA,CAAqB,CAAA,EAAG,CAAA,EAAG,CAAA;EAAA;;;;;;;EAAA,MAAA,sCAAA,CAAA,IAAA,EAatB,CAAA,EAAA,QAAA,MAAA,IAAA,EACc,CAAA,KAAM,CAAA,GACzB,oBAAA,CAAqB,CAAA,EAAG,CAAA,EAAG,CAAA;EAAA;;;;AAUf;EAVe,MAAA,GAUrB,MAAA,aAAA,IAAA;AAAA;AAAA;;AAAM;;AAAN,KAsEN,oBAAA,iDACG,CAAA,OAAA,IAAA,EAAc,CAAA,KAAM,CAAA,uBAAwB,OAAA,CAAQ,OAAA,CAAQ,CAAA,OAChE,IAAA,CAAK,iBAAA,EAAmB,CAAA;AAAA;;;AAAA,KAKvB,iBAAA;EAAA,GAAA,yCAAA,IAAA,EAEK,CAAA,EAAA,OAAA,MAAA,IAAA,EACa,CAAA,KAAM,CAAA,KACtB,oBAAA,CAAqB,CAAA,EAAG,CAAA,EAAG,CAAA;EAAA,MAAA,yCAAA,IAAA,EAExB,CAAA,EAAA,OAAA,MAAA,IAAA,EACa,CAAA,KAAM,CAAA,KACtB,oBAAA,CAAqB,CAAA,EAAG,CAAA,EAAG,CAAA;EAAA,KAAA,QACnB,MAAA,aAAA,IAAA;AAAA;AAAA;;AAYf;;;;;;;AAZe,iBAYC,SAAA,CAAA,OAAA,GAAmB,gBAAA,GAAmB,eAAA,GAAuB,IAAA,CAC3E,UAAA;EAAA,KAAA,QAGa,MAAA,aAAA,IAAA;AAAA"}

package/dist/renderer/builder.mjs

@@ -0,0 +1,101 @@
+import { i as RpcTimeoutError } from "../error-xVRu7Lxq.mjs";
+import { getLogger } from "../debug.mjs";
+import { n as createTracker, r as getExposedApi, t as DEFAULT_API_NAME } from "../internal-BZK_0O3n.mjs";
+
+//#region src/renderer/builder.ts
+/**
+* RpcBuilder for fluent API definition
+*
+* Accumulates method definitions and builds a typed client.
+*/
+var RpcBuilder = class {
+	methods = /* @__PURE__ */ new Map();
+	options;
+	apiName;
+	constructor(options = {}, apiName = DEFAULT_API_NAME) {
+		this.options = options;
+		this.apiName = apiName;
+	}
+	/**
+	* Add a regular RPC method
+	*
+	* @param name - Method name
+	* @param _handler - Handler function for type inference only (not executed)
+	* @returns Builder with method added
+	*/
+	add(name, _handler) {
+		this.methods.set(name, { kind: "call" });
+		return this;
+	}
+	/**
+	* Add a stream RPC method
+	*
+	* @param name - Method name
+	* @param _handler - Handler function for type inference only (not executed)
+	* @returns Builder with stream method added
+	*/
+	stream(name, _handler) {
+		this.methods.set(name, { kind: "stream" });
+		return this;
+	}
+	/**
+	* Build the final typed API client
+	*
+	* @returns Typed RPC client
+	*/
+	build() {
+		const api = getExposedApi(this.apiName);
+		if (!api) throw new Error(`RPC API not found. Make sure exposeRpcApi() is called in your preload script with apiName='${this.apiName}'.`);
+		const { timeout = 3e4, debug, logger } = this.options;
+		const debugTracker = createTracker(debug, logger ?? getLogger());
+		const requestIdCounter = { value: 0 };
+		const methods = this.methods;
+		return new Proxy({}, { get(_target, prop) {
+			const methodInfo = methods.get(prop);
+			if (!methodInfo) throw new Error(`Method '${prop}' was not registered in the RPC builder`);
+			if (methodInfo.kind === "stream") return (...args) => {
+				debugTracker.onStream(prop, args);
+				return api.stream(prop, ...args);
+			};
+			return (...args) => {
+				const requestId = ++requestIdCounter.value;
+				const startTime = performance.now();
+				debugTracker.onRequest(prop, args, requestId);
+				return new Promise((resolve, reject) => {
+					const timeoutId = setTimeout(() => {
+						const duration = Math.round(performance.now() - startTime);
+						debugTracker.onError(prop, args, `Timeout after ${timeout}ms`, duration, requestId);
+						reject(new RpcTimeoutError(timeout));
+					}, timeout);
+					api.call(prop, ...args).then((result) => {
+						clearTimeout(timeoutId);
+						const duration = Math.round(performance.now() - startTime);
+						debugTracker.onResponse(prop, args, result, duration, requestId);
+						resolve(result);
+					}).catch((error) => {
+						clearTimeout(timeoutId);
+						const duration = Math.round(performance.now() - startTime);
+						debugTracker.onError(prop, args, error.message, duration, requestId);
+						reject(error);
+					});
+				});
+			};
+		} });
+	}
+};
+/**
+* Create a fluent RPC API builder
+*
+* Build a typed RPC API by chaining method definitions.
+* Types are inferred from the handler functions.
+*
+* @param options - Client options
+* @returns Builder instance
+*/
+function createRpc(options = {}) {
+	return new RpcBuilder(options);
+}
+
+//#endregion
+export { createRpc };
+//# sourceMappingURL=builder.mjs.map

package/dist/renderer/builder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.mjs","names":[],"sources":["../../src/renderer/builder.ts"],"sourcesContent":["/**\n * RpcBuilder for fluent API definition\n *\n * Build a typed RPC API by chaining method definitions.\n * Types are inferred from the handler functions.\n */\n\nimport type { RpcClientOptions, RpcDebugOptions } from \"../types.js\";\nimport { RpcTimeoutError } from \"../error.js\";\nimport { getLogger } from \"../debug.js\";\nimport { DEFAULT_API_NAME, getExposedApi, createTracker } from \"./internal.js\";\n\n/**\n * RpcBuilder for fluent API definition\n *\n * Accumulates method definitions and builds a typed client.\n */\nclass RpcBuilder {\n  private methods: Map<string, { kind: \"call\" | \"stream\" }> = new Map();\n  private options: RpcClientOptions & RpcDebugOptions;\n  private apiName: string;\n\n  constructor(\n    options: RpcClientOptions & RpcDebugOptions = {},\n    apiName: string = DEFAULT_API_NAME,\n  ) {\n    this.options = options;\n    this.apiName = apiName;\n  }\n\n  /**\n   * Add a regular RPC method\n   *\n   * @param name - Method name\n   * @param _handler - Handler function for type inference only (not executed)\n   * @returns Builder with method added\n   */\n  add<K extends string, P extends any[], R>(\n    name: K,\n    _handler: (...args: P) => R,\n  ): RpcBuilderWithMethod<K, P, R> {\n    this.methods.set(name, { kind: \"call\" });\n    return this as unknown as RpcBuilderWithMethod<K, P, R>;\n  }\n\n  /**\n   * Add a stream RPC method\n   *\n   * @param name - Method name\n   * @param _handler - Handler function for type inference only (not executed)\n   * @returns Builder with stream method added\n   */\n  stream<K extends string, P extends any[], R>(\n    name: K,\n    _handler: (...args: P) => R,\n  ): RpcBuilderWithMethod<K, P, R> {\n    this.methods.set(name, { kind: \"stream\" });\n    return this as unknown as RpcBuilderWithMethod<K, P, R>;\n  }\n\n  /**\n   * Build the final typed API client\n   *\n   * @returns Typed RPC client\n   */\n  build(): Record<string, (...args: any[]) => any> {\n    const api = getExposedApi(this.apiName);\n    if (!api) {\n      throw new Error(\n        `RPC API not found. Make sure exposeRpcApi() is called in your preload script with apiName='${this.apiName}'.`,\n      );\n    }\n\n    const { timeout = 30000, debug, logger } = this.options;\n\n    const debugTracker = createTracker(debug, logger ?? getLogger());\n    const requestIdCounter = { value: 0 };\n\n    // Capture methods map for use in proxy\n    const methods = this.methods;\n\n    // Create a proxy that routes method calls to the underlying API\n    return new Proxy({} as Record<string, (...args: any[]) => any>, {\n      get(_target, prop: string) {\n        const methodInfo = methods.get(prop);\n        if (!methodInfo) {\n          throw new Error(`Method '${prop}' was not registered in the RPC builder`);\n        }\n\n        if (methodInfo.kind === \"stream\") {\n          return (...args: unknown[]) => {\n            debugTracker.onStream(prop, args);\n            return api.stream(prop, ...args);\n          };\n        }\n\n        // Regular method - handle both calls and notifications\n        return (...args: unknown[]) => {\n          const requestId = ++requestIdCounter.value;\n          const startTime = performance.now();\n\n          debugTracker.onRequest(prop, args, requestId);\n\n          return new Promise((resolve, reject) => {\n            const timeoutId = setTimeout(() => {\n              const duration = Math.round(performance.now() - startTime);\n              debugTracker.onError(prop, args, `Timeout after ${timeout}ms`, duration, requestId);\n              reject(new RpcTimeoutError(timeout));\n            }, timeout);\n\n            api\n              .call(prop, ...args)\n              .then((result: unknown) => {\n                clearTimeout(timeoutId);\n                const duration = Math.round(performance.now() - startTime);\n                debugTracker.onResponse(prop, args, result, duration, requestId);\n                resolve(result as any);\n              })\n              .catch((error: Error) => {\n                clearTimeout(timeoutId);\n                const duration = Math.round(performance.now() - startTime);\n                debugTracker.onError(prop, args, error.message, duration, requestId);\n                reject(error);\n              });\n          });\n        };\n      },\n    });\n  }\n}\n\n/**\n * Builder type with one method added\n * Provides fluent chaining for building the API\n */\ntype RpcBuilderWithMethod<K extends string, P extends any[], R> = {\n  [M in K]: (...args: P) => R extends void ? void : Promise<Awaited<R>>;\n} & Omit<RpcBuilderMethods, K>;\n\n/**\n * Available methods on the builder\n */\ntype RpcBuilderMethods = {\n  add: <K extends string, P extends any[], R>(\n    name: K,\n    handler: (...args: P) => R,\n  ) => RpcBuilderWithMethod<K, P, R>;\n  stream: <K extends string, P extends any[], R>(\n    name: K,\n    handler: (...args: P) => R,\n  ) => RpcBuilderWithMethod<K, P, R>;\n  build: () => Record<string, (...args: any[]) => any>;\n};\n\n/**\n * Create a fluent RPC API builder\n *\n * Build a typed RPC API by chaining method definitions.\n * Types are inferred from the handler functions.\n *\n * @param options - Client options\n * @returns Builder instance\n */\nexport function createRpc(options: RpcClientOptions & RpcDebugOptions = {}): Omit<\n  RpcBuilder,\n  \"build\"\n> & {\n  build: () => Record<string, (...args: any[]) => any>;\n} {\n  return new RpcBuilder(options);\n}\n\n/**\n * Re-export types for convenience\n */\nexport type { RpcBuilder, RpcBuilderMethods, RpcBuilderWithMethod };\n"],"mappings":";;;;;;;;;;AAiBA,IAAM,aAAN,MAAiB;CACf,AAAQ,0BAAoD,IAAI,KAAK;CACrE,AAAQ;CACR,AAAQ;CAER,YACE,UAA8C,EAAE,EAChD,UAAkB,kBAClB;AACA,OAAK,UAAU;AACf,OAAK,UAAU;;;;;;;;;CAUjB,IACE,MACA,UAC+B;AAC/B,OAAK,QAAQ,IAAI,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,SAAO;;;;;;;;;CAUT,OACE,MACA,UAC+B;AAC/B,OAAK,QAAQ,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC1C,SAAO;;;;;;;CAQT,QAAiD;EAC/C,MAAM,MAAM,cAAc,KAAK,QAAQ;AACvC,MAAI,CAAC,IACH,OAAM,IAAI,MACR,8FAA8F,KAAK,QAAQ,IAC5G;EAGH,MAAM,EAAE,UAAU,KAAO,OAAO,WAAW,KAAK;EAEhD,MAAM,eAAe,cAAc,OAAO,UAAU,WAAW,CAAC;EAChE,MAAM,mBAAmB,EAAE,OAAO,GAAG;EAGrC,MAAM,UAAU,KAAK;AAGrB,SAAO,IAAI,MAAM,EAAE,EAA6C,EAC9D,IAAI,SAAS,MAAc;GACzB,MAAM,aAAa,QAAQ,IAAI,KAAK;AACpC,OAAI,CAAC,WACH,OAAM,IAAI,MAAM,WAAW,KAAK,yCAAyC;AAG3E,OAAI,WAAW,SAAS,SACtB,SAAQ,GAAG,SAAoB;AAC7B,iBAAa,SAAS,MAAM,KAAK;AACjC,WAAO,IAAI,OAAO,MAAM,GAAG,KAAK;;AAKpC,WAAQ,GAAG,SAAoB;IAC7B,MAAM,YAAY,EAAE,iBAAiB;IACrC,MAAM,YAAY,YAAY,KAAK;AAEnC,iBAAa,UAAU,MAAM,MAAM,UAAU;AAE7C,WAAO,IAAI,SAAS,SAAS,WAAW;KACtC,MAAM,YAAY,iBAAiB;MACjC,MAAM,WAAW,KAAK,MAAM,YAAY,KAAK,GAAG,UAAU;AAC1D,mBAAa,QAAQ,MAAM,MAAM,iBAAiB,QAAQ,KAAK,UAAU,UAAU;AACnF,aAAO,IAAI,gBAAgB,QAAQ,CAAC;QACnC,QAAQ;AAEX,SACG,KAAK,MAAM,GAAG,KAAK,CACnB,MAAM,WAAoB;AACzB,mBAAa,UAAU;MACvB,MAAM,WAAW,KAAK,MAAM,YAAY,KAAK,GAAG,UAAU;AAC1D,mBAAa,WAAW,MAAM,MAAM,QAAQ,UAAU,UAAU;AAChE,cAAQ,OAAc;OACtB,CACD,OAAO,UAAiB;AACvB,mBAAa,UAAU;MACvB,MAAM,WAAW,KAAK,MAAM,YAAY,KAAK,GAAG,UAAU;AAC1D,mBAAa,QAAQ,MAAM,MAAM,MAAM,SAAS,UAAU,UAAU;AACpE,aAAO,MAAM;OACb;MACJ;;KAGP,CAAC;;;;;;;;;;;;AAoCN,SAAgB,UAAU,UAA8C,EAAE,EAKxE;AACA,QAAO,IAAI,WAAW,QAAQ"}