@univerjs/rpc 0.20.1 → 0.21.0-insiders.20260422-d7fcb4d

package/lib/cjs/index.js

@@ -1 +1,776 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});let e=require(`@univerjs/core`),t=require(`rxjs/operators`),n=require(`rxjs`);const r=`rpc.main-thread.config`;Symbol(r);const i={},a=`rpc.worker-thread.config`;Symbol(a);const o={};function s(e,t){return function(n,r){t(n,r,e)}}function c(e,t,n,r){var i=arguments.length,a=i<3?t:r===null?r=Object.getOwnPropertyDescriptor(t,n):r,o;if(typeof Reflect==`object`&&typeof Reflect.decorate==`function`)a=Reflect.decorate(e,t,n,r);else for(var s=e.length-1;s>=0;s--)(o=e[s])&&(a=(i<3?o(a):i>3?o(t,n,a):o(t,n))||a);return i>3&&a&&Object.defineProperty(t,n,a),a}const l=`rpc.remote-sync.service`,u=(0,e.createIdentifier)(l);let d=class{constructor(e){this._commandService=e}async syncMutation(e,t){let{fromCollab:n,...r}=t||{};return this._commandService.syncExecuteCommand(e.mutationInfo.id,e.mutationInfo.params,{...r,onlyLocal:!0,fromSync:!0})}};d=c([s(0,e.ICommandService)],d);const f=`univer.remote-instance-service`,p=(0,e.createIdentifier)(f);let m=class{constructor(e,t,n){this._univerInstanceService=e,this._commandService=t,this._logService=n}whenReady(){return Promise.resolve(!0)}async syncMutation(e,t){return this._applyMutation(e.mutationInfo,t)}async createInstance(t){this._logService.debug(`[WebWorkerRemoteInstanceService]: Creating instance with id ${t.unitID}`);let{type:n,snapshot:r}=t;try{switch(n){case e.UniverInstanceType.UNIVER_SHEET:return this._univerInstanceService.createUnit(e.UniverInstanceType.UNIVER_SHEET,r),!0;default:throw Error(`[WebWorkerRemoteInstanceService]: cannot create replica for document type: ${n}.`)}}catch(e){throw e instanceof Error?e:TypeError(`${e}`)}}async disposeInstance(e){return this._logService.debug(`[WebWorkerRemoteInstanceService]: Disposing instance with id ${e.unitID}`),this._univerInstanceService.disposeUnit(e.unitID)}_applyMutation(e,t){let{id:n,params:r}=e,{fromCollab:i,...a}=t||{};return this._commandService.syncExecuteCommand(n,r,{...a,onlyLocal:!0,fromSync:!0})}};m=c([s(0,e.IUniverInstanceService),s(1,e.ICommandService),s(2,e.ILogService)],m);function h(e){"@babel/helpers - typeof";return h=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},h(e)}function g(e,t){if(h(e)!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(h(r)!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function _(e){var t=g(e,`string`);return h(t)==`symbol`?t:t+``}function v(e,t,n){return(t=_(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function y(e){let t=e;return new class{call(e,n){let r=t[e];if(typeof r==`function`){let e=n?r.apply(t,n):r.call(t);return e instanceof Promise||(e=Promise.resolve(e)),e}throw Error(`[RPC]: method not found for ${e}!`)}subscribe(e,r){let i=t[e];if(typeof i==`function`){let e=r?i.apply(t,r):i.call(t);return(0,n.isObservable)(e)?e:(0,n.of)(e)}throw Error(`[RPC]: observable method not found for ${e}!`)}}}function b(e){return new Proxy({},{get(t,n){if(n!==`dispose`)return function(...t){return x(n)?e.subscribe(n,t):e.call(n,t)}}})}function x(e){return e.endsWith(`$`)}var S=function(e){return e[e.REQUEST_INITIALIZATION=50]=`REQUEST_INITIALIZATION`,e[e.CALL=100]=`CALL`,e[e.SUBSCRIBE=101]=`SUBSCRIBE`,e[e.UNSUBSCRIBE=102]=`UNSUBSCRIBE`,e}(S||{}),C=function(e){return e[e.INITIALIZE=0]=`INITIALIZE`,e[e.CALL_SUCCESS=201]=`CALL_SUCCESS`,e[e.CALL_FAILURE=202]=`CALL_FAILURE`,e[e.SUBSCRIBE_NEXT=300]=`SUBSCRIBE_NEXT`,e[e.SUBSCRIBE_ERROR=301]=`SUBSCRIBE_ERROR`,e[e.SUBSCRIBE_COMPLETE=302]=`SUBSCRIBE_COMPLETE`,e}(C||{}),w=class extends e.RxDisposable{constructor(e){super(),this._protocol=e,v(this,`_initialized`,new n.BehaviorSubject(!1)),v(this,`_lastRequestCounter`,0),v(this,`_pendingRequests`,new Map),this._protocol.send({type:S.REQUEST_INITIALIZATION}),this._protocol.onMessage.pipe((0,t.takeUntil)(this.dispose$)).subscribe(e=>this._onMessage(e))}dispose(){this._pendingRequests.clear()}getChannel(e){return{call:(t,n)=>this._disposed?Promise.reject(Error(`[ChannelClient]: client is disposed!`)):this._remoteCall(e,t,n),subscribe:(t,n)=>{if(this._disposed)throw Error(`[ChannelClient]: client is disposed!`);return this._remoteSubscribe(e,t,n)}}}_whenReady(){return(0,n.firstValueFrom)(this._initialized.pipe((0,t.filter)(e=>e),(0,t.take)(1)))}_remoteCall(e,t,n){return this._initialized.getValue()?this._doRemoteCall(e,t,n):this._whenReady().then(()=>this._doRemoteCall(e,t,n))}_doRemoteCall(e,t,n){let r=++this._lastRequestCounter,i={seq:r,type:S.CALL,channelName:e,method:t,args:n},a=this._pendingRequests;return new Promise((e,t)=>{this._pendingRequests.set(r,{handle(n){switch(n.type){case C.CALL_SUCCESS:a.delete(r),e(n.data);break;case C.CALL_FAILURE:a.delete(r),t(n.data);break;default:throw Error(`[ChannelClient]: unknown response type!`)}}}),this._sendRequest(i)})}_remoteSubscribe(e,t,r){return new n.Observable(n=>{let i=-1,a=()=>{i=++this._lastRequestCounter;let a=S.SUBSCRIBE,o={seq:i,type:a,channelName:e,method:t,args:r};this._pendingRequests.set(i,{handle(e){switch(e.type){case C.SUBSCRIBE_NEXT:n.next(e.data);break;case C.SUBSCRIBE_ERROR:n.error(e.data);break;case C.SUBSCRIBE_COMPLETE:n.complete();break;default:throw Error(`[ChannelClient]: unknown response type!`)}}}),this._sendRequest(o)};return this._initialized.getValue()?a():this._whenReady().then(a),()=>{if(i===-1)return;let n={type:S.UNSUBSCRIBE,seq:i,channelName:e,method:t};this._sendRequest(n)}})}_sendRequest(e){this._protocol.send(e)}_onMessage(e){let{type:t,seq:n}=e;switch(t){case C.INITIALIZE:this._initialized.next(!0);break;case C.CALL_SUCCESS:case C.CALL_FAILURE:case C.SUBSCRIBE_NEXT:case C.SUBSCRIBE_COMPLETE:case C.SUBSCRIBE_ERROR:{var r;let{_pendingRequests:i}=this;(r=i.get(n))==null||r.handle(e),t!==C.SUBSCRIBE_NEXT&&i.delete(n);break}}}},T=class extends e.RxDisposable{constructor(e){super(),this._protocol=e,v(this,`_channels`,new Map),v(this,`_subscriptions`,new Map),this._protocol.onMessage.pipe((0,t.takeUntil)(this.dispose$)).subscribe(e=>this._onRequest(e)),this._sendInitialize()}dispose(){super.dispose(),this._subscriptions.clear(),this._channels.clear()}registerChannel(e,t){this._channels.set(e,t)}_onRequest(e){switch(e.type){case S.REQUEST_INITIALIZATION:this._sendInitialize();break;case S.CALL:this._onMethodCall(e);break;case S.SUBSCRIBE:this._onSubscribe(e);break;case S.UNSUBSCRIBE:this._onUnsubscribe(e);break;default:break}}_sendInitialize(){this._sendResponse({seq:-1,type:C.INITIALIZE})}_onMethodCall(e){let{channelName:t,method:n,args:r}=e,i=this._channels.get(t),a;try{if(!i)throw Error(`[ChannelServer]: Channel ${t} not found!`);a=r?i.call(n,r):i.call(n)}catch(e){a=Promise.reject(e instanceof Error?e:Error(String(e)))}a.then(t=>{this._sendResponse({seq:e.seq,type:C.CALL_SUCCESS,data:t})}).catch(t=>{t instanceof Error?this._sendResponse({seq:e.seq,type:C.CALL_FAILURE,data:t.message}):this._sendResponse({seq:e.seq,type:C.CALL_FAILURE,data:String(t)})})}_onSubscribe(e){let{channelName:t,seq:n}=e,r=this._channels.get(t);try{if(!r)throw Error(`[ChannelServer]: Channel ${t} not found!`);let i=r.subscribe(e.method,e.args).subscribe({next:e=>{this._sendResponse({seq:n,type:C.SUBSCRIBE_NEXT,data:e})},error:e=>{this._sendResponse({seq:n,type:C.SUBSCRIBE_ERROR,data:e.message}),this._sendResponse({seq:n,type:C.SUBSCRIBE_COMPLETE})},complete:()=>{this._sendResponse({seq:n,type:C.SUBSCRIBE_COMPLETE})}});this._subscriptions.set(e.seq,i)}catch(t){t instanceof Error?this._sendResponse({seq:e.seq,type:C.SUBSCRIBE_ERROR,data:t.message}):this._sendResponse({seq:e.seq,type:C.SUBSCRIBE_ERROR,data:String(t)})}}_onUnsubscribe(e){let t=this._subscriptions.get(e.seq);t&&(t.unsubscribe(),this._subscriptions.delete(e.seq))}_sendResponse(e){this._protocol.send(e)}};const E=(0,e.createIdentifier)(`IRPCChannelService`);var D=class{constructor(e){v(this,`_client`,void 0),v(this,`_server`,void 0),this._client=new w(e),this._server=new T(e)}dispose(){this._client.dispose(),this._server.dispose()}requestChannel(e){return this._client.getChannel(e)}registerChannel(e,t){this._server.registerChannel(e,t)}};let O=class extends e.RxDisposable{constructor(e,t,n,r,i){super(),this._injector=e,this._commandService=t,this._univerInstanceService=n,this._rpcChannelService=r,this._remoteSyncService=i,v(this,`_remoteInstanceService`,void 0),v(this,`_syncingUnits`,new Set),v(this,`_syncingMutations`,new Set),this._initRPCChannels(),this._init()}registerSyncingMutations(e){this._syncingMutations.add(e.id)}syncUnit(t){return this._syncingUnits.add(t),(0,e.toDisposable)(()=>this._syncingUnits.delete(t))}_initRPCChannels(){this._rpcChannelService.registerChannel(l,y(this._remoteSyncService)),this._injector.add([p,{useFactory:()=>b(this._rpcChannelService.requestChannel(f))}]),this._remoteInstanceService=this._injector.get(p)}_init(){this._univerInstanceService.getTypeOfUnitAdded$(e.UniverInstanceType.UNIVER_SHEET).pipe((0,t.takeUntil)(this.dispose$)).subscribe(t=>{this._syncingUnits.add(t.getUnitId()),this._remoteInstanceService.createInstance({unitID:t.getUnitId(),type:e.UniverInstanceType.UNIVER_SHEET,snapshot:t.getSnapshot()})}),this._univerInstanceService.getTypeOfUnitDisposed$(e.UniverInstanceType.UNIVER_SHEET).pipe((0,t.takeUntil)(this.dispose$)).subscribe(e=>{this._syncingUnits.delete(e.getUnitId()),this._remoteInstanceService.disposeInstance({unitID:e.getUnitId()})}),this.disposeWithMe(this._commandService.onCommandExecuted((t,n)=>{let{type:r,params:i,id:a}=t,o=(i==null?void 0:i.unitId)||``;r===e.CommandType.MUTATION&&(!o||this._syncingUnits.has(o))&&!(n!=null&&n.fromSync)&&this._syncingMutations.has(a)&&this._remoteInstanceService.syncMutation({mutationInfo:t},n)}))}};O=c([s(0,(0,e.Inject)(e.Injector)),s(1,e.ICommandService),s(2,e.IUniverInstanceService),s(3,E),s(4,u)],O);let k=class extends e.Disposable{constructor(e,t,n,r){super(),this._injector=e,this._remoteInstanceService=t,this._commandService=n,this._rpcChannelService=r,v(this,`_remoteSyncService`,void 0),this._initRPCChannels(),this._init()}_initRPCChannels(){this._rpcChannelService.registerChannel(f,y(this._remoteInstanceService)),this._injector.add([u,{useFactory:()=>b(this._rpcChannelService.requestChannel(l))}]),this._remoteSyncService=this._injector.get(u)}_init(){this.disposeWithMe(this._commandService.onCommandExecuted((t,n)=>{t.type===e.CommandType.MUTATION&&!(n!=null&&n.fromSync)&&this._remoteSyncService.syncMutation({mutationInfo:t},n)}))}};k=c([s(0,(0,e.Inject)(e.Injector)),s(1,p),s(2,e.ICommandService),s(3,E)],k);var A=`@univerjs/rpc`,j=`0.20.1`;function M(){return{send(e){postMessage(e)},onMessage:new n.Observable(e=>{let t=t=>{e.next(t.data)};return addEventListener(`message`,t),()=>removeEventListener(`message`,t)}).pipe((0,n.shareReplay)(1))}}function N(e){return{send(t){e.postMessage(t)},onMessage:new n.Observable(t=>{let n=e=>{t.next(e.data)};return e.addEventListener(`message`,n),()=>e.removeEventListener(`message`,n)}).pipe((0,n.shareReplay)(1))}}let P=class extends e.Plugin{constructor(t=i,n,a){super(),this._config=t,this._injector=n,this._configService=a,v(this,`_internalWorker`,null);let{...o}=(0,e.merge)({},i,this._config);this._configService.setConfig(r,o)}dispose(){super.dispose(),this._internalWorker&&(this._internalWorker.terminate(),this._internalWorker=null)}onStarting(){let{workerURL:e}=this._config;if(!e)throw Error(`[UniverRPCMainThreadPlugin]: The workerURL is required for the RPC main thread plugin.`);let t=e instanceof Worker?e:new Worker(e);this._internalWorker=e instanceof Worker?null:t;let n=N(t);[[E,{useFactory:()=>new D(n)}],[O],[u,{useClass:d}]].forEach(e=>this._injector.add(e)),this._injector.get(O)}};v(P,`pluginName`,`UNIVER_RPC_MAIN_THREAD_PLUGIN`),v(P,`packageName`,A),v(P,`version`,j),P=c([s(1,(0,e.Inject)(e.Injector)),s(2,e.IConfigService)],P);let F=class extends e.Plugin{constructor(t=o,n,r){super(),this._config=t,this._injector=n,this._configService=r;let{...i}=(0,e.merge)({},o,this._config);this._configService.setConfig(a,i)}onStarting(){[[k],[E,{useFactory:()=>new D(M())}],[p,{useClass:m}]].forEach(e=>this._injector.add(e)),this._injector.get(k)}};v(F,`pluginName`,`UNIVER_RPC_WORKER_THREAD_PLUGIN`),v(F,`packageName`,A),v(F,`version`,j),F=c([s(1,(0,e.Inject)(e.Injector)),s(2,e.IConfigService)],F),exports.ChannelClient=w,exports.ChannelServer=T,exports.ChannelService=D,Object.defineProperty(exports,`DataSyncPrimaryController`,{enumerable:!0,get:function(){return O}}),Object.defineProperty(exports,`DataSyncReplicaController`,{enumerable:!0,get:function(){return k}}),exports.IRPCChannelService=E,exports.IRemoteInstanceService=p,exports.IRemoteSyncService=u,exports.PLUGIN_CONFIG_KEY_MAIN_THREAD=r,exports.PLUGIN_CONFIG_KEY_WORKER_THREAD=a,exports.RemoteInstanceServiceName=f,Object.defineProperty(exports,`RemoteSyncPrimaryService`,{enumerable:!0,get:function(){return d}}),exports.RemoteSyncServiceName=l,Object.defineProperty(exports,`UniverRPCMainThreadPlugin`,{enumerable:!0,get:function(){return P}}),Object.defineProperty(exports,`UniverRPCWorkerThreadPlugin`,{enumerable:!0,get:function(){return F}}),Object.defineProperty(exports,`WebWorkerRemoteInstanceService`,{enumerable:!0,get:function(){return m}}),exports.fromModule=y,exports.toModule=b;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _univerjs_core = require("@univerjs/core");
+let rxjs_operators = require("rxjs/operators");
+let rxjs = require("rxjs");
+
+//#region src/config/config.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+const PLUGIN_CONFIG_KEY_MAIN_THREAD = "rpc.main-thread.config";
+const configSymbolMainThread = Symbol(PLUGIN_CONFIG_KEY_MAIN_THREAD);
+const defaultPluginMainThreadConfig = {};
+const PLUGIN_CONFIG_KEY_WORKER_THREAD = "rpc.worker-thread.config";
+const configSymbolWorkerThread = Symbol(PLUGIN_CONFIG_KEY_WORKER_THREAD);
+const defaultPluginWorkerThreadConfig = {};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region src/services/remote-instance/remote-instance.service.ts
+const RemoteSyncServiceName = "rpc.remote-sync.service";
+/**
+* This service is provided by the primary Univer.
+*
+* Replica Univer could call this service to update mutations back to the primary Univer.
+*/
+const IRemoteSyncService = (0, _univerjs_core.createIdentifier)(RemoteSyncServiceName);
+let RemoteSyncPrimaryService = class RemoteSyncPrimaryService {
+	constructor(_commandService) {
+		this._commandService = _commandService;
+	}
+	async syncMutation(params, options) {
+		const { fromCollab, ...restOptions } = options || {};
+		return this._commandService.syncExecuteCommand(params.mutationInfo.id, params.mutationInfo.params, {
+			...restOptions,
+			onlyLocal: true,
+			fromSync: true
+		});
+	}
+};
+RemoteSyncPrimaryService = __decorate([__decorateParam(0, _univerjs_core.ICommandService)], RemoteSyncPrimaryService);
+const RemoteInstanceServiceName = "univer.remote-instance-service";
+/**
+* This service is provided by the replica Univer.
+*
+* Primary univer could call this service to init and dispose univer business instances
+* and sync mutations to replica univer.
+*/
+const IRemoteInstanceService = (0, _univerjs_core.createIdentifier)(RemoteInstanceServiceName);
+let WebWorkerRemoteInstanceService = class WebWorkerRemoteInstanceService {
+	constructor(_univerInstanceService, _commandService, _logService) {
+		this._univerInstanceService = _univerInstanceService;
+		this._commandService = _commandService;
+		this._logService = _logService;
+	}
+	whenReady() {
+		return Promise.resolve(true);
+	}
+	async syncMutation(params, options) {
+		return this._applyMutation(params.mutationInfo, options);
+	}
+	async createInstance(params) {
+		this._logService.debug(`[WebWorkerRemoteInstanceService]: Creating instance with id ${params.unitID}`);
+		const { type, snapshot } = params;
+		try {
+			switch (type) {
+				case _univerjs_core.UniverInstanceType.UNIVER_SHEET:
+					this._univerInstanceService.createUnit(_univerjs_core.UniverInstanceType.UNIVER_SHEET, snapshot);
+					return true;
+				default: throw new Error(`[WebWorkerRemoteInstanceService]: cannot create replica for document type: ${type}.`);
+			}
+		} catch (err) {
+			if (err instanceof Error) throw err;
+			else throw new TypeError(`${err}`);
+		}
+	}
+	async disposeInstance(params) {
+		this._logService.debug(`[WebWorkerRemoteInstanceService]: Disposing instance with id ${params.unitID}`);
+		return this._univerInstanceService.disposeUnit(params.unitID);
+	}
+	_applyMutation(mutationInfo, options) {
+		const { id, params: mutationParams } = mutationInfo;
+		const { fromCollab, ...restOptions } = options || {};
+		return this._commandService.syncExecuteCommand(id, mutationParams, {
+			...restOptions,
+			onlyLocal: true,
+			fromSync: true
+		});
+	}
+};
+WebWorkerRemoteInstanceService = __decorate([
+	__decorateParam(0, _univerjs_core.IUniverInstanceService),
+	__decorateParam(1, _univerjs_core.ICommandService),
+	__decorateParam(2, _univerjs_core.ILogService)
+], WebWorkerRemoteInstanceService);
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.124.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/services/rpc/rpc.service.ts
+/**
+* Wrapper a service or a controller into a channel so it could be invoked by
+* a remote client. When the protocol is called, it would forward to the
+* underlying service or controller.
+*
+* @param module the wrapper service or controller
+* @returns the channel instance
+*/
+function fromModule(module) {
+	const handler = module;
+	return new class {
+		call(method, args) {
+			const target = handler[method];
+			if (typeof target === "function") {
+				let res = args ? target.apply(handler, args) : target.call(handler);
+				if (!(res instanceof Promise)) res = Promise.resolve(res);
+				return res;
+			}
+			throw new Error(`[RPC]: method not found for ${method}!`);
+		}
+		subscribe(eventMethod, args) {
+			const target = handler[eventMethod];
+			if (typeof target === "function") {
+				const res = args ? target.apply(handler, args) : target.call(handler);
+				if (!(0, rxjs.isObservable)(res)) return (0, rxjs.of)(res);
+				return res;
+			}
+			throw new Error(`[RPC]: observable method not found for ${eventMethod}!`);
+		}
+	}();
+}
+/**
+* Wrap a channel into a service or a controller so it could be invoked by
+* the upper layer modules. When the service or controller is called, it would
+* request the remote server by calling the channel.
+*
+* @param channel
+* @returns A proxy object that forwards calls/subscriptions to the remote channel.
+*/
+function toModule(channel) {
+	return new Proxy({}, { get(_, propKey) {
+		if (propKey === "dispose") return;
+		return function(...args) {
+			if (propertyIsEventSource(propKey)) return channel.subscribe(propKey, args);
+			return channel.call(propKey, args);
+		};
+	} });
+}
+function propertyIsEventSource(name) {
+	return name.endsWith("$");
+}
+var RequestType = /* @__PURE__ */ function(RequestType) {
+	/**
+	* In Univer, we cannot make sure that when IPCServer constructs, the process (or thread)
+	* where the corresponding IPCClient residents has bootstrapped and been ready to recieve messages.
+	* This may result in the IPCClient hanging there, waiting for the `INITIALIZE` message that it has
+	* already missed. So the client should send a REQUEST_INITIALIZATION in case of that.
+	*
+	* Later, we may want a more sophisticated RPC system where the server can serve more than
+	* one clients, and this event may be removed.
+	*/
+	RequestType[RequestType["REQUEST_INITIALIZATION"] = 50] = "REQUEST_INITIALIZATION";
+	/** A simple remote calling wrapper in a Promise. */
+	RequestType[RequestType["CALL"] = 100] = "CALL";
+	/** Subscribe to a remote Observable. */
+	RequestType[RequestType["SUBSCRIBE"] = 101] = "SUBSCRIBE";
+	/** Cancel subscription to that remove Observable. */
+	RequestType[RequestType["UNSUBSCRIBE"] = 102] = "UNSUBSCRIBE";
+	return RequestType;
+}(RequestType || {});
+var ResponseType = /* @__PURE__ */ function(ResponseType) {
+	/**
+	* When underlying protocol is established. The server should send the
+	* client an `INITIALIZE` response to indicate that the server is up
+	* and ready to provide services.
+	*/
+	ResponseType[ResponseType["INITIALIZE"] = 0] = "INITIALIZE";
+	ResponseType[ResponseType["CALL_SUCCESS"] = 201] = "CALL_SUCCESS";
+	ResponseType[ResponseType["CALL_FAILURE"] = 202] = "CALL_FAILURE";
+	ResponseType[ResponseType["SUBSCRIBE_NEXT"] = 300] = "SUBSCRIBE_NEXT";
+	ResponseType[ResponseType["SUBSCRIBE_ERROR"] = 301] = "SUBSCRIBE_ERROR";
+	ResponseType[ResponseType["SUBSCRIBE_COMPLETE"] = 302] = "SUBSCRIBE_COMPLETE";
+	return ResponseType;
+}(ResponseType || {});
+/**
+* This method provides implementation for `IChannel` and is responsible for
+* transforming a local calling to a RPC calling.
+*/
+var ChannelClient = class extends _univerjs_core.RxDisposable {
+	constructor(_protocol) {
+		super();
+		this._protocol = _protocol;
+		_defineProperty(this, "_initialized", new rxjs.BehaviorSubject(false));
+		_defineProperty(this, "_lastRequestCounter", 0);
+		_defineProperty(this, "_pendingRequests", /* @__PURE__ */ new Map());
+		this._protocol.send({ type: RequestType.REQUEST_INITIALIZATION });
+		this._protocol.onMessage.pipe((0, rxjs_operators.takeUntil)(this.dispose$)).subscribe((message) => this._onMessage(message));
+	}
+	dispose() {
+		this._pendingRequests.clear();
+	}
+	getChannel(channelName) {
+		return {
+			call: (method, args) => {
+				if (this._disposed) return Promise.reject(/* @__PURE__ */ new Error("[ChannelClient]: client is disposed!"));
+				return this._remoteCall(channelName, method, args);
+			},
+			subscribe: (eventMethod, args) => {
+				if (this._disposed) throw new Error("[ChannelClient]: client is disposed!");
+				return this._remoteSubscribe(channelName, eventMethod, args);
+			}
+		};
+	}
+	_whenReady() {
+		return (0, rxjs.firstValueFrom)(this._initialized.pipe((0, rxjs_operators.filter)((v) => v), (0, rxjs_operators.take)(1)));
+	}
+	_remoteCall(channelName, method, args) {
+		if (this._initialized.getValue()) return this._doRemoteCall(channelName, method, args);
+		return this._whenReady().then(() => this._doRemoteCall(channelName, method, args));
+	}
+	_doRemoteCall(channelName, method, args) {
+		const sequence = ++this._lastRequestCounter;
+		const request = {
+			seq: sequence,
+			type: RequestType.CALL,
+			channelName,
+			method,
+			args
+		};
+		const pendingRequests = this._pendingRequests;
+		return new Promise((resolve, reject) => {
+			this._pendingRequests.set(sequence, { handle(response) {
+				switch (response.type) {
+					case ResponseType.CALL_SUCCESS:
+						pendingRequests.delete(sequence);
+						resolve(response.data);
+						break;
+					case ResponseType.CALL_FAILURE:
+						pendingRequests.delete(sequence);
+						reject(response.data);
+						break;
+					default: throw new Error("[ChannelClient]: unknown response type!");
+				}
+			} });
+			this._sendRequest(request);
+		});
+	}
+	_remoteSubscribe(channelName, method, args) {
+		return new rxjs.Observable((subscriber) => {
+			let sequence = -1;
+			const doSubscribe = () => {
+				sequence = ++this._lastRequestCounter;
+				const type = RequestType.SUBSCRIBE;
+				const request = {
+					seq: sequence,
+					type,
+					channelName,
+					method,
+					args
+				};
+				this._pendingRequests.set(sequence, { handle(response) {
+					switch (response.type) {
+						case ResponseType.SUBSCRIBE_NEXT:
+							subscriber.next(response.data);
+							break;
+						case ResponseType.SUBSCRIBE_ERROR:
+							subscriber.error(response.data);
+							break;
+						case ResponseType.SUBSCRIBE_COMPLETE:
+							subscriber.complete();
+							break;
+						default: throw new Error("[ChannelClient]: unknown response type!");
+					}
+				} });
+				this._sendRequest(request);
+			};
+			if (this._initialized.getValue()) doSubscribe();
+			else this._whenReady().then(doSubscribe);
+			return () => {
+				if (sequence === -1) return;
+				const cancelSubscriptionRequest = {
+					type: RequestType.UNSUBSCRIBE,
+					seq: sequence,
+					channelName,
+					method
+				};
+				this._sendRequest(cancelSubscriptionRequest);
+			};
+		});
+	}
+	_sendRequest(request) {
+		this._protocol.send(request);
+	}
+	_onMessage(response) {
+		const { type: responseType, seq } = response;
+		switch (responseType) {
+			case ResponseType.INITIALIZE:
+				this._initialized.next(true);
+				break;
+			case ResponseType.CALL_SUCCESS:
+			case ResponseType.CALL_FAILURE:
+			case ResponseType.SUBSCRIBE_NEXT:
+			case ResponseType.SUBSCRIBE_COMPLETE:
+			case ResponseType.SUBSCRIBE_ERROR: {
+				var _pendingRequests$get;
+				const { _pendingRequests } = this;
+				(_pendingRequests$get = _pendingRequests.get(seq)) === null || _pendingRequests$get === void 0 || _pendingRequests$get.handle(response);
+				responseType !== ResponseType.SUBSCRIBE_NEXT && _pendingRequests.delete(seq);
+				break;
+			}
+		}
+	}
+};
+var ChannelServer = class extends _univerjs_core.RxDisposable {
+	constructor(_protocol) {
+		super();
+		this._protocol = _protocol;
+		_defineProperty(this, "_channels", /* @__PURE__ */ new Map());
+		_defineProperty(this, "_subscriptions", /* @__PURE__ */ new Map());
+		this._protocol.onMessage.pipe((0, rxjs_operators.takeUntil)(this.dispose$)).subscribe((message) => this._onRequest(message));
+		this._sendInitialize();
+	}
+	dispose() {
+		super.dispose();
+		this._subscriptions.clear();
+		this._channels.clear();
+	}
+	registerChannel(channelName, channel) {
+		this._channels.set(channelName, channel);
+	}
+	_onRequest(request) {
+		switch (request.type) {
+			case RequestType.REQUEST_INITIALIZATION:
+				this._sendInitialize();
+				break;
+			case RequestType.CALL:
+				this._onMethodCall(request);
+				break;
+			case RequestType.SUBSCRIBE:
+				this._onSubscribe(request);
+				break;
+			case RequestType.UNSUBSCRIBE:
+				this._onUnsubscribe(request);
+				break;
+			default: break;
+		}
+	}
+	_sendInitialize() {
+		this._sendResponse({
+			seq: -1,
+			type: ResponseType.INITIALIZE
+		});
+	}
+	_onMethodCall(request) {
+		const { channelName, method, args } = request;
+		const channel = this._channels.get(channelName);
+		let promise;
+		try {
+			if (!channel) throw new Error(`[ChannelServer]: Channel ${channelName} not found!`);
+			promise = args ? channel.call(method, args) : channel.call(method);
+		} catch (err) {
+			promise = Promise.reject(err instanceof Error ? err : new Error(String(err)));
+		}
+		promise.then((data) => {
+			this._sendResponse({
+				seq: request.seq,
+				type: ResponseType.CALL_SUCCESS,
+				data
+			});
+		}).catch((err) => {
+			if (err instanceof Error) this._sendResponse({
+				seq: request.seq,
+				type: ResponseType.CALL_FAILURE,
+				data: err.message
+			});
+			else this._sendResponse({
+				seq: request.seq,
+				type: ResponseType.CALL_FAILURE,
+				data: String(err)
+			});
+		});
+	}
+	_onSubscribe(request) {
+		const { channelName, seq } = request;
+		const channel = this._channels.get(channelName);
+		try {
+			if (!channel) throw new Error(`[ChannelServer]: Channel ${channelName} not found!`);
+			const subscription = channel.subscribe(request.method, request.args).subscribe({
+				next: (data) => {
+					this._sendResponse({
+						seq,
+						type: ResponseType.SUBSCRIBE_NEXT,
+						data
+					});
+				},
+				error: (err) => {
+					this._sendResponse({
+						seq,
+						type: ResponseType.SUBSCRIBE_ERROR,
+						data: err.message
+					});
+					this._sendResponse({
+						seq,
+						type: ResponseType.SUBSCRIBE_COMPLETE
+					});
+				},
+				complete: () => {
+					this._sendResponse({
+						seq,
+						type: ResponseType.SUBSCRIBE_COMPLETE
+					});
+				}
+			});
+			this._subscriptions.set(request.seq, subscription);
+		} catch (err) {
+			if (err instanceof Error) this._sendResponse({
+				seq: request.seq,
+				type: ResponseType.SUBSCRIBE_ERROR,
+				data: err.message
+			});
+			else this._sendResponse({
+				seq: request.seq,
+				type: ResponseType.SUBSCRIBE_ERROR,
+				data: String(err)
+			});
+		}
+	}
+	_onUnsubscribe(request) {
+		const subscription = this._subscriptions.get(request.seq);
+		if (subscription) {
+			subscription.unsubscribe();
+			this._subscriptions.delete(request.seq);
+		}
+	}
+	_sendResponse(response) {
+		this._protocol.send(response);
+	}
+};
+
+//#endregion
+//#region src/services/rpc/channel.service.ts
+const IRPCChannelService = (0, _univerjs_core.createIdentifier)("IRPCChannelService");
+/**
+* This service is responsible for managing the RPC channels.
+*/
+var ChannelService = class {
+	constructor(_messageProtocol) {
+		_defineProperty(this, "_client", void 0);
+		_defineProperty(this, "_server", void 0);
+		this._client = new ChannelClient(_messageProtocol);
+		this._server = new ChannelServer(_messageProtocol);
+	}
+	dispose() {
+		this._client.dispose();
+		this._server.dispose();
+	}
+	requestChannel(name) {
+		return this._client.getChannel(name);
+	}
+	registerChannel(name, channel) {
+		this._server.registerChannel(name, channel);
+	}
+};
+
+//#endregion
+//#region src/controllers/data-sync/data-sync-primary.controller.ts
+let DataSyncPrimaryController = class DataSyncPrimaryController extends _univerjs_core.RxDisposable {
+	constructor(_injector, _commandService, _univerInstanceService, _rpcChannelService, _remoteSyncService) {
+		super();
+		this._injector = _injector;
+		this._commandService = _commandService;
+		this._univerInstanceService = _univerInstanceService;
+		this._rpcChannelService = _rpcChannelService;
+		this._remoteSyncService = _remoteSyncService;
+		_defineProperty(this, "_remoteInstanceService", void 0);
+		_defineProperty(this, "_syncingUnits", /* @__PURE__ */ new Set());
+		_defineProperty(this, "_syncingMutations", /* @__PURE__ */ new Set());
+		this._initRPCChannels();
+		this._init();
+	}
+	registerSyncingMutations(mutation) {
+		this._syncingMutations.add(mutation.id);
+	}
+	/**
+	* Only spreadsheets would be synced to the web worker in normal situations. If you would like to
+	* sync other types of documents, you should manually call this method with that document's id.
+	*/
+	syncUnit(unitId) {
+		this._syncingUnits.add(unitId);
+		return (0, _univerjs_core.toDisposable)(() => this._syncingUnits.delete(unitId));
+	}
+	_initRPCChannels() {
+		this._rpcChannelService.registerChannel(RemoteSyncServiceName, fromModule(this._remoteSyncService));
+		this._injector.add([IRemoteInstanceService, { useFactory: () => toModule(this._rpcChannelService.requestChannel(RemoteInstanceServiceName)) }]);
+		this._remoteInstanceService = this._injector.get(IRemoteInstanceService);
+	}
+	_init() {
+		this._univerInstanceService.getTypeOfUnitAdded$(_univerjs_core.UniverInstanceType.UNIVER_SHEET).pipe((0, rxjs_operators.takeUntil)(this.dispose$)).subscribe((sheet) => {
+			this._syncingUnits.add(sheet.getUnitId());
+			this._remoteInstanceService.createInstance({
+				unitID: sheet.getUnitId(),
+				type: _univerjs_core.UniverInstanceType.UNIVER_SHEET,
+				snapshot: sheet.getSnapshot()
+			});
+		});
+		this._univerInstanceService.getTypeOfUnitDisposed$(_univerjs_core.UniverInstanceType.UNIVER_SHEET).pipe((0, rxjs_operators.takeUntil)(this.dispose$)).subscribe((workbook) => {
+			this._syncingUnits.delete(workbook.getUnitId());
+			this._remoteInstanceService.disposeInstance({ unitID: workbook.getUnitId() });
+		});
+		this.disposeWithMe(this._commandService.onCommandExecuted((commandInfo, options) => {
+			const { type, params, id } = commandInfo;
+			const unitId = (params === null || params === void 0 ? void 0 : params.unitId) || "";
+			if (type === _univerjs_core.CommandType.MUTATION && (!unitId || this._syncingUnits.has(unitId)) && !(options === null || options === void 0 ? void 0 : options.fromSync) && this._syncingMutations.has(id)) this._remoteInstanceService.syncMutation({ mutationInfo: commandInfo }, options);
+		}));
+	}
+};
+DataSyncPrimaryController = __decorate([
+	__decorateParam(0, (0, _univerjs_core.Inject)(_univerjs_core.Injector)),
+	__decorateParam(1, _univerjs_core.ICommandService),
+	__decorateParam(2, _univerjs_core.IUniverInstanceService),
+	__decorateParam(3, IRPCChannelService),
+	__decorateParam(4, IRemoteSyncService)
+], DataSyncPrimaryController);
+
+//#endregion
+//#region src/controllers/data-sync/data-sync-replica.controller.ts
+let DataSyncReplicaController = class DataSyncReplicaController extends _univerjs_core.Disposable {
+	constructor(_injector, _remoteInstanceService, _commandService, _rpcChannelService) {
+		super();
+		this._injector = _injector;
+		this._remoteInstanceService = _remoteInstanceService;
+		this._commandService = _commandService;
+		this._rpcChannelService = _rpcChannelService;
+		_defineProperty(this, "_remoteSyncService", void 0);
+		this._initRPCChannels();
+		this._init();
+	}
+	_initRPCChannels() {
+		this._rpcChannelService.registerChannel(RemoteInstanceServiceName, fromModule(this._remoteInstanceService));
+		this._injector.add([IRemoteSyncService, { useFactory: () => toModule(this._rpcChannelService.requestChannel(RemoteSyncServiceName)) }]);
+		this._remoteSyncService = this._injector.get(IRemoteSyncService);
+	}
+	_init() {
+		this.disposeWithMe(this._commandService.onCommandExecuted((commandInfo, options) => {
+			if (commandInfo.type === _univerjs_core.CommandType.MUTATION && !(options === null || options === void 0 ? void 0 : options.fromSync)) this._remoteSyncService.syncMutation({ mutationInfo: commandInfo }, options);
+		}));
+	}
+};
+DataSyncReplicaController = __decorate([
+	__decorateParam(0, (0, _univerjs_core.Inject)(_univerjs_core.Injector)),
+	__decorateParam(1, IRemoteInstanceService),
+	__decorateParam(2, _univerjs_core.ICommandService),
+	__decorateParam(3, IRPCChannelService)
+], DataSyncReplicaController);
+
+//#endregion
+//#region package.json
+var name = "@univerjs/rpc";
+var version = "0.21.0-insiders.20260422-d7fcb4d";
+
+//#endregion
+//#region src/services/rpc/implementations/web-worker-rpc.service.ts
+/**
+* Generate an `IMessageProtocol` on the web worker.
+* @returns A protocol wrapper around worker global messaging APIs.
+*/
+function createWebWorkerMessagePortOnWorker() {
+	return {
+		send(message) {
+			postMessage(message);
+		},
+		onMessage: new rxjs.Observable((subscriber) => {
+			const handler = (event) => {
+				subscriber.next(event.data);
+			};
+			addEventListener("message", handler);
+			return () => removeEventListener("message", handler);
+		}).pipe((0, rxjs.shareReplay)(1))
+	};
+}
+/**
+* Generate an `IMessageProtocol` on the main thread side.
+* @param worker The Web Worker object
+* @returns A protocol wrapper around the given worker messaging APIs.
+*/
+function createWebWorkerMessagePortOnMain(worker) {
+	return {
+		send(message) {
+			worker.postMessage(message);
+		},
+		onMessage: new rxjs.Observable((subscriber) => {
+			const handler = (event) => {
+				subscriber.next(event.data);
+			};
+			worker.addEventListener("message", handler);
+			return () => worker.removeEventListener("message", handler);
+		}).pipe((0, rxjs.shareReplay)(1))
+	};
+}
+
+//#endregion
+//#region src/plugin.ts
+let UniverRPCMainThreadPlugin = class UniverRPCMainThreadPlugin extends _univerjs_core.Plugin {
+	constructor(_config = defaultPluginMainThreadConfig, _injector, _configService) {
+		super();
+		this._config = _config;
+		this._injector = _injector;
+		this._configService = _configService;
+		_defineProperty(this, "_internalWorker", null);
+		const { ...rest } = (0, _univerjs_core.merge)({}, defaultPluginMainThreadConfig, this._config);
+		this._configService.setConfig(PLUGIN_CONFIG_KEY_MAIN_THREAD, rest);
+	}
+	dispose() {
+		super.dispose();
+		if (this._internalWorker) {
+			this._internalWorker.terminate();
+			this._internalWorker = null;
+		}
+	}
+	onStarting() {
+		const { workerURL } = this._config;
+		if (!workerURL) throw new Error("[UniverRPCMainThreadPlugin]: The workerURL is required for the RPC main thread plugin.");
+		const worker = workerURL instanceof Worker ? workerURL : new Worker(workerURL);
+		this._internalWorker = workerURL instanceof Worker ? null : worker;
+		const messageProtocol = createWebWorkerMessagePortOnMain(worker);
+		[
+			[IRPCChannelService, { useFactory: () => new ChannelService(messageProtocol) }],
+			[DataSyncPrimaryController],
+			[IRemoteSyncService, { useClass: RemoteSyncPrimaryService }]
+		].forEach((dependency) => this._injector.add(dependency));
+		this._injector.get(DataSyncPrimaryController);
+	}
+};
+_defineProperty(UniverRPCMainThreadPlugin, "pluginName", "UNIVER_RPC_MAIN_THREAD_PLUGIN");
+_defineProperty(UniverRPCMainThreadPlugin, "packageName", name);
+_defineProperty(UniverRPCMainThreadPlugin, "version", version);
+UniverRPCMainThreadPlugin = __decorate([__decorateParam(1, (0, _univerjs_core.Inject)(_univerjs_core.Injector)), __decorateParam(2, _univerjs_core.IConfigService)], UniverRPCMainThreadPlugin);
+let UniverRPCWorkerThreadPlugin = class UniverRPCWorkerThreadPlugin extends _univerjs_core.Plugin {
+	constructor(_config = defaultPluginWorkerThreadConfig, _injector, _configService) {
+		super();
+		this._config = _config;
+		this._injector = _injector;
+		this._configService = _configService;
+		const { ...rest } = (0, _univerjs_core.merge)({}, defaultPluginWorkerThreadConfig, this._config);
+		this._configService.setConfig(PLUGIN_CONFIG_KEY_WORKER_THREAD, rest);
+	}
+	onStarting() {
+		[
+			[DataSyncReplicaController],
+			[IRPCChannelService, { useFactory: () => new ChannelService(createWebWorkerMessagePortOnWorker()) }],
+			[IRemoteInstanceService, { useClass: WebWorkerRemoteInstanceService }]
+		].forEach((dependency) => this._injector.add(dependency));
+		this._injector.get(DataSyncReplicaController);
+	}
+};
+_defineProperty(UniverRPCWorkerThreadPlugin, "pluginName", "UNIVER_RPC_WORKER_THREAD_PLUGIN");
+_defineProperty(UniverRPCWorkerThreadPlugin, "packageName", name);
+_defineProperty(UniverRPCWorkerThreadPlugin, "version", version);
+UniverRPCWorkerThreadPlugin = __decorate([__decorateParam(1, (0, _univerjs_core.Inject)(_univerjs_core.Injector)), __decorateParam(2, _univerjs_core.IConfigService)], UniverRPCWorkerThreadPlugin);
+
+//#endregion
+exports.ChannelClient = ChannelClient;
+exports.ChannelServer = ChannelServer;
+exports.ChannelService = ChannelService;
+Object.defineProperty(exports, 'DataSyncPrimaryController', {
+  enumerable: true,
+  get: function () {
+    return DataSyncPrimaryController;
+  }
+});
+Object.defineProperty(exports, 'DataSyncReplicaController', {
+  enumerable: true,
+  get: function () {
+    return DataSyncReplicaController;
+  }
+});
+exports.IRPCChannelService = IRPCChannelService;
+exports.IRemoteInstanceService = IRemoteInstanceService;
+exports.IRemoteSyncService = IRemoteSyncService;
+exports.PLUGIN_CONFIG_KEY_MAIN_THREAD = PLUGIN_CONFIG_KEY_MAIN_THREAD;
+exports.PLUGIN_CONFIG_KEY_WORKER_THREAD = PLUGIN_CONFIG_KEY_WORKER_THREAD;
+exports.RemoteInstanceServiceName = RemoteInstanceServiceName;
+Object.defineProperty(exports, 'RemoteSyncPrimaryService', {
+  enumerable: true,
+  get: function () {
+    return RemoteSyncPrimaryService;
+  }
+});
+exports.RemoteSyncServiceName = RemoteSyncServiceName;
+Object.defineProperty(exports, 'UniverRPCMainThreadPlugin', {
+  enumerable: true,
+  get: function () {
+    return UniverRPCMainThreadPlugin;
+  }
+});
+Object.defineProperty(exports, 'UniverRPCWorkerThreadPlugin', {
+  enumerable: true,
+  get: function () {
+    return UniverRPCWorkerThreadPlugin;
+  }
+});
+Object.defineProperty(exports, 'WebWorkerRemoteInstanceService', {
+  enumerable: true,
+  get: function () {
+    return WebWorkerRemoteInstanceService;
+  }
+});
+exports.fromModule = fromModule;
+exports.toModule = toModule;