diff --git a/packages/typecheck/src/cli.ts b/packages/typecheck/src/cli.ts
index 5b6075d3..bf7c26e1 100644
--- a/packages/typecheck/src/cli.ts
+++ b/packages/typecheck/src/cli.ts
@@ -62,8 +62,8 @@ function formatLocation(
   start: TS.server.protocol.Location,
 ): string {
   const relativeFileName = convertToRelativePath(fileName)
-  const line = start.line + 1
-  const column = start.offset + 1
+  const line = start.line
+  const column = start.offset
 
   let output = ''
   output += chalk.cyan(relativeFileName)
diff --git a/packages/typescript-plugin-vue/src/contracts/TypeScript.ts b/packages/typescript-plugin-vue/src/contracts/TypeScript.ts
index 475924f2..cb569e34 100644
--- a/packages/typescript-plugin-vue/src/contracts/TypeScript.ts
+++ b/packages/typescript-plugin-vue/src/contracts/TypeScript.ts
@@ -4,11 +4,7 @@ import type { TS_LANGUAGE_SERVICE } from '../constants'
 export { TypeScript }
 export type TSLanguageService = TypeScript.LanguageService
 export type TSLanguageServiceHost = TypeScript.LanguageServiceHost
-export type TSProject = TypeScript.server.Project & {
-  getParsedCommandLine?(
-    fileName: string,
-  ): TypeScript.ParsedCommandLine | undefined
-}
+export type TSProject = TypeScript.server.Project
 export type TSServerHost = TypeScript.server.ServerHost
 export interface ExtendedTSLanguageService extends TSLanguageService {
   [TS_LANGUAGE_SERVICE](): TSLanguageService
diff --git a/packages/typescript-plugin-vue/src/features/TemplateCompletionsService.ts b/packages/typescript-plugin-vue/src/features/TemplateCompletionsService.ts
deleted file mode 100644
index 8f2c304c..00000000
--- a/packages/typescript-plugin-vue/src/features/TemplateCompletionsService.ts
+++ /dev/null
@@ -1,129 +0,0 @@
-import { getComponentName } from '@vuedx/shared'
-import {
-  ElementNode,
-  findTemplateNodeAt,
-  isElementNode,
-} from '@vuedx/template-ast-types'
-import { inject, injectable } from 'inversify'
-import * as Path from 'path'
-import type { CompletionItem, Range } from 'vscode-languageserver-types'
-import { FilesystemService } from '../services/FilesystemService'
-import { LoggerService } from '../services/LoggerService'
-import { TypescriptContextService } from '../services/TypescriptContextService'
-
-@injectable()
-export class TemplateCompletionsService {
-  private readonly logger = LoggerService.getLogger('Completions')
-  private readonly cache = new Map<string, CompletionItem[]>()
-
-  constructor(
-    @inject(TypescriptContextService)
-    private readonly ts: TypescriptContextService,
-    @inject(FilesystemService)
-    private readonly fs: FilesystemService,
-  ) {
-    this.logger.debug('TepmlateCompletion')
-  }
-
-  public getLocalComponents(
-    fileName: string,
-    position: number,
-  ): CompletionItem[] | undefined {
-    const vueFile = this.fs.getVueFile(fileName)
-    const program = this.ts.service.getProgram()
-    const tsProject = this.ts.getProjectFor(fileName)
-    if (program == null || tsProject == null || vueFile == null) {
-      return undefined
-    }
-    const key = `components:${fileName}:${tsProject.getScriptVersion(
-      fileName,
-    )}:${position}`
-    if (this.cache.has(key)) return this.cache.get(key)
-
-    const dir = Path.posix.dirname(fileName)
-
-    const content = vueFile.getText()
-    const openTagIndex = content.substr(0, position).lastIndexOf('<')
-    if (openTagIndex < 0) return []
-    const lastTag = content.substring(openTagIndex, position)
-    if (/[\s\n]/.test(lastTag)) return []
-    const isClosingTag = lastTag.startsWith('</')
-    const completions: CompletionItem[] = []
-
-    const replacementRange = {
-      start: vueFile.positionAt(openTagIndex),
-      end: vueFile.positionAt(position),
-    }
-
-    if (isClosingTag && vueFile.templateAST != null) {
-      const ast = vueFile.templateAST
-      const { node, ancestors } = findTemplateNodeAt(ast, position)
-      if (isElementNode(node)) {
-        completions.push(
-          this.createClosingTagCompletionItem(node, replacementRange),
-        )
-        ancestors.forEach(({ node }) => {
-          if (isElementNode(node)) {
-            const tag = `</${node.tag}>`
-            completions.push({
-              label: tag,
-              kind: 1,
-              preselect: true,
-              sortText: '0',
-              textEdit: {
-                range: replacementRange,
-                newText: tag,
-              },
-            })
-          }
-        })
-      }
-    } else {
-      // const { tagCase } = this.ts.getVueProjectFor(
-      //   fileName,
-      // ).config.preferences.template
-
-      program.getSourceFiles().forEach(({ fileName }) => {
-        if (!this.fs.isVueFile(fileName)) return
-        const sortText = this.getRelativeFileName(dir, fileName)
-        const name = getComponentName(fileName)
-
-        // TODO: Support <script> environment for autocomplete.
-
-        completions.push({
-          label: name,
-          sortText,
-          textEdit: {
-            range: replacementRange,
-            newText: name,
-          },
-        })
-      })
-    }
-
-    this.cache.set(key, completions)
-
-    return completions
-  }
-
-  private createClosingTagCompletionItem(
-    node: ElementNode,
-    replacementRange: Range,
-  ): CompletionItem {
-    return {
-      label: `</${node.tag}>`,
-      kind: 1,
-      sortText: '0',
-      textEdit: {
-        range: replacementRange,
-        newText: `</${node.tag}>`,
-      },
-    }
-  }
-
-  private getRelativeFileName(dir: string, fileName: string): string {
-    const relName = Path.posix.relative(dir, fileName)
-
-    return relName.startsWith('.') ? relName : `./${relName}`
-  }
-}
diff --git a/packages/typescript-plugin-vue/src/helpers/createFilesystemProvider.ts b/packages/typescript-plugin-vue/src/helpers/createFilesystemProvider.ts
index e20b8341..9abf3b50 100644
--- a/packages/typescript-plugin-vue/src/helpers/createFilesystemProvider.ts
+++ b/packages/typescript-plugin-vue/src/helpers/createFilesystemProvider.ts
@@ -10,13 +10,13 @@ const watchers = new Map<
 >()
 
 export function createFilesystemProvider(
-  projectService: TypeScript.server.ProjectService,
   serverHost: TypeScript.server.ServerHost,
+  projectService?: TypeScript.server.ProjectService,
 ): FilesystemProvider {
   const logger = LoggerService.getLogger('virtualFs')
 
   const fix = (fileName: string): void => {
-    const scriptInfo = projectService.getScriptInfo(fileName)
+    const scriptInfo = projectService?.getScriptInfo(fileName)
     if (scriptInfo == null) return
     overrideMethod(
       scriptInfo,
@@ -42,7 +42,7 @@ export function createFilesystemProvider(
   const fs: FilesystemProvider = {
     exists(fileName) {
       const result =
-        projectService.getScriptInfo(fileName) != null ||
+        projectService?.getScriptInfo(fileName) != null ||
         serverHost.fileExists(fileName)
 
       logger.debug(`${result ? 'Y' : 'N'} = exists(${fileName})`)
@@ -50,7 +50,7 @@ export function createFilesystemProvider(
       return result
     },
     read(fileName) {
-      const snapshot = projectService.getScriptInfo(fileName)?.getSnapshot()
+      const snapshot = projectService?.getScriptInfo(fileName)?.getSnapshot()
       if (snapshot == null) return serverHost.readFile(fileName) ?? ''
       return snapshot.getText(0, snapshot.getLength())
     },
diff --git a/packages/typescript-plugin-vue/src/index.ts b/packages/typescript-plugin-vue/src/index.ts
index 03f41ada..7b58e154 100644
--- a/packages/typescript-plugin-vue/src/index.ts
+++ b/packages/typescript-plugin-vue/src/index.ts
@@ -10,7 +10,6 @@ console.log =
 import 'reflect-metadata'
 
 import { Telemetry } from '@vuedx/shared'
-import * as Path from 'path'
 import type { Modules, PluginCreateInfo, TS } from './interfaces'
 import type { PluginConfig } from './managers/ConfigManager'
 import { pluginManager } from './managers/PluginManager'
@@ -30,12 +29,17 @@ export default function init({ typescript }: Modules): TS.server.PluginModule {
     { typescriptVersion: typescript.versionMajorMinor },
   )
 
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const { resolve } = require('node:path') as {
+    resolve: typeof import('node:path').resolve
+  }
+
   return {
     create(info: PluginCreateInfo) {
       return pluginManager.create({
         ...info,
         typescript,
-        typesDir: Path.resolve(__dirname, '..', 'runtime'),
+        typesDir: resolve(__dirname, '..', 'runtime'),
       })
     },
     getExternalFiles(project) {
diff --git a/packages/typescript-plugin-vue/src/managers/PluginManager.ts b/packages/typescript-plugin-vue/src/managers/PluginManager.ts
index faf69909..a1516c06 100644
--- a/packages/typescript-plugin-vue/src/managers/PluginManager.ts
+++ b/packages/typescript-plugin-vue/src/managers/PluginManager.ts
@@ -1,4 +1,4 @@
-import { first, setDebugging } from '@vuedx/shared'
+import { first, invariant, setDebugging } from '@vuedx/shared'
 import { Container } from 'inversify'
 import { TS_LANGUAGE_SERVICE } from '../constants'
 import type {
@@ -15,7 +15,12 @@ import { TypescriptContextService } from '../services/TypescriptContextService'
 import { TypescriptPluginService } from '../services/TypescriptPluginService'
 import { ConfigManager, PluginConfig } from './ConfigManager'
 
-export interface Options extends TypeScript.server.PluginCreateInfo {
+export interface Options {
+  project?: TSProject
+  languageService: TSLanguageService
+  languageServiceHost: TSLanguageServiceHost
+  serverHost: TSServerHost
+  config: PluginConfig
   typescript: typeof TypeScript
   typesDir: string
 }
@@ -29,7 +34,9 @@ export class PluginManager {
 
   private _activeContainerId: string | undefined
   public create(options: Options): TSLanguageService {
-    this.#setupLogger(options)
+    const containerKey =
+      options.project?.getProjectName() ?? `${Date.now()}-${Math.random()}`
+    this.#setupLogger(containerKey, options)
 
     if (TS_LANGUAGE_SERVICE in options.languageService) {
       return options.languageService
@@ -37,10 +44,9 @@ export class PluginManager {
 
     this.#patchTypescript(options.typescript)
 
-    const containerKey = options.project.getProjectName()
-
     const container =
       this.#containers.get(containerKey) ?? this.#createContainer(options)
+    this.#containers.set(containerKey, container)
 
     if (this._activeContainerId === containerKey) {
       return this.#createLanguageService(
@@ -51,14 +57,19 @@ export class PluginManager {
 
     this.logger.debug(
       'Creating language service for project:',
-      options.project.getProjectName(),
+      options.project?.getProjectName(),
     )
 
     container.get(TypescriptContextService).updateOptions(options)
 
-    this.#patchProject(container, options.project)
-    this.#patchServerHost(container, options.serverHost)
-    this.#patchLanguageServerHost(container, options.languageServiceHost)
+    if (options.project != null) this.#patchProject(container, options.project)
+    this.#patchFilesystem(container, options.serverHost)
+    this.#patchFilesystemWatcher(container, options.serverHost)
+    this.#patchResolveModuleNames(container, options.languageServiceHost)
+    this.#patchGetScriptVersionAndGetScriptSnapshot(
+      container,
+      options.languageServiceHost,
+    )
 
     try {
       const plugin = container.get(TypescriptPluginService)
@@ -70,7 +81,7 @@ export class PluginManager {
     } finally {
       this._activeContainerId = containerKey
       const current = (
-        (options.project.projectService as any)
+        (options.project?.projectService as any)
           .hostConfiguration as TypeScript.server.HostConfiguration
       ).extraFileExtensions
 
@@ -81,7 +92,7 @@ export class PluginManager {
         // .vue exists
       } else if (Array.isArray(current)) {
         // Enable .vue after enhancing the language server.
-        options.project.projectService.setHostConfiguration({
+        options.project?.projectService.setHostConfiguration({
           extraFileExtensions: [],
         })
       }
@@ -94,7 +105,7 @@ export class PluginManager {
       this.#containers
         .get(project.getProjectName())
         ?.get(TypescriptPluginService)
-        .getExternalFiles() ?? []
+        .getExternalFiles(project) ?? []
     )
   }
 
@@ -225,68 +236,12 @@ export class PluginManager {
     )
   }
 
-  #patchServerHost(container: Container, serverHost: TSServerHost): void {
-    const fs = container.get(FilesystemService)
-    const ts = container.get(TypescriptContextService)
-    const logger = LoggerService.getLogger('ServerHost')
-
-    // Patch: check virtual files in activeTSDocIDs of VueSFCDocument
-    overrideMethod(serverHost, 'fileExists', (fileExists) => (fileName) => {
-      return (
-        fs.isProjectRuntimeFile(fileName) ||
-        fileExists(fs.getRealFileNameIfAny(fileName))
-      )
-    })
-
-    // Patch: check virtual files in activeTSDocIDs of VueSFCDocument
-    overrideMethod(
-      serverHost,
-      'watchFile',
-      (watchFile) => (fileName, callback) => {
-        if (fs.isGeneratedVueFile(fileName)) {
-          return watchFile(
-            fs.getRealFileNameIfAny(fileName),
-            (id, eventKind) => {
-              logger.info(
-                `Patched watchFile: ${fileName} - ${id} - ${eventKind}`,
-              )
-              callback(fileName, eventKind)
-            },
-          )
-        }
-
-        if (fs.isProjectRuntimeFile(fileName)) {
-          return { close: () => {} }
-        }
-
-        return watchFile(fileName, callback)
-      },
-    )
-
-    // Patch: get contents for virtual files from VueSFCDocument
-    overrideMethod(
-      serverHost,
-      'readFile',
-      (readFile) => (fileName, encoding) => {
-        if (fs.isGeneratedVueFile(fileName)) {
-          return fs.getVueFile(fileName)?.getText()
-        } else if (fs.isProjectRuntimeFile(fileName)) {
-          return ts.getProjectRuntimeFile(fileName)
-        }
-
-        return readFile(fileName, encoding)
-      },
-    )
-  }
-
-  #patchLanguageServerHost(
+  #patchGetScriptVersionAndGetScriptSnapshot(
     container: Container,
     languageServiceHost: TSLanguageServiceHost,
   ): void {
     const fs = container.get(FilesystemService)
     const ts = container.get(TypescriptContextService)
-    const plugin = container.get(TypescriptPluginService)
-    const logger = LoggerService.getLogger('LanguageServiceHost')
 
     overrideMethod(
       languageServiceHost,
@@ -313,9 +268,6 @@ export class PluginManager {
             if (file != null) {
               return ts.lib.ScriptSnapshot.fromString(file.getText())
             }
-
-            logger.debug(`VueTS file - missing snapshot: ${fileName}`)
-
             return undefined
           } else if (fs.isProjectRuntimeFile(fileName)) {
             return ts.lib.ScriptSnapshot.fromString(
@@ -326,26 +278,17 @@ export class PluginManager {
           }
         },
     )
+  }
 
-    // Patch: Add .vue.tsx, file for every .vue file
-    // This is used to create program.
-    overrideMethod(
-      languageServiceHost,
-      'getScriptFileNames',
-      (getScriptFileNames) => () => {
-        const original = getScriptFileNames()
-
-        try {
-          const fileNames = plugin.getScriptFileNames(original)
-          logger.debug('@@@ getScriptFileNames:', fileNames)
-          return fileNames
-        } catch (e) {
-          logger.error('@@@ Error in getScriptFileNames:', e)
-          return original
-        }
-      },
-    )
+  #patchResolveModuleNames(
+    container: Container,
+    languageServiceHost: TSLanguageServiceHost,
+  ): void {
+    const fs = container.get(FilesystemService)
+    const ts = container.get(TypescriptContextService)
+    const logger = LoggerService.getLogger('LanguageServiceHost')
 
+    let importedFrom: string | undefined
     overrideMethod(
       languageServiceHost,
       'resolveModuleNames',
@@ -359,9 +302,10 @@ export class PluginManager {
           containingSourceFile,
         ) => {
           if (fs.isVueRuntimeFile(containingFile)) {
-            const anyProjectFile = first(ts.project.getRootFiles())
+            const anyProjectFile =
+              importedFrom ?? first(ts.project?.getRootFiles() ?? [])
+
             // Runtime dependencies have only 'vue' dependency for now.
-            // TODO: Switch to resolveModuleNameFromCache
             const core = ts.lib.resolveModuleName(
               '@vue/runtime-core',
               anyProjectFile,
@@ -390,33 +334,33 @@ export class PluginManager {
             )
           }
 
-          const result =
-            resolveModuleNames != null // Very unlikely to be undefined
-              ? resolveModuleNames(
-                  moduleNames,
-                  containingFile,
-                  reusedNames,
-                  redirectedReference,
-                  options,
-                )
-              : ts.project.resolveModuleNames(
-                  moduleNames,
-                  containingFile,
-                  reusedNames,
-                  redirectedReference,
-                  options,
-                  containingSourceFile,
-                )
+          invariant(resolveModuleNames != null)
+
+          const result = resolveModuleNames(
+            moduleNames,
+            containingFile,
+            reusedNames,
+            redirectedReference,
+            options,
+            containingSourceFile,
+          )
 
           const known = {
-            'vuedx~runtime': () => ({
-              resolvedFileName: ts.getVueRuntimeFileNameFor(containingFile),
-              isExternalLibraryImport: true,
-            }),
-            'vuedx~runtime~project': () => ({
-              resolvedFileName: ts.getProjectRuntimeFileNameFor(containingFile),
-              isExternalLibraryImport: false,
-            }),
+            'vuedx~runtime': () => {
+              importedFrom = containingFile
+
+              return {
+                resolvedFileName: ts.getVueRuntimeFileNameFor(containingFile),
+                isExternalLibraryImport: true,
+              }
+            },
+            'vuedx~runtime~project': () => {
+              return {
+                resolvedFileName:
+                  ts.getProjectRuntimeFileNameFor(containingFile),
+                isExternalLibraryImport: false,
+              }
+            },
           }
           moduleNames.forEach((name, index) => {
             const handler = known[name as keyof typeof known]
@@ -431,12 +375,73 @@ export class PluginManager {
     )
   }
 
+  #patchFilesystem(
+    container: Container,
+    host: TSLanguageServiceHost | TSServerHost,
+  ): void {
+    const fs = container.get(FilesystemService)
+    const ts = container.get(TypescriptContextService)
+    // Patch: check virtual files in activeTSDocIDs of VueSFCDocument
+    overrideMethod(host, 'fileExists', (fileExists) => (fileName) => {
+      return (
+        fs.isProjectRuntimeFile(fileName) ||
+        fileExists(fs.getRealFileNameIfAny(fileName))
+      )
+    })
+
+    // Patch: get contents for virtual files from VueSFCDocument
+    overrideMethod(host, 'readFile', (readFile) => (fileName, encoding) => {
+      if (fs.isGeneratedVueFile(fileName)) {
+        return fs.getVueFile(fileName)?.getText()
+      } else if (fs.isProjectRuntimeFile(fileName)) {
+        return ts.getProjectRuntimeFile(fileName)
+      }
+
+      return readFile(fileName, encoding)
+    })
+  }
+
+  #patchFilesystemWatcher(
+    container: Container,
+    serverHost: TSServerHost,
+  ): void {
+    const fs = container.get(FilesystemService)
+    const logger = LoggerService.getLogger('ServerHost')
+
+    // Patch: check virtual files in activeTSDocIDs of VueSFCDocument
+    overrideMethod(
+      serverHost,
+      'watchFile',
+      (watchFile) => (fileName, callback) => {
+        if (fs.isGeneratedVueFile(fileName)) {
+          return watchFile(
+            fs.getRealFileNameIfAny(fileName),
+            (id, eventKind) => {
+              logger.info(
+                `Patched watchFile: ${fileName} - ${id} - ${eventKind}`,
+              )
+              callback(fileName, eventKind)
+            },
+          )
+        }
+
+        if (fs.isProjectRuntimeFile(fileName)) {
+          return { close: () => {} }
+        }
+
+        return watchFile(fileName, callback)
+      },
+    )
+  }
+
   #createContainer(options: Options): Container {
-    if (!options.project.projectService.logger.loggingEnabled()) {
+    if (options.project?.projectService.logger.loggingEnabled() === true) {
+      setDebugging(true)
+    } else {
       setDebugging(false)
     }
-    this.logger.debug('New project:', options.project.getProjectName(), {
-      rootDir: options.project.getCurrentDirectory(),
+    this.logger.debug('New project:', options.project?.getProjectName(), {
+      rootDir: options.project?.getCurrentDirectory(),
     })
     this.logger.debug('Active projects:', Array.from(this.#containers.keys()))
 
@@ -452,34 +457,33 @@ export class PluginManager {
     container.bind(TypescriptContextService).toConstantValue(ts)
     container.bind(FilesystemService).toConstantValue(fs)
 
-    this.#containers.set(options.project.getProjectName(), container)
-
     return container
   }
 
   readonly #loggerIds = new Map<string, string>()
-  #setupLogger(options: Options): void {
-    const id =
-      this.#loggerIds.get(options.project.getProjectName()) ??
-      `${this.#loggerIds.size}`
+  #setupLogger(name: string, options: Options): void {
+    const id = this.#loggerIds.get(name) ?? `${this.#loggerIds.size}`
 
-    this.#loggerIds.set(options.project.getProjectName(), id)
+    this.#loggerIds.set(name, id)
 
     if (LoggerService.currentId === id) return
-    const logger = options.project.projectService.logger
+    const logger = options.project?.projectService.logger
     const LogLevel = options.typescript.server.LogLevel
     LoggerService.currentId = id
 
     LoggerService.setWriter({
       info: (line) => {
+        if (logger == null) return
         if (!logger.hasLevel(LogLevel.normal)) return
         logger.msg(line, options.typescript.server.Msg.Info)
       },
       debug: (line) => {
+        if (logger == null) return
         if (!logger.hasLevel(LogLevel.verbose)) return
         logger.msg(line, options.typescript.server.Msg.Info)
       },
       error: (line) => {
+        if (logger == null) return
         logger.msg(line, options.typescript.server.Msg.Err)
       },
     })
diff --git a/packages/typescript-plugin-vue/src/services/FilesystemService.ts b/packages/typescript-plugin-vue/src/services/FilesystemService.ts
index 00d7e9a2..d6fa9487 100644
--- a/packages/typescript-plugin-vue/src/services/FilesystemService.ts
+++ b/packages/typescript-plugin-vue/src/services/FilesystemService.ts
@@ -26,7 +26,7 @@ export class FilesystemService implements Disposable {
     ts: TypescriptContextService,
   ): FilesystemService {
     return new FilesystemService(
-      createFilesystemProvider(ts.projectService, ts.serverHost),
+      createFilesystemProvider(ts.serverHost, ts.projectService),
       ts,
     )
   }
@@ -41,9 +41,7 @@ export class FilesystemService implements Disposable {
   ) {}
 
   public getVersion(fileName: string): string {
-    return `${this.ts.project.getProjectVersion()}|${this.ts.project.getScriptVersion(
-      fileName,
-    )}`
+    return this.ts.serviceHost.getScriptVersion(fileName)
   }
 
   private readonly textDocumentCache = new CacheService<TextDocument>(
@@ -108,65 +106,67 @@ export class FilesystemService implements Disposable {
     if (!this.provider.exists(fileName)) return null
 
     const file = VueSFCDocument.create(fileName, this.provider.read(fileName), {
-      isTypeScript: this.ts.isTypeScriptProject,
+      isTypeScript: true,
       typescript: this.ts.lib,
     })
 
-    const registerFileUpdate = (
-      fileName: string,
-    ): TypeScript.server.ScriptInfo | undefined => {
-      const info = this.ts.project.getScriptInfo(fileName)
-      this.ts.project.registerFileUpdate(fileName)
-      this.ts.project.markAsDirty()
-      if (info == null) return
-      info.registerFileUpdate()
-      info.markContainingProjectsAsDirty()
-      return info
-    }
+    const project = this.ts.project
+    if (project != null) {
+      const registerFileUpdate = (
+        fileName: string,
+      ): TypeScript.server.ScriptInfo | undefined => {
+        const info = project.getScriptInfo(fileName)
+        project.registerFileUpdate(fileName)
+        project.markAsDirty()
+        if (info == null) return
+        info.registerFileUpdate()
+        info.markContainingProjectsAsDirty()
+        return info
+      }
 
-    const stopWatching = this.provider.watch(
-      file.originalFileName,
-      (changes, version) => {
-        file.update(changes, version)
-        registerFileUpdate(file.generatedFileName)
-        const scriptInfo = registerFileUpdate(file.originalFileName)
-        if (scriptInfo == null) return
-        scriptInfo.containingProjects.forEach((project) => {
-          project.refreshDiagnostics()
-        })
-      },
-    )
+      const stopWatching = this.provider.watch(
+        file.originalFileName,
+        (changes, version) => {
+          file.update(changes, version)
+          registerFileUpdate(file.generatedFileName)
+          const scriptInfo = registerFileUpdate(file.originalFileName)
+          if (scriptInfo == null) return
+          scriptInfo.containingProjects.forEach((project) => {
+            project.refreshDiagnostics()
+          })
+        },
+      )
 
-    this.watchers.add(stopWatching)
-    this.vueFiles.set(fileName, file)
+      this.watchers.add(stopWatching)
+      this.vueFiles.set(fileName, file)
+
+      const fsWatcher = this.ts.serverHost.watchFile(
+        file.originalFileName,
+        (fileName, eventKind) => {
+          this.logger.info(`File changed: ${eventKind} - ${fileName}`)
+          if (eventKind === this.ts.lib.FileWatcherEventKind.Deleted) {
+            const generatedScriptInfo = project.getScriptInfo(
+              file.generatedFileName,
+            )
+            if (generatedScriptInfo != null) {
+              project.removeFile(generatedScriptInfo, false, true)
+            }
 
-    const fsWatcher = this.ts.serverHost.watchFile(
-      file.originalFileName,
-      (fileName, eventKind) => {
-        this.logger.info(`File changed: ${eventKind} - ${fileName}`)
-        if (eventKind === this.ts.lib.FileWatcherEventKind.Deleted) {
-          const generatedScriptInfo = this.ts.project.getScriptInfo(
-            file.generatedFileName,
-          )
-          if (generatedScriptInfo != null) {
-            this.ts.project.removeFile(generatedScriptInfo, false, true)
-          }
+            const originalScriptInfo = project.getScriptInfo(
+              file.originalFileName,
+            )
+            if (originalScriptInfo != null) {
+              project.removeFile(originalScriptInfo, false, true)
+            }
 
-          const originalScriptInfo = this.ts.project.getScriptInfo(
-            file.originalFileName,
-          )
-          if (originalScriptInfo != null) {
-            this.ts.project.removeFile(originalScriptInfo, false, true)
+            stopWatching()
+            this.vueFiles.delete(file.originalFileName)
+            this.watchers.delete(stopWatching)
+            fsWatcher.close()
           }
-
-          stopWatching()
-          this.vueFiles.delete(file.originalFileName)
-          this.watchers.delete(stopWatching)
-          fsWatcher.close()
-        }
-      },
-    )
-
+        },
+      )
+    }
     return file
   }
 
diff --git a/packages/typescript-plugin-vue/src/services/TypescriptContextService.ts b/packages/typescript-plugin-vue/src/services/TypescriptContextService.ts
index 3f1f2496..71685d07 100644
--- a/packages/typescript-plugin-vue/src/services/TypescriptContextService.ts
+++ b/packages/typescript-plugin-vue/src/services/TypescriptContextService.ts
@@ -20,7 +20,7 @@ import { CacheService } from './CacheService'
 import { LoggerService, LogLevel } from './LoggerService'
 
 interface TypescriptContextServiceOptions {
-  project: TSProject
+  project?: TSProject
   typesDir: string
   typescript: typeof TypeScript
   languageService: TSLanguageService
@@ -48,46 +48,20 @@ export class TypescriptContextService implements Disposable {
     return this.options.serverHost
   }
 
-  public get projectService(): TypeScript.server.ProjectService {
-    return this.options.project.projectService
+  public get projectService(): TypeScript.server.ProjectService | undefined {
+    return this.options.project?.projectService
   }
 
   public get service(): TSLanguageService {
     return this.options.languageService
   }
 
-  public get project(): TSProject {
-    return this.options.project
-  }
-
-  public get isTypeScriptProject(): boolean {
-    try {
-      switch (this.project.projectKind) {
-        case this.lib.server.ProjectKind.Configured:
-          try {
-            return !this.project.isJsOnlyProject()
-          } catch {
-            return true
-          }
-
-        default:
-          return true
-      }
-    } catch {
-      return true
-    }
+  public get serviceHost(): TSLanguageServiceHost {
+    return this.options.languageServiceHost
   }
 
-  public isConfiguredProject(
-    project: TSProject,
-  ): project is TypeScript.server.ConfiguredProject & TSProject {
-    return project.projectKind === this.lib.server.ProjectKind.Configured
-  }
-
-  public isInferredProject(
-    project: TSProject,
-  ): project is TypeScript.server.InferredProject & TSProject {
-    return project.projectKind === this.lib.server.ProjectKind.Inferred
+  public get project(): TSProject | undefined {
+    return this.options.project
   }
 
   public updateOptions(
@@ -195,18 +169,6 @@ export class TypescriptContextService implements Disposable {
     return toPosixPath(project.runtimeFile)
   }
 
-  /**
-   * Find typescript project for the file.
-   */
-  public getProjectFor(fileName: string): TypeScript.server.Project | null {
-    return (
-      this.projectService.getDefaultProjectForFile(
-        this.toNormalizedPath(fileName),
-        false,
-      ) ?? null
-    )
-  }
-
   public getVuePreferencesFor(fileName: string): ProjectPreferences {
     const project = this.getVueProjectFor(fileName)
     const preferences = ConfigManager.instance.state.preferences
@@ -232,11 +194,6 @@ export class TypescriptContextService implements Disposable {
       : project.config.preferences
   }
 
-  @cache()
-  public toNormalizedPath(fileName: string): TypeScript.server.NormalizedPath {
-    return this.lib.server.toNormalizedPath(fileName)
-  }
-
   readonly #projects = new Map<string, VueProject>()
 
   @cache()
@@ -296,48 +253,9 @@ export class TypescriptContextService implements Disposable {
     }
   }
 
-  public ensureUptoDate(fileName: string): void {
-    this.project.getLanguageService(true) // forces update
-    if (isVueFile(fileName)) {
-      fileName = this.getGeneratedFileName(fileName)
-    }
-
-    if (
-      this.projectService.getScriptInfoEnsuringProjectsUptoDate(fileName) ==
-      null
-    ) {
-      this.logger.debug(`No ScriptInfo for ${fileName}. Creating one.`)
-      this.projectService.getOrCreateScriptInfoForNormalizedPath(
-        this.toNormalizedPath(fileName),
-        true,
-      )
-    }
-  }
-
   public getGeneratedFileName(fileName: string): string {
     invariant(isVueFile(fileName), 'fileName must be a vue file')
-    return this.isTypeScriptProject ? `${fileName}.tsx` : `${fileName}.jsx`
-  }
-
-  /** @deprecated */
-  public ensureProject(fileName: string): void {
-    const filePath = this.toNormalizedPath(fileName)
-    if (this.project.containsFile(filePath)) {
-      return // already in project
-    }
-
-    const scriptInfo =
-      this.projectService.getOrCreateScriptInfoForNormalizedPath(
-        filePath,
-        false,
-      )
-
-    if (scriptInfo == null) {
-      this.logger.debug('No ScriptInfo for project file:', fileName)
-      return
-    }
-
-    scriptInfo.attachToProject(this.project)
+    return `${fileName}.tsx`
   }
 
   public getTokenAtPosition(
diff --git a/packages/typescript-plugin-vue/src/services/TypescriptPluginService.ts b/packages/typescript-plugin-vue/src/services/TypescriptPluginService.ts
index ac82e0eb..5686cde9 100644
--- a/packages/typescript-plugin-vue/src/services/TypescriptPluginService.ts
+++ b/packages/typescript-plugin-vue/src/services/TypescriptPluginService.ts
@@ -1,7 +1,7 @@
-import { cache, invariant } from '@vuedx/shared'
 import { inject, injectable } from 'inversify'
 import type {
   ExtendedTSLanguageService,
+  TSProject,
   TypeScript,
 } from '../contracts/TypeScript'
 import { CodeFixService } from '../features/CodeFixService'
@@ -74,43 +74,15 @@ export class TypescriptPluginService
     return this.#isVueProject
   }
 
-  public getScriptFileNames(all: string[]): string[] {
-    const isTypeScript = this.ts.isTypeScriptProject
+  private getScriptFileNames(all: string[]): string[] {
     const output = new Set<string>(all)
 
-    const ext = isTypeScript ? 'tsx' : 'jsx'
+    const ext = 'tsx'
     all.forEach((fileName) => {
       if (!this.fs.isVueFile(fileName)) return
       if (!this.ts.serverHost.fileExists(fileName)) return
       const generatedFileName = `${fileName}.${ext}`
 
-      if (this.ts.project.getScriptInfo(fileName) == null) {
-        const scriptInfo =
-          this.ts.projectService.getOrCreateScriptInfoForNormalizedPath(
-            this.ts.toNormalizedPath(fileName),
-            false,
-          )
-
-        invariant(scriptInfo != null, "Couldn't create script info")
-        if (scriptInfo.attachToProject(this.ts.project)) {
-          this.ts.project.markAsDirty()
-        }
-      }
-
-      if (this.ts.project.getScriptInfo(generatedFileName) == null) {
-        this.logger.debug(`Creating generated .vue file: ${generatedFileName}`)
-        const scriptInfo =
-          this.ts.projectService.getOrCreateScriptInfoForNormalizedPath(
-            this.ts.toNormalizedPath(generatedFileName),
-            false,
-          )
-
-        invariant(scriptInfo != null, "Couldn't create script info")
-        if (scriptInfo.attachToProject(this.ts.project)) {
-          this.ts.project.markAsDirty()
-        }
-      }
-
       output.add(generatedFileName)
       output.add(this.ts.getProjectRuntimeFileNameFor(fileName))
     })
@@ -118,37 +90,27 @@ export class TypescriptPluginService
     return Array.from(output)
   }
 
-  @cache((_args, { ts }: TypescriptPluginService) => {
-    ts.project.getLanguageService(true) // triggers updateGraph if project is dirty
-    return ts.project.getProjectVersion()
-  })
-  public getExternalFiles(): string[] {
-    const all: string[] = this.ts.project.getFileNames(true, true)
+  public getExternalFiles(project: TSProject): string[] {
+    const all: string[] = project.getRootFiles()
     const vue = new Set<string>()
     const virtual = new Set<string>()
 
     // This is not needed for any functionality, but it's needed to prevent unnecessary creation of inferred project.
-    this.ts.projectService.openFiles.forEach((_, file) => {
-      const scriptInfo = this.ts.projectService.getScriptInfoForPath(
+
+    const projectService = project.projectService
+    projectService.openFiles.forEach((_, file) => {
+      const scriptInfo = projectService.getScriptInfoForPath(
         file as TypeScript.Path,
       )
       if (scriptInfo == null) return
       if (
         scriptInfo.containingProjects.length === 0 || // creating new project, so this is likely to be part of current project. TODO: verify hypothesis.
-        scriptInfo.containingProjects.includes(this.ts.project)
+        scriptInfo.containingProjects.includes(project)
       ) {
         all.push(scriptInfo.fileName)
       }
     })
 
-    if (this.ts.isConfiguredProject(this.ts.project)) {
-      const options = this.ts.project.getParsedCommandLine?.(
-        this.ts.project.getConfigFilePath(),
-      )
-
-      if (options != null) all.push(...options.fileNames)
-    }
-
     for (const fileName of all) {
       if (fileName.charAt(0) === '^') {
         // ignore typescript virtual files
@@ -163,14 +125,14 @@ export class TypescriptPluginService
 
     if (vue.size === 0) {
       this.#isVueProject = false
-      this.logger.debug('Not a Vue project:', this.ts.project.getProjectName())
+      this.logger.debug('Not a Vue project:', project.getProjectName())
       return [] // do not retain any files if no .vue files
     }
 
     this.#isVueProject = true
     const fileNames = [...this.getScriptFileNames([...vue]), ...virtual]
 
-    this.logger.debug(`Project:`, this.ts.project.getProjectName())
+    this.logger.debug(`Project:`, project.getProjectName())
     this.logger.debug(`External files:`, fileNames)
 
     return fileNames