diff --git a/reference-implementation/__tests__/helpers/common-test-helper.js b/reference-implementation/__tests__/helpers/common-test-helper.js
index 28695df..cb9a228 100644
--- a/reference-implementation/__tests__/helpers/common-test-helper.js
+++ b/reference-implementation/__tests__/helpers/common-test-helper.js
@@ -3,6 +3,7 @@ const assert = require('assert');
 const { URL } = require('url');
 const { parseFromString } = require('../../lib/parser.js');
 const { resolve } = require('../../lib/resolver.js');
+const { traceDepcache } = require('../../lib/depcache.js');
 
 function assertNoExtraProperties(object, expectedProperties, description) {
   for (const actualProperty in object) {
@@ -22,6 +23,14 @@ function assertOwnProperty(j, name) {
 // expected import maps (taken from JSONs) uses strings.
 // This function converts `m` (expected import maps or its part)
 // into URL-based, for comparison.
+function replaceImportMapStringWithURL(m) {
+  return {
+    depcache: m.depcache,
+    imports: replaceStringWithURL(m.imports),
+    scopes: replaceStringWithURL(m.scopes)
+  };
+}
+
 function replaceStringWithURL(m) {
   if (typeof m === 'string') {
     return new URL(m);
@@ -59,7 +68,7 @@ function runTests(j) {
   assertNoExtraProperties(
     j,
     [
-      'expectedResults', 'expectedParsedImportMap',
+      'expectedResults', 'expectedParsedImportMap', 'expectedDepcache',
       'baseURL', 'name', 'parsedImportMap',
       'importMap', 'importMapBaseURL',
       'link', 'details'
@@ -85,8 +94,9 @@ function runTests(j) {
     }
     assert(
       'expectedResults' in j ||
-           'expectedParsedImportMap' in j,
-      'expectedResults or expectedParsedImportMap should exist'
+           'expectedParsedImportMap' in j ||
+           'expectedDepcache' in j,
+      'expectedResults, expectedParsedImportMap or expectedDepcache should exist'
     );
 
     // Resolution tests.
@@ -119,7 +129,31 @@ function runTests(j) {
           expect(j.parsedImportMap).toBeInstanceOf(TypeError);
         } else {
           expect(j.parsedImportMap)
-            .toEqual(replaceStringWithURL(j.expectedParsedImportMap));
+            .toEqual(replaceImportMapStringWithURL(j.expectedParsedImportMap));
+        }
+      });
+    }
+
+    // Depcache tests
+    if ('expectedDepcache' in j) {
+      it(j.name, () => {
+        assertOwnProperty(j, 'baseURL');
+        describe(
+          'Import map registration should be successful for resolution tests',
+          () => {
+            expect(j.parsedImportMap).not.toBeInstanceOf(Error);
+          }
+        );
+
+        for (const specifier in j.expectedDepcache) {
+          const expected = j.expectedDepcache[specifier];
+          const resolved = resolve(specifier, j.parsedImportMap, new URL(j.baseURL));
+          if (expected === null) {
+            expect(() => traceDepcache(resolved, j.parsedImportMap)).toThrow(TypeError);
+          } else {
+            const traced = traceDepcache(resolved, j.parsedImportMap);
+            expect(traced).toEqual(j.expectedDepcache[specifier]);
+          }
         }
       });
     }
diff --git a/reference-implementation/__tests__/helpers/matchers.js b/reference-implementation/__tests__/helpers/matchers.js
index 27980b7..f40e657 100644
--- a/reference-implementation/__tests__/helpers/matchers.js
+++ b/reference-implementation/__tests__/helpers/matchers.js
@@ -15,7 +15,7 @@ expect.extend({
     }
 
     received = received.href;
-    expected = (new URL(expected)).href;
+    expected = new URL(expected).href;
 
     const pass = received === expected;
 
diff --git a/reference-implementation/__tests__/json/depcache.json b/reference-implementation/__tests__/json/depcache.json
new file mode 100644
index 0000000..0cb992d
--- /dev/null
+++ b/reference-implementation/__tests__/json/depcache.json
@@ -0,0 +1,144 @@
+{
+  "importMapBaseURL": "https://example.com/app/index.html",
+  "tests": {
+    "Invalid depcache": {
+      "importMap": {
+        "depcache": []
+      },
+      "tests": {
+        "should report invalid depcache": {
+          "expectedParsedImportMap": null
+        }
+      }
+    },
+    "Invalid depcache URL": {
+      "importMap": {
+        "depcache": {
+          "http://[www.example.com]/": [],
+          "/a.js": ["/b.js"]
+        }
+      },
+      "tests": {
+        "should ignore invalid depcache URL": {
+          "baseURL": "https://example.com/",
+          "expectedDepcache": {
+            "/a.js": [
+              "https://example.com/a.js",
+              "https://example.com/b.js"
+            ]
+          }
+        }
+      }
+    },
+    "Invalid depcache keys and specifiers": {
+      "importMap": {
+        "depcache": {
+          "/a.js": ["/b.js"],
+          "/c.js": ["http://[www.example.com]/"]
+        }
+      },
+      "tests": {
+        "should ignore invalid depcache URL": {
+          "baseURL": "https://example.com/",
+          "expectedParsedImportMap": {
+            "depcache": {
+              "https://example.com/a.js": ["/b.js"],
+              "https://example.com/c.js": ["http://[www.example.com]/"]
+            },
+            "imports": {},
+            "scopes": {}
+          },
+          "expectedDepcache": {
+            "/a.js": [
+              "https://example.com/a.js",
+              "https://example.com/b.js"
+            ]
+          }
+        },
+        "invalid depcache key resolution": {
+          "baseURL": "https://example.com/",
+          "expectedDepcache": {
+            "/c.js": null
+          }
+        }
+      }
+    },
+    "Invalid depcache dependencies list": {
+      "importMap": {
+        "depcache": {
+          "/valid.js": ["/a.js"],
+          "/a.js": {}
+        }
+      },
+      "tests": {
+        "should ignore invalid depcache items": {
+          "baseURL": "https://example.com/",
+          "expectedParsedImportMap": {
+            "depcache": {
+              "https://example.com/valid.js": ["/a.js"]
+            },
+            "imports": {},
+            "scopes": {}
+          }
+        }
+      }
+    },
+    "Invalid depcache list items": {
+      "importMap": {
+        "depcache": {
+          "/valid.js": ["/a.js"],
+          "/a.js": ["/b.js", null, {}]
+        }
+      },
+      "tests": {
+        "should ignore invalid depcache items": {
+          "baseURL": "https://example.com/",
+          "expectedParsedImportMap": {
+            "depcache": {
+              "https://example.com/valid.js": ["/a.js"]
+            },
+            "imports": {},
+            "scopes": {}
+          }
+        }
+      }
+    },
+    "Depcache resolution": {
+      "importMap": {
+        "imports": {
+          "a": "/a-1.mjs",
+          "b": "/scope/b-1.mjs"
+        },
+        "scopes": {
+          "/a-1.mjs": {
+            "a": "/a-2.mjs"
+          },
+          "/scope/": {
+            "a": "/scope/a-3.mjs",
+            "b": "./b-2.mjs"
+          }
+        },
+        "depcache": {
+          "/a-1.mjs": ["a"],
+          "/a-2.mjs": ["b", "a"],
+          "/scope/b-1.mjs": ["./b-2.mjs"],
+          "/scope/b-2.mjs": ["a"]
+        }
+      },
+      "tests": {
+        "should trace full depcache": {
+          "baseURL": "https://example.com/",
+          "expectedDepcache": {
+            "a": [
+              "https://example.com/a-1.mjs",
+              "https://example.com/a-2.mjs",
+              "https://example.com/scope/b-1.mjs",
+              "https://example.com/scope/b-2.mjs",
+              "https://example.com/scope/a-3.mjs"
+            ]
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/reference-implementation/__tests__/json/parsing-addresses-absolute.json b/reference-implementation/__tests__/json/parsing-addresses-absolute.json
index b400439..a9af87c 100644
--- a/reference-implementation/__tests__/json/parsing-addresses-absolute.json
+++ b/reference-implementation/__tests__/json/parsing-addresses-absolute.json
@@ -20,6 +20,7 @@
       },
       "importMapBaseURL": "https://base.example/path1/path2/path3",
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "about": "about:good",
           "blob": "blob:good",
@@ -50,6 +51,7 @@
       },
       "importMapBaseURL": "https://base.example/path1/path2/path3",
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "unparseable2": null,
           "unparseable3": null,
diff --git a/reference-implementation/__tests__/json/parsing-addresses-invalid.json b/reference-implementation/__tests__/json/parsing-addresses-invalid.json
index 4e5f182..25fcf96 100644
--- a/reference-implementation/__tests__/json/parsing-addresses-invalid.json
+++ b/reference-implementation/__tests__/json/parsing-addresses-invalid.json
@@ -13,6 +13,7 @@
       },
       "importMapBaseURL": "https://base.example/path1/path2/path3",
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "foo1": null,
           "foo2": null,
diff --git a/reference-implementation/__tests__/json/parsing-addresses.json b/reference-implementation/__tests__/json/parsing-addresses.json
index fe92709..4ed3eba 100644
--- a/reference-implementation/__tests__/json/parsing-addresses.json
+++ b/reference-implementation/__tests__/json/parsing-addresses.json
@@ -3,6 +3,7 @@
   "tests": {
     "should accept strings prefixed with ./, ../, or /": {
       "importMap": {
+        "depcache": {},
         "imports": {
           "dotSlash": "./foo",
           "dotDotSlash": "../foo",
@@ -11,6 +12,7 @@
       },
       "importMapBaseURL": "https://base.example/path1/path2/path3",
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "dotSlash": "https://base.example/path1/path2/foo",
           "dotDotSlash": "https://base.example/path1/foo",
@@ -21,6 +23,7 @@
     },
     "should not accept strings prefixed with ./, ../, or / for data: base URLs": {
       "importMap": {
+        "depcache": {},
         "imports": {
           "dotSlash": "./foo",
           "dotDotSlash": "../foo",
@@ -29,6 +32,7 @@
       },
       "importMapBaseURL": "data:text/html,test",
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "dotSlash": null,
           "dotDotSlash": null,
@@ -39,6 +43,7 @@
     },
     "should accept the literal strings ./, ../, or / with no suffix": {
       "importMap": {
+        "depcache": {},
         "imports": {
           "dotSlash": "./",
           "dotDotSlash": "../",
@@ -47,6 +52,7 @@
       },
       "importMapBaseURL": "https://base.example/path1/path2/path3",
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "dotSlash": "https://base.example/path1/path2/",
           "dotDotSlash": "https://base.example/path1/",
@@ -57,6 +63,7 @@
     },
     "should ignore percent-encoded variants of ./, ../, or /": {
       "importMap": {
+        "depcache": {},
         "imports": {
           "dotSlash1": "%2E/",
           "dotDotSlash1": "%2E%2E/",
@@ -69,6 +76,7 @@
       },
       "importMapBaseURL": "https://base.example/path1/path2/path3",
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "dotSlash1": null,
           "dotDotSlash1": null,
diff --git a/reference-implementation/__tests__/json/parsing-schema-normalization.json b/reference-implementation/__tests__/json/parsing-schema-normalization.json
index a330bb8..9f77458 100644
--- a/reference-implementation/__tests__/json/parsing-schema-normalization.json
+++ b/reference-implementation/__tests__/json/parsing-schema-normalization.json
@@ -5,6 +5,7 @@
     "should normalize empty import maps to have imports and scopes keys": {
       "importMap": {},
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {}
       }
@@ -14,6 +15,7 @@
         "scopes": {}
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {}
       }
@@ -23,6 +25,7 @@
         "imports": {}
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {}
       }
diff --git a/reference-implementation/__tests__/json/parsing-schema-specifier-map.json b/reference-implementation/__tests__/json/parsing-schema-specifier-map.json
index 7d7d4be..ec168c5 100644
--- a/reference-implementation/__tests__/json/parsing-schema-specifier-map.json
+++ b/reference-implementation/__tests__/json/parsing-schema-specifier-map.json
@@ -17,6 +17,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "null": null,
           "boolean": null,
@@ -36,6 +37,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {}
       }
diff --git a/reference-implementation/__tests__/json/parsing-schema-toplevel.json b/reference-implementation/__tests__/json/parsing-schema-toplevel.json
index 278cad2..8bf15ca 100644
--- a/reference-implementation/__tests__/json/parsing-schema-toplevel.json
+++ b/reference-implementation/__tests__/json/parsing-schema-toplevel.json
@@ -89,6 +89,7 @@
         "scops": {}
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {}
       }
diff --git a/reference-implementation/__tests__/json/parsing-scope-keys.json b/reference-implementation/__tests__/json/parsing-scope-keys.json
index 4b2f1ee..fdd466d 100644
--- a/reference-implementation/__tests__/json/parsing-scope-keys.json
+++ b/reference-implementation/__tests__/json/parsing-scope-keys.json
@@ -8,6 +8,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {
           "https://base.example/path1/path2/foo": {}
@@ -23,6 +24,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {
           "https://base.example/path1/path2/foo": {},
@@ -41,6 +43,7 @@
       },
       "importMapBaseURL": "data:text/html,test",
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {}
       }
@@ -54,6 +57,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {
           "https://base.example/path1/path2/": {},
@@ -69,6 +73,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {
           "https://base.example/path1/path2/foo/bar?baz#qux": {}
@@ -82,6 +87,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {
           "https://base.example/path1/path2/path3": {}
@@ -99,6 +105,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {
           "https://base.example/path1/path2/foo/": {},
@@ -123,6 +130,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {
           "https://base.example/path1/path2/foo//": {
@@ -149,6 +157,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {
           "about:good": {},
@@ -178,6 +187,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {
           "https://base.example/path1/path2/example.org": {},
diff --git a/reference-implementation/__tests__/json/parsing-specifier-keys.json b/reference-implementation/__tests__/json/parsing-specifier-keys.json
index b2d9cf4..3c31f28 100644
--- a/reference-implementation/__tests__/json/parsing-specifier-keys.json
+++ b/reference-implementation/__tests__/json/parsing-specifier-keys.json
@@ -10,6 +10,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "https://base.example/path1/path2/foo": "https://base.example/dotslash",
           "https://base.example/path1/foo": "https://base.example/dotdotslash",
@@ -28,6 +29,7 @@
       },
       "importMapBaseURL": "data:text/html,",
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "./foo": "https://example.com/dotslash",
           "../foo": "https://example.com/dotdotslash",
@@ -45,6 +47,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "https://base.example/path1/path2/": "https://base.example/dotslash/",
           "https://base.example/path1/": "https://base.example/dotdotslash/",
@@ -60,6 +63,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "https://base.example/path1/path2/foo/bar?baz#qux": "https://base.example/foo"
         },
@@ -73,6 +77,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {},
         "scopes": {}
       }
@@ -90,6 +95,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "%2E/": "https://base.example/dotSlash1/",
           "%2E%2E/": "https://base.example/dotDotSlash1/",
@@ -111,6 +117,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "https://base.example/path1/path2/foo//": "https://base.example/foo3"
         },
@@ -135,6 +142,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "about:good": "https://base.example/about",
           "blob:good": "https://base.example/blob",
@@ -164,6 +172,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "https://example.com:demo": "https://base.example/unparseable2",
           "http://[www.example.com]/": "https://base.example/unparseable3/",
@@ -183,6 +192,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "https://example.com/aaa": "https://example.com/aaa",
           "https://example.com/a": "https://example.com/a"
@@ -198,6 +208,7 @@
         }
       },
       "expectedParsedImportMap": {
+        "depcache": {},
         "imports": {
           "https://example.com/aaa": "https://example.com/aaa",
           "https://example.com/a": "https://example.com/a"
diff --git a/reference-implementation/__tests__/json/parsing-trailing-slashes.json b/reference-implementation/__tests__/json/parsing-trailing-slashes.json
index 89c454f..06f1e5e 100644
--- a/reference-implementation/__tests__/json/parsing-trailing-slashes.json
+++ b/reference-implementation/__tests__/json/parsing-trailing-slashes.json
@@ -7,6 +7,7 @@
   },
   "importMapBaseURL": "https://base.example/path1/path2/path3",
   "expectedParsedImportMap": {
+    "depcache": {},
     "imports": {
       "trailer/": null
     },
diff --git a/reference-implementation/__tests__/test.js b/reference-implementation/__tests__/test.js
index c7f30b3..da9acc9 100644
--- a/reference-implementation/__tests__/test.js
+++ b/reference-implementation/__tests__/test.js
@@ -2,6 +2,7 @@
 const { runTests } = require('./helpers/common-test-helper.js');
 for (const jsonFile of [
   'data-base-url.json',
+  'depcache.json',
   'empty-import-map.json',
   'overlapping-entries.json',
   'packages-via-trailing-slashes.json',
diff --git a/reference-implementation/lib/depcache.js b/reference-implementation/lib/depcache.js
new file mode 100644
index 0000000..f8e3e40
--- /dev/null
+++ b/reference-implementation/lib/depcache.js
@@ -0,0 +1,21 @@
+'use strict';
+
+const { resolve } = require('./resolver.js');
+
+// This implementation differs from the specification since the specification
+// implementation integrates closely with the module loading algorithm.
+exports.traceDepcache = traceDepcache;
+function traceDepcache(url, parsedImportMap, visited = new Set()) {
+  const urlString = url.href;
+  if (visited.has(urlString)) {
+    return visited;
+  }
+  visited.add(urlString);
+
+  const dependencies = parsedImportMap.depcache[urlString] || [];
+  for (const dep of dependencies) {
+    const resolved = resolve(dep, parsedImportMap, url);
+    traceDepcache(resolved, parsedImportMap, visited);
+  }
+  return [...visited];
+}
diff --git a/reference-implementation/lib/parser.js b/reference-implementation/lib/parser.js
index 77b7309..6a4c908 100644
--- a/reference-implementation/lib/parser.js
+++ b/reference-implementation/lib/parser.js
@@ -25,17 +25,27 @@ exports.parseFromString = (input, baseURL) => {
     sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL);
   }
 
+  let normalizedDepcache = {};
+  if ('depcache' in parsed) {
+    if (!isJSONObject(parsed.depcache)) {
+      throw new TypeError('Import map\'s depcache value must be an object.');
+    }
+    normalizedDepcache = normalizeDepcache(parsed.depcache, baseURL);
+  }
+
   const badTopLevelKeys = new Set(Object.keys(parsed));
   badTopLevelKeys.delete('imports');
   badTopLevelKeys.delete('scopes');
+  badTopLevelKeys.delete('depcache');
   for (const badKey of badTopLevelKeys) {
-    console.warn(`Invalid top-level key "${badKey}". Only "imports" and "scopes" can be present.`);
+    console.warn(`Invalid top-level key "${badKey}". Only "imports", "scopes" and "depcache" can be present.`);
   }
 
   // Always have these two keys, and exactly these two keys, in the result.
   return {
     imports: sortedAndNormalizedImports,
-    scopes: sortedAndNormalizedScopes
+    scopes: sortedAndNormalizedScopes,
+    depcache: normalizedDepcache
   };
 };
 
@@ -108,6 +118,37 @@ function sortAndNormalizeScopes(obj, baseURL) {
   return sortedAndNormalized;
 }
 
+function normalizeDepcache(obj, baseURL) {
+  const normalized = {};
+  for (const [module, dependencies] of Object.entries(obj)) {
+    const moduleURL = tryURLParse(module, baseURL);
+    if (moduleURL === null) {
+      console.warn(`Invalid depcache entry URL "${module}" (parsed against base URL "${baseURL}").`);
+      continue;
+    }
+
+    if (!isJSONArray(dependencies)) {
+      console.warn(`The value for the "${module}" depcache dependencies must be an array.`);
+      continue;
+    }
+
+    let validDependencies = true;
+    for (const dependency of dependencies) {
+      if (typeof dependency !== 'string') {
+        console.warn(`Invalid depcache item type "${typeof dependency}" for "${module}, only strings are permitted.`);
+        validDependencies = false;
+        break;
+      }
+    }
+    if (dependencies.length && validDependencies) {
+      const normalizedModule = moduleURL.href;
+      normalized[normalizedModule] = dependencies;
+    }
+  }
+
+  return normalized;
+}
+
 function normalizeSpecifierKey(specifierKey, baseURL) {
   // Ignore attempts to use the empty string as a specifier key
   if (specifierKey === '') {
@@ -127,6 +168,10 @@ function isJSONObject(value) {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
+function isJSONArray(value) {
+  return Array.isArray(value);
+}
+
 function codeUnitCompare(a, b) {
   if (a > b) {
     return 1;
diff --git a/spec.bs b/spec.bs
index 504e42e..7f5d98d 100644
--- a/spec.bs
+++ b/spec.bs
@@ -30,7 +30,11 @@ spec: html; type: dfn; urlPrefix: https://html.spec.whatwg.org/multipage/
   text: fetch an import() module script graph; url: webappapis.html#fetch-an-import()-module-script-graph
   text: fetch a modulepreload module script graph; url: webappapis.html#fetch-a-modulepreload-module-script-graph
   text: fetch an inline module script graph; url: webappapis.html#fetch-an-inline-module-script-graph
+  text: fetch a single module script; url: webappapis.html#fetch-a-single-module-script
   text: script; url: webappapis.html#concept-script
+
+urlPrefix: https://tc39.github.io/ecma262/#; spec: ECMA-262; type: abstract-op;
+  text: IsArray; url: sec-isarray
 </pre>
 
 <style>
@@ -57,12 +61,15 @@ A <dfn>resolution result</dfn> is either a [=URL=] or null.
 
 A <dfn>specifier map</dfn> is an [=ordered map=] from [=strings=] to [=resolution results=].
 
-A <dfn>import map</dfn> is a [=struct=] with two [=struct/items=]:
+A <dfn>dependency cache list</dfn> is a optimization cache [=list=] of the dependency [=strings=] of a module.
+
+A <dfn>import map</dfn> is a [=struct=] with three [=struct/items=]:
 
 * <dfn for="import map">imports</dfn>, a [=specifier map=], and
 * <dfn for="import map">scopes</dfn>, an [=ordered map=] of [=URLs=] to [=specifier maps=].
+* <dfn for="import map">depcache</dfn>, an [=ordered map=] of [=URLs=] to [=dependency cache lists=].
 
-An <dfn>empty import map</dfn> is an [=/import map=] with its [=import map/imports=] and [=import map/scopes=] both being empty maps.
+An <dfn>empty import map</dfn> is an [=/import map=] with its [=import map/imports=], [=import map/scopes=] and [=import map/depcache=] all being empty maps.
 
 <h2 id="acquiring">Acquiring import maps</h2>
 
@@ -173,7 +180,7 @@ Inside the <a spec="html">prepare a script</a> algorithm, we make the following
 
 <div algorithm>
   To <dfn export>fetch an import map</dfn> given |url|, |settings object|, and |options|, run the following steps. This algorithm asynchronously returns an [=/import map=] or null.
-  <p class="note">This algorithm is specified consistently with <a spec="html">fetch a single module script</a> steps 5, 7, 8, 9, 10, and 12.1. Particularly, we enforce CORS to avoid leaking the import map contents that shouldn't be accessed.</p>
+  <p class="note">This algorithm is specified consistently with [=fetch a single module script=] steps 5, 7, 8, 9, 10, and 12.1. Particularly, we enforce CORS to avoid leaking the import map contents that shouldn't be accessed.</p>
 
   1. Let |request| be a new [=/request=] whose [=request/url=] is |url|, [=request/destination=] is "`script`", [=request/mode=] is "`cors`", [=request/referrer=] is "`client`", and [=request/client=] is |settings object|.
      <p class="note">Here we use "`script`" as the [=request/destination=], which means the `script-src-elem` CSP directive applies.</p>
@@ -266,9 +273,12 @@ To <dfn>register an import map</dfn> given an {{HTMLScriptElement}} |element|:
   1. If |parsed|["`scopes`"] [=map/exists=], then:
     1. If |parsed|["`scopes`"] is not a [=map=], then throw a {{TypeError}} indicating that the "`scopes`" top-level key must be a JSON object.
     1. Set |sortedAndNormalizedScopes| to the result of [=sorting and normalizing scopes=] given |parsed|["`scopes`"] and |baseURL|.
-  1. If |parsed|'s [=map/get the keys|keys=] [=set/contains=] any items besides "`imports`" or "`scopes`", [=report a warning to the console=] that an invalid top-level key was present in the import map.
+  1. If |parsed|["`depcache`"] [=map/exists=], then:
+    1. If |parsed|["`depcache`"] is not a [=map=], then throw a {{TypeError}} indicating that the "`depcache`" top-level key must be a JSON object.
+    1. Set |normalizedDepcache| to the result of [=normalizing depcache=] given |parsed|["`depcache`"] and |baseURL|.
+  1. If |parsed|'s [=map/get the keys|keys=] [=set/contains=] any items besides "`imports`", "`scopes`" or "`depcache`", [=report a warning to the console=] that an invalid top-level key was present in the import map.
      <p class="note">This can help detect typos. It is not an error, because that would prevent any future extensions from being added backward-compatibly.</p>
-  1. Return the [=/import map=] whose [=import map/imports=] are |sortedAndNormalizedImports| and whose [=import map/scopes=] scopes are |sortedAndNormalizedScopes|.
+  1. Return the [=/import map=] whose [=import map/imports=] are |sortedAndNormalizedImports|, [=import map/scopes=] scopes are |sortedAndNormalizedScopes| and [=import map/depcache=] depcache are |normalizedDepcache|.
 </div>
 
 <div algorithm>
@@ -300,7 +310,7 @@ To <dfn>register an import map</dfn> given an {{HTMLScriptElement}} |element|:
   ]»
   </xmp>
 
-  and (despite nothing being present in the input) an empty [=map=] for its [=import map/scopes=].
+  and (despite nothing being present in the input) empty [=map=] entries for its [=import map/scopes=] and [=import map/depcache=].
 </div>
 
 <div algorithm>
@@ -342,6 +352,30 @@ To <dfn>register an import map</dfn> given an {{HTMLScriptElement}} |element|:
   1. Return the result of [=map/sorting=] |normalized|, with an entry |a| being less than an entry |b| if |b|'s [=map/key=] is [=code unit less than=] |a|'s [=map/key=].
 </div>
 
+<div algorithm>
+  To <dfn lt="normalize depcache|normalizing depcache">normalize depcache</dfn>, given a [=map=] |originalMap| and a [=URL=] |baseURL|:
+
+  1. Let |normalized| be an empty [=map=].
+  1. [=map/For each=] |module| → |dependencies| of |originalMap|,
+    1. Let |moduleURL| be the result of [=URL parser|parsing=] |module| with |baseURL| as the base URL.
+    1. If |moduleURL| is failure, then:
+      1. [=Report a warning to the console=] that the depcache URL was not parseable.
+      1. [=Continue=].
+    1. If ![$IsArray$](dependencies), then:
+      1. [=Report a warning to the console=] that the value of the depcache for module |module| must be a JSON array.
+      1. [=Continue=].
+    1. Let |validDependencies| be true.
+    1. [=list/For each=] |dependency| of |dependencies|,
+      1. If |dependency| is not a Javascript [=string=], then:
+        1. [=Report a warning to the console=] that the depcache list for |moduleURL| is invalid.
+        1. Set _validDependencies_ to false.
+        1. [=Break=].
+    1. If |dependencies| is not [=list/empty=] and |validDependencies| is true, then:
+      1. Let |normalizedModule| be the [=URL serializer|serialization=] of |moduleURL|.
+      1. Set |normalized|[|normalizedModule|] to |dependencies|.
+  1. Return |normalized|.
+</div>
+
 <p class="note">We sort keys/scopes in reverse order, to put `"foo/bar/"` before `"foo/"` so that `"foo/bar/"` has a higher priority than `"foo/"`.</p>
 
 <div algorithm>
@@ -389,6 +423,12 @@ To <dfn>register an import map</dfn> given an {{HTMLScriptElement}} |element|:
     1. Set |settingsObject| to |referringScript|'s [=script/settings object=].
     1. Set |baseURL| to |referringScript|'s [=script/base URL=].
   1. Let |importMap| be |settingsObject|'s [=environment settings object/import map=].
+  1. Return the result of [=resolve an import map=] given |specifier|, |importMap| and |baseURL|.
+
+</div>
+
+<div algorithm>
+  To <dfn lt="resolve an import map|resolve an import map">resolve an import map</dfn>, given a [=string=] |specifier|, an [=/import map=] |importMap| and a [=URL=] |baseURL|:
   1. Let |baseURLString| be |baseURL|, [=URL serializer|serialized=].
   1. Let |asURL| be the result of [=parsing a URL-like import specifier=] given |specifier| and |baseURL|.
   1. Let |normalizedSpecifier| be the [=URL serializer|serialization=] of |asURL|, if |asURL| is non-null; otherwise, |specifier|.
@@ -436,6 +476,39 @@ All call sites of HTML's existing <a spec="html">resolve a module specifier</a>
 
 Call sites will also need to be updated to account for [=resolve a module specifier=] now throwing exceptions, instead of returning failure. (Previously most call sites just turned failures into {{TypeError}}s manually, so this is straightforward.)
 
+<h2 id="parallelizing">Parallelizing module graphs</h2>
+
+  To parallelize the loading of modules in the import map, a module graph [=dependency cache list=] can be used to provide upfront a cache of module dependencies so they can be loaded in parallel when lazily loaded, without unnecessary requests or extra round trips.
+
+  When this list of dependency hints is provided for a module [=URL=] the algorithm will, on resolution for that module [=URL=], immediately trigger resolution and preloading for each dependency hint provided.
+
+  The behavior of the dependency cache preloader is distinct from the [=fetch a modulepreload module script graph=] preloader in that it immediately iterates all dependency preloads, and does not trigger instantiation since the top-level module instantiation would already be queued.
+
+<h3 id="preloading-dependency-graphs">Preloading dependency graphs</h3>
+
+  The [=preload depcache=] steps below should be included in [=fetch a single module script=], right after step 4 setting moduleMap[url] to "fetching" combining to form an optimizally-terminating graph fetch parallelizing operation, with minimum complexity. Alternatively these steps can be inlined into [=fetch a single module script=] directly. The rationale of this ordering being that dependencies should be triggered for fetching before their parents, even when fetching in parallel.
+
+<div algorithm>
+  To <dfn lt="preload a dependency graph cache|preload depcache">preload a dependency graph cache</dfn>, given a |url|, a |fetch client settings object|, a |destination|, some |options| and a |module map settings object|, run these steps:
+
+  1. Let |urlString| be |url|, [=URL serializer|serialized=].
+  1. Let |moduleMap| be |module map settings object|'s [=module map=].
+  1. If |moduleMap|[|urlString|] is not undefined, return null.
+    <p class="note">null entries in the |moduleMap| for errored modules will also return here.</p>
+  1. Let |importMap| be |module map settings object|'s [=environment settings object/import map=].
+  1. Let |depcache| be |importMap|'s [=import map/depcache=],
+  1. If |depcache| contains an entry for |urlString|, then:
+    1. Let |dependencies| be the [=list=] |depcache|[|urlString|].
+    1. For each |dependency| of |dependencies|,
+      1. Let |resolvedDependencyURL| be the result of [=resolve an import map=] called with |dependency|, |importMap| and |url|.
+      1. If |resolvedDependencyURL| is null, then:
+        1. Throw a {{TypeError}} indicating that |dependency| was a specifier preloaded by the depcache for |urlString|, but was not resolved by |importMap|.
+      1. Perfom the steps of HTML's [=fetch a single module script] with |resolvedDependencyURL|, |fetch client settings object|, |destination|, |options|, |module map settings object|, |url|, and with the top-level module fetch flag unset, without waiting for asynchronous completion.
+        <p class="note">This triggers the recursive fetch preload operations in turn, since this algorithm is in turn called by [=fetch a single module script=].</p>
+</div>
+
+<p class="note">Only dependency preload resolution errors are thrown, not dependency preload instantiation errors. These can be ignored as they will be rethrown appropriately by the top-level module load operation.</p>
+
 <h2 id="security-and-privacy">Security and Privacy</h2>
 
 <h3 id="threat-models">Threat models</h3>