@lvce-editor/file-system-process 4.1.0 → 5.1.0

package/dist/index.js

@@ -6,72 +6,6 @@ import { join } from 'node:path';
 import _trash from 'trash';
 import { Buffer } from 'node:buffer';
 
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const Object$1 = 1;
-const Number = 2;
-const Array$1 = 3;
-const String = 4;
-const Boolean$1 = 5;
-const Function = 6;
-const Null = 7;
-const Unknown$1 = 8;
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return Number;
-    case 'function':
-      return Function;
-    case 'string':
-      return String;
-    case 'object':
-      if (value === null) {
-        return Null;
-      }
-      if (Array.isArray(value)) {
-        return Array$1;
-      }
-      return Object$1;
-    case 'boolean':
-      return Boolean$1;
-    default:
-      return Unknown$1;
-  }
-};
-const object = value => {
-  const type = getType(value);
-  if (type !== Object$1) {
-    throw new AssertionError('expected value to be of type object');
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== Number) {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const string = value => {
-  const type = getType(value);
-  if (type !== String) {
-    throw new AssertionError('expected value to be of type string');
-  }
-};
-
-const assertUri = uri => {
-  if (!uri.startsWith('file://')) {
-    throw new Error(`path must be a valid file uri`);
-  }
-};
-
-const Utf8 = 'utf8';
-
-const ENOENT = 'ENOENT';
-const EXDEV = 'EXDEV';
-
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -128,128 +62,59 @@ class VError extends Error {
   }
 }
 
-const getDisplayPath = path => {
-  if (path === '') {
-    return '<empty string>';
-  }
-  return path;
-};
-class FileNotFoundError extends VError {
-  constructor(path) {
-    super(`File not found: '${getDisplayPath(path)}'`);
-    this.code = ENOENT;
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
   }
 }
-
-const BlockDevice = 1;
-const CharacterDevice = 2;
-const Directory = 3;
-const Fifo = 6;
-const File = 7;
-const Socket = 8;
-const Symlink = 9;
-const Unknown = 12;
-
-const getDirentType = dirent => {
-  if (dirent.isFile()) {
-    return File;
-  }
-  if (dirent.isDirectory()) {
-    return Directory;
-  }
-  if (dirent.isSymbolicLink()) {
-    return Symlink;
-  }
-  if (dirent.isSocket()) {
-    return Socket;
-  }
-  if (dirent.isBlockDevice()) {
-    return BlockDevice;
-  }
-  if (dirent.isCharacterDevice()) {
-    return CharacterDevice;
-  }
-  if (dirent.isFIFO()) {
-    return Fifo;
-  }
-  return Unknown;
-};
-
-const getFolderSizeInternal = async path => {
-  if (path === '/') {
-    throw new Error('Invalid path for folder size');
-  }
-  let total = 0;
-  try {
-    const stats = await fs.stat(path);
-    total += stats.size;
-    if (stats.isDirectory() && !stats.isSymbolicLink()) {
-      const dirents = await fs.readdir(path);
-      for (const dirent of dirents) {
-        total += await getFolderSizeInternal(join(path, dirent));
+const Object$1 = 1;
+const Number = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean$1 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown$1 = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number;
+    case 'function':
+      return Function;
+    case 'string':
+      return String;
+    case 'object':
+      if (value === null) {
+        return Null;
       }
-    }
-  } catch {
-    return 0;
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean$1;
+    default:
+      return Unknown$1;
   }
-  return total;
 };
-
-// @ts-ignore
-const isEnoentErrorWindows = error => {
-  if (!error || !error.message) {
-    return false;
+const object = value => {
+  const type = getType(value);
+  if (type !== Object$1) {
+    throw new AssertionError('expected value to be of type object');
   }
-  return error.message.includes('The system cannot find the path specified.');
 };
-
-// @ts-ignore
-const isEnoentErrorLinux = error => {
-  return Boolean(error && error.code === ENOENT);
-};
-
-// @ts-ignore
-const isEnoentError = error => {
-  if (!error) {
-    return false;
+const number = value => {
+  const type = getType(value);
+  if (type !== Number) {
+    throw new AssertionError('expected value to be of type number');
   }
-  return isEnoentErrorLinux(error) || isEnoentErrorWindows(error);
-};
-
-const FileSystemProcess = 210;
-const MainProcess = -5;
-const SharedProcess$1 = 1492;
-
-const rpcs = Object.create(null);
-const set$2 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$1 = id => {
-  return rpcs[id];
 };
-
-const create$3 = rpcId => {
-  return {
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
-    },
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$2(rpcId, rpc);
-    }
-  };
+const string = value => {
+  const type = getType(value);
+  if (type !== String) {
+    throw new AssertionError('expected value to be of type string');
+  }
 };
 
 const isMessagePort = value => {
@@ -882,12 +747,33 @@ const IpcChildWithWebSocket = {
   wrap: wrap$9
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const get = id => {
+const get$1 = id => {
   return callbacks[id];
 };
-const remove$1 = id => {
+const remove$2 = id => {
   delete callbacks[id];
 };
 class JsonRpcError extends Error {
@@ -906,12 +792,12 @@ const getErrorConstructor = (message, type) => {
     switch (type) {
       case DomException:
         return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
       case ReferenceError$1:
         return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
       default:
         return Error;
     }
@@ -1033,14 +919,14 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get(id);
+  const fn = get$1(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
-  remove$1(id);
+  remove$2(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -1067,56 +953,56 @@ const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
-      message: error.message,
-      data: error.stack
+      data: error.stack,
+      message: error.message
     };
   }
   return {
     code: Custom,
-    message: prettyError.message,
     data: {
-      stack: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
       code: prettyError.code,
-      name: prettyError.name
-    }
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
-const create$1 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two$1,
+    error,
     id,
-    error
+    jsonrpc: Two$1
   };
 };
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(id, errorProperty);
+  return create$1$1(id, errorProperty);
 };
-const create$2 = (message, result) => {
+const create$c = (message, result) => {
   return {
-    jsonrpc: Two$1,
     id: message.id,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$2(message, resultProperty);
+  return create$c(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two$1,
-    id,
     error: {
       code: Custom,
+      data: error,
       // @ts-ignore
-      message: error.message,
-      data: error
-    }
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -1146,35 +1032,35 @@ const normalizeParams = args => {
   if (args.length === 1) {
     const options = args[0];
     return {
+      execute: options.execute,
       ipc: options.ipc,
+      logError: options.logError || defaultLogError,
       message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
       preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
   }
   return {
+    execute: args[2],
     ipc: args[0],
+    logError: args[5],
     message: args[1],
-    execute: args[2],
-    resolve: args[3],
     preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    message,
-    ipc,
     execute,
-    resolve,
-    preparePrettyError,
+    ipc,
     logError,
-    requiresSocket
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
   if ('id' in message) {
     if ('method' in message) {
@@ -1197,36 +1083,17 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
 const Two = '2.0';
-const create$s = (method, params) => {
+
+const create$b = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const create$r = (id, method, params) => {
+
+const create$a = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -1235,15 +1102,14 @@ const create$r = (id, method, params) => {
   };
   return message;
 };
+
 let id = 0;
-const create$q = () => {
+const create$9 = () => {
   return ++id;
 };
 
-/* eslint-disable n/no-unsupported-features/es-syntax */
-
 const registerPromise = map => {
-  const id = create$q();
+  const id = create$9();
   const {
     promise,
     resolve
@@ -1255,13 +1121,12 @@ const registerPromise = map => {
   };
 };
 
-// @ts-ignore
 const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
   const {
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$r(id, method, params);
+  const message = create$a(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -1297,12 +1162,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$s(method, params);
+      const message = create$b(method, params);
       ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket$1 = () => {
   return false;
 };
@@ -1317,6 +1183,7 @@ const handleMessage = event => {
   const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -1325,7 +1192,8 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
-const listen$2 = async (module, options) => {
+
+const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
     module.signal(rawIpc);
@@ -1333,14 +1201,15 @@ const listen$2 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$p = async ({
+
+const create$8 = async ({
   commandMap,
   messagePort,
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithElectronMessagePort$1, {
+  const ipc = await listen$1(IpcChildWithElectronMessagePort$1, {
     messagePort
   });
   if (requiresSocket) {
@@ -1350,26 +1219,17 @@ const create$p = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const ElectronMessagePortRpcClient = {
-  __proto__: null,
-  create: create$p
-};
-const create$o = async ({
+
+const create$7 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithElectronUtilityProcess$1);
+  const ipc = await listen$1(IpcChildWithElectronUtilityProcess$1);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
 };
-const ElectronUtilityProcessRpcClient = {
-  __proto__: null,
-  create: create$o
-};
-
-/* eslint-disable @typescript-eslint/no-misused-promises */
 
 const createSharedLazyRpc = factory => {
   let rpcPromise;
@@ -1398,7 +1258,8 @@ const createSharedLazyRpc = factory => {
     }
   };
 };
-const create$k = async ({
+
+const create$6 = async ({
   commandMap,
   getPortTuple,
   send
@@ -1408,44 +1269,39 @@ const create$k = async ({
     port2
   } = await getPortTuple();
   await send(port1);
-  const rpc = create$p({
+  const rpc = create$8({
     commandMap,
     messagePort: port2
   });
   return rpc;
 };
-const create$j = async ({
+
+const create$5 = async ({
   commandMap,
   getPortTuple,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$k({
+    return create$6({
       commandMap,
       getPortTuple,
       send
     });
   });
 };
-const LazyTransferElectronMessagePortRpc = {
-  __proto__: null,
-  create: create$j
-};
-const create$9 = async ({
+
+const create$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithNodeForkedProcess$1);
+  const ipc = await listen$1(IpcChildWithNodeForkedProcess$1);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
 };
-const NodeForkedProcessRpcClient = {
-  __proto__: null,
-  create: create$9
-};
-const create$7 = async ({
+
+const create$3 = async ({
   commandMap,
   handle,
   request,
@@ -1453,7 +1309,7 @@ const create$7 = async ({
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithWebSocket, {
+  const ipc = await listen$1(IpcChildWithWebSocket, {
     handle,
     request
   });
@@ -1464,50 +1320,253 @@ const create$7 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const NodeWebSocketRpcClient = {
-  __proto__: null,
-  create: create$7
-};
-const create$6 = async ({
+
+const create$2 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithNodeWorker$1);
+  const ipc = await listen$1(IpcChildWithNodeWorker$1);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
 };
-const NodeWorkerRpcClient = {
-  __proto__: null,
-  create: create$6
+
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
+};
+
+const rpcs = Object.create(null);
+const set$2 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get = id => {
+  return rpcs[id];
+};
+const remove$1 = id => {
+  delete rpcs[id];
 };
 
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create$1 = rpcId => {
+  return {
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$2(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove$1(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$2(rpcId, rpc);
+    }
+  };
+};
+
+const FileSystemProcess = 210;
+const MainProcess = -5;
+const SharedProcess = 1492;
+
 const {
-  invoke: invoke$2,
+  invoke: invoke$1,
   set: set$1
-} = create$3(MainProcess);
+} = create$1(MainProcess);
 
 const {
-  dispose,
-  invoke: invoke$1,
-  invokeAndTransfer: invokeAndTransfer$1,
+  invoke,
+  invokeAndTransfer,
   set
-} = create$3(SharedProcess$1);
+} = create$1(SharedProcess);
 
-const SharedProcess = {
-  __proto__: null,
-  dispose,
-  invoke: invoke$1,
-  invokeAndTransfer: invokeAndTransfer$1,
-  set
+const state = {
+  id: 0
+};
+const create = () => {
+  return ++state.id;
+};
+
+const ports = Object.create(null);
+const getPortTuple$1 = async () => {
+  const id1 = create();
+  const id2 = create();
+  await invoke('TemporaryMessagePort.getPortTuple3', id1, id2, FileSystemProcess);
+  const port1 = ports[id1];
+  const port2 = ports[id2];
+  delete ports[id1];
+  delete ports[id2];
+  return {
+    port1,
+    port2
+  };
+};
+const handlePorts = (port1, port2, id1, id2) => {
+  number(id1);
+  number(id2);
+  object(port1);
+  object(port2);
+  ports[id1] = port1;
+  ports[id2] = port2;
+};
+
+const getPortTuple = async () => {
+  const {
+    port1,
+    port2
+  } = await getPortTuple$1();
+  return {
+    port1,
+    port2
+  };
+};
+
+const initializeMainProcessRpc = async () => {
+  const rpc = await create$5({
+    commandMap: {},
+    getPortTuple,
+    async send(port) {
+      await invokeAndTransfer('TemporaryMessagePort.sendToElectron', port, MainProcess, FileSystemProcess);
+    }
+  });
+  set$1(rpc);
+};
+
+const assertUri = uri => {
+  if (!uri.startsWith('file://')) {
+    throw new Error(`path must be a valid file uri`);
+  }
+};
+
+const Utf8 = 'utf8';
+
+const ENOENT = 'ENOENT';
+const EXDEV = 'EXDEV';
+
+const getDisplayPath = path => {
+  if (path === '') {
+    return '<empty string>';
+  }
+  return path;
+};
+class FileNotFoundError extends VError {
+  constructor(path) {
+    super(`File not found: '${getDisplayPath(path)}'`);
+    this.code = ENOENT;
+  }
+}
+
+const BlockDevice = 1;
+const CharacterDevice = 2;
+const Directory = 3;
+const Fifo = 6;
+const File = 7;
+const Socket = 8;
+const Symlink = 9;
+const Unknown = 12;
+
+const getDirentType = dirent => {
+  if (dirent.isFile()) {
+    return File;
+  }
+  if (dirent.isDirectory()) {
+    return Directory;
+  }
+  if (dirent.isSymbolicLink()) {
+    return Symlink;
+  }
+  if (dirent.isSocket()) {
+    return Socket;
+  }
+  if (dirent.isBlockDevice()) {
+    return BlockDevice;
+  }
+  if (dirent.isCharacterDevice()) {
+    return CharacterDevice;
+  }
+  if (dirent.isFIFO()) {
+    return Fifo;
+  }
+  return Unknown;
+};
+
+const getFolderSizeInternal = async path => {
+  if (path === '/') {
+    throw new Error('Invalid path for folder size');
+  }
+  let total = 0;
+  try {
+    const stats = await fs.stat(path);
+    total += stats.size;
+    if (stats.isDirectory() && !stats.isSymbolicLink()) {
+      const dirents = await fs.readdir(path);
+      for (const dirent of dirents) {
+        total += await getFolderSizeInternal(join(path, dirent));
+      }
+    }
+  } catch {
+    return 0;
+  }
+  return total;
+};
+
+const isEnoentErrorWindows = error => {
+  if (!error || !error.message) {
+    return false;
+  }
+  return error.message.includes('The system cannot find the path specified.');
+};
+
+const isEnoentErrorLinux = error => {
+  return Boolean(error && error.code === ENOENT);
+};
+const isEnoentError = error => {
+  if (!error) {
+    return false;
+  }
+  return isEnoentErrorLinux(error) || isEnoentErrorWindows(error);
 };
 
 const trash$2 = async path => {
   if (!existsSync(path)) {
     return;
   }
-  await invoke$2('Trash.trash', path);
+  await invoke$1('Trash.trash', path);
 };
 
 // @ts-ignore
@@ -1529,6 +1588,8 @@ const getElectronRunAsNode = () => {
 const isElectron = Boolean(getElectronRunAsNode()) || 'electron' in process.versions;
 
 const trash = async path => {
+  // TODO pass iselectron as parameter
+  // TODO only accept file uris
   if (!path || path.trim() === '') {
     throw new Error('Path cannot be empty');
   }
@@ -1777,55 +1838,12 @@ const unwatchFile = uri => {
   // TODO
 };
 
-const NodeWorker = 1;
-const NodeForkedProcess = 2;
-const ElectronUtilityProcess = 3;
-const ElectronMessagePort = 4;
-const WebSocket = 6;
-const Auto = argv => {
-  if (argv.includes('--ipc-type=node-worker')) {
-    return NodeWorker;
-  }
-  if (argv.includes('--ipc-type=node-forked-process')) {
-    return NodeForkedProcess;
-  }
-  if (argv.includes('--ipc-type=electron-utility-process')) {
-    return ElectronUtilityProcess;
-  }
-  throw new Error(`[file-system-process] unknown ipc type`);
-};
-
-const getModule = method => {
-  switch (method) {
-    case ElectronMessagePort:
-      return ElectronMessagePortRpcClient.create;
-    case ElectronUtilityProcess:
-      return ElectronUtilityProcessRpcClient.create;
-    case NodeForkedProcess:
-      return NodeForkedProcessRpcClient.create;
-    case NodeWorker:
-      return NodeWorkerRpcClient.create;
-    case WebSocket:
-      return NodeWebSocketRpcClient.create;
-    default:
-      throw new Error('unexpected ipc type');
-  }
-};
-
-const listen$1 = async ({
-  method,
-  ...params
-}) => {
-  const create = getModule(method);
-  const rpc = await create(params);
-  return rpc;
-};
-
 const handleElectronMessagePort = async (messagePort, rpcId) => {
   object(messagePort);
-  const rpc = await listen$1({
+  const rpc = await create$8({
+    commandMap: {},
     messagePort,
-    method: ElectronMessagePort
+    requiresSocket: false
   });
   if (rpcId) {
     set$2(rpcId, rpc);
@@ -1838,75 +1856,16 @@ const requiresSocket = method => {
 const handleWebSocket = async (handle, request) => {
   object(handle);
   object(request);
-  await listen$1({
+  await create$3({
+    commandMap: {},
     handle,
-    method: WebSocket,
     request,
     requiresSocket
   });
 };
 
-const state = {
-  id: 0
-};
-const create = () => {
-  return ++state.id;
-};
-
-const {
-  invoke,
-  invokeAndTransfer} = SharedProcess;
-
-const ports = Object.create(null);
-const getPortTuple$1 = async () => {
-  const id1 = create();
-  const id2 = create();
-  // @ts-ignore
-  await invoke('TemporaryMessagePort.getPortTuple3', id1, id2, FileSystemProcess);
-  const port1 = ports[id1];
-  const port2 = ports[id2];
-  delete ports[id1];
-  delete ports[id2];
-  return {
-    port1,
-    port2
-  };
-};
-const handlePorts = (port1, port2, id1, id2) => {
-  number(id1);
-  number(id2);
-  object(port1);
-  object(port2);
-  ports[id1] = port1;
-  ports[id2] = port2;
-};
-
-const getPortTuple = async () => {
-  const {
-    port1,
-    port2
-  } = await getPortTuple$1();
-  return {
-    port1,
-    port2
-  };
-};
-
-const createMainProcessRpc = async () => {
-  const rpc = await LazyTransferElectronMessagePortRpc.create({
-    commandMap: {},
-    getPortTuple,
-    async send(port) {
-      await invokeAndTransfer(
-      // @ts-ignore
-      'TemporaryMessagePort.sendToElectron', port, MainProcess, FileSystemProcess);
-    }
-  });
-  set$1(rpc);
-};
-
 const initialize = async () => {
-  await createMainProcessRpc();
+  // TODO this function is not needed anymore
 };
 
 const commandMap = {
@@ -1933,11 +1892,32 @@ const commandMap = {
   'TemporaryMessagePort.handlePorts': handlePorts
 };
 
+const getRpc = argv => {
+  if (argv.includes('--ipc-type=node-worker')) {
+    return create$2({
+      commandMap: commandMap
+    });
+  }
+  if (argv.includes('--ipc-type=node-forked-process')) {
+    return create$4({
+      commandMap: commandMap
+    });
+  }
+  if (argv.includes('--ipc-type=electron-utility-process')) {
+    return create$7({
+      commandMap: commandMap
+    });
+  }
+  throw new Error(`[file-system-process] unknown ipc type`);
+};
+const initializeParentProcessRpc = async argv => {
+  const rpc = await getRpc(argv);
+  // TODO we don't know at this point if we have been launched by shared process or electron main process
+  set(rpc);
+};
+
 const listen = async argv => {
-  await listen$1({
-    commandMap: commandMap,
-    method: Auto(argv)
-  });
+  await Promise.all([initializeParentProcessRpc(argv), initializeMainProcessRpc()]);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-process",
-  "version": "4.1.0",
+  "version": "5.1.0",
   "description": "File System Process",
   "keywords": [
     "Lvce Editor",
@@ -18,10 +18,10 @@
     "file-system-process": "bin/fileSystemProcess.js"
   },
   "dependencies": {
-    "trash": "^10.0.1",
-    "ws": "^8.19.0"
+    "trash": "^10.1.1",
+    "ws": "^8.20.0"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   }
 }