@remix-run/assets 0.5.0 → 0.7.0

package/src/lib/scripts/compiler.ts

@@ -3,6 +3,7 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { IfNoneMatch } from '@remix-run/headers/if-none-match'
+import { getTsconfig } from 'get-tsconfig'
 
 import { createAssetServerCompilationError } from '../compilation-error.ts'
 import { createFileMatcher } from '../file-matcher.ts'
@@ -20,6 +21,7 @@ import {
   supportedScriptExtensions,
 } from './resolve.ts'
 import type { ResolveArgs, ResolvedModule } from './resolve.ts'
+import { isBareImportSpecifier } from './specifiers.ts'
 import type { CompiledRoutes } from '../routes.ts'
 import type { ResolvedScriptTarget } from '../target.ts'
 import { createModuleStore } from '../module-store.ts'
@@ -34,6 +36,7 @@ import type {
 import { createTsconfigTransformOptionsResolver, transformModule } from './transform.ts'
 import type { ResolveModuleResult, TransformArgs, TransformedModule } from './transform.ts'
 import { ResolverFactory } from 'oxc-resolver'
+import type { NapiResolveOptions } from 'oxc-resolver'
 import type { EmittedAsset, EmittedModule } from './emit.ts'
 
 type ScriptRecord = ModuleRecord<TransformedModule, ResolvedModule, EmittedModule>
@@ -45,6 +48,11 @@ type ScriptCompileResult = {
   sourceMap: EmittedAsset | null
 }
 
+export type ScriptImportMap = {
+  imports: Record<string, string>
+  scopes?: Record<string, Record<string, string>>
+}
+
 type ScriptGetResult =
   | {
       script: ScriptCompileResult
@@ -62,7 +70,6 @@ type ScriptGetOptions = {
 }
 
 type ScriptCompilerOptions = {
-  buildId?: string
   define?: Record<string, string>
   external: string[]
   fingerprintAssets: boolean
@@ -87,7 +94,9 @@ type ScriptCompilerOptions = {
 type ScriptCompiler = {
   getScript(filePath: string, options: ScriptGetOptions): Promise<ScriptGetResult>
   getPreloadLayers(filePath: string | readonly string[]): Promise<string[][]>
+  getImportMap(filePath: string | readonly string[]): Promise<ScriptImportMap>
   getHref(filePath: string): Promise<string>
+  resolveSpecifierFromRoot(specifier: string): Promise<string>
   classifyHmrFileEvent(filePath: string, event: ModuleWatchEvent): Promise<ScriptHmrUpdate[]>
   invalidateFileEvent(filePath: string, event: ModuleWatchEvent): void
   parseRequestPathname(pathname: string): ParsedRequestPathname | null
@@ -109,7 +118,8 @@ export type ScriptHmrUpdate =
     }
   | {
       accepted: true
-      acceptedPath: string
+      acceptedFilePath: string
+      acceptedUrlPathname: string
       filePath: string
       path: string
       timestamp: number
@@ -120,8 +130,13 @@ type ScriptHmrBoundary = {
   boundaryModule: ResolvedModule
 }
 
+type DirectoryTsconfig = {
+  fileIndependent: boolean
+  path: string | null
+}
+
 const supportedScriptExtensionSet = new Set<string>(supportedScriptExtensions)
-const preloadConcurrency = Math.max(1, Math.min(8, os.availableParallelism() - 1))
+const scriptConcurrency = Math.max(1, Math.min(8, os.availableParallelism() - 1))
 
 export function createScriptCompiler(options: ScriptCompilerOptions): ScriptCompiler {
   let resolvedOptions = {
@@ -146,19 +161,22 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     onWatchFilesChange: options.onWatchFilesChange,
   })
   let tsconfigTransformOptionsResolver = createTsconfigTransformOptionsResolver()
-  let resolverFactory = new ResolverFactory({
+  let resolverOptions = {
     aliasFields: [['browser']],
     conditionNames: ['browser', 'import', 'module', 'default'],
     extensionAlias: resolverExtensionAlias,
     extensions: resolverExtensions,
     mainFields: ['browser', 'module', 'main'],
-    tsconfig: 'auto',
-  })
+  } satisfies NapiResolveOptions
+  let resolverFactory = new ResolverFactory({ ...resolverOptions, tsconfig: 'auto' })
+  let directoryResolverByTsconfig = new Map<string | null, ResolverFactory>()
+  let tsconfigByDirectory = new Map<string, DirectoryTsconfig>()
+  let directoryResolutionIdentityByCacheKey = new Map<string, Promise<string | null>>()
   let resolveInFlightByCacheKey = new Map<string, Promise<ResolvedModule>>()
   let emitInFlightByCacheKey = new Map<string, Promise<EmittedModule>>()
+  let hasResolvedScripts = false
 
   let transformArgs: TransformArgs = {
-    buildId: resolvedOptions.buildId ?? null,
     define: resolvedOptions.define ?? null,
     externalSet: resolvedOptions.externalSet,
     isWatchIgnored,
@@ -172,10 +190,13 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     tsconfigTransformOptionsResolver,
   }
   let resolveArgs: ResolveArgs = {
+    concurrency: scriptConcurrency,
+    isDirectoryResolutionFileIndependent,
     isAllowed: resolvedOptions.isAllowed,
     isWatchIgnored,
     resolveModulePath,
     resolverFactory,
+    resolveDirectorySpecifierIdentity,
     routes: resolvedOptions.routes,
   }
 
@@ -194,17 +215,7 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     },
 
     async getPreloadLayers(filePath) {
-      let resolvedEntries: string[] = []
-      let seen = new Set<string>()
-
-      for (let resolvedModule of (Array.isArray(filePath) ? filePath : [filePath]).map((nextPath) =>
-        resolveServedScriptOrThrow(resolveInputFilePath(nextPath)),
-      )) {
-        if (seen.has(resolvedModule.identityPath)) continue
-        seen.add(resolvedModule.identityPath)
-        resolvedEntries.push(resolvedModule.identityPath)
-      }
-
+      let resolvedEntries = resolveInputScriptRoots(filePath)
       let visited = new Set(resolvedEntries)
       let queue = [...resolvedEntries]
       let layers: string[][] = []
@@ -218,9 +229,9 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
         let layer: string[] = []
 
         for (let resolvedModule of resolvedModules) {
-          layer.push(getServedUrlForResolvedScript(resolvedModule))
+          layer.push(await getServedUrl(resolvedModule.identityPath))
 
-          for (let dep of resolvedModule.deps) {
+          for (let dep of resolvedModule.staticDeps) {
             if (visited.has(dep)) continue
             visited.add(dep)
             queue.push(dep)
@@ -233,11 +244,88 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
       return layers
     },
 
+    async getImportMap(filePath) {
+      let resolvedEntries = resolveInputScriptRoots(filePath)
+      let resolvedEntrySet = new Set(resolvedEntries)
+      let visited = new Set<string>()
+      let queue = [...resolvedEntries]
+      let imports: Record<string, string> = {}
+      let scopes: Record<string, Record<string, string>> = {}
+
+      while (queue.length > 0) {
+        let frontier = queue
+        queue = []
+        let resolvedModules = await getOrCreateResolvedScripts(
+          frontier.map((identityPath) => scriptStore.get(identityPath)),
+        )
+
+        for (let resolvedModule of resolvedModules) {
+          if (visited.has(resolvedModule.identityPath)) continue
+          visited.add(resolvedModule.identityPath)
+          if (!resolvedEntrySet.has(resolvedModule.identityPath)) {
+            addImportMapEntry(
+              imports,
+              resolvedModule.stableUrlPathname,
+              await getServedUrl(resolvedModule.identityPath),
+            )
+          }
+
+          for (let imported of resolvedModule.imports) {
+            let depUrl = await getServedUrl(imported.depPath)
+            if (isBareImportSpecifier(imported.specifier)) {
+              let scopePathname = imported.scopePathname
+              if (!scopePathname) {
+                throw new Error(
+                  `Expected import map scope for bare import "${imported.specifier}" in ${resolvedModule.identityPath}`,
+                )
+              }
+              let scopeImports = (scopes[scopePathname] ??= {})
+              addImportMapEntry(scopeImports, imported.specifier, depUrl)
+            } else {
+              let browserResolvedSpecifier = resolveImportMapUrlSpecifier(
+                imported.specifier,
+                resolvedModule.stableUrlPathname,
+              )
+              addImportMapEntry(imports, browserResolvedSpecifier, depUrl)
+            }
+          }
+
+          for (let dep of resolvedModule.deps) {
+            if (!visited.has(dep)) {
+              queue.push(dep)
+            }
+          }
+        }
+      }
+
+      for (let [scopePathname, scopeImports] of Object.entries(scopes)) {
+        if (Object.keys(scopeImports).length === 0) {
+          delete scopes[scopePathname]
+        }
+      }
+
+      return Object.keys(scopes).length > 0 ? { imports, scopes } : { imports }
+    },
+
     async getHref(filePath) {
       let resolvedModule = resolveServedScriptOrThrow(resolveInputFilePath(filePath))
       return getServedUrl(resolvedModule.identityPath)
     },
 
+    async resolveSpecifierFromRoot(specifier) {
+      let importerPath = path.join(resolvedOptions.rootDir, '__remix_virtual_entry__.js')
+      let resolutionResult = await resolverFactory.resolveFileAsync(importerPath, specifier)
+      if (resolutionResult.error || !resolutionResult.path) {
+        throw createAssetServerCompilationError(
+          `Failed to resolve browser module "${specifier}" from asset server root.`,
+          { code: 'IMPORT_RESOLUTION_FAILED' },
+        )
+      }
+
+      let resolvedModule = resolveServedScriptOrThrow(resolutionResult.path)
+      return getServedUrl(resolvedModule.identityPath)
+    },
+
     async classifyHmrFileEvent(filePath, event) {
       let normalizedFilePath = normalizeFilePath(filePath)
       if (isWatchIgnored(normalizedFilePath)) return []
@@ -245,9 +333,24 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
       let timestamp = Date.now()
       let previousResolvedModule = scriptStore.getLastResolved(normalizedFilePath)
       let updatePathname = previousResolvedModule?.stableUrlPathname
+      let resolutionMetadataChanged =
+        isPackageJsonPath(normalizedFilePath) || isTsconfigPath(normalizedFilePath)
 
       invalidateScriptFileEvent(normalizedFilePath, event)
 
+      if (resolutionMetadataChanged && hasResolvedScripts) {
+        let hmrUpdate: ScriptHmrUpdate[] = [
+          {
+            accepted: false,
+            filePath: normalizedFilePath,
+            path: normalizedFilePath,
+            timestamp,
+          },
+        ]
+        resolvedOptions.hmr?.send(hmrUpdate)
+        return hmrUpdate
+      }
+
       let resolvedModule =
         event === 'change' && updatePathname
           ? await tryGetOrCreateResolvedScript(scriptStore.get(normalizedFilePath))
@@ -305,6 +408,11 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
 
     if (shouldClearResolverCacheForFileEvent(normalizedFilePath, event)) {
       resolverFactory.clearCache()
+      for (let directoryResolver of directoryResolverByTsconfig.values()) {
+        directoryResolver.clearCache()
+      }
+      tsconfigByDirectory.clear()
+      directoryResolutionIdentityByCacheKey.clear()
     }
 
     if (isTsconfigPath(normalizedFilePath)) {
@@ -321,6 +429,50 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     scriptStore.invalidateForFileEvent(normalizedFilePath, event)
   }
 
+  function isDirectoryResolutionFileIndependent(directory: string): boolean {
+    return getDirectoryTsconfig(directory).fileIndependent
+  }
+
+  function getDirectoryTsconfig(directory: string): DirectoryTsconfig {
+    let existing = tsconfigByDirectory.get(directory)
+    if (existing) return existing
+
+    let tsconfig = getTsconfig(directory)
+    let result = {
+      fileIndependent: !tsconfig?.config.references?.length,
+      path: tsconfig?.path ?? null,
+    }
+    tsconfigByDirectory.set(directory, result)
+    return result
+  }
+
+  async function resolveDirectorySpecifierIdentity(
+    directory: string,
+    specifier: string,
+  ): Promise<string | null> {
+    let cacheKey = `${directory}\0${specifier}`
+    let existing = directoryResolutionIdentityByCacheKey.get(cacheKey)
+    if (existing) return existing
+
+    let promise = (async () => {
+      let tsconfigPath = getDirectoryTsconfig(directory).path
+      let directoryResolver = directoryResolverByTsconfig.get(tsconfigPath)
+      if (!directoryResolver) {
+        directoryResolver = new ResolverFactory({
+          ...resolverOptions,
+          tsconfig: tsconfigPath ? { configFile: tsconfigPath } : undefined,
+        })
+        directoryResolverByTsconfig.set(tsconfigPath, directoryResolver)
+      }
+
+      let result = await directoryResolver.async(directory, specifier)
+      if (!result.path || !path.isAbsolute(result.path)) return null
+      return resolveModulePath(normalizeFilePath(result.path))?.identityPath ?? null
+    })()
+    directoryResolutionIdentityByCacheKey.set(cacheKey, promise)
+    return promise
+  }
+
   function resolveServedScriptOrThrow(absolutePath: string): ResolveModuleResult {
     let resolvedModule = resolveModulePath(absolutePath)
     if (!resolvedModule) {
@@ -342,6 +494,20 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     return resolvedModule
   }
 
+  function resolveInputScriptRoots(filePath: string | readonly string[]): string[] {
+    let resolvedEntries: string[] = []
+    let seen = new Set<string>()
+
+    for (let nextPath of Array.isArray(filePath) ? filePath : [filePath]) {
+      let resolvedModule = resolveServedScriptOrThrow(resolveInputFilePath(nextPath))
+      if (seen.has(resolvedModule.identityPath)) continue
+      seen.add(resolvedModule.identityPath)
+      resolvedEntries.push(resolvedModule.identityPath)
+    }
+
+    return resolvedEntries
+  }
+
   function getNotModifiedScript(
     record: ScriptRecord,
     options: ScriptGetOptions,
@@ -363,7 +529,7 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
   }
 
   async function getOrCreateResolvedScripts(records: ScriptRecord[]): Promise<ResolvedModule[]> {
-    return mapWithConcurrency(records, preloadConcurrency, (record) =>
+    return mapWithConcurrency(records, scriptConcurrency, (record) =>
       getOrCreateResolvedScript(record),
     )
   }
@@ -400,6 +566,7 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
           resolveModuleResult.tracking,
         ])
       }
+      hasResolvedScripts = true
 
       return resolveModuleResult.value
     })()
@@ -463,10 +630,12 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     let promise = (async () => {
       let startedVersion = record.invalidationVersion
       let resolvedModule = await getOrCreateResolvedScript(record)
+      await resolveScriptGraph(resolvedModule)
       let emitResolvedModuleResult = await emitResolvedModule(resolvedModule, {
+        fingerprintAssets: resolvedOptions.fingerprintAssets,
+        getHmrImportTimestamp,
         getServedUrl,
         getStableUrl,
-        getHmrImportTimestamp,
         hmrClientPathname: resolvedOptions.hmr?.clientPathname,
         sourceMaps: resolvedOptions.sourceMaps,
       })
@@ -497,26 +666,47 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     }
   }
 
-  async function getServedUrl(identityPath: string): Promise<string> {
-    return getServedUrlForResolvedScript(
-      await getOrCreateResolvedScript(scriptStore.get(identityPath)),
-    )
+  async function resolveScriptGraph(root: ResolvedModule): Promise<void> {
+    let visited = new Set([root.identityPath])
+    let queue = [...root.deps]
+
+    while (queue.length > 0) {
+      let frontier = queue
+      queue = []
+      let resolvedModules = await getOrCreateResolvedScripts(
+        frontier
+          .filter((identityPath) => !visited.has(identityPath))
+          .map((identityPath) => scriptStore.get(identityPath)),
+      )
+
+      for (let resolvedModule of resolvedModules) {
+        if (visited.has(resolvedModule.identityPath)) continue
+        visited.add(resolvedModule.identityPath)
+
+        for (let dep of resolvedModule.deps) {
+          if (!visited.has(dep)) queue.push(dep)
+        }
+      }
+    }
   }
 
-  function getServedUrlForResolvedScript(resolvedModule: ResolvedModule): string {
-    return formatFingerprintedPathname(
-      resolvedModule.stableUrlPathname,
-      resolvedOptions.fingerprintAssets ? resolvedModule.fingerprint : null,
-    )
+  async function getServedUrl(identityPath: string): Promise<string> {
+    let resolvedModule = await getOrCreateResolvedScript(scriptStore.get(identityPath))
+    if (!resolvedOptions.fingerprintAssets) {
+      return resolvedModule.stableUrlPathname
+    }
+
+    let emittedModule = await getOrCreateEmittedScript(scriptStore.get(identityPath))
+    return formatFingerprintedPathname(resolvedModule.stableUrlPathname, emittedModule.fingerprint)
   }
 
   function getStableUrl(identityPath: string): string {
     let stableUrlPathname = resolvedOptions.routes.toUrlPathname(identityPath)
     if (!stableUrlPathname) {
       throw createAssetServerCompilationError(
-        `File ${identityPath} is outside all configured fileMap entries.`,
+        `File ${identityPath} is outside all configured mounts.`,
         {
-          code: 'FILE_OUTSIDE_FILE_MAP',
+          code: 'FILE_OUTSIDE_MOUNTS',
         },
       )
     }
@@ -545,7 +735,8 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
       return [
         {
           accepted: true,
-          acceptedPath: updatePathname,
+          acceptedFilePath: resolvedModule.identityPath,
+          acceptedUrlPathname: updatePathname,
           filePath: resolvedModule.identityPath,
           path: updatePathname,
           timestamp,
@@ -558,7 +749,8 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     if (sourceFilePath !== undefined && boundaries) {
       return dedupeHmrBoundaries(boundaries).map(({ acceptedModule, boundaryModule }) => ({
         accepted: true,
-        acceptedPath: acceptedModule.stableUrlPathname,
+        acceptedFilePath: acceptedModule.identityPath,
+        acceptedUrlPathname: acceptedModule.stableUrlPathname,
         filePath: sourceFilePath,
         path: boundaryModule.stableUrlPathname,
         timestamp,
@@ -630,6 +822,15 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
   }
 }
 
+function resolveImportMapUrlSpecifier(specifier: string, importerUrlPathname: string): string {
+  return new URL(specifier, `http://localhost${importerUrlPathname}`).pathname
+}
+
+function addImportMapEntry(imports: Record<string, string>, specifier: string, url: string): void {
+  if (specifier === url) return
+  imports[specifier] = url
+}
+
 function dedupeHmrBoundaries(boundaries: ScriptHmrBoundary[]): ScriptHmrBoundary[] {
   let seen = new Set<string>()
   let result: ScriptHmrBoundary[] = []
@@ -658,16 +859,13 @@ function getNotModifiedResult(
 ): ScriptGetResult | null {
   if (!emittedModule || options.ifNoneMatch === null) return null
 
-  if (
-    options.requestedFingerprint !== null &&
-    emittedModule.fingerprint !== options.requestedFingerprint
-  ) {
-    return null
-  }
-
   let asset = getEmittedAssetForRequest(emittedModule, options.isSourceMapRequest)
   if (!asset) return null
 
+  if (options.requestedFingerprint !== null && asset.fingerprint !== options.requestedFingerprint) {
+    return null
+  }
+
   if (!IfNoneMatch.from(options.ifNoneMatch).matches(asset.etag)) return null
   return { type: 'not-modified', etag: asset.etag }
 }
@@ -801,18 +999,6 @@ function resolveActualPath(identityPath: string): string | null {
   }
 }
 
-function isBareImportSpecifier(specifier: string): boolean {
-  return (
-    !specifier.startsWith('./') &&
-    !specifier.startsWith('../') &&
-    !specifier.startsWith('/') &&
-    !specifier.startsWith('file:') &&
-    !specifier.startsWith('data:') &&
-    !specifier.startsWith('http://') &&
-    !specifier.startsWith('https://')
-  )
-}
-
 function isNoEntityError(
   error: unknown,
 ): error is NodeJS.ErrnoException & { code: 'ENOENT' | 'ENOTDIR' } {

package/src/lib/scripts/emit.ts

@@ -4,7 +4,7 @@ import {
   createAssetServerCompilationError,
   isAssetServerCompilationError,
 } from '../compilation-error.ts'
-import { hashContent } from '../fingerprint.ts'
+import { formatFingerprintedPathname, hashContent } from '../fingerprint.ts'
 import type { ResolvedModule } from './resolve.ts'
 import { composeSourceMaps } from '../source-maps.ts'
 import type { AssetServerCompilationError } from '../compilation-error.ts'
@@ -12,12 +12,12 @@ import type { AssetServerCompilationError } from '../compilation-error.ts'
 export type EmittedAsset = {
   content: string
   etag: string
+  fingerprint: string
 }
 
 export type EmittedModule = {
   code: EmittedAsset
   fingerprint: string | null
-  importUrls: string[]
   sourceMap: EmittedAsset | null
 }
 
@@ -40,6 +40,7 @@ type RewriteImportsOptions = {
 export async function emitResolvedModule(
   resolvedModule: ResolvedModule,
   options: {
+    fingerprintAssets: boolean
     getHmrImportTimestamp(identityPath: string): number | null
     getServedUrl(identityPath: string): Promise<string>
     getStableUrl(identityPath: string): string
@@ -48,30 +49,32 @@ export async function emitResolvedModule(
   },
 ): Promise<EmitResult> {
   try {
-    let importUrls = await Promise.all(
-      resolvedModule.deps.map((depPath) => options.getServedUrl(depPath)),
-    )
     let rewriteResult = await rewriteImports(resolvedModule, options)
     let finalCode = prependHmrContext(resolvedModule, rewriteResult.code, options)
+    let sourceMap = rewriteResult.sourceMap
+      ? await createEmittedAsset(rewriteResult.sourceMap)
+      : null
 
     if (rewriteResult.sourceMap) {
       if (options.sourceMaps === 'inline') {
         let encoded = Buffer.from(rewriteResult.sourceMap).toString('base64')
         finalCode += `\n//# sourceMappingURL=data:application/json;base64,${encoded}`
       } else if (options.sourceMaps === 'external') {
-        finalCode += `\n//# sourceMappingURL=${await options.getServedUrl(resolvedModule.identityPath)}.map`
+        finalCode += `\n//# sourceMappingURL=${formatFingerprintedPathname(
+          resolvedModule.stableUrlPathname,
+          options.fingerprintAssets && sourceMap ? sourceMap.fingerprint : null,
+        )}.map`
       }
     }
 
+    let code = await createEmittedAsset(finalCode)
+
     return {
       ok: true,
       value: {
-        code: await createEmittedAsset(finalCode),
-        fingerprint: resolvedModule.fingerprint,
-        importUrls,
-        sourceMap: rewriteResult.sourceMap
-          ? await createEmittedAsset(rewriteResult.sourceMap)
-          : null,
+        code,
+        fingerprint: options.fingerprintAssets ? code.fingerprint : null,
+        sourceMap,
       },
     }
   } catch (error) {
@@ -87,18 +90,28 @@ async function rewriteImports(
   options: RewriteImportsOptions,
 ): Promise<{ code: string; sourceMap: string | null }> {
   let rewrittenSource = new MagicString(resolvedModule.rawCode)
+  let changed = false
 
   for (let imported of resolvedModule.imports) {
-    let url = await options.getServedUrl(imported.depPath)
     let hmrImportTimestamp = options.getHmrImportTimestamp(imported.depPath)
+    let replacementSpecifier = imported.specifier
     if (hmrImportTimestamp !== null) {
-      url = addTimestampQuery(url, hmrImportTimestamp)
+      replacementSpecifier = addTimestampQuery(
+        await options.getServedUrl(imported.depPath),
+        hmrImportTimestamp,
+      )
+    } else if (imported.compiledSpecifier === imported.specifier) {
+      continue
     }
+
     rewrittenSource.overwrite(
       imported.start,
       imported.end,
-      imported.quote ? `${imported.quote}${url}${imported.quote}` : url,
+      imported.quote
+        ? `${imported.quote}${replacementSpecifier}${imported.quote}`
+        : replacementSpecifier,
     )
+    changed = true
   }
 
   for (let acceptedDep of resolvedModule.hmr.acceptedDeps) {
@@ -108,12 +121,12 @@ async function rewriteImports(
       acceptedDep.end,
       acceptedDep.quote ? `${acceptedDep.quote}${url}${acceptedDep.quote}` : url,
     )
+    changed = true
   }
 
-  let code = rewrittenSource.toString()
+  let code = changed ? rewrittenSource.toString() : resolvedModule.rawCode
   let sourceMap =
-    resolvedModule.sourceMap &&
-    (resolvedModule.imports.length > 0 || resolvedModule.hmr.acceptedDeps.length > 0)
+    resolvedModule.sourceMap && changed
       ? composeSourceMaps(
           rewrittenSource.generateMap({ hires: true }).toString(),
           resolvedModule.sourceMap,
@@ -148,9 +161,11 @@ function prependHmrContext(
 }
 
 async function createEmittedAsset(content: string): Promise<EmittedAsset> {
+  let fingerprint = await hashContent(content)
   return {
     content,
-    etag: `W/"${await hashContent(content)}"`,
+    etag: `W/"${fingerprint}"`,
+    fingerprint,
   }
 }