diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 03c90e0..6ad4a1f 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -57,28 +57,6 @@ jobs:
     - name: Create the package
       run: dotnet pack ${{ env.PROJECT }} --no-build --no-restore --configuration Release -o ${{ env.OUTPUT_PATH }}
       
-    - name: Publish to NuGet
-      if: github.event_name == 'release'
-      working-directory: ${{ env.OUTPUT_PATH }}
-      run: dotnet nuget push *.nupkg -s https://api.nuget.org/v3/index.json --skip-duplicate --api-key ${{ secrets.NUGET_API_KEY }}
-
-    - uses: avakar/tag-and-release@v1
-      if: github.event_name == 'release'
-      name: Create Release Tag v${{ steps.package_version.outputs.version }}
-      id: release
-      with:
-        tag_name: v${{ steps.package_version.outputs.version }}
-        prerelease: ${{ steps.check_prerelease.outputs.prerelease }}
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        
-    - name: Release information for v${{ steps.package_version.outputs.version }}
-      if: github.event_name == 'release'
-      run: |
-        echo Release Id: ${{ steps.release.outputs.id }}
-        echo Upload URL: ${{ steps.release.outputs.upload_url }}
-        echo Release URL: ${{ steps.release.outputs.html_url }}
-
     - name: Upload artifacts
       uses: actions/upload-artifact@v4
       with:
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 566d283..791c8af 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -32,7 +32,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        language: [ 'csharp', 'javascript' ]
+        language: [ 'csharp' ]
         # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
         # Learn more about CodeQL language support at https://git.io/codeql-language-support
 
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 47ab129..105a4fa 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -30,7 +30,6 @@ jobs:
       
     - name: Setup .NET Core SDK ${{ matrix.dotnet-version }}
       uses: actions/setup-dotnet@v4
-
       with:
         dotnet-version: ${{ matrix.dotnet-version }}
   
@@ -58,12 +57,12 @@ jobs:
     - name: Create the package
       run: dotnet pack ${{ env.PROJECT }} --no-build --no-restore --configuration Release -o ${{ env.OUTPUT_PATH }}
       
-  # Get a short-lived NuGet API key
+    # Get a short-lived NuGet API key
     - name: NuGet login (OIDC → temp API key)
       uses: NuGet/login@v1
       id: login
       with:
-        user: ${{ secrets.NUGET_USER }} # Recommended: use a secret like ${{ secrets.NUGET_USER }} for your nuget.org username (profile name), NOT your email address
+        user: ${{ secrets.NUGET_USER }}
   
     # Push the package
     - name: NuGet push
diff --git a/.gitignore b/.gitignore
index 7282dbf..660bb80 100644
--- a/.gitignore
+++ b/.gitignore
@@ -55,3 +55,4 @@ CodeCoverage/
 *.VisualState.xml
 TestResult.xml
 nunit-*.xml
+*.csproj.lscache
diff --git a/README.md b/README.md
index 238e536..074e963 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,8 @@ A production Vite build emits a manifest that maps each logical entry (e.g. `ind
 
 `ViteManifestService` loads this manifest from `{WebRootPath}/.vite/manifest.json`, resolves an entry, prefixes the files with a configurable base path, and renders the tags. The `<vite>` tag helper is a thin wrapper over the service.
 
+Resolution follows the entry's `imports` graph transitively: CSS contributed by shared/split chunks (which Vite records against those chunks, not the entry) is collected and rendered, and each imported chunk is emitted as a `<link rel="modulepreload">` hint alongside the entry `<script>`. Imports are deduplicated and cycle-guarded.
+
 ## Setup
 
 Two things wire it up:
@@ -138,8 +140,9 @@ Returned URLs are prefixed with the supplied base path. Pass `""` as the base pa
 | `GetEntry(entry)`                                                        | `ViteManifestEntry?`   | Resolve + cache lookup (`~/` tolerated).           |
 | `GetCssFiles()` / `(entry, basePath)` / `(ViteManifestEntry, basePath)`  | `IReadOnlyList<string>`| Resolved CSS URLs.                                 |
 | `GetJsFile()` / `(entry, basePath)` / `(ViteManifestEntry, basePath)`    | `string?`              | Resolved JS URL.                                   |
+| `GetModulePreloadFiles(ViteManifestEntry, basePath)`                     | `IReadOnlyList<string>`| Transitively-imported chunk URLs (for modulepreload). |
 | `RenderCss(entry, basePath, preload)`                                    | `IHtmlContent`         | CSS `<link>` tags only.                            |
-| `RenderJs(entry, basePath)`                                              | `IHtmlContent`         | Module `<script>` tag only.                        |
+| `RenderJs(entry, basePath)`                                              | `IHtmlContent`         | `<link rel="modulepreload">` for imported chunks + the module `<script>` tag. |
 | `RenderEntry(entry, basePath, preloadCss, assets, devServer)`            | `IHtmlContent`         | Full render; handles dev-server + not-found cases. |
 
 ## Development mode
diff --git a/Vite.dotnet.Tests/ManifestTestContext.cs b/Vite.dotnet.Tests/ManifestTestContext.cs
new file mode 100644
index 0000000..b248901
--- /dev/null
+++ b/Vite.dotnet.Tests/ManifestTestContext.cs
@@ -0,0 +1,83 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+using Vite.Configuration;
+using Vite.Services;
+
+namespace Vite.dotnet.Tests;
+
+/// <summary>
+/// Builds a <see cref="ViteManifestService"/> backed by a real manifest.json written
+/// into a throwaway web-root directory, then cleans the directory up on dispose.
+/// The service reads <c>{WebRootPath}/.vite/manifest.json</c> once and caches it, so
+/// each test gets its own isolated context.
+/// </summary>
+public sealed class ManifestTestContext : IDisposable
+{
+  private readonly string _webRoot;
+
+  private ManifestTestContext(string webRoot, ViteManifestService service)
+  {
+    _webRoot = webRoot;
+    Service = service;
+  }
+
+  public ViteManifestService Service { get; }
+
+  public static ManifestTestContext Create(string manifestJson, ViteManifestOptions? options = null)
+  {
+    var webRoot = Path.Combine(Path.GetTempPath(), "vite-dotnet-tests", Guid.NewGuid().ToString("N"));
+    var viteDir = Path.Combine(webRoot, ".vite");
+    Directory.CreateDirectory(viteDir);
+    File.WriteAllText(Path.Combine(viteDir, "manifest.json"), manifestJson);
+
+    var env = new FakeWebHostEnvironment { WebRootPath = webRoot };
+    var service = new ViteManifestService(
+      env,
+      NullLogger<ViteManifestService>.Instance,
+      Options.Create(options ?? new ViteManifestOptions()));
+
+    return new ManifestTestContext(webRoot, service);
+  }
+
+  /// <summary>Creates a context whose manifest file does not exist on disk.</summary>
+  public static ManifestTestContext CreateWithoutManifest(ViteManifestOptions? options = null)
+  {
+    var webRoot = Path.Combine(Path.GetTempPath(), "vite-dotnet-tests", Guid.NewGuid().ToString("N"));
+    Directory.CreateDirectory(webRoot);
+
+    var env = new FakeWebHostEnvironment { WebRootPath = webRoot };
+    var service = new ViteManifestService(
+      env,
+      NullLogger<ViteManifestService>.Instance,
+      Options.Create(options ?? new ViteManifestOptions()));
+
+    return new ManifestTestContext(webRoot, service);
+  }
+
+  public void Dispose()
+  {
+    try
+    {
+      if (Directory.Exists(_webRoot))
+      {
+        Directory.Delete(_webRoot, recursive: true);
+      }
+    }
+    catch (IOException)
+    {
+      // Best-effort cleanup; a locked temp file must not fail the test run.
+    }
+  }
+
+  private sealed class FakeWebHostEnvironment : IWebHostEnvironment
+  {
+    public string WebRootPath { get; set; } = "";
+    public IFileProvider WebRootFileProvider { get; set; } = new NullFileProvider();
+    public string ApplicationName { get; set; } = "Vite.dotnet.Tests";
+    public string ContentRootPath { get; set; } = "";
+    public IFileProvider ContentRootFileProvider { get; set; } = new NullFileProvider();
+    public string EnvironmentName { get; set; } = "Production";
+  }
+}
diff --git a/Vite.dotnet.Tests/Vite.dotnet.Tests.csproj b/Vite.dotnet.Tests/Vite.dotnet.Tests.csproj
new file mode 100644
index 0000000..2a137ba
--- /dev/null
+++ b/Vite.dotnet.Tests/Vite.dotnet.Tests.csproj
@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="3.1.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Vite.dotnet\Vite.dotnet.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/Vite.dotnet.Tests/ViteManifestServiceTests.cs b/Vite.dotnet.Tests/ViteManifestServiceTests.cs
new file mode 100644
index 0000000..4e12188
--- /dev/null
+++ b/Vite.dotnet.Tests/ViteManifestServiceTests.cs
@@ -0,0 +1,402 @@
+using Vite.Configuration;
+using Vite.Models;
+using Xunit;
+
+namespace Vite.dotnet.Tests;
+
+public class ViteManifestServiceTests
+{
+  // A manifest shaped like a real multi-entry Vite build: two entries share a split
+  // chunk ("_client.gen") that carries its own CSS, exactly the case the transitive
+  // walk exists to cover.
+  private const string SharedChunkManifest = """
+  {
+    "_client.gen-WrdE9yCN.js": {
+      "file": "assets/client.gen-WrdE9yCN.js",
+      "name": "client.gen",
+      "css": ["assets/client-CYzq3z7c.css"]
+    },
+    "index.html": {
+      "file": "assets/main-espf9ZVg.js",
+      "name": "main",
+      "src": "index.html",
+      "isEntry": true,
+      "imports": ["_client.gen-WrdE9yCN.js"],
+      "css": ["assets/main-COZv9l4K.css"]
+    },
+    "checkout/index.html": {
+      "file": "assets/checkout-DLgJ9jU3.js",
+      "name": "checkout",
+      "src": "checkout/index.html",
+      "isEntry": true,
+      "imports": ["_client.gen-WrdE9yCN.js"],
+      "css": ["assets/checkout-CfozXp2E.css"]
+    }
+  }
+  """;
+
+  [Fact]
+  public void GetCssFiles_IncludesCssFromImportedChunk()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+
+    var css = ctx.Service.GetCssFiles("index.html", "/");
+
+    Assert.Contains("/assets/client-CYzq3z7c.css", css);
+    Assert.Contains("/assets/main-COZv9l4K.css", css);
+  }
+
+  [Fact]
+  public void GetCssFiles_OrdersImportedCssBeforeOwnCss()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+
+    var css = ctx.Service.GetCssFiles("checkout/index.html", "/");
+
+    Assert.Equal(
+      ["/assets/client-CYzq3z7c.css", "/assets/checkout-CfozXp2E.css"],
+      css);
+  }
+
+  [Fact]
+  public void GetCssFiles_AppliesBasePathToImportedCss()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+
+    var css = ctx.Service.GetCssFiles("index.html", "/dist/");
+
+    Assert.Equal(
+      ["/dist/assets/client-CYzq3z7c.css", "/dist/assets/main-COZv9l4K.css"],
+      css);
+  }
+
+  [Fact]
+  public void GetCssFiles_DeduplicatesCssSharedAcrossImports()
+  {
+    // Two imported chunks that both reference the same CSS file.
+    const string manifest = """
+    {
+      "_a.js": { "file": "assets/a.js", "css": ["assets/shared.css"] },
+      "_b.js": { "file": "assets/b.js", "css": ["assets/shared.css"] },
+      "index.html": {
+        "file": "assets/main.js",
+        "isEntry": true,
+        "imports": ["_a.js", "_b.js"],
+        "css": ["assets/main.css"]
+      }
+    }
+    """;
+    using var ctx = ManifestTestContext.Create(manifest);
+
+    var css = ctx.Service.GetCssFiles("index.html", "/");
+
+    Assert.Equal(
+      ["/assets/shared.css", "/assets/main.css"],
+      css);
+  }
+
+  [Fact]
+  public void GetCssFiles_WalksNestedImportsTransitively()
+  {
+    // entry -> _mid -> _leaf, each contributing CSS.
+    const string manifest = """
+    {
+      "_leaf.js": { "file": "assets/leaf.js", "css": ["assets/leaf.css"] },
+      "_mid.js": { "file": "assets/mid.js", "imports": ["_leaf.js"], "css": ["assets/mid.css"] },
+      "index.html": {
+        "file": "assets/main.js",
+        "isEntry": true,
+        "imports": ["_mid.js"],
+        "css": ["assets/main.css"]
+      }
+    }
+    """;
+    using var ctx = ManifestTestContext.Create(manifest);
+
+    var css = ctx.Service.GetCssFiles("index.html", "/");
+
+    Assert.Equal(
+      ["/assets/leaf.css", "/assets/mid.css", "/assets/main.css"],
+      css);
+  }
+
+  [Fact]
+  public void GetCssFiles_DoesNotInfiniteLoopOnCyclicImports()
+  {
+    // _a imports _b, _b imports _a. The cycle guard must terminate the walk.
+    const string manifest = """
+    {
+      "_a.js": { "file": "assets/a.js", "imports": ["_b.js"], "css": ["assets/a.css"] },
+      "_b.js": { "file": "assets/b.js", "imports": ["_a.js"], "css": ["assets/b.css"] },
+      "index.html": {
+        "file": "assets/main.js",
+        "isEntry": true,
+        "imports": ["_a.js"],
+        "css": ["assets/main.css"]
+      }
+    }
+    """;
+    using var ctx = ManifestTestContext.Create(manifest);
+
+    var css = ctx.Service.GetCssFiles("index.html", "/");
+
+    Assert.Equal(3, css.Count);
+    Assert.Contains("/assets/a.css", css);
+    Assert.Contains("/assets/b.css", css);
+    Assert.Contains("/assets/main.css", css);
+  }
+
+  [Fact]
+  public void GetCssFiles_IgnoresUnknownImportKeys()
+  {
+    const string manifest = """
+    {
+      "index.html": {
+        "file": "assets/main.js",
+        "isEntry": true,
+        "imports": ["_missing.js"],
+        "css": ["assets/main.css"]
+      }
+    }
+    """;
+    using var ctx = ManifestTestContext.Create(manifest);
+
+    var css = ctx.Service.GetCssFiles("index.html", "/");
+
+    Assert.Equal(["/assets/main.css"], css);
+  }
+
+  [Fact]
+  public void GetCssFiles_ReturnsEmptyWhenEntryHasNoCssAnywhere()
+  {
+    const string manifest = """
+    {
+      "_dep.js": { "file": "assets/dep.js" },
+      "index.html": {
+        "file": "assets/main.js",
+        "isEntry": true,
+        "imports": ["_dep.js"]
+      }
+    }
+    """;
+    using var ctx = ManifestTestContext.Create(manifest);
+
+    Assert.Empty(ctx.Service.GetCssFiles("index.html", "/"));
+  }
+
+  [Fact]
+  public void GetCssFiles_TrimsTrailingSlashFromBasePath()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+
+    var css = ctx.Service.GetCssFiles("index.html", "/dist///");
+
+    Assert.All(css, href => Assert.StartsWith("/dist/assets/", href));
+    Assert.DoesNotContain(css, href => href.Contains("//assets"));
+  }
+
+  [Fact]
+  public void GetEntry_StripsLeadingTilde()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+
+    var entry = ctx.Service.GetEntry("~/index.html");
+
+    Assert.NotNull(entry);
+    Assert.Equal("assets/main-espf9ZVg.js", entry!.File);
+  }
+
+  [Fact]
+  public void GetEntry_ReturnsNullForMissingEntry()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+
+    Assert.Null(ctx.Service.GetEntry("does-not-exist.html"));
+  }
+
+  [Fact]
+  public void GetJsFile_ResolvesEntryFileWithBasePath()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+
+    Assert.Equal("/assets/checkout-DLgJ9jU3.js", ctx.Service.GetJsFile("checkout/index.html", "/"));
+  }
+
+  [Fact]
+  public void GetModulePreloadFiles_ReturnsImportedChunkFiles()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+
+    var preloads = ctx.Service.GetModulePreloadFiles(ctx.Service.GetEntry("index.html")!, "/");
+
+    Assert.Equal(["/assets/client.gen-WrdE9yCN.js"], preloads);
+  }
+
+  [Fact]
+  public void GetModulePreloadFiles_ExcludesTheEntrysOwnFile()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+
+    var preloads = ctx.Service.GetModulePreloadFiles(ctx.Service.GetEntry("index.html")!, "/");
+
+    Assert.DoesNotContain("/assets/main-espf9ZVg.js", preloads);
+  }
+
+  [Fact]
+  public void GetModulePreloadFiles_WalksNestedImportsDeepestFirst()
+  {
+    const string manifest = """
+    {
+      "_leaf.js": { "file": "assets/leaf.js" },
+      "_mid.js": { "file": "assets/mid.js", "imports": ["_leaf.js"] },
+      "index.html": {
+        "file": "assets/main.js",
+        "isEntry": true,
+        "imports": ["_mid.js"]
+      }
+    }
+    """;
+    using var ctx = ManifestTestContext.Create(manifest);
+
+    var preloads = ctx.Service.GetModulePreloadFiles(ctx.Service.GetEntry("index.html")!, "/");
+
+    Assert.Equal(["/assets/leaf.js", "/assets/mid.js"], preloads);
+  }
+
+  [Fact]
+  public void GetModulePreloadFiles_DeduplicatesAndHandlesCycles()
+  {
+    const string manifest = """
+    {
+      "_a.js": { "file": "assets/a.js", "imports": ["_b.js"] },
+      "_b.js": { "file": "assets/b.js", "imports": ["_a.js"] },
+      "index.html": {
+        "file": "assets/main.js",
+        "isEntry": true,
+        "imports": ["_a.js", "_b.js"]
+      }
+    }
+    """;
+    using var ctx = ManifestTestContext.Create(manifest);
+
+    var preloads = ctx.Service.GetModulePreloadFiles(ctx.Service.GetEntry("index.html")!, "/");
+
+    Assert.Equal(2, preloads.Count);
+    Assert.Contains("/assets/a.js", preloads);
+    Assert.Contains("/assets/b.js", preloads);
+  }
+
+  [Fact]
+  public void GetModulePreloadFiles_EmptyWhenNoImports()
+  {
+    const string manifest = """
+    { "index.html": { "file": "assets/main.js", "isEntry": true } }
+    """;
+    using var ctx = ManifestTestContext.Create(manifest);
+
+    Assert.Empty(ctx.Service.GetModulePreloadFiles(ctx.Service.GetEntry("index.html")!, "/"));
+  }
+
+  [Fact]
+  public void RenderJs_EmitsModulePreloadLinksBeforeEntryScript()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+    var entry = ctx.Service.GetEntry("index.html")!;
+
+    var html = RenderToString(ctx.Service.RenderJs(entry, "/"));
+
+    Assert.Contains("<link rel=\"modulepreload\" href=\"/assets/client.gen-WrdE9yCN.js\" />", html);
+    Assert.Contains("<script type=\"module\" src=\"/assets/main-espf9ZVg.js\"></script>", html);
+    Assert.True(
+      html.IndexOf("modulepreload", StringComparison.Ordinal) < html.IndexOf("<script", StringComparison.Ordinal),
+      "modulepreload links must precede the entry script tag");
+  }
+
+  [Fact]
+  public void RenderJs_EmitsSingleScriptTagForEntry()
+  {
+    // The entry's imported chunks are preloaded, never given their own <script> tag
+    // (the module loader fetches them via the entry's import statements).
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+    var entry = ctx.Service.GetEntry("index.html")!;
+
+    var html = RenderToString(ctx.Service.RenderJs(entry, "/"));
+
+    var scriptCount = html.Split("<script", StringSplitOptions.None).Length - 1;
+    Assert.Equal(1, scriptCount);
+  }
+
+  [Fact]
+  public void GetCssFiles_UsesConfiguredDefaultEntry()
+  {
+    var options = new ViteManifestOptions { DefaultEntry = "index.html", DefaultBasePath = "/" };
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest, options);
+
+    var css = ctx.Service.GetCssFiles();
+
+    Assert.Contains("/assets/client-CYzq3z7c.css", css);
+    Assert.Contains("/assets/main-COZv9l4K.css", css);
+  }
+
+  [Fact]
+  public void RenderCss_EmitsStylesheetLinksForEntryAndImports()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+    var entry = ctx.Service.GetEntry("index.html")!;
+
+    var html = RenderToString(ctx.Service.RenderCss(entry, "/"));
+
+    Assert.Contains("<link rel=\"stylesheet\" href=\"/assets/client-CYzq3z7c.css\" />", html);
+    Assert.Contains("<link rel=\"stylesheet\" href=\"/assets/main-COZv9l4K.css\" />", html);
+  }
+
+  [Fact]
+  public void RenderCss_WithPreloadEmitsPreloadAndNoscriptFallback()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+    var entry = ctx.Service.GetEntry("index.html")!;
+
+    var html = RenderToString(ctx.Service.RenderCss(entry, "/", preload: true));
+
+    Assert.Contains("rel=\"preload\"", html);
+    Assert.Contains("<noscript>", html);
+  }
+
+  [Fact]
+  public void RenderEntry_EmitsCommentWhenEntryMissing()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+
+    var html = RenderToString(ctx.Service.RenderEntry("missing.html"));
+
+    Assert.Contains("not found in manifest", html);
+  }
+
+  [Fact]
+  public void RenderEntry_CssOnly_DoesNotEmitScriptTag()
+  {
+    using var ctx = ManifestTestContext.Create(SharedChunkManifest);
+
+    var html = RenderToString(ctx.Service.RenderEntry("index.html", "/", assets: ViteAssets.Css));
+
+    Assert.Contains("<link", html);
+    Assert.DoesNotContain("<script", html);
+  }
+
+  [Fact]
+  public void MissingManifest_YieldsEmptyResultsWithoutThrowing()
+  {
+    using var ctx = ManifestTestContext.CreateWithoutManifest();
+
+    Assert.Null(ctx.Service.GetEntry("index.html"));
+    Assert.Empty(ctx.Service.GetCssFiles("index.html", "/"));
+    Assert.Null(ctx.Service.GetJsFile("index.html", "/"));
+  }
+
+  private static string RenderToString(Microsoft.AspNetCore.Html.IHtmlContent content)
+  {
+    using var writer = new StringWriter();
+    content.WriteTo(writer, System.Text.Encodings.Web.HtmlEncoder.Default);
+    return writer.ToString();
+  }
+}
diff --git a/Vite.dotnet.slnx b/Vite.dotnet.slnx
index 313f8e6..f1794fb 100644
--- a/Vite.dotnet.slnx
+++ b/Vite.dotnet.slnx
@@ -7,5 +7,6 @@
   <Folder Name="/Documentation/">
     <File Path="README.md" />
   </Folder>
+  <Project Path="Vite.dotnet.Tests/Vite.dotnet.Tests.csproj" />
   <Project Path="Vite.dotnet/Vite.dotnet.csproj" />
 </Solution>
diff --git a/Vite.dotnet/Services/IViteManifestService.cs b/Vite.dotnet/Services/IViteManifestService.cs
index 7024198..e6074cc 100644
--- a/Vite.dotnet/Services/IViteManifestService.cs
+++ b/Vite.dotnet/Services/IViteManifestService.cs
@@ -30,7 +30,9 @@ public interface IViteManifestService
   IReadOnlyList<string> GetCssFiles(string entry, string basePath);
 
   /// <summary>
-  /// Returns the base-path-resolved CSS file URLs for a manifest entry.
+  /// Returns the base-path-resolved CSS file URLs for a manifest entry, including CSS
+  /// contributed by chunks the entry imports (walked transitively). Imported chunks'
+  /// CSS is ordered before the entry's own so the entry can override its dependencies.
   /// </summary>
   IReadOnlyList<string> GetCssFiles(ViteManifestEntry entry, string basePath);
 
@@ -51,6 +53,14 @@ public interface IViteManifestService
   /// </summary>
   string? GetJsFile(ViteManifestEntry entry, string basePath);
 
+  /// <summary>
+  /// Returns the base-path-resolved URLs of the chunks a manifest entry imports
+  /// (walked transitively, deepest dependency first, deduplicated). These are the
+  /// files worth emitting as <c>&lt;link rel="modulepreload"&gt;</c> hints; the entry's
+  /// own file is excluded. Empty when the entry imports nothing.
+  /// </summary>
+  IReadOnlyList<string> GetModulePreloadFiles(ViteManifestEntry entry, string basePath);
+
   /// <summary>
   /// Renders only the CSS &lt;link&gt; tags for a manifest entry.
   /// </summary>
diff --git a/Vite.dotnet/Services/ViteManifestService.cs b/Vite.dotnet/Services/ViteManifestService.cs
index 95fbd9d..9f42425 100644
--- a/Vite.dotnet/Services/ViteManifestService.cs
+++ b/Vite.dotnet/Services/ViteManifestService.cs
@@ -54,13 +54,56 @@ public IReadOnlyList<string> GetCssFiles(string entry, string basePath)
 
   public IReadOnlyList<string> GetCssFiles(ViteManifestEntry entry, string basePath)
   {
-    if (entry.Css is null || entry.Css.Count == 0)
+    // Collect CSS from the whole dependency graph: an entry's own `css` only
+    // covers the modules bundled into its chunk. CSS pulled in by shared/imported
+    // chunks (Vite splits those out) lives on those chunks' manifest records and
+    // is reachable only by walking `imports` transitively.
+    var collected = new List<string>();
+    var seenCss = new HashSet<string>(StringComparer.Ordinal);
+    var visited = new HashSet<string>(StringComparer.Ordinal);
+    CollectCss(entry, collected, seenCss, visited);
+
+    if (collected.Count == 0)
     {
       return [];
     }
 
     var basePrefix = basePath.TrimEnd('/');
-    return [.. entry.Css.Select(css => $"{basePrefix}/{css}")];
+    return [.. collected.Select(css => $"{basePrefix}/{css}")];
+  }
+
+  // Depth-first walk of the import graph. Imported chunks are processed before the
+  // current entry's own CSS so a dependency's styles load first and the entry's own
+  // styles can override them (mirrors Vite's own backend-integration collectCss).
+  private void CollectCss(ViteManifestEntry entry, List<string> collected, HashSet<string> seenCss, HashSet<string> visited)
+  {
+    if (entry.Imports is { Count: > 0 })
+    {
+      foreach (var import in entry.Imports)
+      {
+        // Guard against cycles and redundant work when several entries share a chunk.
+        if (!visited.Add(import))
+        {
+          continue;
+        }
+
+        if (_manifest.Value.TryGetValue(import, out var importedChunk))
+        {
+          CollectCss(importedChunk, collected, seenCss, visited);
+        }
+      }
+    }
+
+    if (entry.Css is { Count: > 0 })
+    {
+      foreach (var css in entry.Css)
+      {
+        if (seenCss.Add(css))
+        {
+          collected.Add(css);
+        }
+      }
+    }
   }
 
   public string? GetJsFile()
@@ -72,6 +115,56 @@ public IReadOnlyList<string> GetCssFiles(ViteManifestEntry entry, string basePat
   public string? GetJsFile(ViteManifestEntry entry, string basePath)
     => string.IsNullOrEmpty(entry.File) ? null : $"{basePath.TrimEnd('/')}/{entry.File}";
 
+  public IReadOnlyList<string> GetModulePreloadFiles(ViteManifestEntry entry, string basePath)
+  {
+    // The browser's ES module loader fetches statically-imported chunks on its own,
+    // but only after it has parsed the entry chunk. Emitting modulepreload hints for
+    // those imported chunks removes that discovery round-trip (matches Vite's own
+    // generated HTML). Walks the same import graph GetCssFiles uses.
+    var collected = new List<string>();
+    var seenFiles = new HashSet<string>(StringComparer.Ordinal);
+    var visited = new HashSet<string>(StringComparer.Ordinal);
+    CollectImportedJs(entry, collected, seenFiles, visited);
+
+    if (collected.Count == 0)
+    {
+      return [];
+    }
+
+    var basePrefix = basePath.TrimEnd('/');
+    return [.. collected.Select(file => $"{basePrefix}/{file}")];
+  }
+
+  // Depth-first walk collecting the output file of every transitively imported chunk
+  // (deepest dependency first). The entry's own file is excluded — it gets a real
+  // <script> tag, not a preload.
+  private void CollectImportedJs(ViteManifestEntry entry, List<string> collected, HashSet<string> seenFiles, HashSet<string> visited)
+  {
+    if (entry.Imports is not { Count: > 0 })
+    {
+      return;
+    }
+
+    foreach (var import in entry.Imports)
+    {
+      // Guard against cycles and redundant work when several entries share a chunk.
+      if (!visited.Add(import))
+      {
+        continue;
+      }
+
+      if (_manifest.Value.TryGetValue(import, out var importedChunk))
+      {
+        CollectImportedJs(importedChunk, collected, seenFiles, visited);
+
+        if (!string.IsNullOrEmpty(importedChunk.File) && seenFiles.Add(importedChunk.File))
+        {
+          collected.Add(importedChunk.File);
+        }
+      }
+    }
+  }
+
   public IHtmlContent RenderCss(ViteManifestEntry entry, string basePath, bool preload = false)
   {
     var hrefs = GetCssFiles(entry, basePath);
@@ -109,7 +202,22 @@ public IHtmlContent RenderCss(ViteManifestEntry entry, string basePath, bool pre
   public IHtmlContent RenderJs(ViteManifestEntry entry, string basePath)
   {
     var src = GetJsFile(entry, basePath);
-    return src is null ? HtmlString.Empty : new HtmlString($"<script type=\"module\" src=\"{src}\"></script>\n");
+    if (src is null)
+    {
+      return HtmlString.Empty;
+    }
+
+    var html = new StringBuilder();
+
+    // Preload statically-imported chunks so the browser fetches them in parallel with
+    // the entry rather than discovering them only after the entry has been parsed.
+    foreach (var preload in GetModulePreloadFiles(entry, basePath))
+    {
+      html.AppendLine($"<link rel=\"modulepreload\" href=\"{preload}\" />");
+    }
+
+    html.Append($"<script type=\"module\" src=\"{src}\"></script>\n");
+    return new HtmlString(html.ToString());
   }
 
   public IHtmlContent RenderEntry(string? entry = null, string? basePath = null, bool preloadCss = false, ViteAssets assets = ViteAssets.All, string? devServer = null)
diff --git a/Vite.dotnet/Vite.dotnet.csproj b/Vite.dotnet/Vite.dotnet.csproj
index 4b542ec..36b6292 100644
--- a/Vite.dotnet/Vite.dotnet.csproj
+++ b/Vite.dotnet/Vite.dotnet.csproj
@@ -4,7 +4,7 @@
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <Version>0.2.0</Version>
+    <Version>0.3.0</Version>
   </PropertyGroup>
 
   <PropertyGroup>