@remix-run/assets 0.4.4 → 0.5.0

package/src/lib/scripts/compiler.ts

@@ -23,6 +23,7 @@ import type { ResolveArgs, ResolvedModule } from './resolve.ts'
 import type { CompiledRoutes } from '../routes.ts'
 import type { ResolvedScriptTarget } from '../target.ts'
 import { createModuleStore } from '../module-store.ts'
+import type { ModuleLoader } from '../loaders.ts'
 import type {
   FileSnapshot,
   ModuleRecord,
@@ -65,9 +66,15 @@ type ScriptCompilerOptions = {
   define?: Record<string, string>
   external: string[]
   fingerprintAssets: boolean
+  hmr?: {
+    clientPathname: string
+    send(updates: ScriptHmrUpdate[]): void
+  }
   isAllowed(absolutePath: string): boolean
   minify: boolean
+  loaders: readonly ModuleLoader[]
   onWatchDirectoriesChange?: (delta: { add: string[]; remove: string[] }) => void
+  onWatchFilesChange?: (delta: { add: string[]; remove: string[] }) => void
   rootDir: string
   routes: CompiledRoutes
   sourceMapSourcePaths: 'absolute' | 'url'
@@ -81,7 +88,8 @@ type ScriptCompiler = {
   getScript(filePath: string, options: ScriptGetOptions): Promise<ScriptGetResult>
   getPreloadLayers(filePath: string | readonly string[]): Promise<string[][]>
   getHref(filePath: string): Promise<string>
-  handleFileEvent(filePath: string, event: ModuleWatchEvent): Promise<void>
+  classifyHmrFileEvent(filePath: string, event: ModuleWatchEvent): Promise<ScriptHmrUpdate[]>
+  invalidateFileEvent(filePath: string, event: ModuleWatchEvent): void
   parseRequestPathname(pathname: string): ParsedRequestPathname | null
 }
 
@@ -92,6 +100,26 @@ type ParsedRequestPathname = {
   requestedFingerprint: string | null
 }
 
+export type ScriptHmrUpdate =
+  | {
+      accepted: false
+      filePath: string
+      path: string
+      timestamp: number
+    }
+  | {
+      accepted: true
+      acceptedPath: string
+      filePath: string
+      path: string
+      timestamp: number
+    }
+
+type ScriptHmrBoundary = {
+  acceptedModule: ResolvedModule
+  boundaryModule: ResolvedModule
+}
+
 const supportedScriptExtensionSet = new Set<string>(supportedScriptExtensions)
 const preloadConcurrency = Math.max(1, Math.min(8, os.availableParallelism() - 1))
 
@@ -108,7 +136,14 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     ResolvedModule,
     EmittedModule
   >({
+    getAcceptedDependencies(resolvedModule) {
+      return resolvedModule.hmr.acceptedDeps.map((acceptedDep) => acceptedDep.depPath)
+    },
+    getDependencies(resolvedModule) {
+      return resolvedModule.deps
+    },
     onWatchDirectoriesChange: options.onWatchDirectoriesChange,
+    onWatchFilesChange: options.onWatchFilesChange,
   })
   let tsconfigTransformOptionsResolver = createTsconfigTransformOptionsResolver()
   let resolverFactory = new ResolverFactory({
@@ -128,6 +163,7 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     externalSet: resolvedOptions.externalSet,
     isWatchIgnored,
     minify: resolvedOptions.minify,
+    loaders: resolvedOptions.loaders,
     resolveActualPath,
     routes: resolvedOptions.routes,
     sourceMapSourcePaths: resolvedOptions.sourceMapSourcePaths,
@@ -202,26 +238,38 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
       return getServedUrl(resolvedModule.identityPath)
     },
 
-    async handleFileEvent(filePath, event) {
+    async classifyHmrFileEvent(filePath, event) {
       let normalizedFilePath = normalizeFilePath(filePath)
-      if (isWatchIgnored(normalizedFilePath)) return
-
-      if (shouldClearResolverCacheForFileEvent(normalizedFilePath, event)) {
-        resolverFactory.clearCache()
-      }
-
-      if (isTsconfigPath(normalizedFilePath)) {
-        tsconfigTransformOptionsResolver.clear()
-        scriptStore.invalidateAll()
-        return
-      }
-
-      if (isPackageJsonPath(normalizedFilePath)) {
-        scriptStore.invalidateAll()
-        return
+      if (isWatchIgnored(normalizedFilePath)) return []
+
+      let timestamp = Date.now()
+      let previousResolvedModule = scriptStore.getLastResolved(normalizedFilePath)
+      let updatePathname = previousResolvedModule?.stableUrlPathname
+
+      invalidateScriptFileEvent(normalizedFilePath, event)
+
+      let resolvedModule =
+        event === 'change' && updatePathname
+          ? await tryGetOrCreateResolvedScript(scriptStore.get(normalizedFilePath))
+          : undefined
+      let hmrUpdate =
+        event === 'change' && updatePathname
+          ? getHmrUpdatesForChange(
+              resolvedModule ?? previousResolvedModule,
+              previousResolvedModule,
+              updatePathname,
+              timestamp,
+            )
+          : []
+
+      if (hmrUpdate.length > 0) {
+        resolvedOptions.hmr?.send(hmrUpdate)
       }
+      return hmrUpdate
+    },
 
-      scriptStore.invalidateForFileEvent(normalizedFilePath, event)
+    invalidateFileEvent(filePath, event) {
+      invalidateScriptFileEvent(normalizeFilePath(filePath), event)
     },
 
     parseRequestPathname(pathname) {
@@ -252,6 +300,27 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     return resolveFilePath(resolvedOptions.rootDir, filePath)
   }
 
+  function invalidateScriptFileEvent(normalizedFilePath: string, event: ModuleWatchEvent): void {
+    if (isWatchIgnored(normalizedFilePath)) return
+
+    if (shouldClearResolverCacheForFileEvent(normalizedFilePath, event)) {
+      resolverFactory.clearCache()
+    }
+
+    if (isTsconfigPath(normalizedFilePath)) {
+      tsconfigTransformOptionsResolver.clear()
+      scriptStore.invalidateAll()
+      return
+    }
+
+    if (isPackageJsonPath(normalizedFilePath)) {
+      scriptStore.invalidateAll()
+      return
+    }
+
+    scriptStore.invalidateForFileEvent(normalizedFilePath, event)
+  }
+
   function resolveServedScriptOrThrow(absolutePath: string): ResolveModuleResult {
     let resolvedModule = resolveModulePath(absolutePath)
     if (!resolvedModule) {
@@ -262,7 +331,8 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
 
     if (!resolvedOptions.isAllowed(resolvedModule.identityPath)) {
       throw createAssetServerCompilationError(
-        `File is not allowed: ${resolvedModule.identityPath}`,
+        `File "${resolvedModule.identityPath}" is not allowed by the asset server access configuration. ` +
+          `Add a matching allowFiles or allowPackages rule, or remove a conflicting denyFiles rule.`,
         {
           code: 'FILE_NOT_ALLOWED',
         },
@@ -276,8 +346,14 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     record: ScriptRecord,
     options: ScriptGetOptions,
   ): ScriptGetResult | null {
-    let current = getNotModifiedResult(record.emitted, options)
-    if (current) return current
+    if (hasHmrTimestampedDependency(record.resolved)) {
+      return null
+    }
+
+    if (scriptStore.isEmittedFresh(record)) {
+      let current = getNotModifiedResult(record.emitted, options)
+      if (current) return current
+    }
 
     if (!record.staleEmittedSnapshot || !isModuleSnapshotFresh(record.staleEmittedSnapshot)) {
       return null
@@ -293,7 +369,7 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
   }
 
   async function getOrCreateResolvedScript(record: ScriptRecord): Promise<ResolvedModule> {
-    if (record.resolved) return record.resolved
+    if (record.resolved && scriptStore.isResolvedFresh(record)) return record.resolved
 
     let cacheKey = getRecordCacheKey(record)
     let existing = resolveInFlightByCacheKey.get(cacheKey)
@@ -339,8 +415,18 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     }
   }
 
+  async function tryGetOrCreateResolvedScript(
+    record: ScriptRecord,
+  ): Promise<ResolvedModule | undefined> {
+    try {
+      return await getOrCreateResolvedScript(record)
+    } catch {
+      return undefined
+    }
+  }
+
   async function getOrCreateTransformedScript(record: ScriptRecord): Promise<TransformedModule> {
-    if (record.transformed) return record.transformed
+    if (record.transformed && scriptStore.isTransformedFresh(record)) return record.transformed
 
     let startedVersion = record.invalidationVersion
     let transformModuleResult = await transformModule(record, transformArgs)
@@ -362,7 +448,13 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
   }
 
   async function getOrCreateEmittedScript(record: ScriptRecord): Promise<EmittedModule> {
-    if (record.emitted) return record.emitted
+    if (
+      record.emitted &&
+      scriptStore.isEmittedFresh(record) &&
+      !hasHmrTimestampedDependency(record.resolved)
+    ) {
+      return record.emitted
+    }
 
     let cacheKey = getRecordCacheKey(record)
     let existing = emitInFlightByCacheKey.get(cacheKey)
@@ -373,6 +465,9 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
       let resolvedModule = await getOrCreateResolvedScript(record)
       let emitResolvedModuleResult = await emitResolvedModule(resolvedModule, {
         getServedUrl,
+        getStableUrl,
+        getHmrImportTimestamp,
+        hmrClientPathname: resolvedOptions.hmr?.clientPathname,
         sourceMaps: resolvedOptions.sourceMaps,
       })
 
@@ -415,11 +510,140 @@ export function createScriptCompiler(options: ScriptCompilerOptions): ScriptComp
     )
   }
 
+  function getStableUrl(identityPath: string): string {
+    let stableUrlPathname = resolvedOptions.routes.toUrlPathname(identityPath)
+    if (!stableUrlPathname) {
+      throw createAssetServerCompilationError(
+        `File ${identityPath} is outside all configured fileMap entries.`,
+        {
+          code: 'FILE_OUTSIDE_FILE_MAP',
+        },
+      )
+    }
+    return stableUrlPathname
+  }
+
+  function getHmrImportTimestamp(identityPath: string): number | null {
+    return scriptStore.getHmrUpdateTimestamp(identityPath) ?? null
+  }
+
+  function hasHmrTimestampedDependency(resolvedModule: ResolvedModule | undefined): boolean {
+    return resolvedModule?.deps.some((depPath) => getHmrImportTimestamp(depPath) !== null) === true
+  }
+
+  function getHmrUpdatesForChange(
+    resolvedModule: ResolvedModule | undefined,
+    previousResolvedModule: ResolvedModule | undefined,
+    updatePathname: string,
+    timestamp: number,
+  ): ScriptHmrUpdate[] {
+    if (resolvedModule) {
+      scriptStore.setHmrUpdateTimestamp(resolvedModule.identityPath, timestamp)
+    }
+
+    if (resolvedModule?.hmr.selfAccepting === true) {
+      return [
+        {
+          accepted: true,
+          acceptedPath: updatePathname,
+          filePath: resolvedModule.identityPath,
+          path: updatePathname,
+          timestamp,
+        },
+      ]
+    }
+
+    let sourceFilePath = resolvedModule?.identityPath
+    let boundaries = findHmrBoundaries(sourceFilePath)
+    if (sourceFilePath !== undefined && boundaries) {
+      return dedupeHmrBoundaries(boundaries).map(({ acceptedModule, boundaryModule }) => ({
+        accepted: true,
+        acceptedPath: acceptedModule.stableUrlPathname,
+        filePath: sourceFilePath,
+        path: boundaryModule.stableUrlPathname,
+        timestamp,
+      }))
+    }
+
+    return [
+      {
+        accepted: false,
+        filePath:
+          resolvedModule?.identityPath ?? previousResolvedModule?.identityPath ?? updatePathname,
+        path: updatePathname,
+        timestamp,
+      },
+    ]
+  }
+
+  function findHmrBoundaries(identityPath: string | undefined): ScriptHmrBoundary[] | null {
+    if (identityPath === undefined) return null
+    return propagateHmrUpdate(identityPath, new Set())
+  }
+
+  function propagateHmrUpdate(
+    identityPath: string,
+    traversed: Set<string>,
+  ): ScriptHmrBoundary[] | null {
+    if (traversed.has(identityPath)) return []
+    traversed.add(identityPath)
+
+    let resolvedModule = scriptStore.getLastResolved(identityPath)
+    if (!resolvedModule) return null
+
+    if (resolvedModule.hmr.selfAccepting) {
+      return [
+        {
+          acceptedModule: resolvedModule,
+          boundaryModule: resolvedModule,
+        },
+      ]
+    }
+
+    let importerPaths = scriptStore.getImporters(identityPath)
+    if (!importerPaths || importerPaths.size === 0) return null
+
+    let acceptedImporterPaths = scriptStore.getAcceptedImporters(identityPath)
+    let boundaries: ScriptHmrBoundary[] = []
+    for (let importerPath of importerPaths) {
+      let importer = scriptStore.getLastResolved(importerPath)
+      if (!importer) return null
+
+      if (acceptedImporterPaths?.has(importerPath)) {
+        boundaries.push({
+          acceptedModule: resolvedModule,
+          boundaryModule: importer,
+        })
+        continue
+      }
+
+      let importerBoundaries = propagateHmrUpdate(importerPath, traversed)
+      if (!importerBoundaries) return null
+      boundaries.push(...importerBoundaries)
+    }
+
+    return boundaries
+  }
+
   function isWatchIgnored(filePath: string): boolean {
     return resolvedOptions.watchIgnoreMatchers.some((matcher) => matcher(filePath))
   }
 }
 
+function dedupeHmrBoundaries(boundaries: ScriptHmrBoundary[]): ScriptHmrBoundary[] {
+  let seen = new Set<string>()
+  let result: ScriptHmrBoundary[] = []
+
+  for (let boundary of boundaries) {
+    let key = `${boundary.boundaryModule.identityPath}\0${boundary.acceptedModule.identityPath}`
+    if (seen.has(key)) continue
+    seen.add(key)
+    result.push(boundary)
+  }
+
+  return result
+}
+
 function getRecordCacheKey(record: ScriptRecord): string {
   return `${record.identityPath}\0${record.invalidationVersion}`
 }

package/src/lib/scripts/conditions.ts

@@ -0,0 +1 @@
+export const scriptLoaderConditions = ['browser', 'import', 'module', 'default'] as const

package/src/lib/scripts/emit.ts

@@ -31,10 +31,19 @@ type EmitResult =
       error: AssetServerCompilationError
     }
 
+type RewriteImportsOptions = {
+  getHmrImportTimestamp(identityPath: string): number | null
+  getServedUrl(identityPath: string): Promise<string>
+  getStableUrl(identityPath: string): string
+}
+
 export async function emitResolvedModule(
   resolvedModule: ResolvedModule,
   options: {
+    getHmrImportTimestamp(identityPath: string): number | null
     getServedUrl(identityPath: string): Promise<string>
+    getStableUrl(identityPath: string): string
+    hmrClientPathname?: string
     sourceMaps?: 'external' | 'inline'
   },
 ): Promise<EmitResult> {
@@ -43,7 +52,7 @@ export async function emitResolvedModule(
       resolvedModule.deps.map((depPath) => options.getServedUrl(depPath)),
     )
     let rewriteResult = await rewriteImports(resolvedModule, options)
-    let finalCode = rewriteResult.code
+    let finalCode = prependHmrContext(resolvedModule, rewriteResult.code, options)
 
     if (rewriteResult.sourceMap) {
       if (options.sourceMaps === 'inline') {
@@ -75,14 +84,16 @@ export async function emitResolvedModule(
 
 async function rewriteImports(
   resolvedModule: ResolvedModule,
-  options: {
-    getServedUrl(identityPath: string): Promise<string>
-  },
+  options: RewriteImportsOptions,
 ): Promise<{ code: string; sourceMap: string | null }> {
   let rewrittenSource = new MagicString(resolvedModule.rawCode)
 
   for (let imported of resolvedModule.imports) {
     let url = await options.getServedUrl(imported.depPath)
+    let hmrImportTimestamp = options.getHmrImportTimestamp(imported.depPath)
+    if (hmrImportTimestamp !== null) {
+      url = addTimestampQuery(url, hmrImportTimestamp)
+    }
     rewrittenSource.overwrite(
       imported.start,
       imported.end,
@@ -90,9 +101,19 @@ async function rewriteImports(
     )
   }
 
+  for (let acceptedDep of resolvedModule.hmr.acceptedDeps) {
+    let url = options.getStableUrl(acceptedDep.depPath)
+    rewrittenSource.overwrite(
+      acceptedDep.start,
+      acceptedDep.end,
+      acceptedDep.quote ? `${acceptedDep.quote}${url}${acceptedDep.quote}` : url,
+    )
+  }
+
   let code = rewrittenSource.toString()
   let sourceMap =
-    resolvedModule.sourceMap && resolvedModule.imports.length > 0
+    resolvedModule.sourceMap &&
+    (resolvedModule.imports.length > 0 || resolvedModule.hmr.acceptedDeps.length > 0)
       ? composeSourceMaps(
           rewrittenSource.generateMap({ hires: true }).toString(),
           resolvedModule.sourceMap,
@@ -102,6 +123,30 @@ async function rewriteImports(
   return { code, sourceMap }
 }
 
+function addTimestampQuery(pathname: string, timestamp: number): string {
+  return `${pathname}${pathname.includes('?') ? '&' : '?'}t=${timestamp}`
+}
+
+function prependHmrContext(
+  resolvedModule: ResolvedModule,
+  code: string,
+  options: {
+    hmrClientPathname?: string
+  },
+): string {
+  if (!options.hmrClientPathname || !resolvedModule.hmr.usesImportMetaHot) return code
+
+  return (
+    `import { createHotContext as __remixCreateHotContext } from ${JSON.stringify(
+      options.hmrClientPathname,
+    )};\n` +
+    `import.meta.hot = __remixCreateHotContext(${JSON.stringify(
+      resolvedModule.stableUrlPathname,
+    )});\n` +
+    code
+  )
+}
+
 async function createEmittedAsset(content: string): Promise<EmittedAsset> {
   return {
     content,

package/src/lib/scripts/resolve.ts

@@ -37,6 +37,8 @@ type ResolvedImport = {
   start: number
 }
 
+type ResolvedHmrAcceptedDependency = ResolvedImport
+
 type RelativeImportResolution = {
   candidatePaths: readonly string[]
   candidatePrefixes: readonly string[]
@@ -50,6 +52,9 @@ type TrackedResolution = RelativeImportResolution & {
 export type ResolvedModule = {
   deps: string[]
   fingerprint: string | null
+  hmr: Omit<TransformedModule['hmr'], 'acceptedDeps'> & {
+    acceptedDeps: ResolvedHmrAcceptedDependency[]
+  }
   identityPath: string
   imports: ResolvedImport[]
   trackedFiles: string[]
@@ -116,6 +121,7 @@ export async function resolveModule(
   }
 
   let importsWithPaths: ResolvedImport[] = []
+  let acceptedDepsWithPaths: ResolvedHmrAcceptedDependency[] = []
   let deps = new Set<string>()
 
   for (let unresolved of transformed.unresolvedImports) {
@@ -163,8 +169,8 @@ export async function resolveModule(
     if (!args.isAllowed(resolvedImport.identityPath)) {
       return failResolve(
         createAssetServerCompilationError(
-          `Import "${displaySpecifier}" in ${transformed.resolvedPath}, resolved to "${resolvedImport.identityPath}", is not allowed by the asset server allow/deny configuration. ` +
-            `Add a matching allow rule for this file path, remove a conflicting deny rule for this file path, or mark this import as external.`,
+          `Import "${displaySpecifier}" in ${transformed.resolvedPath}, resolved to "${resolvedImport.identityPath}", is not allowed by the asset server access configuration. ` +
+            `Add a matching allowFiles or allowPackages rule, remove a conflicting denyFiles rule, or mark this import as external.`,
           {
             code: 'IMPORT_NOT_ALLOWED',
           },
@@ -218,12 +224,124 @@ export async function resolveModule(
     })
   }
 
+  for (let unresolved of transformed.hmr.acceptedDeps) {
+    if (isBrowserExternalModuleUrl(unresolved.specifier)) continue
+
+    let displaySpecifier = getDisplayImportSpecifier(unresolved.specifier)
+    let trackedResolution = getTrackedRelativeImportResolution(
+      transformed.importerDir,
+      displaySpecifier,
+      args.isWatchIgnored,
+    )
+
+    let resolvedSpec = resolvedImports.get(unresolved.specifier)
+    if (!resolvedSpec?.absolutePath) {
+      try {
+        resolvedSpec = await batchResolveSpecifiers(
+          [unresolved.specifier],
+          transformed.resolvedPath,
+          args.resolverFactory,
+        ).then((resolved) => resolved.get(unresolved.specifier))
+      } catch (error) {
+        return failResolve(error, trackedFiles, trackedResolutions, transformed.resolvedPath, {
+          isWatchIgnored: args.isWatchIgnored,
+          trackedResolution,
+        })
+      }
+    }
+
+    if (!resolvedSpec?.absolutePath) {
+      return failResolve(
+        createAssetServerCompilationError(
+          `Failed to resolve accepted HMR dependency "${displaySpecifier}" in ${transformed.resolvedPath}. ` +
+            `Ensure it resolves to a file within the configured asset server fileMap, or mark it as external.`,
+          {
+            code: 'IMPORT_RESOLUTION_FAILED',
+          },
+        ),
+        trackedFiles,
+        trackedResolutions,
+        transformed.resolvedPath,
+        { isWatchIgnored: args.isWatchIgnored, trackedResolution },
+      )
+    }
+
+    let resolvedImport = args.resolveModulePath(resolvedSpec.absolutePath)
+    if (!resolvedImport) {
+      return failResolve(
+        createAssetServerCompilationError(
+          `Accepted HMR dependency "${displaySpecifier}" in ${transformed.resolvedPath}, resolved to "${resolvedSpec.absolutePath}", is not a supported script file. ` +
+            `Supported extensions are ${supportedScriptExtensions.join(', ')}.`,
+          {
+            code: 'IMPORT_NOT_SUPPORTED',
+          },
+        ),
+        trackedFiles,
+        trackedResolutions,
+        transformed.resolvedPath,
+        { isWatchIgnored: args.isWatchIgnored, trackedResolution },
+      )
+    }
+
+    if (!args.isAllowed(resolvedImport.identityPath)) {
+      return failResolve(
+        createAssetServerCompilationError(
+          `Accepted HMR dependency "${displaySpecifier}" in ${transformed.resolvedPath}, resolved to "${resolvedImport.identityPath}", is not allowed by the asset server allow/deny configuration. ` +
+            `Add a matching allow rule for this file path, remove a conflicting deny rule for this file path, or mark this import as external.`,
+          {
+            code: 'IMPORT_NOT_ALLOWED',
+          },
+        ),
+        trackedFiles,
+        trackedResolutions,
+        transformed.resolvedPath,
+        { isWatchIgnored: args.isWatchIgnored, trackedResolution },
+      )
+    }
+
+    let stableUrlPathname = args.routes.toUrlPathname(resolvedImport.identityPath)
+    if (!stableUrlPathname) {
+      return failResolve(
+        createAssetServerCompilationError(
+          `Accepted HMR dependency "${displaySpecifier}" in ${transformed.resolvedPath}, resolved to "${resolvedImport.identityPath}", is outside all configured fileMap entries. ` +
+            `Add a matching fileMap entry for this file path, or mark this import as external.`,
+          {
+            code: 'IMPORT_OUTSIDE_FILE_MAP',
+          },
+        ),
+        trackedFiles,
+        trackedResolutions,
+        transformed.resolvedPath,
+        { isWatchIgnored: args.isWatchIgnored, trackedResolution },
+      )
+    }
+
+    if (trackedResolution) {
+      trackedResolutions.push({
+        ...trackedResolution,
+        resolvedIdentityPath: resolvedImport.identityPath,
+      })
+    }
+
+    acceptedDepsWithPaths.push({
+      depPath: resolvedImport.identityPath,
+      end: unresolved.end,
+      quote: unresolved.quote,
+      start: unresolved.start,
+    })
+  }
+
   return {
     ok: true,
     tracking: toResolveTracking(trackedFiles, trackedResolutions),
     value: {
       deps: [...deps],
       fingerprint: transformed.fingerprint,
+      hmr: {
+        acceptedDeps: acceptedDepsWithPaths,
+        selfAccepting: transformed.hmr.selfAccepting,
+        usesImportMetaHot: transformed.hmr.usesImportMetaHot,
+      },
       identityPath: record.identityPath,
       imports: importsWithPaths,
       trackedFiles: [...trackedFiles],
@@ -416,6 +534,10 @@ function getDisplayImportSpecifier(specifier: string): string {
   return restoreAuthoredInjectedPackageSpecifier(specifier) ?? specifier
 }
 
+function isBrowserExternalModuleUrl(url: string): boolean {
+  return url.startsWith('data:') || url.startsWith('http://') || url.startsWith('https://')
+}
+
 function failResolve(
   error: unknown,
   trackedFiles: ReadonlySet<string>,