@remix-run/assets 0.6.0 → 0.7.0

package/src/lib/scripts/resolve.ts

@@ -17,6 +17,7 @@ import { normalizeFilePath } from '../paths.ts'
 import type { CompiledRoutes } from '../routes.ts'
 import type { ResolveModuleResult, TransformedModule } from './transform.ts'
 import type { EmittedModule } from './emit.ts'
+import { isBareImportSpecifier } from './specifiers.ts'
 
 type ScriptRecord = ModuleRecord<TransformedModule, ResolvedModule, EmittedModule>
 
@@ -31,14 +32,24 @@ export const supportedScriptExtensions = ['.ts', '.tsx', '.js', '.jsx', '.mts',
 const supportedScriptExtensionSet = new Set<string>(supportedScriptExtensions)
 
 type ResolvedImport = {
+  compiledSpecifier: string
   depPath: string
   end: number
   quote?: '"' | "'" | '`'
+  scopePathname?: string
+  specifier: string
   start: number
 }
 
 type ResolvedHmrAcceptedDependency = ResolvedImport
 
+type PendingBareImportScope = {
+  imported: ResolvedImport
+  resolvedIdentityPath: string
+  specifier: string
+  trackedResolution: RelativeImportResolution | null
+}
+
 type RelativeImportResolution = {
   candidatePaths: readonly string[]
   candidatePrefixes: readonly string[]
@@ -51,7 +62,6 @@ type TrackedResolution = RelativeImportResolution & {
 
 export type ResolvedModule = {
   deps: string[]
-  fingerprint: string | null
   hmr: Omit<TransformedModule['hmr'], 'acceptedDeps'> & {
     acceptedDeps: ResolvedHmrAcceptedDependency[]
   }
@@ -61,6 +71,7 @@ export type ResolvedModule = {
   rawCode: string
   resolvedPath: string
   sourceMap: string | null
+  staticDeps: string[]
   stableUrlPathname: string
 }
 
@@ -78,10 +89,13 @@ type ResolveResult = {
 )
 
 export type ResolveArgs = {
+  concurrency: number
+  isDirectoryResolutionFileIndependent(directory: string): boolean
   isAllowed(absolutePath: string): boolean
   isWatchIgnored(filePath: string): boolean
   resolveModulePath(absolutePath: string): ResolveModuleResult | null
   resolverFactory: ResolverFactory
+  resolveDirectorySpecifierIdentity(directory: string, specifier: string): Promise<string | null>
   routes: CompiledRoutes
 }
 
@@ -121,8 +135,10 @@ export async function resolveModule(
   }
 
   let importsWithPaths: ResolvedImport[] = []
+  let pendingBareImportScopes: PendingBareImportScope[] = []
   let acceptedDepsWithPaths: ResolvedHmrAcceptedDependency[] = []
   let deps = new Set<string>()
+  let staticDeps = new Set<string>()
 
   for (let unresolved of transformed.unresolvedImports) {
     let displaySpecifier = getDisplayImportSpecifier(unresolved.specifier)
@@ -200,6 +216,7 @@ export async function resolveModule(
     }
 
     deps.add(resolvedImport.identityPath)
+    if (!unresolved.dynamic) staticDeps.add(resolvedImport.identityPath)
 
     if (transformed.packageSpecifiers.includes(unresolved.specifier)) {
       let packageJsonPath =
@@ -216,12 +233,50 @@ export async function resolveModule(
       })
     }
 
-    importsWithPaths.push({
+    let imported: ResolvedImport = {
+      compiledSpecifier: unresolved.specifier,
       depPath: resolvedImport.identityPath,
       end: unresolved.end,
       quote: unresolved.quote,
+      specifier: displaySpecifier,
       start: unresolved.start,
-    })
+    }
+    importsWithPaths.push(imported)
+
+    if (isBareImportSpecifier(displaySpecifier)) {
+      pendingBareImportScopes.push({
+        imported,
+        resolvedIdentityPath: resolvedImport.identityPath,
+        specifier: normalizeSpecifierResolution(unresolved.specifier, transformed.resolvedPath)
+          .specifier,
+        trackedResolution,
+      })
+    }
+  }
+
+  if (pendingBareImportScopes.length > 0) {
+    let scopeResults = await resolveBareImportScopes(
+      pendingBareImportScopes,
+      transformed.resolvedPath,
+      args,
+    )
+    for (let index = 0; index < scopeResults.length; index++) {
+      let result = scopeResults[index]
+      let pending = pendingBareImportScopes[index]
+      if (!result.ok) {
+        return failResolve(
+          result.error,
+          trackedFiles,
+          trackedResolutions,
+          transformed.resolvedPath,
+          {
+            isWatchIgnored: args.isWatchIgnored,
+            trackedResolution: pending.trackedResolution,
+          },
+        )
+      }
+      pending.imported.scopePathname = result.scopePathname
+    }
   }
 
   for (let unresolved of transformed.hmr.acceptedDeps) {
@@ -324,9 +379,11 @@ export async function resolveModule(
     }
 
     acceptedDepsWithPaths.push({
+      compiledSpecifier: unresolved.specifier,
       depPath: resolvedImport.identityPath,
       end: unresolved.end,
       quote: unresolved.quote,
+      specifier: displaySpecifier,
       start: unresolved.start,
     })
   }
@@ -336,7 +393,6 @@ export async function resolveModule(
     tracking: toResolveTracking(trackedFiles, trackedResolutions),
     value: {
       deps: [...deps],
-      fingerprint: transformed.fingerprint,
       hmr: {
         acceptedDeps: acceptedDepsWithPaths,
         selfAccepting: transformed.hmr.selfAccepting,
@@ -348,11 +404,117 @@ export async function resolveModule(
       rawCode: transformed.rawCode,
       resolvedPath: transformed.resolvedPath,
       sourceMap: transformed.sourceMap,
+      staticDeps: [...staticDeps],
       stableUrlPathname: transformed.stableUrlPathname,
     },
   }
 }
 
+async function resolveBareImportScopes(
+  pendingScopes: PendingBareImportScope[],
+  importerPath: string,
+  args: ResolveArgs,
+): Promise<
+  ({ ok: true; scopePathname: string } | { ok: false; error: AssetServerCompilationError })[]
+> {
+  let results = new Array<
+    { ok: true; scopePathname: string } | { ok: false; error: AssetServerCompilationError }
+  >(pendingScopes.length)
+  let nextIndex = 0
+
+  async function worker(): Promise<void> {
+    while (nextIndex < pendingScopes.length) {
+      let index = nextIndex++
+      let pending = pendingScopes[index]
+      try {
+        results[index] = {
+          ok: true,
+          scopePathname: await getBareImportScopePathname({
+            importerPath,
+            resolvedIdentityPath: pending.resolvedIdentityPath,
+            specifier: pending.specifier,
+            ...args,
+          }),
+        }
+      } catch (error) {
+        results[index] = {
+          ok: false,
+          error: isAssetServerCompilationError(error)
+            ? error
+            : createAssetServerCompilationError(
+                `Failed to determine an import map scope for "${pending.imported.specifier}" in ${importerPath}. ${formatUnknownError(error)}`,
+                { cause: error, code: 'IMPORT_RESOLUTION_FAILED' },
+              ),
+        }
+      }
+    }
+  }
+
+  if (pendingScopes.length === 1) {
+    await worker()
+  } else {
+    await Promise.all(
+      Array.from({ length: Math.min(args.concurrency, pendingScopes.length) }, () => worker()),
+    )
+  }
+  return results
+}
+
+async function getBareImportScopePathname(args: {
+  importerPath: string
+  isDirectoryResolutionFileIndependent(directory: string): boolean
+  resolvedIdentityPath: string
+  resolveDirectorySpecifierIdentity(directory: string, specifier: string): Promise<string | null>
+  routes: CompiledRoutes
+  specifier: string
+}): Promise<string> {
+  let importerDirectory = normalizeFilePath(path.dirname(args.importerPath))
+  let importerScopePathname = args.routes.toUrlPathname(importerDirectory)
+  if (!importerScopePathname) {
+    throw new Error(`Expected a URL pathname for ${importerDirectory}`)
+  }
+
+  let importerDirectoryResolution: string | null = args.resolvedIdentityPath
+  if (!args.isDirectoryResolutionFileIndependent(importerDirectory)) {
+    importerDirectoryResolution = await args.resolveDirectorySpecifierIdentity(
+      importerDirectory,
+      args.specifier,
+    )
+    if (importerDirectoryResolution !== args.resolvedIdentityPath) {
+      throw createAssetServerCompilationError(
+        `Bare import "${args.specifier}" in ${args.importerPath} resolves differently based on the importer file. ` +
+          `Browser module resolution must be uniform for all files in the same directory.`,
+        { code: 'IMPORT_RESOLUTION_NOT_DIRECTORY_UNIFORM' },
+      )
+    }
+  }
+
+  let directory = importerDirectory
+  let scopePathname = importerScopePathname
+  let broadestScopePathname = importerScopePathname
+  while (true) {
+    let resolvedIdentityPath =
+      directory === importerDirectory
+        ? importerDirectoryResolution
+        : await args.resolveDirectorySpecifierIdentity(directory, args.specifier)
+    if (resolvedIdentityPath !== args.resolvedIdentityPath) break
+
+    broadestScopePathname = scopePathname
+    let parentDirectory = normalizeFilePath(path.dirname(directory))
+    if (parentDirectory === directory) break
+    let parentScopePathname = args.routes.toUrlPathname(parentDirectory)
+    if (!parentScopePathname) break
+    directory = parentDirectory
+    scopePathname = parentScopePathname
+  }
+
+  return ensureTrailingSlash(broadestScopePathname)
+}
+
+function ensureTrailingSlash(value: string): string {
+  return value.endsWith('/') ? value : `${value}/`
+}
+
 function findNearestPackageJsonPath(filePath: string): string | null {
   let directory = path.dirname(filePath)
 

package/src/lib/scripts/specifiers.ts

@@ -0,0 +1,11 @@
+export function isBareImportSpecifier(specifier: string): boolean {
+  return (
+    !specifier.startsWith('./') &&
+    !specifier.startsWith('../') &&
+    !specifier.startsWith('/') &&
+    !specifier.startsWith('file:') &&
+    !specifier.startsWith('data:') &&
+    !specifier.startsWith('http://') &&
+    !specifier.startsWith('https://')
+  )
+}

package/src/lib/scripts/transform.ts

@@ -18,7 +18,6 @@ import {
   isAssetServerCompilationError,
 } from '../compilation-error.ts'
 import type { AssetServerCompilationError } from '../compilation-error.ts'
-import { generateFingerprint } from '../fingerprint.ts'
 import {
   maskAuthoredInjectedPackageSpecifier,
   mayContainInjectedPackageSpecifier,
@@ -38,6 +37,7 @@ import type { EmittedModule } from './emit.ts'
 import type { ResolvedScriptTarget } from '../target.ts'
 import type { ResolvedModule } from './resolve.ts'
 import { scriptLoaderConditions } from './conditions.ts'
+import { isBareImportSpecifier } from './specifiers.ts'
 
 type ScriptRecord = ModuleRecord<TransformedModule, ResolvedModule, EmittedModule>
 
@@ -74,16 +74,16 @@ export type ResolveModuleResult = {
 }
 
 type UnresolvedImport = {
+  dynamic: boolean
   end: number
   quote?: '"' | "'" | '`'
   specifier: string
   start: number
 }
 
-type HmrAcceptedDependency = UnresolvedImport
+type HmrAcceptedDependency = Omit<UnresolvedImport, 'dynamic'>
 
 export type TransformedModule = {
-  fingerprint: string | null
   hmr: {
     acceptedDeps: HmrAcceptedDependency[]
     selfAccepting: boolean
@@ -121,7 +121,6 @@ type TsconfigTransformOptions = {
 type TsconfigTransformOptionsResolver = ReturnType<typeof createTsconfigTransformOptionsResolver>
 
 export type TransformArgs = {
-  buildId: string | null
   define: Record<string, string> | null
   externalSet: ReadonlySet<string>
   isWatchIgnored(filePath: string): boolean
@@ -272,13 +271,6 @@ export async function transformModule(
         trackedFiles,
       },
       value: {
-        fingerprint:
-          args.buildId === null
-            ? null
-            : await generateFingerprint({
-                buildId: args.buildId,
-                content: sourceText,
-              }),
         hmr: getHmrAnalysis(analysis.rawCode),
         identityPath: record.identityPath,
         importerDir: path.dirname(resolvedPath),
@@ -434,18 +426,6 @@ function findNearestTsconfigPath(directory: 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://')
-  )
-}
-
 async function analyzeModuleSource(
   sourceText: string,
   resolvedPath: string,
@@ -823,6 +803,7 @@ async function getUnresolvedImportsFromLexer(rawCode: string): Promise<Unresolve
     let specifier = getStaticImportSpecifier(rawCode, imported)
     if (specifier == null || isBrowserExternalModuleUrl(specifier)) continue
     unresolvedImports.push({
+      dynamic: imported.d !== -1,
       specifier,
       start: imported.s,
       end: imported.e,

package/src/lib/styles/compiler.ts

@@ -2,6 +2,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 { createAssetServerCompilationError } from '../compilation-error.ts'
 import { createFileMatcher } from '../file-matcher.ts'
 import { formatFingerprintedPathname } from '../fingerprint.ts'
 import { createModuleStore } from '../module-store.ts'
@@ -18,6 +19,11 @@ import type { TransformArgs, TransformedStyle } from './transform.ts'
 
 type StyleRecord = ModuleRecord<TransformedStyle, ResolvedStyle, EmittedStyle>
 type StyleStore = ModuleStore<TransformedStyle, ResolvedStyle, EmittedStyle>
+type ResolvedStyleGraphEntry = {
+  invalidationVersion: number
+  resolvedStyle: ResolvedStyle
+}
+type ResolvedStyleGraph = ReadonlyMap<string, ResolvedStyleGraphEntry>
 
 type StyleCompileResult = {
   code: EmittedAsset
@@ -42,7 +48,6 @@ type StyleGetOptions = {
 }
 
 type StyleCompilerOptions = {
-  buildId?: string
   fingerprintAssets: boolean
   getServedFileUrl?(
     identityPath: string,
@@ -109,7 +114,6 @@ export function createStyleCompiler(options: StyleCompilerOptions): StyleCompile
     routes: resolvedOptions.routes,
   }
   let transformArgs: TransformArgs = {
-    buildId: resolvedOptions.buildId ?? null,
     isWatchIgnored,
     minify: resolvedOptions.minify,
     routes: resolvedOptions.routes,
@@ -121,7 +125,8 @@ export function createStyleCompiler(options: StyleCompilerOptions): StyleCompile
   return {
     async getHref(filePath) {
       let resolvedStyle = resolveServedStyleOrThrow(resolveInputFilePath(filePath), resolveArgs)
-      return getServedUrl(resolvedStyle.identityPath)
+      let graph = await resolveStyleGraph(resolvedStyle.identityPath)
+      return getServedUrlFromGraph(resolvedStyle.identityPath, graph)
     },
 
     async getPreloadLayers(filePath) {
@@ -139,17 +144,18 @@ export function createStyleCompiler(options: StyleCompilerOptions): StyleCompile
       let visited = new Set(resolvedEntries)
       let queue = [...resolvedEntries]
       let layers: string[][] = []
+      let graph = await resolveStyleGraph(resolvedEntries)
 
       while (queue.length > 0) {
         let frontier = queue
         queue = []
-        let resolvedStyles = await getOrCreateResolvedStyles(
-          frontier.map((identityPath) => styleStore.get(identityPath)),
-        )
         let layer: string[] = []
 
-        for (let resolvedStyle of resolvedStyles) {
-          layer.push(getServedUrlForResolvedStyle(resolvedStyle))
+        for (let identityPath of frontier) {
+          let graphEntry = graph.get(identityPath)
+          if (!graphEntry) throw new Error(`Missing resolved style ${identityPath}`)
+          let resolvedStyle = graphEntry.resolvedStyle
+          layer.push(await getServedUrlFromGraph(identityPath, graph))
 
           for (let dep of resolvedStyle.deps) {
             if (visited.has(dep)) continue
@@ -220,12 +226,6 @@ export function createStyleCompiler(options: StyleCompilerOptions): StyleCompile
     return resolveFilePath(resolvedOptions.rootDir, filePath)
   }
 
-  async function getOrCreateResolvedStyles(records: StyleRecord[]): Promise<ResolvedStyle[]> {
-    return mapWithConcurrency(records, preloadConcurrency, (record) =>
-      getOrCreateResolvedStyle(record),
-    )
-  }
-
   async function getOrCreateResolvedStyle(record: StyleRecord): Promise<ResolvedStyle> {
     if (record.resolved && styleStore.isResolvedFresh(record)) return record.resolved
 
@@ -296,16 +296,39 @@ export function createStyleCompiler(options: StyleCompilerOptions): StyleCompile
       return record.emitted
     }
 
-    let cacheKey = getRecordCacheKey(record)
+    let graph = await resolveStyleGraph(record.identityPath)
+    return getOrCreateEmittedStyleFromGraph(record, graph)
+  }
+
+  async function getOrCreateEmittedStyleFromGraph(
+    record: StyleRecord,
+    graph: ResolvedStyleGraph,
+  ): Promise<EmittedStyle> {
+    let graphEntry = graph.get(record.identityPath)
+    if (!graphEntry) {
+      throw new Error(`Missing resolved style ${record.identityPath}`)
+    }
+
+    if (
+      record.invalidationVersion === graphEntry.invalidationVersion &&
+      record.emitted &&
+      styleStore.isEmittedFresh(record) &&
+      !hasHmrTimestampedDependency(record.resolved)
+    ) {
+      return record.emitted
+    }
+
+    let cacheKey = getCacheKey(record.identityPath, graphEntry.invalidationVersion)
     let existing = emitInFlightByCacheKey.get(cacheKey)
     if (existing) return existing
 
     let promise = (async () => {
-      let startedVersion = record.invalidationVersion
-      let resolvedStyle = await getOrCreateResolvedStyle(record)
-      let emitResolvedStyleResult = await emitResolvedStyle(resolvedStyle, {
+      let emitResolvedStyleResult = await emitResolvedStyle(graphEntry.resolvedStyle, {
+        fingerprintAssets: resolvedOptions.fingerprintAssets,
         getServedFileUrl: resolvedOptions.getServedFileUrl,
-        getServedUrl,
+        getServedUrl(identityPath) {
+          return getServedUrlFromGraph(identityPath, graph)
+        },
         sourceMaps: resolvedOptions.sourceMaps,
       })
 
@@ -313,7 +336,7 @@ export function createStyleCompiler(options: StyleCompilerOptions): StyleCompile
         throw emitResolvedStyleResult.error
       }
 
-      if (isFresh(record, startedVersion)) {
+      if (isFresh(record, graphEntry.invalidationVersion)) {
         styleStore.setEmitted(record.identityPath, emitResolvedStyleResult.value, null)
       }
 
@@ -331,21 +354,95 @@ export function createStyleCompiler(options: StyleCompilerOptions): StyleCompile
     }
   }
 
-  async function getServedUrl(identityPath: string): Promise<string> {
-    return getServedUrlForResolvedStyle(
-      await getOrCreateResolvedStyle(styleStore.get(identityPath)),
-    )
-  }
+  async function getServedUrlFromGraph(
+    identityPath: string,
+    graph: ResolvedStyleGraph,
+  ): Promise<string> {
+    let graphEntry = graph.get(identityPath)
+    if (!graphEntry) throw new Error(`Missing resolved style ${identityPath}`)
+    let pathname = graphEntry.resolvedStyle.stableUrlPathname
+
+    if (resolvedOptions.fingerprintAssets) {
+      let emittedStyle = await getOrCreateEmittedStyleFromGraph(styleStore.get(identityPath), graph)
+      pathname = formatFingerprintedPathname(
+        graphEntry.resolvedStyle.stableUrlPathname,
+        emittedStyle.fingerprint,
+      )
+    }
 
-  function getServedUrlForResolvedStyle(resolvedStyle: ResolvedStyle): string {
-    let pathname = formatFingerprintedPathname(
-      resolvedStyle.stableUrlPathname,
-      resolvedOptions.fingerprintAssets ? resolvedStyle.fingerprint : null,
-    )
-    let timestamp = styleStore.getHmrUpdateTimestamp(resolvedStyle.identityPath)
+    let timestamp = styleStore.getHmrUpdateTimestamp(graphEntry.resolvedStyle.identityPath)
     return timestamp ? appendTimestamp(pathname, timestamp) : pathname
   }
 
+  async function resolveStyleGraph(
+    rootPath: string | readonly string[],
+  ): Promise<ResolvedStyleGraph> {
+    let resolvedByPath = new Map<string, ResolvedStyleGraphEntry>()
+    let rootPaths = Array.isArray(rootPath) ? rootPath : [rootPath]
+    let discovered = new Set(rootPaths)
+    let queue = [...rootPaths]
+
+    while (queue.length > 0) {
+      let frontier = queue
+      queue = []
+      let graphEntries = await mapWithConcurrency(
+        frontier,
+        preloadConcurrency,
+        async (identityPath): Promise<ResolvedStyleGraphEntry> => {
+          let record = styleStore.get(identityPath)
+          let invalidationVersion = record.invalidationVersion
+          let resolvedStyle = await getOrCreateResolvedStyle(record)
+          return {
+            invalidationVersion,
+            resolvedStyle,
+          }
+        },
+      )
+
+      for (let [index, identityPath] of frontier.entries()) {
+        let graphEntry = graphEntries[index]
+        resolvedByPath.set(identityPath, graphEntry)
+        for (let depPath of graphEntry.resolvedStyle.deps) {
+          if (discovered.has(depPath)) continue
+          discovered.add(depPath)
+          queue.push(depPath)
+        }
+      }
+    }
+
+    assertNoCircularImports(resolvedByPath, rootPaths)
+    return resolvedByPath
+  }
+
+  function assertNoCircularImports(graph: ResolvedStyleGraph, rootPaths: readonly string[]): void {
+    let visited = new Set<string>()
+    let path: string[] = []
+    let pathIndexByIdentity = new Map<string, number>()
+
+    function visit(identityPath: string): void {
+      let cycleStart = pathIndexByIdentity.get(identityPath)
+      if (cycleStart !== undefined) {
+        let cycle = [...path.slice(cycleStart), identityPath]
+        throw createAssetServerCompilationError(
+          `Circular CSS imports are not supported: ${cycle.join(' -> ')}`,
+          { code: 'EMIT_FAILED' },
+        )
+      }
+      if (visited.has(identityPath)) return
+
+      let graphEntry = graph.get(identityPath)
+      if (!graphEntry) throw new Error(`Missing resolved style ${identityPath}`)
+      pathIndexByIdentity.set(identityPath, path.length)
+      path.push(identityPath)
+      for (let depPath of graphEntry.resolvedStyle.deps) visit(depPath)
+      path.pop()
+      pathIndexByIdentity.delete(identityPath)
+      visited.add(identityPath)
+    }
+
+    for (let identityPath of rootPaths) visit(identityPath)
+  }
+
   function getHmrUpdatePathnames(identityPath: string, timestamp: number): string[] {
     let resolvedStyles = findHmrUpdateStyles(identityPath, new Set())
     // Mark update timestamps before invalidating so re-emitted importer stylesheets
@@ -389,7 +486,11 @@ export function createStyleCompiler(options: StyleCompilerOptions): StyleCompile
 }
 
 function getRecordCacheKey(record: StyleRecord): string {
-  return `${record.identityPath}\0${record.invalidationVersion}`
+  return getCacheKey(record.identityPath, record.invalidationVersion)
+}
+
+function getCacheKey(identityPath: string, version: number): string {
+  return `${identityPath}\0${version}`
 }
 
 function isFresh(record: StyleRecord, version: number): boolean {
@@ -407,16 +508,13 @@ function getNotModifiedStyle(
   let emittedStyle = record.emitted
   if (!emittedStyle || options.ifNoneMatch === null) return null
 
-  if (
-    options.requestedFingerprint !== null &&
-    emittedStyle.fingerprint !== options.requestedFingerprint
-  ) {
-    return null
-  }
-
   let asset = getEmittedAssetForRequest(emittedStyle, 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 { etag: asset.etag, type: 'not-modified' }
 }