@danielx/civet 0.11.7 → 0.11.8

package/dist/unplugin/unplugin.mjs

@@ -1,193 +1,16 @@
 import { createRequire as __civetCreateRequire } from 'node:module'; const require = __civetCreateRequire(import.meta.url);
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 
 // unplugin-civet:/home/runner/work/Civet/Civet/source/unplugin/unplugin.civet
 import { createUnplugin } from "unplugin";
 import civet, { decode, lib, SourceMap } from "@danielx/civet";
 import { findInDir, loadConfig } from "@danielx/civet/config";
 import {
-  remapRange,
+  remapPosition,
   flattenDiagnosticMessageText
 } from "@danielx/civet/ts-diagnostic";
 import * as fs from "fs";
 import path from "path";
-
-// node_modules/.pnpm/@typescript+vfs@1.6.4_typescript@5.8.3/node_modules/@typescript/vfs/dist/vfs.esm.js
-function _extends() {
-  return _extends = Object.assign ? Object.assign.bind() : function(n) {
-    for (var e = 1; e < arguments.length; e++) {
-      var t = arguments[e];
-      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
-    }
-    return n;
-  }, _extends.apply(null, arguments);
-}
-var hasLocalStorage = false;
-try {
-  hasLocalStorage = typeof localStorage !== "undefined";
-} catch (error) {
-}
-var hasProcess = typeof process !== "undefined";
-var shouldDebug = hasLocalStorage && typeof localStorage.getItem === "function" && /* @__PURE__ */ localStorage.getItem("DEBUG") || hasProcess && process.env.DEBUG;
-var debugLog = shouldDebug ? console.log : function(_message) {
-  return "";
-};
-function notImplemented(methodName) {
-  throw new Error("Method '" + methodName + "' is not implemented.");
-}
-function audit(name, fn) {
-  return function() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    var res = fn.apply(void 0, args);
-    var smallres = typeof res === "string" ? res.slice(0, 80) + "..." : res;
-    debugLog.apply(void 0, ["> " + name].concat(args));
-    debugLog("< " + smallres);
-    return res;
-  };
-}
-var defaultCompilerOptions = function defaultCompilerOptions2(ts) {
-  return _extends({}, ts.getDefaultCompilerOptions(), {
-    jsx: ts.JsxEmit.React,
-    strict: true,
-    esModuleInterop: true,
-    module: ts.ModuleKind.ESNext,
-    suppressOutputPathCheck: true,
-    skipLibCheck: true,
-    skipDefaultLibCheck: true
-  }, ts.versionMajorMinor && Number(ts.versionMajorMinor.split(".")[0]) >= 6 ? {
-    ignoreDeprecations: "6.0"
-  } : {
-    moduleResolution: ts.ModuleResolutionKind.NodeJs
-  });
-};
-function createFSBackedSystem(files, _projectRoot, ts, tsLibDirectory) {
-  var root = _projectRoot + "/vfs";
-  var path2 = requirePath();
-  var nodeSys = ts.sys;
-  var tsLib = tsLibDirectory != null ? tsLibDirectory : path2.dirname(__require.resolve("typescript"));
-  return {
-    // @ts-ignore
-    name: "fs-vfs",
-    root,
-    args: [],
-    createDirectory: function createDirectory() {
-      return notImplemented("createDirectory");
-    },
-    // TODO: could make a real file tree
-    directoryExists: audit("directoryExists", function(directory) {
-      return Array.from(files.keys()).some(function(path3) {
-        return path3.startsWith(directory);
-      }) || nodeSys.directoryExists(directory);
-    }),
-    exit: nodeSys.exit,
-    fileExists: audit("fileExists", function(fileName) {
-      if (files.has(fileName)) return true;
-      if (fileName.includes("tsconfig.json") || fileName.includes("tsconfig.json")) return false;
-      if (fileName.startsWith("/lib")) {
-        var tsLibName = tsLib + "/" + fileName.replace("/", "");
-        return nodeSys.fileExists(tsLibName);
-      }
-      return nodeSys.fileExists(fileName);
-    }),
-    getCurrentDirectory: function getCurrentDirectory() {
-      return root;
-    },
-    getDirectories: nodeSys.getDirectories,
-    getExecutingFilePath: function getExecutingFilePath() {
-      return notImplemented("getExecutingFilePath");
-    },
-    readDirectory: audit("readDirectory", function() {
-      if ((arguments.length <= 0 ? void 0 : arguments[0]) === "/") {
-        return Array.from(files.keys());
-      } else {
-        return nodeSys.readDirectory.apply(nodeSys, arguments);
-      }
-    }),
-    readFile: audit("readFile", function(fileName) {
-      if (files.has(fileName)) return files.get(fileName);
-      if (fileName.startsWith("/lib")) {
-        var tsLibName = tsLib + "/" + fileName.replace("/", "");
-        var result = nodeSys.readFile(tsLibName);
-        if (!result) {
-          var libs = nodeSys.readDirectory(tsLib);
-          throw new Error("TSVFS: A request was made for " + tsLibName + " but there wasn't a file found in the file map. You likely have a mismatch in the compiler options for the CDN download vs the compiler program. Existing Libs: " + libs + ".");
-        }
-        return result;
-      }
-      return nodeSys.readFile(fileName);
-    }),
-    resolvePath: function resolvePath(path3) {
-      if (files.has(path3)) return path3;
-      return nodeSys.resolvePath(path3);
-    },
-    newLine: "\n",
-    useCaseSensitiveFileNames: true,
-    write: function write() {
-      return notImplemented("write");
-    },
-    writeFile: function writeFile(fileName, contents) {
-      files.set(fileName, contents);
-    },
-    deleteFile: function deleteFile(fileName) {
-      files["delete"](fileName);
-    },
-    realpath: nodeSys.realpath
-  };
-}
-function createVirtualCompilerHost(sys, compilerOptions, ts) {
-  var sourceFiles = /* @__PURE__ */ new Map();
-  var save = function save2(sourceFile) {
-    sourceFiles.set(sourceFile.fileName, sourceFile);
-    return sourceFile;
-  };
-  var vHost = {
-    compilerHost: _extends({}, sys, {
-      getCanonicalFileName: function getCanonicalFileName(fileName) {
-        return fileName;
-      },
-      getDefaultLibFileName: function getDefaultLibFileName() {
-        return "/" + ts.getDefaultLibFileName(compilerOptions);
-      },
-      // '/lib.d.ts',
-      // getDefaultLibLocation: () => '/',
-      getNewLine: function getNewLine() {
-        return sys.newLine;
-      },
-      getSourceFile: function getSourceFile(fileName, languageVersionOrOptions) {
-        var _ref;
-        return sourceFiles.get(fileName) || save(ts.createSourceFile(fileName, sys.readFile(fileName), (_ref = languageVersionOrOptions != null ? languageVersionOrOptions : compilerOptions.target) != null ? _ref : defaultCompilerOptions(ts).target, false));
-      },
-      useCaseSensitiveFileNames: function useCaseSensitiveFileNames() {
-        return sys.useCaseSensitiveFileNames;
-      }
-    }),
-    updateFile: function updateFile(sourceFile) {
-      var alreadyExists = sourceFiles.has(sourceFile.fileName);
-      sys.writeFile(sourceFile.fileName, sourceFile.text);
-      sourceFiles.set(sourceFile.fileName, sourceFile);
-      return alreadyExists;
-    },
-    deleteFile: function deleteFile(sourceFile) {
-      var alreadyExists = sourceFiles.has(sourceFile.fileName);
-      sourceFiles["delete"](sourceFile.fileName);
-      sys.deleteFile(sourceFile.fileName);
-      return alreadyExists;
-    }
-  };
-  return vHost;
-}
-var requirePath = function requirePath2() {
-  return __require(String.fromCharCode(112, 97, 116, 104));
-};
-
-// unplugin-civet:/home/runner/work/Civet/Civet/source/unplugin/unplugin.civet
+import { pathToFileURL } from "url";
 import os from "os";
 var DEFAULT_EXTENSIONS = [".mjs", ".js", ".mts", ".ts", ".jsx", ".tsx", ".json"];
 var DiagnosticCategory = {};
@@ -281,8 +104,15 @@ var rawPlugin = (options = {}, meta) => {
   let outDir = path.join(rootDir, "dist");
   let esbuildOptions;
   let configErrors;
-  let configFileNames;
+  let configFileNames = [];
+  const pluginResolvedIds = /* @__PURE__ */ new Set();
   let skipWorker = false;
+  let tsBuildInfoTarget;
+  let nextDocVersion = 0;
+  let tsService;
+  let docFactory;
+  let service = null;
+  let incrementalTypecheckSetup;
   let ref;
   if (transformTS || ts === "tsc") {
     ref = import("typescript").then(($1) => $1.default);
@@ -291,10 +121,19 @@ var rawPlugin = (options = {}, meta) => {
   }
   ;
   const tsPromise = ref;
+  let ref1;
+  if (transformTS) {
+    ref1 = import("@danielx/civet/ts-service");
+  } else {
+    ref1 = void 0;
+  }
+  ;
+  const tsServicePromise = ref1;
   const getFormatHost = (sys) => {
     return {
       getCurrentDirectory: () => sys.getCurrentDirectory(),
       getNewLine: () => sys.newLine,
+      /* c8 ignore next 3 -- platform-dependent: tests run where useCaseSensitiveFileNames=true */
       getCanonicalFileName: sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
     };
   };
@@ -303,6 +142,7 @@ var rawPlugin = (options = {}, meta) => {
     name: "unplugin-civet",
     enforce: "pre",
     async buildStart() {
+      pluginResolvedIds.clear();
       let civetConfigPath = options.config;
       if (civetConfigPath === void 0) {
         civetConfigPath = await findInDir(process.cwd());
@@ -331,6 +171,10 @@ var rawPlugin = (options = {}, meta) => {
           return;
         };
         const ts2 = await tsPromise;
+        if (transformTS) {
+          tsService = await tsServicePromise;
+          docFactory ??= tsService.createInMemoryDocFactory();
+        }
         let config, error, tsConfigPath;
         if (options.tsConfig) {
           config = options.tsConfig;
@@ -379,105 +223,223 @@ var rawPlugin = (options = {}, meta) => {
           sourceMap: true
         };
         fsMap = /* @__PURE__ */ new Map();
+        let ref2;
+        if (tsConfigPath) {
+          ref2 = path.dirname(tsConfigPath);
+        } else ref2 = process.cwd();
+        const servicePath = ref2;
+        let extraCompilerOptions;
+        if (options.tsBuildInfoFile) {
+          tsBuildInfoTarget = path.resolve(servicePath, options.tsBuildInfoFile);
+          extraCompilerOptions = {
+            incremental: true,
+            tsBuildInfoFile: tsBuildInfoTarget,
+            noEmit: false
+          };
+        }
+        if (transformTS && tsService && docFactory) {
+          const transpileCache = tsService.createDiskCache(path.resolve(servicePath, ".cache/build"));
+          const plugins = [
+            tsService.makeCivetPlugin({
+              Civet: civet,
+              config: compileOptions,
+              cache: transpileCache
+            }),
+            tsService.makeHeraPlugin({
+              Civet: civet,
+              config: compileOptions,
+              cache: transpileCache
+            })
+          ];
+          const useIncremental = options.typecheck && !options.emitDeclaration && (options.discoverProjectFiles ?? false);
+          if (useIncremental) {
+            incrementalTypecheckSetup = {
+              plugins,
+              tsConfig: config,
+              extraCompilerOptions,
+              projectPath: servicePath
+            };
+          } else {
+            service = tsService.TSService(servicePath, {
+              plugins,
+              docFactory,
+              discoverProjectFiles: options.discoverProjectFiles ?? false,
+              extraCompilerOptions,
+              // TSService's own configSys handles .civet + .hera mogrification;
+              // unplugin's local one only adds .civet.
+              tsConfig: config
+            });
+          }
+        }
       }
     },
+    // useConfigFileNames=true expands the typecheck scope to every path
+    // tsconfig matched (captured in buildStart's `configFileNames`); the
+    // false default keeps it scoped to load()-tracked files + their
+    // transitive imports.
     async buildEnd(useConfigFileNames = false) {
       if (transformTS) {
         const ts2 = await tsPromise;
-        const system = createFSBackedSystem(fsMap, process.cwd(), ts2);
-        const {
-          fileExists: systemFileExists,
-          readFile: systemReadFile,
-          readDirectory: systemReadDirectory
-        } = system;
-        system.fileExists = (filename) => {
-          if (!filename.endsWith(".civet.tsx")) return systemFileExists(filename);
-          if (fsMap.has(filename)) return true;
-          return systemFileExists(filename.slice(0, -4));
-        };
-        system.readDirectory = (path2) => {
-          return systemReadDirectory(path2).map(($3) => $3.endsWith(".civet") ? $3 + ".tsx" : $3);
-        };
-        const tsCompileOptions = {
-          ...compileOptions,
-          rewriteCivetImports: false,
-          rewriteTsImports: true
+        let rawDiagnostics;
+        let getMeta;
+        let emitTsBuildInfo;
+        emitTsBuildInfo = () => {
+          return;
         };
-        system.readFile = (filename, encoding = "utf-8") => {
-          if (path.basename(filename) === "package.json") {
-            let recurse = function(node) {
-              if (node != null && typeof node === "object") {
-                for (const key in node) {
-                  const value = node[key];
-                  if (typeof value === "string") {
-                    if (value.endsWith(".civet")) {
-                      node[key] = value + ".tsx";
-                      modified = true;
-                    }
-                  } else if (value) {
-                    recurse(value);
-                  }
-                }
+        let program;
+        if (incrementalTypecheckSetup) {
+          if (!(tsService != null)) {
+            return;
+          }
+          const { builder, getMeta: gm, configErrors: cErrors } = tsService.makeIncrementalTypecheckProgram(
+            incrementalTypecheckSetup.projectPath,
+            incrementalTypecheckSetup
+          );
+          getMeta = gm;
+          while (true) {
+            const r = builder.getSemanticDiagnosticsOfNextAffectedFile();
+            if (!r) {
+              break;
+            }
+          }
+          program = builder.getProgram();
+          const collected = [];
+          collected.push(...builder.getOptionsDiagnostics());
+          collected.push(...builder.getGlobalDiagnostics());
+          for (const f of program.getSourceFiles()) {
+            collected.push(...builder.getSyntacticDiagnostics(f));
+            collected.push(...builder.getSemanticDiagnostics(f));
+            collected.push(...builder.getDeclarationDiagnostics(f));
+          }
+          rawDiagnostics = ts2.sortAndDeduplicateDiagnostics(collected);
+          if (cErrors && cErrors.length > 0) {
+            configErrors = [...cErrors];
+          }
+          if (tsBuildInfoTarget) {
+            const target = tsBuildInfoTarget;
+            const writeFile = (fileName, data) => {
+              if (fileName === target) {
+                return ts2.sys.writeFile(fileName, data);
               }
+              ;
+              return;
+            };
+            emitTsBuildInfo = () => {
+              return builder.emit(void 0, writeFile, void 0, false);
             };
-            const json = systemReadFile(filename, encoding);
-            if (!json) {
-              return json;
+          }
+        } else {
+          if (!(service != null)) {
+            return;
+          }
+          for (const tsxPath of fsMap.keys()) {
+            if (!tsxPath.endsWith(".civet.tsx")) {
+              continue;
             }
-            const parsed = JSON.parse(json);
-            let modified = false;
-            recurse(parsed.imports);
-            return modified ? JSON.stringify(parsed) : json;
+            const civetPath = tsxPath.slice(0, -4);
+            service.host.getMeta(civetPath);
+          }
+          if (useConfigFileNames) {
+            for (const fn of configFileNames) {
+              service.host.addScriptFileName(fn);
+            }
+          }
+          program = service.getProgram();
+          let builder;
+          if (options.tsBuildInfoFile) {
+            const builderHost = {};
+            const readHost = {
+              useCaseSensitiveFileNames: () => ts2.sys.useCaseSensitiveFileNames,
+              getCurrentDirectory: () => ts2.sys.getCurrentDirectory(),
+              readFile: (fileName) => ts2.sys.readFile(fileName)
+            };
+            const oldProgram = ts2.readBuilderProgram(program.getCompilerOptions(), readHost);
+            builder = ts2.createSemanticDiagnosticsBuilderProgram(program, builderHost, oldProgram);
+          }
+          rawDiagnostics = ts2.getPreEmitDiagnostics(builder ?? program);
+          getMeta = (p) => service.host.getMeta(p);
+          if (builder && tsBuildInfoTarget) {
+            const target = tsBuildInfoTarget;
+            const writeFile = (fileName, data) => {
+              if (fileName === target) {
+                return ts2.sys.writeFile(fileName, data);
+              }
+              ;
+              return;
+            };
+            emitTsBuildInfo = () => {
+              return builder.emit(void 0, writeFile, void 0, false);
+            };
+          }
+        }
+        const realFileCache = /* @__PURE__ */ new Map();
+        const realSourceFile = (realPath) => {
+          const cached = realFileCache.get(realPath);
+          if (cached) {
+            return cached;
+          }
+          try {
+            const src = fs.readFileSync(realPath, "utf8");
+            const sf = ts2.createSourceFile(realPath, src, ts2.ScriptTarget.ESNext, true);
+            realFileCache.set(realPath, sf);
+            return sf;
+          } catch {
+            return void 0;
           }
-          if (!filename.endsWith(".civet.tsx")) return systemReadFile(filename, encoding);
-          if (fsMap.has(filename)) return fsMap.get(filename);
-          const civetFilename = filename.slice(0, -4);
-          const rawCivetSource = fs.readFileSync(civetFilename, { encoding });
-          const { code: compiledTS, sourceMap } = civet.compile(rawCivetSource, {
-            ...tsCompileOptions,
-            filename,
-            js: false,
-            sourceMap: true,
-            sync: true
-            // TS readFile API seems to need to be synchronous
-          });
-          fsMap.set(filename, compiledTS);
-          sourceMaps.set(filename, sourceMap);
-          return compiledTS;
         };
-        const host = createVirtualCompilerHost(
-          system,
-          compilerOptions,
-          ts2
-        );
-        const program = ts2.createProgram({
-          rootNames: useConfigFileNames ? configFileNames : [...fsMap.keys()],
-          options: compilerOptions,
-          host: host.compilerHost
-        });
-        const diagnostics = ts2.getPreEmitDiagnostics(program).map((diagnostic) => {
-          const file = diagnostic.file;
-          if (!file) return diagnostic;
-          const sourceMap = sourceMaps.get(file.fileName);
-          if (!sourceMap) return diagnostic;
-          const sourcemapLines = sourceMap.lines ?? sourceMap.data.lines;
-          const range = remapRange(
-            {
-              start: diagnostic.start || 0,
-              end: (diagnostic.start || 0) + (diagnostic.length || 1)
-            },
-            sourcemapLines
-          );
-          return {
-            ...diagnostic,
-            messageText: flattenDiagnosticMessageText(diagnostic.messageText),
-            length: diagnostic.length,
-            start: range.start
+        const diagnostics = [];
+        for (const d of rawDiagnostics) {
+          const file = d.file;
+          if (!file) {
+            diagnostics.push(d);
+            continue;
+          }
+          const isHera = file.fileName.endsWith(".hera.tsx");
+          const isTranspiled = file.fileName.endsWith(".civet.tsx") || isHera;
+          const sourcePath = isTranspiled ? file.fileName.slice(0, -4) : file.fileName;
+          const meta2 = getMeta(sourcePath);
+          const sourcemapLines = meta2?.sourcemapLines;
+          if (!sourcemapLines) {
+            diagnostics.push(d);
+            continue;
+          }
+          const startLc = file.getLineAndCharacterOfPosition(d.start || 0);
+          const endLc = file.getLineAndCharacterOfPosition((d.start || 0) + (d.length || 1));
+          const remappedStartLc = remapPosition(startLc, sourcemapLines);
+          const remappedEndLc = remapPosition(endLc, sourcemapLines);
+          const realFile = realSourceFile(sourcePath);
+          if (!realFile) {
+            diagnostics.push({
+              ...d,
+              messageText: flattenDiagnosticMessageText(d.messageText)
+            });
+            continue;
+          }
+          const toPos = (lc) => {
+            try {
+              return realFile.getPositionOfLineAndCharacter(lc.line, lc.character);
+            } catch {
+              return void 0;
+            }
           };
-        });
+          const remappedStart = toPos(remappedStartLc);
+          if (remappedStart === void 0) {
+            diagnostics.push(d);
+            continue;
+          }
+          const remappedEnd = toPos(remappedEndLc) ?? remappedStart + 1;
+          diagnostics.push({
+            ...d,
+            file: realFile,
+            start: remappedStart,
+            length: Math.max(1, remappedEnd - remappedStart),
+            messageText: flattenDiagnosticMessageText(d.messageText)
+          });
+        }
         if (configErrors?.length) {
           diagnostics.unshift(...configErrors);
         }
+        emitTsBuildInfo();
         if (diagnostics.length > 0) {
           console.error(
             ts2.formatDiagnosticsWithColorAndContext(
@@ -499,9 +461,17 @@ var rawPlugin = (options = {}, meta) => {
               failures.push(DiagnosticCategory.Error);
             }
             const count = diagnostics.filter((d) => failures.includes(d.category)).length;
-            if (count) {
+            const threshold = options.maxErrors ?? 0;
+            if (count > threshold) {
               const reason = count === diagnostics.length ? count : `${count} out of ${diagnostics.length}`;
-              throw new Error(`Aborting build because of ${reason} TypeScript diagnostic${diagnostics.length > 1 ? "s" : ""} above`);
+              let ref3;
+              if (threshold > 0) {
+                ref3 = ` (baseline ${threshold})`;
+              } else ref3 = "";
+              const note = ref3;
+              throw new Error(`Aborting build because of ${reason} TypeScript diagnostic${diagnostics.length > 1 ? "s" : ""} above${note}`);
+            } else if (threshold > 0 && count > 0) {
+              console.error(`Within baseline of ${threshold} TypeScript diagnostic${threshold > 1 ? "s" : ""}; not failing.`);
             }
           }
         }
@@ -561,14 +531,14 @@ var rawPlugin = (options = {}, meta) => {
       }
       if (/\0/.test(id)) return null;
       const { filename, postfix } = extractCivetFilename(id, outExt);
-      let ref1;
+      let ref4;
       if (path.isAbsolute(filename)) {
-        ref1 = resolveAbsolutePath(rootDir, filename, implicitExtension);
+        ref4 = resolveAbsolutePath(rootDir, filename, implicitExtension);
       } else {
-        ref1 = path.resolve(path.dirname(importer ?? ""), filename);
+        ref4 = path.resolve(path.dirname(importer ?? ""), filename);
       }
       ;
-      let resolved = ref1;
+      let resolved = ref4;
       if (!resolved) return null;
       if (!resolved.endsWith(civetSuffix)) {
         if (!implicitExtension) return null;
@@ -576,6 +546,7 @@ var rawPlugin = (options = {}, meta) => {
         if (!implicitId) return null;
         resolved = implicitId;
       }
+      pluginResolvedIds.add(resolved);
       if (options2.scan && meta.framework === "vite") {
         resolved = `\0${resolved}`;
       }
@@ -604,9 +575,9 @@ var rawPlugin = (options = {}, meta) => {
             if (cached.promise) {
               await cached.promise;
             }
-            let ref2;
-            if ((ref2 = cached.result) != null) {
-              const result = ref2;
+            let ref5;
+            if ((ref5 = cached.result) != null) {
+              const result = ref5;
               return result;
             }
           }
@@ -636,9 +607,17 @@ var rawPlugin = (options = {}, meta) => {
           ...civetOptions,
           ast: true
         });
+        let ref6;
+        if (meta.framework === "esbuild" && pluginResolvedIds.has(filename)) {
+          ref6 = path.relative(outDir, filename);
+        } else {
+          ref6 = path.basename(filename);
+        }
+        ;
+        const sourceMapSource = ref6;
         const civetSourceMap = new SourceMap(
           rawCivetSource,
-          normalizePath(path.relative(outDir, filename))
+          normalizePath(sourceMapSource)
         );
         if (ts === "civet") {
           compiled = await civet.generate(ast, {
@@ -685,8 +664,8 @@ var rawPlugin = (options = {}, meta) => {
           }
         }
         if (transformTS) {
-          for (let ref3 = lib.gatherRecursive(ast, (($) => $.type === "ModuleSpecifier")), i = 0, len = ref3.length; i < len; i++) {
-            const _spec = ref3[i];
+          for (let ref7 = lib.gatherRecursive(ast, (($) => $.type === "ModuleSpecifier")), i = 0, len = ref7.length; i < len; i++) {
+            const _spec = ref7[i];
             const spec = _spec;
             if (spec.module?.input) {
               spec.module.token = spec.module.input.replace(/\.([mc])?ts(['"])$/, ".$1js$2");
@@ -706,6 +685,15 @@ var rawPlugin = (options = {}, meta) => {
             fsMap.set(slashed, compiledTS);
             sourceMaps.set(slashed, civetSourceMap);
           }
+          if (service != null && docFactory != null) {
+            const doc = docFactory.create(
+              pathToFileURL(filename).toString(),
+              "civet",
+              ++nextDocVersion,
+              rawCivetSource
+            );
+            service.host.addOrUpdateDocument(doc);
+          }
         }
         const jsonSourceMap = sourceMap && (typeof sourceMap === "string" ? JSON.parse(sourceMap) : sourceMap.json(normalizePath(path.relative(outDir, id))));
         let transformed = {
@@ -768,9 +756,9 @@ var rawPlugin = (options = {}, meta) => {
           return;
         }
         const resolvedId = slash(path.resolve(file) + outExt);
-        let ref4;
-        if (ref4 = server.moduleGraph.getModulesByFile(resolvedId)) {
-          const fileModules = ref4;
+        let ref8;
+        if (ref8 = server.moduleGraph.getModulesByFile(resolvedId)) {
+          const fileModules = ref8;
           server.moduleGraph.onFileChange(resolvedId);
           return [...modules, ...fileModules];
         }
@@ -794,9 +782,9 @@ var rawPlugin = (options = {}, meta) => {
         compiler.options.resolve.extensions.unshift(".civet");
       }
       return aliasResolver = (id) => {
-        let ref5;
-        for (const key in ref5 = compiler.options.resolve.alias) {
-          const value = ref5[key];
+        let ref9;
+        for (const key in ref9 = compiler.options.resolve.alias) {
+          const value = ref9[key];
           if (key.endsWith("$")) {
             if (id === key.slice(0, -1)) {
               return typeof value === "string" ? value : "\0";