evolit 0.1.0-alpha.24 → 0.1.0-alpha.26

package/README.md

@@ -317,6 +317,33 @@ export default {
 };
 ```
 
+For monorepos, development watches only the application project by default. Additional source
+trees can be opted into explicitly; generated output and dependency directories below every root
+remain ignored:
+
+```js
+export default {
+  development: {
+    managedSourceRoots: ["../packages/design-system/src"],
+  },
+};
+```
+
+Imports outside these roots remain unmanaged and produce the existing development warning.
+
+Evolit normally discovers browser boundaries from the static module graph and reconciles that
+inventory with the components actually emitted by SSR. A genuinely computed import cannot be
+enumerated at build time, so production applications can declare only those exceptional modules:
+
+```js
+export default {
+  clientBoundaries: ["./src/components/dynamic-card.litsx", "@acme/ui/product-card"],
+};
+```
+
+These modules are materialized as build artifacts, but are not automatically imported or
+preloaded. They reach the browser only when an SSR hydration root references them.
+
 The framework also exports `ObjectStorageResponseCacheStore`, which is intended for object-store
 backends such as S3. A concrete app can wire it to the AWS SDK without pulling AWS dependencies
 into `evolit` itself.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolit",
-  "version": "0.1.0-alpha.24",
+  "version": "0.1.0-alpha.26",
   "description": "A convention-driven application framework for LitSX and web components.",
   "type": "module",
   "packageManager": "yarn@4.10.3",
@@ -14,7 +14,9 @@
   "homepage": "https://github.com/litsxdev/nextsx#readme",
   "files": [
     "src",
-    "templates"
+    "templates/default/app/**",
+    "templates/default/jsconfig.json",
+    "templates/default/yarnrc.yml.template"
   ],
   "bin": "./src/cli.js",
   "main": "./src/index.js",
@@ -52,10 +54,11 @@
   },
   "dependencies": {
     "@jridgewell/remapping": "^2.3.5",
-    "@litsx/compiler": "0.9.5-canary-feat-ssr-20260726184312",
-    "@litsx/core": "0.17.0-canary-feat-ssr-20260726184312",
-    "@litsx/ssr": "0.2.0-canary-feat-ssr-20260726184312",
+    "@litsx/compiler": "0.10.0-canary-feat-ssr-20260731112627",
+    "@litsx/core": "0.17.0-canary-feat-ssr-20260731112627",
+    "@litsx/ssr": "0.2.0-canary-feat-ssr-20260731112627",
     "@litsx/typescript": "^0.9.0",
+    "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "lit": "^3.3.3",
     "magic-string": "^1.1.0",

package/src/build.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import {
   discoverAppRouteHandlers,
   discoverAppRoutes,
@@ -15,13 +16,20 @@ import {
   emitBundledClientAssets,
   emitHashedClientAssets,
   normalizeHydrationDataForClient,
+  resolveServerStyleUrls,
   resolveHydrationRootClientImports,
-  resolveRouteClientImports,
   resolveSharedVendorModuleUrl,
   rewriteHydrationDataScript,
   rewriteServerAssetPlaceholders,
 } from "./client-assets.js";
-import { compileModuleGraph, importCompiledModule } from "./compiler.js";
+import {
+  collectClientGraphInventory,
+  compileModuleGraph,
+  emitClientStaticAssets,
+  getClientStaticAssetModule,
+  importCompiledModule,
+  resolveProjectModuleSpecifier,
+} from "./compiler.js";
 import { loadEvolitConfig } from "./config.js";
 import {
   BUILD_DIRECTORY,
@@ -125,7 +133,37 @@ export async function buildProject(projectRoot) {
   const routeHandlers = await discoverAppRouteHandlers(projectRoot);
   const buildRoot = path.join(projectRoot, INTERNAL_DIRECTORY, BUILD_DIRECTORY);
   const entryClientModules = new Set();
+  const serverAssetImportsByEntry = {};
+  const clientBoundariesByEntry = {};
   const deployHandlers = [];
+  const compiledClientBoundaries = new Map();
+  const inventoriesBySourceEntry = new Map();
+
+  function getEntryInventory(entryPath) {
+    let inventory = inventoriesBySourceEntry.get(entryPath);
+    if (!inventory) {
+      inventory = collectClientGraphInventory([entryPath], { projectRoot });
+      inventoriesBySourceEntry.set(entryPath, inventory);
+    }
+    return inventory;
+  }
+
+  async function compileProductionClientBoundary(sourcePath) {
+    let clientModule = compiledClientBoundaries.get(sourcePath);
+    if (clientModule) return clientModule;
+    const clientBuild = await compileModuleGraph(sourcePath, {
+      projectRoot,
+      mode: "production",
+      sourceMaps: true,
+      target: "client",
+    });
+    clientModule = path.relative(clientBuild.outputRoot, clientBuild.entrypoint)
+      .split(path.sep)
+      .join("/");
+    compiledClientBoundaries.set(sourcePath, clientModule);
+    entryClientModules.add(clientModule);
+    return clientModule;
+  }
 
   await ensureDirectory(buildRoot);
 
@@ -168,16 +206,6 @@ export async function buildProject(projectRoot) {
       target: "server",
     });
 
-    const pageClientBuild = await compileModuleGraph(route.page, {
-      projectRoot,
-      mode: "production",
-      sourceMaps: true,
-      target: "client",
-    });
-    entryClientModules.add(
-      path.relative(pageClientBuild.outputRoot, pageClientBuild.entrypoint).split(path.sep).join("/"),
-    );
-
     for (const layoutPath of route.layouts) {
       await compileModuleGraph(layoutPath, {
         projectRoot,
@@ -187,15 +215,6 @@ export async function buildProject(projectRoot) {
         target: "server",
       });
 
-      const layoutClientBuild = await compileModuleGraph(layoutPath, {
-        projectRoot,
-        mode: "production",
-        sourceMaps: true,
-        target: "client",
-      });
-      entryClientModules.add(
-        path.relative(layoutClientBuild.outputRoot, layoutClientBuild.entrypoint).split(path.sep).join("/"),
-      );
     }
 
     const boundaryModules = [
@@ -210,23 +229,70 @@ export async function buildProject(projectRoot) {
         ssr: true,
         target: "server",
       });
+    }
 
-      const boundaryClientBuild = await compileModuleGraph(boundaryPath, {
+    const toProjectRelative = (filePath) => path.relative(projectRoot, filePath).split(path.sep).join("/");
+    const segmentEntries = [...new Set([route.page, ...route.layouts, ...boundaryModules])];
+    const inventoriesByEntry = new Map(await Promise.all(segmentEntries.map(async (entryPath) => [
+      entryPath,
+      await getEntryInventory(entryPath),
+    ])));
+    const allStyles = new Set();
+    const allAssets = new Set();
+    const allClientBoundaries = new Set();
+    for (const [entryPath, entryInventory] of inventoriesByEntry) {
+      serverAssetImportsByEntry[toProjectRelative(entryPath)] = {
+        styles: entryInventory.styles.map((filePath) => getClientStaticAssetModule(projectRoot, filePath)),
+        assets: entryInventory.assets.map((filePath) => getClientStaticAssetModule(projectRoot, filePath)),
+      };
+      entryInventory.styles.forEach((filePath) => allStyles.add(filePath));
+      entryInventory.assets.forEach((filePath) => allAssets.add(filePath));
+      entryInventory.clientBoundaries.forEach((filePath) => allClientBoundaries.add(filePath));
+    }
+    await emitClientStaticAssets([...allStyles, ...allAssets], {
+      projectRoot,
+      mode: "production",
+    });
+    const compiledBoundaryModules = new Map();
+    for (const clientBoundary of allClientBoundaries) {
+      compiledBoundaryModules.set(
+        clientBoundary,
+        await compileProductionClientBoundary(clientBoundary),
+      );
+    }
+    for (const [entryPath, entryInventory] of inventoriesByEntry) {
+      clientBoundariesByEntry[toProjectRelative(entryPath)] = entryInventory.clientBoundaries
+        .map((clientBoundary) => compiledBoundaryModules.get(clientBoundary))
+        .filter(Boolean)
+        .sort();
+    }
+  }
+
+  const configuredClientBoundaries = evolitConfig.clientBoundaries ?? [];
+  if (!Array.isArray(configuredClientBoundaries)) {
+    throw new Error("Expected clientBoundaries in evolit.config.js to be an array of module specifiers.");
+  }
+  for (const specifier of configuredClientBoundaries) {
+    if (typeof specifier !== "string" || specifier.length === 0) {
+      throw new Error("Expected every clientBoundaries entry to be a non-empty module specifier.");
+    }
+    const sourcePath = path.isAbsolute(specifier)
+      ? specifier
+      : await resolveProjectModuleSpecifier(
         projectRoot,
-        mode: "production",
-        sourceMaps: true,
-        target: "client",
-      });
-      entryClientModules.add(
-        path.relative(boundaryClientBuild.outputRoot, boundaryClientBuild.entrypoint)
-          .split(path.sep)
-          .join("/"),
+        path.join(projectRoot, "evolit.config.js"),
+        specifier,
       );
+    if (!sourcePath) {
+      throw new Error(`Unable to resolve configured client boundary ${JSON.stringify(specifier)}.`);
     }
+    await compileProductionClientBoundary(sourcePath);
   }
 
   const clientAssets = await emitBundledClientAssets(projectRoot, {
     entryClientModules,
+    serverAssetImportsByEntry,
+    clientBoundariesByEntry,
   });
   const staticAssetPublicUrls = createStaticAssetPublicUrlMap(clientAssets);
   await rewriteServerAssetPlaceholders(projectRoot, clientAssets);
@@ -244,19 +310,68 @@ export async function buildProject(projectRoot) {
   );
   const ssrAdapter = createSsrAdapter({
     assetResolver,
+    async onSsrResult({ routeResult, result }) {
+      const renderedModules = [...new Set([
+        ...(Array.isArray(result.clientImports) ? result.clientImports : []),
+        ...(Array.isArray(result.hydrationData?.roots)
+          ? result.hydrationData.roots.map((root) => root?.moduleId)
+          : []),
+      ].filter((moduleId) => typeof moduleId === "string" && moduleId.length > 0))];
+      const unresolved = [];
+      for (const moduleId of renderedModules) {
+        if (assetResolver(moduleId) || clientAssets.byPublicPath?.[moduleId]) continue;
+        const importerPath = routeResult.boundaryModule
+          ?? routeResult.route?.page
+          ?? path.join(projectRoot, "app", "page.litsx");
+        let sourcePath = null;
+        if (moduleId.startsWith("file:")) {
+          try { sourcePath = fileURLToPath(moduleId); } catch {}
+        } else if (path.isAbsolute(moduleId) && !moduleId.startsWith("/app/") && !moduleId.startsWith("/src/")) {
+          sourcePath = moduleId;
+        } else if (moduleId.startsWith("/")) {
+          sourcePath = await resolveProjectModuleSpecifier(projectRoot, importerPath, `.${moduleId}`);
+        } else {
+          sourcePath = await resolveProjectModuleSpecifier(projectRoot, importerPath, moduleId);
+        }
+        const publicUrl = sourcePath ? assetResolver(sourcePath) : null;
+        if (!publicUrl) {
+          unresolved.push(moduleId);
+          continue;
+        }
+        for (const root of result.hydrationData?.roots ?? []) {
+          if (root?.moduleId === moduleId) root.moduleId = sourcePath;
+        }
+        if (Array.isArray(result.clientImports)) {
+          result.clientImports = result.clientImports.map((value) => value === moduleId ? publicUrl : value);
+        }
+        if (Array.isArray(result.hydrationData?.clientImports)) {
+          result.hydrationData.clientImports = result.hydrationData.clientImports
+            .map((value) => value === moduleId ? publicUrl : value);
+        }
+      }
+      if (unresolved.length > 0) {
+        throw new Error(
+          `SSR rendered client boundaries without build artifacts for ${routeResult.route?.pathname ?? "route"}: `
+          + `${unresolved.join(", ")}.`,
+        );
+      }
+    },
     async resolveAdditionalHead({ routeResult, result }) {
-      const clientImports = [
+      const clientImports = [...new Set([
         ...(Array.isArray(result.clientImports) ? result.clientImports : []),
-        ...resolveRouteClientImports(routeResult, projectRoot, clientAssets),
-      ];
-      const hydratedClientImports = Array.isArray(result.clientImports) ? result.clientImports : [];
+        ...resolveHydrationRootClientImports(result.hydrationData, assetResolver),
+      ])];
+      const hydratedClientImports = clientImports;
       const urls = hydratedClientImports.length > 0
         ? [...new Set([
           ...hydratedClientImports,
           ...collectTransitiveAssetPreloads(hydratedClientImports, clientAssets),
         ])]
         : [];
-      const styleUrls = collectTransitiveStyleUrls(clientImports, clientAssets);
+      const styleUrls = [...new Set([
+        ...collectTransitiveStyleUrls(clientImports, clientAssets),
+        ...resolveServerStyleUrls(routeResult, projectRoot, clientAssets),
+      ])];
 
       return [
         ...urls.map((href) => `<link rel="modulepreload" href="${href}" data-evolit-route-asset="preload">`),
@@ -264,36 +379,23 @@ export async function buildProject(projectRoot) {
       ].join("\n");
     },
     resolveBootstrap({ routeResult, result }) {
-      const routeClientImports = resolveRouteClientImports(
-        routeResult,
-        projectRoot,
-        clientAssets,
-      );
       return createHydrationBootstrap({
         hydrationData: normalizeHydrationDataForClient(
           result.hydrationData,
           projectRoot,
-          routeClientImports,
+          resolveHydrationRootClientImports(result.hydrationData, assetResolver),
         ),
         assetResolver,
         hydrationModuleUrl,
       });
     },
     transformDocument({ routeResult, result, document }) {
-      const routeClientImports = resolveRouteClientImports(
-        routeResult,
-        projectRoot,
-        clientAssets,
-      );
       return rewriteHydrationDataScript(
         document,
         normalizeHydrationDataForClient(
           result.hydrationData,
           projectRoot,
-          [
-            ...routeClientImports,
-            ...resolveHydrationRootClientImports(result.hydrationData, assetResolver),
-          ],
+          resolveHydrationRootClientImports(result.hydrationData, assetResolver),
         ),
       );
     },

package/src/client-assets.js

@@ -6,6 +6,7 @@ import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import MagicString from "magic-string";
 import { rollup } from "rollup";
+import commonjs from "@rollup/plugin-commonjs";
 import { nodeResolve } from "@rollup/plugin-node-resolve";
 import {
   BUILD_DIRECTORY,
@@ -54,6 +55,12 @@ export function resetDevelopmentAssetCaches(projectRoot) {
       }
     }
   }
+  const resolutionPrefix = `${normalizedProjectRoot}::`;
+  for (const cache of [browserSpecifierFilePathCache, packageRootCache]) {
+    for (const key of cache.keys()) {
+      if (key.startsWith(resolutionPrefix)) cache.delete(key);
+    }
+  }
 }
 
 function isBareSpecifier(specifier) {
@@ -125,13 +132,20 @@ function parsePackageSpecifier(specifier) {
   };
 }
 
-export async function resolvePackageRoot(packageName) {
-  if (packageRootCache.has(packageName)) {
-    return packageRootCache.get(packageName);
+export async function resolvePackageRoot(packageName, options = {}) {
+  const resolveFrom = path.resolve(options.projectRoot ?? path.dirname(fileURLToPath(import.meta.url)));
+  const cacheKey = `${resolveFrom}::${packageName}`;
+  if (packageRootCache.has(cacheKey)) {
+    return packageRootCache.get(cacheKey);
   }
 
   const pendingResolution = (async () => {
-    const packageEntryPath = requireFromHere.resolve(packageName);
+    let packageEntryPath;
+    try {
+      packageEntryPath = createRequire(path.join(resolveFrom, "package.json")).resolve(packageName);
+    } catch {
+      packageEntryPath = requireFromHere.resolve(packageName);
+    }
     let currentPath = path.dirname(packageEntryPath);
 
     while (true) {
@@ -157,12 +171,12 @@ export async function resolvePackageRoot(packageName) {
     throw new Error(`Unable to resolve package root for ${packageName}`);
   })();
 
-  packageRootCache.set(packageName, pendingResolution);
+  packageRootCache.set(cacheKey, pendingResolution);
 
   try {
     return await pendingResolution;
   } catch (error) {
-    packageRootCache.delete(packageName);
+    packageRootCache.delete(cacheKey);
     throw error;
   }
 }
@@ -184,13 +198,15 @@ function pickBrowserExportTarget(target) {
     ?? null;
 }
 
-export async function resolveBrowserSpecifierFilePath(specifier) {
+export async function resolveBrowserSpecifierFilePath(specifier, options = {}) {
   if (!isBareSpecifier(specifier)) {
     return null;
   }
 
-  if (browserSpecifierFilePathCache.has(specifier)) {
-    return browserSpecifierFilePathCache.get(specifier);
+  const resolveFrom = path.resolve(options.projectRoot ?? path.dirname(fileURLToPath(import.meta.url)));
+  const cacheKey = `${resolveFrom}::${specifier}`;
+  if (browserSpecifierFilePathCache.has(cacheKey)) {
+    return browserSpecifierFilePathCache.get(cacheKey);
   }
 
   const pendingResolution = (async () => {
@@ -200,13 +216,32 @@ export async function resolveBrowserSpecifierFilePath(specifier) {
     }
 
     const { packageName, subpath } = parsedSpecifier;
-    const { packageRoot, packageJson } = await resolvePackageRoot(packageName);
+    const { packageRoot, packageJson } = await resolvePackageRoot(packageName, { projectRoot: resolveFrom });
     const exportKey = subpath.length > 0 ? `./${subpath}` : ".";
-    const exportTarget = pickBrowserExportTarget(packageJson.exports?.[exportKey]);
+    const exportsField = packageJson.exports;
+    const exportTarget = pickBrowserExportTarget(
+      exportsField && typeof exportsField === "object" && Object.keys(exportsField).some((key) => key.startsWith("."))
+        ? exportsField[exportKey]
+        : exportKey === "." ? exportsField : null,
+    );
     const fallbackTarget = subpath.length > 0
       ? `./${subpath}`
-      : packageJson.module ?? packageJson.main ?? null;
-    const resolvedTarget = exportTarget ?? fallbackTarget;
+      : typeof packageJson.browser === "string"
+        ? packageJson.browser
+        : packageJson.module ?? packageJson.main ?? null;
+    let resolvedTarget = exportTarget ?? fallbackTarget;
+    if (resolvedTarget && packageJson.browser && typeof packageJson.browser === "object") {
+      const normalizedTarget = resolvedTarget.startsWith("./")
+        ? resolvedTarget
+        : `./${resolvedTarget}`;
+      const browserTarget = packageJson.browser[normalizedTarget]
+        ?? packageJson.browser[resolvedTarget]
+        ?? packageJson.browser[exportKey];
+      if (browserTarget === false) {
+        throw new Error(`Browser entry is disabled for ${specifier}`);
+      }
+      if (typeof browserTarget === "string") resolvedTarget = browserTarget;
+    }
 
     if (typeof resolvedTarget !== "string" || resolvedTarget.length === 0) {
       throw new Error(`Unable to resolve browser entry for ${specifier}`);
@@ -215,12 +250,12 @@ export async function resolveBrowserSpecifierFilePath(specifier) {
     return path.resolve(packageRoot, resolvedTarget);
   })();
 
-  browserSpecifierFilePathCache.set(specifier, pendingResolution);
+  browserSpecifierFilePathCache.set(cacheKey, pendingResolution);
 
   try {
     return await pendingResolution;
   } catch (error) {
-    browserSpecifierFilePathCache.delete(specifier);
+    browserSpecifierFilePathCache.delete(cacheKey);
     throw error;
   }
 }
@@ -272,16 +307,22 @@ export async function collectSharedVendorSpecifiers(
   ])].sort();
 }
 
-async function writeSharedRuntimeEntrySources(entriesRoot, specifiers) {
+async function createSharedRuntimeInputEntries(projectRoot, entriesRoot, specifiers) {
   await fs.rm(entriesRoot, { recursive: true, force: true });
   await ensureDirectory(entriesRoot);
 
   const inputEntries = {};
   for (const specifier of specifiers) {
     const entryName = createSharedEntryName(specifier);
-    const entryPath = path.join(entriesRoot, `${entryName}.mjs`);
-    await fs.writeFile(entryPath, createSharedEntrySource(specifier), "utf8");
-    inputEntries[entryName] = entryPath;
+    if (specifier === "@litsx/ssr/hydration") {
+      const entryPath = path.join(entriesRoot, `${entryName}.mjs`);
+      await fs.writeFile(entryPath, createSharedEntrySource(specifier), "utf8");
+      inputEntries[entryName] = entryPath;
+      continue;
+    }
+    inputEntries[entryName] = specifier === "evolit/navigation"
+      ? EVOLIT_NAVIGATION_BROWSER_ENTRY
+      : await resolveBrowserSpecifierFilePath(specifier, { projectRoot });
   }
 
   return inputEntries;
@@ -508,7 +549,7 @@ export async function buildSharedVendorRuntime(
     const specifiers = await collectSharedVendorSpecifiers(additionalEntrySpecifiers, {
       includeBase: options.includeBase !== false,
     });
-    const inputEntries = await writeSharedRuntimeEntrySources(entriesRoot, specifiers);
+    const inputEntries = await createSharedRuntimeInputEntries(projectRoot, entriesRoot, specifiers);
 
     await fs.rm(sharedRoot, { recursive: true, force: true });
     await ensureDirectory(sharedRoot);
@@ -534,7 +575,11 @@ export async function buildSharedVendorRuntime(
           extensions: [".mjs", ".js", ".json"],
           preferBuiltins: false,
         }),
+        commonjs({
+          transformMixedEsModules: true,
+        }),
       ],
+      preserveEntrySignatures: "strict",
       onwarn(warning, warn) {
         if (warning.code === "CIRCULAR_DEPENDENCY") {
           return;
@@ -1597,6 +1642,8 @@ export async function emitHashedClientAssets(projectRoot, options = {}) {
     chunks,
     styles,
     resources,
+    serverAssetImportsByEntry: options.serverAssetImportsByEntry ?? {},
+    clientBoundariesByEntry: options.clientBoundariesByEntry ?? {},
     assets: assets.sort((left, right) => left.clientModule.localeCompare(right.clientModule)),
   };
 
@@ -1893,6 +1940,13 @@ async function bundleClientAssets(projectRoot, options = {}) {
       [...scriptAssetRecords, ...nonScriptAssets, ...mapAssets]
         .map((asset) => asset.outputPath),
     );
+    // Requests for an asset from the previous manifest can still be in flight
+    // while a development rebuild publishes this one. Keep precisely that
+    // generation for one rebuild so those requests do not resolve to a file
+    // which this cleanup has just removed.
+    for (const outputPath of options.retainOutputPaths ?? []) {
+      retainedOutputPaths.add(outputPath);
+    }
     for (const filePath of await walkFiles(staticRoot)) {
       if (!retainedOutputPaths.has(filePath)) {
         await fs.rm(filePath, { force: true });
@@ -1914,6 +1968,8 @@ async function bundleClientAssets(projectRoot, options = {}) {
       .filter((asset) => asset.kind === "asset" && !asset.clientModule.endsWith(".map"))
       .map((asset) => asset.clientModule)
       .sort(),
+    serverAssetImportsByEntry: options.serverAssetImportsByEntry ?? {},
+    clientBoundariesByEntry: options.clientBoundariesByEntry ?? {},
     assets,
   };
 
@@ -2092,6 +2148,40 @@ export function collectTransitiveStyleUrls(publicUrls, assetManifest) {
   return [...styles].sort();
 }
 
+function getServerAssetImports(routeResult, projectRoot, assetManifest) {
+  if (routeResult?.serverAssetImports && typeof routeResult.serverAssetImports === "object") {
+    return routeResult.serverAssetImports;
+  }
+
+  const entryPaths = routeResult?.boundaryModule
+    ? [routeResult.boundaryModule]
+    : [
+      ...(routeResult?.route?.layouts ?? []),
+      routeResult?.route?.page,
+    ].filter((entryPath) => typeof entryPath === "string");
+  if (entryPaths.length === 0 || !assetManifest) {
+    return { styles: [], assets: [] };
+  }
+  const styles = new Set();
+  const assets = new Set();
+  for (const entryPath of entryPaths) {
+    const entry = path.relative(projectRoot, entryPath).split(path.sep).join("/");
+    const imports = assetManifest.serverAssetImportsByEntry?.[entry];
+    for (const style of imports?.styles ?? []) styles.add(style);
+    for (const asset of imports?.assets ?? []) assets.add(asset);
+  }
+  return { styles: [...styles], assets: [...assets] };
+}
+
+export function resolveServerStyleUrls(routeResult, projectRoot, assetManifest) {
+  const normalizedManifest = normalizeClientAssetManifest(assetManifest);
+  if (!normalizedManifest) return [];
+  const imports = getServerAssetImports(routeResult, projectRoot, normalizedManifest);
+  return [...new Set((imports.styles ?? [])
+    .map((style) => normalizedManifest.byClientModule[style])
+    .filter((url) => typeof url === "string"))].sort();
+}
+
 export function normalizeClientAssetManifest(manifest) {
   if (!manifest || typeof manifest !== "object" || !Array.isArray(manifest.assets)) {
     return null;
@@ -2106,6 +2196,14 @@ export function normalizeClientAssetManifest(manifest) {
     chunks: Array.isArray(manifest.chunks) ? manifest.chunks : [],
     styles: Array.isArray(manifest.styles) ? manifest.styles : [],
     resources: Array.isArray(manifest.resources) ? manifest.resources : [],
+    serverAssetImportsByEntry:
+      manifest.serverAssetImportsByEntry && typeof manifest.serverAssetImportsByEntry === "object"
+        ? manifest.serverAssetImportsByEntry
+        : {},
+    clientBoundariesByEntry:
+      manifest.clientBoundariesByEntry && typeof manifest.clientBoundariesByEntry === "object"
+        ? manifest.clientBoundariesByEntry
+        : {},
     assets: manifest.assets,
   };
 }