@typed/virtual-modules 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/CompilerHostAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CompilerHostAdapter.d.ts","sourceRoot":"","sources":["../src/CompilerHostAdapter.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAEhC,MAAM,YAAY,CAAC;AASpB,eAAO,MAAM,yBAAyB,GACpC,SAAS,0BAA0B,KAClC,0BA2SF,CAAC"}
+{"version":3,"file":"CompilerHostAdapter.d.ts","sourceRoot":"","sources":["../src/CompilerHostAdapter.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAEhC,MAAM,YAAY,CAAC;AASpB,eAAO,MAAM,yBAAyB,GACpC,SAAS,0BAA0B,KAClC,0BA6SF,CAAC"}

package/dist/CompilerHostAdapter.js

@@ -71,8 +71,9 @@ export const attachCompilerHostAdapter = (options) => {
         const fallback = originalResolveModuleNames
             ? originalResolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile)
             : moduleNames.map((moduleName) => fallbackResolveModule(moduleName, containingFile, compilerOptions));
+        const effectiveImporter = store.resolveEffectiveImporter(containingFile);
         return moduleNames.map((moduleName, index) => {
-            const record = getOrBuildRecord(moduleName, containingFile);
+            const record = getOrBuildRecord(moduleName, effectiveImporter);
             if (!record) {
                 return fallback[index];
             }
@@ -85,8 +86,9 @@ export const attachCompilerHostAdapter = (options) => {
             : moduleLiterals.map((moduleLiteral) => ({
                 resolvedModule: fallbackResolveModule(moduleLiteral.text, containingFile, compilerOptions),
             }));
+        const effectiveImporter = store.resolveEffectiveImporter(containingFile);
         return moduleLiterals.map((moduleLiteral, index) => {
-            const record = getOrBuildRecord(moduleLiteral.text, containingFile);
+            const record = getOrBuildRecord(moduleLiteral.text, effectiveImporter);
             if (!record) {
                 return fallback[index];
             }

package/dist/LanguageServiceAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LanguageServiceAdapter.d.ts","sourceRoot":"","sources":["../src/LanguageServiceAdapter.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,6BAA6B,EAElC,KAAK,0BAA0B,EAChC,MAAM,YAAY,CAAC;AAiGpB,eAAO,MAAM,4BAA4B,GACvC,SAAS,6BAA6B,KACrC,0BA4gBF,CAAC"}
+{"version":3,"file":"LanguageServiceAdapter.d.ts","sourceRoot":"","sources":["../src/LanguageServiceAdapter.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,6BAA6B,EAElC,KAAK,0BAA0B,EAChC,MAAM,YAAY,CAAC;AAiGpB,eAAO,MAAM,4BAA4B,GACvC,SAAS,6BAA6B,KACrC,0BAugBF,CAAC"}

package/dist/LanguageServiceAdapter.js

@@ -201,7 +201,7 @@ export const attachLanguageServiceAdapter = (options) => {
                     const r = recordsByVirtualFile.get(parsed.virtualPath);
                     if (r) {
                         effectiveContainingFile = r.virtualFileName;
-                        importerForVirtual = r.importer;
+                        importerForVirtual = store.resolveEffectiveImporter(parsed.virtualPath);
                     }
                 }
                 else {
@@ -212,6 +212,13 @@ export const attachLanguageServiceAdapter = (options) => {
                     }
                 }
             }
+            else {
+                const virtualRecord = recordsByVirtualFile.get(containingFile);
+                if (virtualRecord) {
+                    effectiveContainingFile = virtualRecord.virtualFileName;
+                    importerForVirtual = store.resolveEffectiveImporter(containingFile);
+                }
+            }
             const fallback = originalResolveModuleNames
                 ? originalResolveModuleNames(moduleNames, effectiveContainingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile)
                 : moduleNames.map((moduleName) => fallbackResolveModule(moduleName, effectiveContainingFile, compilerOptions));
@@ -265,7 +272,7 @@ export const attachLanguageServiceAdapter = (options) => {
                     const r = recordsByVirtualFile.get(parsed.virtualPath);
                     if (r) {
                         effectiveContainingFile = r.virtualFileName;
-                        importerForVirtual = r.importer;
+                        importerForVirtual = store.resolveEffectiveImporter(parsed.virtualPath);
                     }
                 }
                 else {
@@ -276,6 +283,13 @@ export const attachLanguageServiceAdapter = (options) => {
                     }
                 }
             }
+            else {
+                const virtualRecord = recordsByVirtualFile.get(containingFile);
+                if (virtualRecord) {
+                    effectiveContainingFile = virtualRecord.virtualFileName;
+                    importerForVirtual = store.resolveEffectiveImporter(containingFile);
+                }
+            }
             const fallback = originalResolveModuleNameLiterals
                 ? originalResolveModuleNameLiterals(moduleLiterals, effectiveContainingFile, redirectedReference, compilerOptions, containingSourceFile, reusedNames)
                 : moduleLiterals.map((moduleLiteral) => ({
@@ -285,20 +299,6 @@ export const attachLanguageServiceAdapter = (options) => {
             let hadUnresolvedVirtual = false;
             const results = moduleLiterals.map((moduleLiteral, index) => {
                 const resolved = getOrBuildRecord(moduleLiteral.text, importerForVirtual);
-                if (moduleLiteral.text.includes(":")) {
-                    try {
-                        require("node:fs").appendFileSync("/tmp/vm-ts-plugin-debug.log", JSON.stringify({
-                            tag: "LS:resolveLiterals",
-                            id: moduleLiteral.text,
-                            status: resolved.status,
-                            err: resolved.status === "error" ? resolved.diagnostic?.message : undefined,
-                            t: Date.now(),
-                        }) + "\n", { flag: "a" });
-                    }
-                    catch {
-                        /* noop */
-                    }
-                }
                 if (resolved.status === "resolved") {
                     pendingRetry = false;
                     return {

package/dist/internal/VirtualRecordStore.d.ts

@@ -55,6 +55,7 @@ export declare function createVirtualRecordStore(options: VirtualRecordStoreOpti
     flushPendingStale: () => void;
     resolveRecord: (id: string, importer: string, previous?: MutableVirtualRecord) => ResolveRecordResult;
     getOrBuildRecord: (id: string, importer: string) => ResolveRecordResult;
+    resolveEffectiveImporter: (containingFile: string) => string;
     dispose: () => void;
 };
 //# sourceMappingURL=VirtualRecordStore.d.ts.map

package/dist/internal/VirtualRecordStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VirtualRecordStore.d.ts","sourceRoot":"","sources":["../../src/internal/VirtualRecordStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EACV,2BAA2B,EAC3B,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,aAAa,CAAC;AAGrB,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,mBAAmB,EAAE,SAAS,GAAG,OAAO,CAAC,GAAG;IAClF,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;CACvC;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,uBAAuB,CAAC;CAC9C;AAED,MAAM,MAAM,mBAAmB,GAC3B,2BAA2B,GAC3B,6BAA6B,GAC7B,wBAAwB,CAAC;AAE7B,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE;QACjB,aAAa,CAAC,OAAO,EAAE,2BAA2B,GAAG,uBAAuB,CAAC;KAC9E,CAAC;IACF,QAAQ,CAAC,wBAAwB,CAAC,EAAE,2BAA2B,CAAC,0BAA0B,CAAC,CAAC;IAC5F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE;QACnB,SAAS,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,EAAE,CAAC,WAAW,CAAC;QAC/D,cAAc,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC;KAC1F,CAAC;IACF,oFAAoF;IACpF,QAAQ,CAAC,iBAAiB,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,OAAO,CAAC;IACtE,gFAAgF;IAChF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IACnC,qGAAqG;IACrG,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC9D,uEAAuE;IACvE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IACtC,8EAA8E;IAC9E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;IACrC,yGAAyG;IACzG,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACnE,iFAAiF;IACjF,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;CACjE;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,YAAY,CAAC,EAClC,QAAQ,EAAE,MAAM,GACf,EAAE,CAAC,kBAAkB,CAMvB;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB;;;;;0BAoB5C,oBAAoB,KAAG,IAAI;+BAqBxB,IAAI;+BAYF,oBAAoB,KAAG,IAAI;+BAmD3B,MAAM,KAAG,IAAI;6BAtBjB,IAAI;wBAgD5B,MAAM,YACA,MAAM,aACL,oBAAoB,KAC9B,mBAAmB;2BAsDQ,MAAM,YAAY,MAAM,KAAG,mBAAmB;mBAexD,IAAI;EA8BzB"}
+{"version":3,"file":"VirtualRecordStore.d.ts","sourceRoot":"","sources":["../../src/internal/VirtualRecordStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EACV,2BAA2B,EAC3B,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,aAAa,CAAC;AAGrB,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,mBAAmB,EAAE,SAAS,GAAG,OAAO,CAAC,GAAG;IAClF,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;CACvC;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,uBAAuB,CAAC;CAC9C;AAED,MAAM,MAAM,mBAAmB,GAC3B,2BAA2B,GAC3B,6BAA6B,GAC7B,wBAAwB,CAAC;AAE7B,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE;QACjB,aAAa,CAAC,OAAO,EAAE,2BAA2B,GAAG,uBAAuB,CAAC;KAC9E,CAAC;IACF,QAAQ,CAAC,wBAAwB,CAAC,EAAE,2BAA2B,CAAC,0BAA0B,CAAC,CAAC;IAC5F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE;QACnB,SAAS,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,EAAE,CAAC,WAAW,CAAC;QAC/D,cAAc,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC;KAC1F,CAAC;IACF,oFAAoF;IACpF,QAAQ,CAAC,iBAAiB,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,OAAO,CAAC;IACtE,gFAAgF;IAChF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IACnC,qGAAqG;IACrG,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC9D,uEAAuE;IACvE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IACtC,8EAA8E;IAC9E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;IACrC,yGAAyG;IACzG,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACnE,iFAAiF;IACjF,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;CACjE;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,YAAY,CAAC,EAClC,QAAQ,EAAE,MAAM,GACf,EAAE,CAAC,kBAAkB,CAMvB;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB;;;;;0BAoB5C,oBAAoB,KAAG,IAAI;+BAqBxB,IAAI;+BAYF,oBAAoB,KAAG,IAAI;+BAmD3B,MAAM,KAAG,IAAI;6BAtBjB,IAAI;wBAgD5B,MAAM,YACA,MAAM,aACL,oBAAoB,KAC9B,mBAAmB;2BAsDQ,MAAM,YAAY,MAAM,KAAG,mBAAmB;+CAqB1B,MAAM,KAAG,MAAM;mBAa7C,IAAI;EA+BzB"}

package/dist/internal/VirtualRecordStore.js

@@ -168,6 +168,26 @@ export function createVirtualRecordStore(options) {
         }
         return resolveRecord(id, importer, existing);
     };
+    /**
+     * Walk the virtual-file chain from containingFile back to the root real-file importer.
+     * When a virtual module imports another virtual module, the containing file is a virtual
+     * file path; plugins must receive the real file as importer. Returns input unchanged if
+     * not a virtual file. Handles cycles by breaking the loop.
+     */
+    const resolveEffectiveImporter = (containingFile) => {
+        let current = containingFile;
+        const visited = new Set();
+        while (true) {
+            if (visited.has(current))
+                break;
+            visited.add(current);
+            const record = recordsByVirtualFile.get(current);
+            if (!record)
+                break;
+            current = record.importer;
+        }
+        return current;
+    };
     const dispose = () => {
         if (debounceTimer !== undefined) {
             clearTimeout(debounceTimer);
@@ -194,6 +214,7 @@ export function createVirtualRecordStore(options) {
         flushPendingStale,
         resolveRecord,
         getOrBuildRecord,
+        resolveEffectiveImporter,
         dispose,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed/virtual-modules",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.2",
   "type": "module",
   "exports": {
     ".": {
@@ -15,24 +15,24 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "[ -d dist ] || rm -f tsconfig.tsbuildinfo; tsc",
-    "clean": "rm -rf dist tsconfig.tsbuildinfo",
-    "test": "vitest run --passWithNoTests",
-    "test:coverage": "vitest run --coverage"
-  },
   "devDependencies": {
     "@manuth/typescript-languageservice-tester": "^5.0.2",
     "@types/node": "^25.3.0",
     "@vitest/coverage-v8": "^4.0.0",
-    "typescript": "catalog:",
-    "vitest": "catalog:"
+    "typescript": "5.9.3",
+    "vitest": "4.0.18"
   },
   "peerDependencies": {
-    "typescript": "catalog:"
+    "typescript": "5.9.3"
   },
   "files": [
     "dist",
     "src"
-  ]
-}
+  ],
+  "scripts": {
+    "build": "[ -d dist ] || rm -f tsconfig.tsbuildinfo; tsc",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "test": "vitest run --passWithNoTests",
+    "test:coverage": "vitest run --coverage"
+  }
+}

package/src/CompilerHostAdapter.test.ts

@@ -72,6 +72,60 @@ export const value: Foo = { n: 1 };
     adapter.dispose();
   });
 
+  it("resolves virtual module that imports another virtual module (virtual-to-virtual)", () => {
+    const dir = createTempDir();
+    const entry = join(dir, "entry.ts");
+    writeFileSync(entry, `import { x } from "virtual:a"; export const out = x;`, "utf8");
+
+    const receivedImporters: string[] = [];
+    const manager = new PluginManager([
+      {
+        name: "virtual-a",
+        shouldResolve: (id) => id === "virtual:a",
+        build: (_id, importer) => {
+          receivedImporters.push(`a:${importer}`);
+          return `import { x } from "virtual:b"; export { x };`;
+        },
+      },
+      {
+        name: "virtual-b",
+        shouldResolve: (id) => id === "virtual:b",
+        build: (_id, importer) => {
+          receivedImporters.push(`b:${importer}`);
+          return `export const x = 1;`;
+        },
+      },
+    ]);
+
+    const compilerOptions: ts.CompilerOptions = {
+      strict: true,
+      noEmit: true,
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      skipLibCheck: true,
+    };
+    const host = ts.createCompilerHost(compilerOptions);
+    attachCompilerHostAdapter({
+      ts,
+      compilerHost: host,
+      resolver: manager,
+      projectRoot: dir,
+    });
+
+    const program = ts.createProgram([entry], compilerOptions, host);
+    const diagnostics = ts.getPreEmitDiagnostics(program);
+    expect(diagnostics).toHaveLength(0);
+    expect(receivedImporters).toContain(`a:${entry}`);
+    expect(receivedImporters).toContain(`b:${entry}`);
+    expect(
+      program.getSourceFiles().some((sf) => sf.fileName.includes("__virtual_virtual-a_")),
+    ).toBe(true);
+    expect(
+      program.getSourceFiles().some((sf) => sf.fileName.includes("__virtual_virtual-b_")),
+    ).toBe(true);
+  });
+
   it("evicts virtual record when importer no longer exists (fileExists returns false)", () => {
     const dir = createTempDir();
     const entry1 = join(dir, "entry1.ts");

package/src/CompilerHostAdapter.ts

@@ -140,8 +140,9 @@ export const attachCompilerHostAdapter = (
           fallbackResolveModule(moduleName, containingFile, compilerOptions),
         );
 
+    const effectiveImporter = store.resolveEffectiveImporter(containingFile);
     return moduleNames.map((moduleName, index) => {
-      const record = getOrBuildRecord(moduleName, containingFile);
+      const record = getOrBuildRecord(moduleName, effectiveImporter);
       if (!record) {
         return fallback[index];
       }
@@ -174,8 +175,9 @@ export const attachCompilerHostAdapter = (
           ),
         }));
 
+    const effectiveImporter = store.resolveEffectiveImporter(containingFile);
     return moduleLiterals.map((moduleLiteral, index) => {
-      const record = getOrBuildRecord(moduleLiteral.text, containingFile);
+      const record = getOrBuildRecord(moduleLiteral.text, effectiveImporter);
       if (!record) {
         return fallback[index];
       }

package/src/LanguageServiceAdapter.test.ts

@@ -270,6 +270,12 @@ export const value: Foo = { n: 1 };
           {
             file: () => ({ ok: false as const, error: "file-not-in-program" as const }),
             directory: () => [],
+            resolveExport: () => {
+              throw new Error("not implemented")
+            },
+            isAssignableTo: () => {
+              throw new Error("not implemented")
+            }
           },
           { _host: host },
         ),
@@ -457,6 +463,171 @@ export const value: Foo = { n: 1 };
     expect(snapshot).toBeUndefined();
   });
 
+  it("resolves virtual module that imports another virtual module (virtual-to-virtual)", () => {
+    const dir = createTempDir();
+    const entryFile = join(dir, "entry.ts");
+    writeFileSync(
+      entryFile,
+      `import { x } from "virtual:a"; export const out = x;`,
+      "utf8",
+    );
+
+    const receivedImporters: string[] = [];
+    const files = new Map<string, { version: number; content: string }>([
+      [entryFile, { version: 1, content: ts.sys.readFile(entryFile) ?? "" }],
+    ]);
+
+    const host: ts.LanguageServiceHost = {
+      getCompilationSettings: () => ({
+        strict: true,
+        noEmit: true,
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        skipLibCheck: true,
+      }),
+      getScriptFileNames: () => [...files.keys()],
+      getScriptVersion: (fileName) => String(files.get(fileName)?.version ?? 0),
+      getScriptSnapshot: (fileName) => {
+        const content = files.get(fileName)?.content ?? ts.sys.readFile(fileName);
+        if (!content) return undefined;
+        return ts.ScriptSnapshot.fromString(content);
+      },
+      getCurrentDirectory: () => dir,
+      getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+      fileExists: (fileName) => files.has(fileName) || ts.sys.fileExists(fileName),
+      readFile: (fileName) => files.get(fileName)?.content ?? ts.sys.readFile(fileName),
+      readDirectory: (...args: Parameters<typeof ts.sys.readDirectory>) =>
+        ts.sys.readDirectory(...args),
+    };
+
+    const manager = new PluginManager([
+      {
+        name: "virtual-a",
+        shouldResolve: (id) => id === "virtual:a",
+        build: (id, importer) => {
+          receivedImporters.push(`a:${importer}`);
+          return `import { x } from "virtual:b"; export { x };`;
+        },
+      },
+      {
+        name: "virtual-b",
+        shouldResolve: (id) => id === "virtual:b",
+        build: (id, importer) => {
+          receivedImporters.push(`b:${importer}`);
+          return `export const x = 1;`;
+        },
+      },
+    ]);
+
+    const languageService = ts.createLanguageService(host);
+    attachLanguageServiceAdapter({
+      ts,
+      languageService,
+      languageServiceHost: host,
+      resolver: manager,
+      projectRoot: dir,
+    });
+
+    const diagnostics = languageService.getSemanticDiagnostics(entryFile);
+    expect(diagnostics).toHaveLength(0);
+    expect(receivedImporters).toContain(`a:${entryFile}`);
+    expect(receivedImporters).toContain(`b:${entryFile}`);
+    expect(
+      languageService
+        .getProgram()
+        ?.getSourceFiles()
+        .some((sf) => sf.fileName.includes("__virtual_virtual-a_")),
+    ).toBe(true);
+    expect(
+      languageService
+        .getProgram()
+        ?.getSourceFiles()
+        .some((sf) => sf.fileName.includes("__virtual_virtual-b_")),
+    ).toBe(true);
+  });
+
+  it("resolves chain virtual:a -> virtual:b -> virtual:c with root importer", () => {
+    const dir = createTempDir();
+    const entryFile = join(dir, "entry.ts");
+    writeFileSync(
+      entryFile,
+      `import { z } from "virtual:a"; export const out = z;`,
+      "utf8",
+    );
+
+    const receivedImporters: string[] = [];
+    const files = new Map<string, { version: number; content: string }>([
+      [entryFile, { version: 1, content: ts.sys.readFile(entryFile) ?? "" }],
+    ]);
+
+    const host: ts.LanguageServiceHost = {
+      getCompilationSettings: () => ({
+        strict: true,
+        noEmit: true,
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.ESNext,
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        skipLibCheck: true,
+      }),
+      getScriptFileNames: () => [...files.keys()],
+      getScriptVersion: (fileName) => String(files.get(fileName)?.version ?? 0),
+      getScriptSnapshot: (fileName) => {
+        const content = files.get(fileName)?.content ?? ts.sys.readFile(fileName);
+        if (!content) return undefined;
+        return ts.ScriptSnapshot.fromString(content);
+      },
+      getCurrentDirectory: () => dir,
+      getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+      fileExists: (fileName) => files.has(fileName) || ts.sys.fileExists(fileName),
+      readFile: (fileName) => files.get(fileName)?.content ?? ts.sys.readFile(fileName),
+      readDirectory: (...args: Parameters<typeof ts.sys.readDirectory>) =>
+        ts.sys.readDirectory(...args),
+    };
+
+    const manager = new PluginManager([
+      {
+        name: "virtual-a",
+        shouldResolve: (id) => id === "virtual:a",
+        build: (_id, importer) => {
+          receivedImporters.push(`a:${importer}`);
+          return `import { y } from "virtual:b"; export { y as z };`;
+        },
+      },
+      {
+        name: "virtual-b",
+        shouldResolve: (id) => id === "virtual:b",
+        build: (_id, importer) => {
+          receivedImporters.push(`b:${importer}`);
+          return `import { y } from "virtual:c"; export { y };`;
+        },
+      },
+      {
+        name: "virtual-c",
+        shouldResolve: (id) => id === "virtual:c",
+        build: (_id, importer) => {
+          receivedImporters.push(`c:${importer}`);
+          return `export const y = 42;`;
+        },
+      },
+    ]);
+
+    const languageService = ts.createLanguageService(host);
+    attachLanguageServiceAdapter({
+      ts,
+      languageService,
+      languageServiceHost: host,
+      resolver: manager,
+      projectRoot: dir,
+    });
+
+    const diagnostics = languageService.getSemanticDiagnostics(entryFile);
+    expect(diagnostics).toHaveLength(0);
+    expect(receivedImporters).toContain(`a:${entryFile}`);
+    expect(receivedImporters).toContain(`b:${entryFile}`);
+    expect(receivedImporters).toContain(`c:${entryFile}`);
+  });
+
   it("dispose then getScriptSnapshot does not throw and returns original behavior", () => {
     const dir = createTempDir();
     const entryFile = join(dir, "entry.ts");

package/src/LanguageServiceAdapter.ts

@@ -281,7 +281,7 @@ export const attachLanguageServiceAdapter = (
           const r = recordsByVirtualFile.get(parsed.virtualPath);
           if (r) {
             effectiveContainingFile = r.virtualFileName;
-            importerForVirtual = r.importer;
+            importerForVirtual = store.resolveEffectiveImporter(parsed.virtualPath);
           }
         } else {
           const r = getOrBuildRecord(parsed.id, parsed.importer);
@@ -290,6 +290,12 @@ export const attachLanguageServiceAdapter = (
             importerForVirtual = r.record.importer;
           }
         }
+      } else {
+        const virtualRecord = recordsByVirtualFile.get(containingFile);
+        if (virtualRecord) {
+          effectiveContainingFile = virtualRecord.virtualFileName;
+          importerForVirtual = store.resolveEffectiveImporter(containingFile);
+        }
       }
 
       const fallback = originalResolveModuleNames
@@ -371,7 +377,7 @@ export const attachLanguageServiceAdapter = (
           const r = recordsByVirtualFile.get(parsed.virtualPath);
           if (r) {
             effectiveContainingFile = r.virtualFileName;
-            importerForVirtual = r.importer;
+            importerForVirtual = store.resolveEffectiveImporter(parsed.virtualPath);
           }
         } else {
           const r = getOrBuildRecord(parsed.id, parsed.importer);
@@ -380,6 +386,12 @@ export const attachLanguageServiceAdapter = (
             importerForVirtual = r.record.importer;
           }
         }
+      } else {
+        const virtualRecord = recordsByVirtualFile.get(containingFile);
+        if (virtualRecord) {
+          effectiveContainingFile = virtualRecord.virtualFileName;
+          importerForVirtual = store.resolveEffectiveImporter(containingFile);
+        }
       }
 
       const fallback: readonly ts.ResolvedModuleWithFailedLookupLocations[] =
@@ -404,23 +416,6 @@ export const attachLanguageServiceAdapter = (
       let hadUnresolvedVirtual = false;
       const results = moduleLiterals.map((moduleLiteral, index) => {
         const resolved = getOrBuildRecord(moduleLiteral.text, importerForVirtual);
-        if (moduleLiteral.text.includes(":")) {
-          try {
-            require("node:fs").appendFileSync(
-              "/tmp/vm-ts-plugin-debug.log",
-              JSON.stringify({
-                tag: "LS:resolveLiterals",
-                id: moduleLiteral.text,
-                status: resolved.status,
-                err: resolved.status === "error" ? (resolved as { diagnostic?: { message?: string } }).diagnostic?.message : undefined,
-                t: Date.now(),
-              }) + "\n",
-              { flag: "a" },
-            );
-          } catch {
-            /* noop */
-          }
-        }
         if (resolved.status === "resolved") {
           pendingRetry = false;
           return {

package/src/internal/VirtualRecordStore.ts

@@ -271,6 +271,25 @@ export function createVirtualRecordStore(options: VirtualRecordStoreOptions) {
     return resolveRecord(id, importer, existing);
   };
 
+  /**
+   * Walk the virtual-file chain from containingFile back to the root real-file importer.
+   * When a virtual module imports another virtual module, the containing file is a virtual
+   * file path; plugins must receive the real file as importer. Returns input unchanged if
+   * not a virtual file. Handles cycles by breaking the loop.
+   */
+  const resolveEffectiveImporter = (containingFile: string): string => {
+    let current = containingFile;
+    const visited = new Set<string>();
+    while (true) {
+      if (visited.has(current)) break;
+      visited.add(current);
+      const record = recordsByVirtualFile.get(current);
+      if (!record) break;
+      current = record.importer;
+    }
+    return current;
+  };
+
   const dispose = (): void => {
     if (debounceTimer !== undefined) {
       clearTimeout(debounceTimer);
@@ -299,6 +318,7 @@ export function createVirtualRecordStore(options: VirtualRecordStoreOptions) {
     flushPendingStale,
     resolveRecord,
     getOrBuildRecord,
+    resolveEffectiveImporter,
     dispose,
   };
 }