@lvce-editor/shared-process 0.106.3 → 0.107.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.106.3",
+  "version": "0.107.0",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,16 +18,15 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "1.9.0",
-    "@lvce-editor/extension-host-helper-process": "0.106.3",
+    "@lvce-editor/extension-host-helper-process": "0.107.0",
     "@lvce-editor/ipc": "16.12.0",
     "@lvce-editor/json-rpc": "8.7.0",
     "@lvce-editor/jsonc-parser": "1.5.0",
     "@lvce-editor/pretty-error": "2.0.0",
     "@lvce-editor/process-explorer": "3.19.0",
-    "@lvce-editor/rpc-registry": "9.52.0",
+    "@lvce-editor/rpc-registry": "9.54.0",
     "@lvce-editor/verror": "1.7.0",
     "is-object": "^1.0.2",
-    "markdown-it": "^15.0.0",
     "xdg-basedir": "^5.1.0"
   },
   "optionalDependencies": {

package/src/parts/BuiltinExtensionsPath/BuiltinExtensionsPath.js

@@ -3,6 +3,6 @@ import { fileURLToPath } from 'url'
 
 export const getBuiltinExtensionsPath = () => {
   const staticServerPath = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'))
-  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', 'b5bf759', 'extensions')
+  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '64c8cbf', 'extensions')
   return builtinExtensionsPath
 }

package/src/parts/ExtensionNodeProcessIpc/ExtensionNodeProcessIpc.js

@@ -0,0 +1,15 @@
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcParent from '../IpcParent/IpcParent.js'
+import * as ResolveExtensionNodeProcess from '../ResolveExtensionNodeProcess/ResolveExtensionNodeProcess.js'
+
+export const create = async ({ extensionId, method, rpcId }     ) => {
+  const { name, path } = await ResolveExtensionNodeProcess.resolveExtensionNodeProcess(extensionId, rpcId)
+  const ipc = await IpcParent.create({
+    execArgv: [],
+    method,
+    name,
+    path,
+  })
+  HandleIpc.handleIpc(ipc)
+  return ipc
+}

package/src/parts/HandleMessagePortForExtensionNodeProcess/HandleMessagePortForExtensionNodeProcess.ipc.js

@@ -0,0 +1,7 @@
+import * as HandleMessagePortForExtensionNodeProcess from './HandleMessagePortForExtensionNodeProcess.js'
+
+export const name = 'HandleMessagePortForExtensionNodeProcess'
+
+export const Commands = {
+  handleMessagePortForExtensionNodeProcess: HandleMessagePortForExtensionNodeProcess.handleMessagePortForExtensionNodeProcess,
+}

package/src/parts/HandleMessagePortForExtensionNodeProcess/HandleMessagePortForExtensionNodeProcess.js

@@ -0,0 +1,35 @@
+import * as Assert from '../Assert/Assert.js'
+import * as ExtensionNodeProcessIpc from '../ExtensionNodeProcessIpc/ExtensionNodeProcessIpc.js'
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+export const handleMessagePortForExtensionNodeProcess = async (
+  rendererWorkerIpc,
+  port,
+  extensionId,
+  rpcId,
+) => {
+  Assert.object(port)
+  Assert.string(extensionId)
+  Assert.string(rpcId)
+  const ipc = await ExtensionNodeProcessIpc.create({
+    extensionId,
+    method: IpcParentType.ElectronUtilityProcess,
+    rpcId,
+  })
+  const dispose = () => {
+    ipc.dispose()
+  }
+  const removeRendererCloseListener = () => {
+    rendererWorkerIpc.off('close', dispose)
+  }
+  rendererWorkerIpc.on('close', dispose)
+  ipc.on('close', removeRendererCloseListener)
+  try {
+    await JsonRpc.invokeAndTransfer(ipc, 'NodeRpcProcess.handleElectronMessagePort', port)
+  } catch (error) {
+    removeRendererCloseListener()
+    ipc.dispose()
+    throw error
+  }
+}

package/src/parts/HandleWebSocketForExtensionNodeProcess/HandleWebSocketForExtensionNodeProcess.js

@@ -0,0 +1,23 @@
+import * as ExtensionNodeProcessIpc from '../ExtensionNodeProcessIpc/ExtensionNodeProcessIpc.js'
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+export const handleWebSocket = async (message, handle) => {
+  const url = new URL(message.url, 'http://localhost')
+  const extensionId = url.searchParams.get('extensionId')
+  const rpcId = url.searchParams.get('rpcId')
+  if (!extensionId || !rpcId) {
+    throw new Error('Remote extension node process request is incomplete')
+  }
+  const ipc = await ExtensionNodeProcessIpc.create({
+    extensionId,
+    method: IpcParentType.NodeForkedProcess,
+    rpcId,
+  })
+  try {
+    await JsonRpc.invokeAndTransfer(ipc, 'NodeRpcProcess.handleWebSocket', handle, message)
+  } catch (error) {
+    ipc.dispose()
+    throw error
+  }
+}

package/src/parts/HandleWebSocketModule/HandleWebSocketModule.js

@@ -1,5 +1,6 @@
 import * as HandleWebSocketForClipBoardProcess from '../HandleWebSocketForClipBoardProcess/HandleWebSocketForClipBoardProcess.js'
 import * as HandleWebSocketForExtensionHostHelperProcess from '../HandleWebSocketForExtensionHostHelperProcess/HandleWebSocketForExtensionHostHelperProcess.js'
+import * as HandleWebSocketForExtensionNodeProcess from '../HandleWebSocketForExtensionNodeProcess/HandleWebSocketForExtensionNodeProcess.js'
 import * as HandleWebSocketForFileSystemProcess from '../HandleWebSocketForFileSystemProcess/HandleWebSocketForFileSystemProcess.js'
 import * as HandleWebSocketForProcessExplorer from '../HandleWebSocketForProcessExplorer/HandleWebSocketForProcessExplorer.js'
 import * as HandleWebSocketForSearchProcess from '../HandleWebSocketForSearchProcess/HandleWebSocketForSearchProcess.js'
@@ -18,6 +19,8 @@ export const load = (protocol) => {
       return HandleWebSocketForClipBoardProcess
     case ProtocolType.ExtensionHostHelperProcess:
       return HandleWebSocketForExtensionHostHelperProcess
+    case ProtocolType.ExtensionNodeProcess:
+      return HandleWebSocketForExtensionNodeProcess
     case ProtocolType.FileSystemProcess:
       return HandleWebSocketForFileSystemProcess
     case ProtocolType.ProcessExplorer:

package/src/parts/IsAllowedWebSocketOrigin/IsAllowedWebSocketOrigin.js

@@ -34,15 +34,14 @@ export const isAllowedWebSocketOrigin = (request) => {
   if (!origin) {
     return false
   }
-  try {
-    const url = new URL(origin)
-    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-      return false
-    }
-    const originHost = url.host.toLowerCase()
-    const allowedHosts = getAllowedHosts(headers)
-    return allowedHosts.includes(originHost)
-  } catch {
+  if (!URL.canParse(origin)) {
+    return false
+  }
+  const url = new URL(origin)
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
     return false
   }
+  const originHost = url.host.toLowerCase()
+  const allowedHosts = getAllowedHosts(headers)
+  return allowedHosts.includes(originHost)
 }

package/src/parts/LanguageServerConnection/LanguageServerConnection.js

@@ -2,10 +2,6 @@ import { spawn,                                     } from 'node:child_process'
 import { basename, extname } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { LanguageServerMessageParser } from '../LanguageServerMessageParser/LanguageServerMessageParser.js'
-import {
-  executeMarkdownLanguageServerRequest,
-  isMarkdownLanguageServerRequest,
-} from '../MarkdownLanguageServerRequest/MarkdownLanguageServerRequest.js'
 import { normalizeLanguageServerDocumentUri } from '../NormalizeLanguageServerDocumentUri/NormalizeLanguageServerDocumentUri.js'
 
                           
@@ -165,7 +161,6 @@ export class LanguageServerConnection {
                    ready               
                    rootUri        
           initializationProgressWasStarted = false
-          markdownConfigured = false
           nextRequestId = 1
           running = true
           stderr = ''
@@ -236,7 +231,6 @@ export class LanguageServerConnection {
 
   async complete(textDocument, offset)                              {
     await this.ready
-    this.configureMarkdown(textDocument.languageId)
     this.syncDocument(textDocument)
     const result = await this.sendRequest('textDocument/completion', {
       context: {
@@ -258,7 +252,6 @@ export class LanguageServerConnection {
 
   async diagnostic(textDocument)                              {
     await this.ready
-    this.configureMarkdown(textDocument.languageId)
     if (this.supportsPullDiagnostics) {
       this.syncDocument(textDocument)
       const result = await this.sendRequest('textDocument/diagnostic', {
@@ -286,7 +279,6 @@ export class LanguageServerConnection {
 
   async definition(textDocument, offset)                   {
     await this.ready
-    this.configureMarkdown(textDocument.languageId)
     this.syncDocument(textDocument)
     return this.sendRequest('textDocument/definition', {
       position: getPosition(textDocument.text, offset),
@@ -346,52 +338,6 @@ export class LanguageServerConnection {
     return Array.isArray(result) ? result : []
   }
 
-          configureMarkdown(languageId)       {
-    if (languageId !== 'markdown' || this.markdownConfigured) {
-      return
-    }
-    this.markdownConfigured = true
-    this.sendNotification('workspace/didChangeConfiguration', {
-      settings: {
-        markdown: {
-          occurrencesHighlight: {
-            enabled: true,
-          },
-          preferredMdPathExtensionStyle: 'auto',
-          server: {
-            log: 'off',
-          },
-          suggest: {
-            paths: {
-              enabled: true,
-              includeWorkspaceHeaderCompletions: 'never',
-            },
-          },
-          validate: {
-            duplicateLinkDefinitions: {
-              enabled: 'warning',
-            },
-            enabled: true,
-            fileLinks: {
-              enabled: 'warning',
-              markdownFragmentLinks: 'inherit',
-            },
-            fragmentLinks: {
-              enabled: 'warning',
-            },
-            ignoredLinks: [],
-            referenceLinks: {
-              enabled: 'warning',
-            },
-            unusedLinkDefinitions: {
-              enabled: 'warning',
-            },
-          },
-        },
-      },
-    })
-  }
-
           async initialize()                {
     const result = (await this.sendRequest('initialize', {
       capabilities: {
@@ -530,7 +476,7 @@ export class LanguageServerConnection {
       return
     }
     if (message.method && message.id !== undefined && message.id !== null) {
-      void this.handleServerRequest(message)
+      this.handleServerRequest(message)
       return
     }
     if (message.id === undefined || message.id === null) {
@@ -579,7 +525,7 @@ export class LanguageServerConnection {
     this.initializationProgressEnded.resolve()
   }
 
-          async handleServerRequest(message)                {
+          handleServerRequest(message)       {
     try {
       let result          = null
       if (message.method === 'workspace/configuration') {
@@ -595,11 +541,6 @@ export class LanguageServerConnection {
             uri: this.rootUri,
           },
         ]
-      } else if (isMarkdownLanguageServerRequest(message.method || '')) {
-        result = await executeMarkdownLanguageServerRequest(message.method || '', message.params || {}, {
-          documents: this.documents,
-          rootUri: this.rootUri,
-        })
       }
       this.sendMessage({
         id: message.id,

package/src/parts/Module/Module.js

@@ -12,8 +12,6 @@ export const load = (moduleId) => {
       return import('../AutoUpdaterWindowsNsis/AutoUpdaterWindowsNsis.ipc.js')
     case ModuleId.BulkReplacement:
       return import('../BulkReplacement/BulkReplacement.ipc.js')
-    case ModuleId.ChromeCookieImport:
-      return import('../ChromeCookieImport/ChromeCookieImport.ipc.js')
     case ModuleId.ClipBoard:
       return import('../ClipBoard/ClipBoard.ipc.js')
     case ModuleId.ContentSecurityPolicy:
@@ -90,6 +88,8 @@ export const load = (moduleId) => {
       return import('../HandleMessagePortForEmbedsProcess/HandleMessagePortForEmbedsProcess.ipc.js')
     case ModuleId.HandleMessagePortForExtensionHostHelperProcess:
       return import('../HandleMessagePortForExtensionHostHelperProcess/HandleMessagePortForExtensionHostHelperProcess.ipc.js')
+    case ModuleId.HandleMessagePortForExtensionNodeProcess:
+      return import('../HandleMessagePortForExtensionNodeProcess/HandleMessagePortForExtensionNodeProcess.ipc.js')
     case ModuleId.HandleMessagePortForFileSystemProcess:
       return import('../HandleMessagePortForFileSystemProcess/HandleMessagePortForFileSystemProcess.ipc.js')
     case ModuleId.HandleMessagePortForProcessExplorer:

package/src/parts/ModuleId/ModuleId.js

@@ -80,6 +80,6 @@ export const HandleMessagePortForAuthProcess = 86
 export const LanguageServer = 87
 export const SendMessagePortToMainProcess = 88
 export const SecretStorage = 89
-export const ChromeCookieImport = 90
 export const FirefoxCookieImport = 91
 export const IpcTrace = 92
+export const HandleMessagePortForExtensionNodeProcess = 93

package/src/parts/ModuleMap/ModuleMap.js

@@ -18,9 +18,6 @@ export const getModuleId = (commandId) => {
       return ModuleId.AutoUpdaterWindowsNsis
     case 'BulkReplacement.applyBulkReplacement':
       return ModuleId.BulkReplacement
-    case 'ChromeCookieImport.getInfo':
-    case 'ChromeCookieImport.importCookies':
-      return ModuleId.ChromeCookieImport
     case 'ChromeExtension.install':
     case 'ChromeExtension.uninstall':
       return ModuleId.ChromeExtension
@@ -187,6 +184,8 @@ export const getModuleId = (commandId) => {
     case 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess':
     case 'HandleMessagePortForExtensionHostHelperProcess.handlePreloadedMessagePortForExtensionHostHelperProcess':
       return ModuleId.HandleMessagePortForExtensionHostHelperProcess
+    case 'HandleMessagePortForExtensionNodeProcess.handleMessagePortForExtensionNodeProcess':
+      return ModuleId.HandleMessagePortForExtensionNodeProcess
     case 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess':
       return ModuleId.HandleMessagePortForFileSystemProcess
     case 'HandleMessagePortForProcessExplorer.handleMessagePortForProcessExplorer':

package/src/parts/NormalizeLanguageServerDocumentUri/NormalizeLanguageServerDocumentUri.js

@@ -3,14 +3,13 @@ import { pathToFileURL } from 'node:url'
 const windowsFileUriRegex = /^file:\/\/\/([a-z])(?::|%3a)(?=\/|$)/i
 
 const normalizeRemoteFileUrl = (uri) => {
-  try {
-    const url = new URL(uri)
-    if ((url.protocol === 'http:' || url.protocol === 'https:') && url.pathname.startsWith('/remote/')) {
-      return `file://${url.pathname.slice('/remote'.length)}`
-    }
-  } catch {
+  if (!URL.canParse(uri)) {
     return undefined
   }
+  const url = new URL(uri)
+  if ((url.protocol === 'http:' || url.protocol === 'https:') && url.pathname.startsWith('/remote/')) {
+    return `file://${url.pathname.slice('/remote'.length)}`
+  }
   return undefined
 }
 

package/src/parts/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.106.3'
+export const version = '0.107.0'
 
-export const commit = 'b5bf759'
+export const commit = '64c8cbf'
 
-export const date = '2026-08-22T14:34:18.000Z'
+export const date = '2026-08-22T16:38:17.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/PreloadUrl/PreloadUrl.js

@@ -2,5 +2,5 @@ import { join } from 'node:path'
 import * as Root from '../Root/Root.js'
 
 export const getPreloadUrl = () => {
-  return join(Root.root, 'static', 'b5bf759', 'packages', 'preload', 'dist', 'index.js')
+  return join(Root.root, 'static', '64c8cbf', 'packages', 'preload', 'dist', 'index.js')
 }

package/src/parts/ProtocolType/ProtocolType.js

@@ -1,5 +1,6 @@
 export const ExtensionHost = 'extension-host'
 export const ExtensionHostHelperProcess = 'extension-host-helper-process'
+export const ExtensionNodeProcess = 'extension-node-process'
 export const SearchProcess = 'search-process'
 export const ProcessExplorer = 'process-explorer'
 export const FileSystemProcess = 'file-system-process'

package/src/parts/RequiresSocket/RequiresSocket.js

@@ -11,6 +11,7 @@ const METHODS_THAT_REQUIRE_SOCKET = new Set([
   'IncrementalTextSearch.start',
   'ElectronApplicationMenu.setItems',
   'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess',
+  'HandleMessagePortForExtensionNodeProcess.handleMessagePortForExtensionNodeProcess',
   'ElectronBrowserView.createBrowserView',
   'ElectronWebContentsView.createWebContentsView',
   'FileWatcher.dispose',

package/src/parts/ResolveExtensionNodeProcess/ResolveExtensionNodeProcess.js

@@ -0,0 +1,55 @@
+import { readFile, realpath } from 'node:fs/promises'
+import path from 'node:path'
+import * as ExtensionManagement from '../ExtensionManagement/ExtensionManagement.js'
+
+const idRegex = /^[A-Za-z0-9][A-Za-z0-9._-]*$/
+const schemeRegex = /^[A-Za-z][A-Za-z\d+.-]*:/
+
+const isInside = (parent, child) => child === parent || child.startsWith(`${parent}${path.sep}`)
+
+const validateId = (value, name) => {
+  if (!idRegex.test(value)) {
+    throw new Error(`Invalid extension node process ${name}`)
+  }
+}
+
+const getExtension = async (extensionId) => {
+  const extensions = await ExtensionManagement.getExtensions()
+  const extension = extensions.find((candidate) => candidate?.id === extensionId)
+  if (!extension || typeof extension.path !== 'string') {
+    throw new Error(`Extension ${extensionId} is not installed`)
+  }
+  return extension
+}
+
+                                           
+                       
+                       
+ 
+
+export const resolveExtensionNodeProcess = async (extensionId, rpcId) => {
+  validateId(extensionId, 'extension id')
+  validateId(rpcId, 'rpc id')
+  const extension = await getExtension(extensionId)
+  const extensionRoot = await realpath(extension.path)
+  const manifestPath = await realpath(path.join(extensionRoot, 'extension.json'))
+  if (!isInside(extensionRoot, manifestPath)) {
+    throw new Error('Extension manifest escapes the extension root')
+  }
+  const manifest = JSON.parse(await readFile(manifestPath, 'utf8'))
+  const rpc = manifest.rpc?.find((candidate) => candidate?.id === rpcId)
+  if (!rpc || rpc.type !== 'node-process' || typeof rpc.url !== 'string') {
+    throw new Error(`Node process ${rpcId} is not declared by extension ${extensionId}`)
+  }
+  if (!rpc.url || path.isAbsolute(rpc.url) || path.win32.isAbsolute(rpc.url) || schemeRegex.test(rpc.url)) {
+    throw new Error(`Node process ${rpcId} must use a relative url`)
+  }
+  const processPath = await realpath(path.resolve(extensionRoot, rpc.url))
+  if (!isInside(extensionRoot, processPath)) {
+    throw new Error('Extension node process path escapes the extension root')
+  }
+  return {
+    name: `Extension ${extensionId}: ${typeof rpc.name === 'string' && rpc.name ? rpc.name : rpcId}`,
+    path: processPath,
+  }
+}

package/src/parts/ChromeCookieImport/ChromeCookieImport.ipc.js

@@ -1,8 +0,0 @@
-import * as ChromeCookieImport from './ChromeCookieImport.js'
-
-export const name = 'ChromeCookieImport'
-
-export const Commands = {
-  getInfo: ChromeCookieImport.getInfo,
-  importCookies: ChromeCookieImport.importCookies,
-}

package/src/parts/ChromeCookieImport/ChromeCookieImport.js

@@ -1,9 +0,0 @@
-import * as MainProcess from '../MainProcess/MainProcess.js'
-
-export const getInfo = () => {
-  return MainProcess.invoke('ChromeCookieImport.getInfo')
-}
-
-export const importCookies = () => {
-  return MainProcess.invoke('ChromeCookieImport.importCookies')
-}

package/src/parts/MarkdownLanguageServerRequest/MarkdownLanguageServerRequest.js

@@ -1,121 +0,0 @@
-import MarkdownIt from 'markdown-it'
-import { readFile, readdir, stat } from 'node:fs/promises'
-import { isAbsolute, relative, resolve, sep } from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
-
-                         
-                       
- 
-
-                                                       
-                                                        
-                          
- 
-
-                                 
-                        
-                       
- 
-
-const markdownFileExtensions = new Set(['.markdown', '.md', '.mdown', '.mdtext', '.mdtxt', '.mdwn', '.mkd', '.mkdn'])
-const ignoredDirectories = new Set(['.git', 'node_modules'])
-const markdownIt = new MarkdownIt({ html: true })
-
-export const isMarkdownLanguageServerRequest = (method) => {
-  return (
-    method === 'markdown/parse' ||
-    method === 'markdown/fs/readFile' ||
-    method === 'markdown/fs/readDirectory' ||
-    method === 'markdown/fs/stat' ||
-    method === 'markdown/fs/watcher/create' ||
-    method === 'markdown/fs/watcher/delete' ||
-    method === 'markdown/findMarkdownFilesInWorkspace'
-  )
-}
-
-const getWorkspacePath = (uri, rootUri) => {
-  const rootPath = resolve(fileURLToPath(rootUri))
-  const targetPath = resolve(fileURLToPath(uri))
-  const relativePath = relative(rootPath, targetPath)
-  if (relativePath === '..' || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
-    throw new Error(`Language server file request is outside the workspace`)
-  }
-  return targetPath
-}
-
-const getMarkdownText = async (params, context) => {
-  if (typeof params.text === 'string') {
-    return params.text
-  }
-  if (!params.uri) {
-    throw new Error(`Markdown parse request is missing a uri`)
-  }
-  const document = context.documents.get(params.uri)
-  if (document) {
-    return document.text
-  }
-  const path = getWorkspacePath(params.uri, context.rootUri)
-  return readFile(path, 'utf8')
-}
-
-const findMarkdownFiles = async (rootPath) => {
-  const result           = []
-  const visit = async (directory) => {
-    const entries = await readdir(directory, { withFileTypes: true })
-    await Promise.all(
-      entries.map(async (entry) => {
-        const path = resolve(directory, entry.name)
-        if (entry.isDirectory()) {
-          if (ignoredDirectories.has(entry.name)) {
-            return
-          }
-          await visit(path)
-          return
-        }
-        const extensionIndex = entry.name.lastIndexOf('.')
-        const extension = extensionIndex === -1 ? '' : entry.name.slice(extensionIndex).toLowerCase()
-        if (markdownFileExtensions.has(extension)) {
-          result.push(pathToFileURL(path).href)
-        }
-      }),
-    )
-  }
-  await visit(rootPath)
-  return result.sort()
-}
-
-export const executeMarkdownLanguageServerRequest = async (
-  method,
-  params,
-  context,
-) => {
-  if (method === 'markdown/parse') {
-    return markdownIt.parse(await getMarkdownText(params, context), {})
-  }
-  if (method === 'markdown/findMarkdownFilesInWorkspace') {
-    return findMarkdownFiles(getWorkspacePath(context.rootUri, context.rootUri))
-  }
-  if (method === 'markdown/fs/watcher/create' || method === 'markdown/fs/watcher/delete') {
-    return null
-  }
-  if (!params.uri) {
-    throw new Error(`Markdown file request is missing a uri`)
-  }
-  const path = getWorkspacePath(params.uri, context.rootUri)
-  if (method === 'markdown/fs/readFile') {
-    return [...(await readFile(path))]
-  }
-  if (method === 'markdown/fs/readDirectory') {
-    const entries = await readdir(path, { withFileTypes: true })
-    return entries.map((entry) => [entry.name, { isDirectory: entry.isDirectory() }])
-  }
-  if (method === 'markdown/fs/stat') {
-    try {
-      const fileStat = await stat(path)
-      return { isDirectory: fileStat.isDirectory() }
-    } catch {
-      return undefined
-    }
-  }
-  throw new Error(`Unsupported Markdown language server request: ${method}`)
-}