diff --git a/html/browsers/browsing-the-web/remote-context-helper/resources/executor.sub.html b/html/browsers/browsing-the-web/remote-context-helper/resources/executor.sub.html
index 38f4429d91e4ee..95ecb349319fe9 100644
--- a/html/browsers/browsing-the-web/remote-context-helper/resources/executor.sub.html
+++ b/html/browsers/browsing-the-web/remote-context-helper/resources/executor.sub.html
@@ -9,6 +9,8 @@
       'sec-fetch-mode': '{{header_or_default(sec-fetch-mode, absent)}}',
       'sec-fetch-site': '{{header_or_default(sec-fetch-site, absent)}}',
       'sec-fetch-dest': '{{header_or_default(sec-fetch-dest, absent)}}',
+      'purpose': "{{header_or_default(Purpose, absent)}}",
+      'sec-purpose': "{{header_or_default(Sec-Purpose, absent)}}",
       'referer': '{{header_or_default(referer, absent)}}',
     };
     requestExecutor();
diff --git a/html/browsers/browsing-the-web/remote-context-helper/resources/remote-context-helper.js b/html/browsers/browsing-the-web/remote-context-helper/resources/remote-context-helper.js
index 6978cef83211e5..7de980f11f8df4 100644
--- a/html/browsers/browsing-the-web/remote-context-helper/resources/remote-context-helper.js
+++ b/html/browsers/browsing-the-web/remote-context-helper/resources/remote-context-helper.js
@@ -161,95 +161,6 @@
    */
   const DEFAULT_CONTEXT_CONFIG = new RemoteContextConfig();
 
-  /**
-   * This class represents a configuration for creating remote contexts. This is
-   * the entry-point
-   * for creating remote contexts, providing @see addWindow .
-   */
-  class RemoteContextHelper {
-    /**
-     * @param {RemoteContextConfig|object} config The configuration
-     *     for this remote context.
-     */
-    constructor(config) {
-      this.config = RemoteContextConfig.ensure(config);
-    }
-
-    /**
-     * Creates a new remote context and returns a `RemoteContextWrapper` giving
-     * access to it.
-     * @private
-     * @param {Object} options
-     * @param {(url: string) => Promise<undefined>} options.executorCreator A
-     *     function that takes a URL and causes the browser to navigate some
-     *     window to that URL, e.g. via an iframe or a new window.
-     * @param {RemoteContextConfig|object} [options.extraConfig] If supplied,
-     *     extra configuration for this remote context to be merged with
-     *     `this`'s existing config. If it's not a `RemoteContextConfig`, it
-     *     will be used to construct a new one.
-     * @returns {Promise<RemoteContextWrapper>}
-     */
-    async createContext({
-      executorCreator,
-      extraConfig,
-      isWorker = false,
-    }) {
-      const config =
-          this.config.merged(RemoteContextConfig.ensure(extraConfig));
-
-      const origin = finalizeOrigin(config.origin);
-      const url = new URL(
-          isWorker ? WORKER_EXECUTOR_PATH : WINDOW_EXECUTOR_PATH, origin);
-
-      // UUID is needed for executor.
-      const uuid = token();
-      url.searchParams.append('uuid', uuid);
-
-      if (config.headers) {
-        addHeaders(url, config.headers);
-      }
-      for (const script of config.scripts) {
-        url.searchParams.append('script', makeAbsolute(script));
-      }
-
-      if (config.startOn) {
-        url.searchParams.append('startOn', config.startOn);
-      }
-
-      await executorCreator(url.href);
-      return new RemoteContextWrapper(new RemoteContext(uuid), this, url.href);
-    }
-
-    /**
-     * Creates a window with a remote context. @see createContext for
-     * @param {RemoteContextConfig|object} [extraConfig] Will be
-     *     merged with `this`'s config.
-     * @param {Object} [options]
-     * @param {string} [options.target] Passed to `window.open` as the
-     *     2nd argument
-     * @param {string} [options.features] Passed to `window.open` as the
-     *     3rd argument
-     * @returns {Promise<RemoteContextWrapper>}
-     */
-    addWindow(extraConfig, options) {
-      return this.createContext({
-        executorCreator: windowExecutorCreator(options),
-        extraConfig,
-      });
-    }
-
-    async createContextWithUrl(extraConfig) {
-      let saveUrl;
-      let wrapper = await this.createContext({
-        executorCreator: (url) => {saveUrl = url},
-        extraConfig,
-      });
-      return [wrapper, saveUrl];
-    }
-  }
-  // Export this class.
-  self.RemoteContextHelper = RemoteContextHelper;
-
   /**
    * Attaches header to the URL. See
    * https://web-platform-tests.org/writing-tests/server-pipes.html#headers
@@ -330,6 +241,15 @@
       return this.context.execute_script(fn, args);
     }
 
+    /**
+     * Returns a JavaScript object containing a subset of the request headers.
+     * The specific headers that are recorded are in ./executor.sub.html.
+     * @returns {Object<string, string>}
+     */
+    async getRequestHeaders() {
+      return this.executeScript(() => window.requestHeaders);
+    }
+
     /**
      * Adds a string of HTML to the executor's document.
      * @param {string} html
@@ -530,4 +450,103 @@
       }
     }
   }
+
+
+  /**
+   * This class represents a configuration for creating remote contexts. This is
+   * the entry-point
+   * for creating remote contexts, providing @see addWindow .
+   */
+  class RemoteContextHelper {
+    /**
+     * The constructor to use when creating new remote context wrappers.
+     * Can be overridden by subclasses.
+     */
+    static RemoteContextWrapper = RemoteContextWrapper;
+
+    /**
+     * @param {RemoteContextConfig|object} config The configuration
+     *     for this remote context.
+     */
+    constructor(config) {
+      this.config = RemoteContextConfig.ensure(config);
+    }
+
+    /**
+     * Creates a new remote context and returns a `RemoteContextWrapper` giving
+     * access to it.
+     * @private
+     * @param {Object} options
+     * @param {(url: string) => Promise<undefined>} options.executorCreator A
+     *     function that takes a URL and causes the browser to navigate some
+     *     window to that URL, e.g. via an iframe or a new window.
+     * @param {RemoteContextConfig|object} [options.extraConfig] If supplied,
+     *     extra configuration for this remote context to be merged with
+     *     `this`'s existing config. If it's not a `RemoteContextConfig`, it
+     *     will be used to construct a new one.
+     * @param {Function} [options.remoteContextWrapperConstructor] If supplied,
+     *     the constructor to use when creating the returned
+     *     `RemoteContextWrapper`. (Useful for subclassing.)
+     * @returns {Promise<RemoteContextWrapper>}
+     */
+    async createContext({
+      executorCreator,
+      extraConfig,
+      isWorker = false
+    }) {
+      const config =
+          this.config.merged(RemoteContextConfig.ensure(extraConfig));
+
+      const origin = finalizeOrigin(config.origin);
+      const url = new URL(
+          isWorker ? WORKER_EXECUTOR_PATH : WINDOW_EXECUTOR_PATH, origin);
+
+      // UUID is needed for executor.
+      const uuid = token();
+      url.searchParams.append('uuid', uuid);
+
+      if (config.headers) {
+        addHeaders(url, config.headers);
+      }
+      for (const script of config.scripts) {
+        url.searchParams.append('script', makeAbsolute(script));
+      }
+
+      if (config.startOn) {
+        url.searchParams.append('startOn', config.startOn);
+      }
+
+      await executorCreator(url.href);
+      return new this.constructor.RemoteContextWrapper(new RemoteContext(uuid), this, url.href);
+    }
+
+    /**
+     * Creates a window with a remote context. @see createContext for
+     * @param {RemoteContextConfig|object} [extraConfig] Will be
+     *     merged with `this`'s config.
+     * @param {Object} [options]
+     * @param {string} [options.target] Passed to `window.open` as the
+     *     2nd argument
+     * @param {string} [options.features] Passed to `window.open` as the
+     *     3rd argument
+     * @returns {Promise<RemoteContextWrapper>}
+     */
+    addWindow(extraConfig, options) {
+      return this.createContext({
+        executorCreator: windowExecutorCreator(options),
+        extraConfig,
+      });
+    }
+
+    async createContextWithUrl(extraConfig) {
+      let saveUrl;
+      let wrapper = await this.createContext({
+        executorCreator: (url) => {saveUrl = url},
+        extraConfig,
+      });
+      return [wrapper, saveUrl];
+    }
+  }
+  // Export this class.
+  self.RemoteContextHelper = RemoteContextHelper;
 }
diff --git a/speculation-rules/common/invalid-rules.https.html b/speculation-rules/common/invalid-rules.https.html
new file mode 100644
index 00000000000000..0c3d042574fb64
--- /dev/null
+++ b/speculation-rules/common/invalid-rules.https.html
@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/utils.js"></script>
+<script src="/common/dispatcher/dispatcher.js"></script>
+<script src="/html/browsers/browsing-the-web/remote-context-helper/resources/remote-context-helper.js"></script>
+<script src="../resources/utils.js"></script>
+
+<meta name="variant" content="?prefetch">
+<meta name="variant" content="?prerender">
+
+<script>
+setup(() => assertSpeculationRulesIsSupported());
+
+const preloadingType = location.search.substring(1);
+
+promise_test(async t => {
+  const rcHelper = new PreloadingRemoteContextHelper();
+  const referrerRC = await rcHelper.addWindow();
+
+  const destinationRC = await referrerRC.createPreloadedContext(preloadingType, {
+    extrasInSpeculationRule: { invalid_key: "value" }
+  });
+
+  await referrerRC.navigateTo(destinationRC.url);
+
+  assert_equals(await destinationRC.getPreloadingStatusFromHeaders(), "none");
+}, `an unrecognized key in a ${preloadingType} rule should prevent it from being preloaded`);
+</script>
diff --git a/speculation-rules/prerender/script-supports-speculationrules.html b/speculation-rules/common/script-supports-speculationrules.html
similarity index 90%
rename from speculation-rules/prerender/script-supports-speculationrules.html
rename to speculation-rules/common/script-supports-speculationrules.html
index 2dc856fce5da7c..7446f2b6b5f2f8 100644
--- a/speculation-rules/prerender/script-supports-speculationrules.html
+++ b/speculation-rules/common/script-supports-speculationrules.html
@@ -1,15 +1,14 @@
 <!DOCTYPE html>
-<html>
 <title>HTMLScriptElement.supports speculationrules</title>
-<meta name="timeout" content="long">
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
+
 <script>
-test(function() {
+test(() => {
   assert_true(HTMLScriptElement.supports('speculationrules'));
 }, 'HTMLScriptElement.supports returns true for \'speculationrules\'');
 
-test(function() {
+test(() => {
   assert_false(HTMLScriptElement.supports(' speculationrules'));
   assert_false(HTMLScriptElement.supports('speculationrules '));
   assert_false(HTMLScriptElement.supports('Speculationrules'));
@@ -17,5 +16,4 @@
   assert_false(HTMLScriptElement.supports('speculationRules'));
   assert_false(HTMLScriptElement.supports('speculation-rules'));
 }, 'HTMLScriptElement.supports returns false for unsupported types');
-
 </script>
diff --git a/speculation-rules/prefetch/invalid-rules.https.html b/speculation-rules/prefetch/invalid-rules.https.html
deleted file mode 100644
index 0fdfacde643958..00000000000000
--- a/speculation-rules/prefetch/invalid-rules.https.html
+++ /dev/null
@@ -1,19 +0,0 @@
-<!DOCTYPE html>
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="/common/dispatcher/dispatcher.js"></script>
-<script src="/common/utils.js"></script>
-<script src="../resources/utils.js"></script>
-<script src="resources/utils.sub.js"></script>
-<script>
-  setup(() => assertSpeculationRulesIsSupported());
-
-  promise_test(async t => {
-    let agent = await spawnWindow(t);
-    let nextUrl = agent.getExecutorURL({ page: 2 });
-    await agent.forceSinglePrefetch(nextUrl, { invalid_key: "value" });
-    await agent.navigate(nextUrl);
-
-    assert_not_prefetched(await agent.getRequestHeaders());
-  }, "an unrecognized key in a prefetch rule should prevent it from being fetched");
-</script>
diff --git a/speculation-rules/prerender/activation-start.html b/speculation-rules/prerender/activation-start.html
index 7aee20c3465dcf..421d5694bb88f6 100644
--- a/speculation-rules/prerender/activation-start.html
+++ b/speculation-rules/prerender/activation-start.html
@@ -16,9 +16,9 @@
 promise_test(async t => {
   const ACTIVATION_DELAY = 10;
 
-  const rcHelper = new RemoteContextHelper();
+  const rcHelper = new PrerenderingRemoteContextHelper();
   const referrerRC = await rcHelper.addWindow(undefined, { features: 'noopener' });
-  const prerenderedRC = await addPrerenderRC(referrerRC);
+  const prerenderedRC = await referrerRC.createPrerenderedContext();
   const iframeRC = await prerenderedRC.addIframe();
 
   assert_equals(
@@ -36,7 +36,7 @@
   // Wait ACTIVATION_DELAY ms before activation.
   await new Promise(resolve => t.step_timeout(resolve, ACTIVATION_DELAY));
 
-  await activatePrerenderRC(referrerRC, prerenderedRC);
+  await referrerRC.navigateExpectingPrerenderingActivation(prerenderedRC);
 
   assert_greater_than_equal(
     await getActivationStart(prerenderedRC),
diff --git a/speculation-rules/prerender/credentialed-prerender-not-opt-in.html b/speculation-rules/prerender/credentialed-prerender-not-opt-in.html
index 697382a6dc8569..fe3bae6fae4057 100644
--- a/speculation-rules/prerender/credentialed-prerender-not-opt-in.html
+++ b/speculation-rules/prerender/credentialed-prerender-not-opt-in.html
@@ -15,9 +15,9 @@
 setup(() => assertSpeculationRulesIsSupported());
 
 promise_test(async t => {
-  const rcHelper = new RemoteContextHelper();
+  const rcHelper = new PrerenderingRemoteContextWrapper();
   const referrerRC = await rcHelper.addWindow({origin: 'HTTPS_ORIGIN'}, { features: 'noopener' });
-  const prerenderedRC = await addPrerenderRC(referrerRC, {origin: 'HTTPS_REMOTE_ORIGIN'});
+  const prerenderedRC = await referrerRC.createPrerenderedContext({origin: 'HTTPS_REMOTE_ORIGIN'});
 
   // Because the prerender doesn't use opt-in header, it is expected to be canceled.
   // And the navigation is expected to create another page instead of activation.
diff --git a/speculation-rules/prerender/credentialed-prerender-opt-in.html b/speculation-rules/prerender/credentialed-prerender-opt-in.html
index 91626bafce677b..21c88775f0081c 100644
--- a/speculation-rules/prerender/credentialed-prerender-opt-in.html
+++ b/speculation-rules/prerender/credentialed-prerender-opt-in.html
@@ -17,8 +17,11 @@
 promise_test(async t => {
   const rcHelper = new RemoteContextHelper();
   const referrerRC = await rcHelper.addWindow({origin: 'HTTPS_ORIGIN'}, { features: 'noopener' });
-  const prerenderedRC = await addPrerenderRC(referrerRC, {origin: 'HTTPS_REMOTE_ORIGIN', headers: [['Supports-Loading-Mode', 'credentialed-prerender']] });
+  const prerenderedRC = await referrerRC.createPrerenderedContext({
+    origin: 'HTTPS_REMOTE_ORIGIN',
+    headers: [['Supports-Loading-Mode', 'credentialed-prerender']]
+  });
 
-  await activatePrerenderRC(referrerRC, prerenderedRC);
+  await referrerRC.navigateExpectingPrerenderingActivation(prerenderedRC);
 });
 </script>
diff --git a/speculation-rules/prerender/referrer-policy-mismatch.html b/speculation-rules/prerender/referrer-policy-mismatch.html
index fa2d424660a367..a5f08832056274 100644
--- a/speculation-rules/prerender/referrer-policy-mismatch.html
+++ b/speculation-rules/prerender/referrer-policy-mismatch.html
@@ -15,17 +15,17 @@
 setup(() => assertSpeculationRulesIsSupported());
 
 promise_test(async t => {
-  const rcHelper = new RemoteContextHelper();
+  const rcHelper = new PrerenderingRemoteContextHelper();
   const referrerRC = await rcHelper.addWindow(undefined, { features: "noopener" });
   await setReferrerPolicy(referrerRC, "strict-origin-when-cross-origin");
-  const prerenderedRC = await addPrerenderRC(referrerRC);
+  const prerenderedRC = await referrerRC.createPrerenderedContext();
 
   const referrerURL = await referrerRC.executeScript(() => location.href);
 
   assert_equals(await prerenderedRC.executeScript(() => document.prerendering), true);
   assert_equals(await prerenderedRC.executeScript(() => document.referrer), referrerURL);
 
-  await activatePrerenderRC(referrerRC, prerenderedRC, url => {
+  await referrerRC.navigateExpectingPrerenderingActivation(prerenderedRC, url => {
     const a = document.createElement("a");
     a.href = url;
     a.referrerPolicy = "no-referrer";
@@ -37,17 +37,17 @@
 }, 'prerendered with "strict-origin-when-cross-origin", activated with "no-referrer"');
 
 promise_test(async t => {
-  const rcHelper = new RemoteContextHelper();
+  const rcHelper = new PrerenderingRemoteContextHelper();
   const referrerRC = await rcHelper.addWindow(undefined, { features: "noopener" });
   await setReferrerPolicy(referrerRC, "strict-origin-when-cross-origin");
-  const prerenderedRC = await addPrerenderRC(referrerRC);
+  const prerenderedRC = await referrerRC.createPrerenderedContext();
 
   const referrerURL = await referrerRC.executeScript(() => location.href);
 
   assert_equals(await prerenderedRC.executeScript(() => document.prerendering), true);
   assert_equals(await prerenderedRC.executeScript(() => document.referrer), referrerURL);
 
-  await activatePrerenderRC(referrerRC, prerenderedRC, url => {
+  await referrerRC.navigateExpectingPrerenderingActivation(prerenderedRC, url => {
     const a = document.createElement("a");
     a.href = url;
     a.referrerPolicy = "strict-origin";
@@ -59,10 +59,10 @@
 }, 'prerendered with "strict-origin-when-cross-origin", activated with "strict-origin"');
 
 promise_test(async t => {
-  const rcHelper = new RemoteContextHelper();
+  const rcHelper = new PrerenderingRemoteContextHelper();
   const referrerRC = await rcHelper.addWindow(undefined, { features: "noopener" });
   await setReferrerPolicy(referrerRC, "strict-origin");
-  const prerenderedRC = await addPrerenderRC(referrerRC);
+  const prerenderedRC = await referrerRC.createPrerenderedContext();
 
   const referrerURL = await referrerRC.executeScript(() => location.href);
   const referrerOrigin = (new URL(referrerURL)).origin + "/";
@@ -70,7 +70,7 @@
   assert_equals(await prerenderedRC.executeScript(() => document.prerendering), true);
   assert_equals(await prerenderedRC.executeScript(() => document.referrer), referrerOrigin);
 
-  await activatePrerenderRC(referrerRC, prerenderedRC, url => {
+  await referrerRC.navigateExpectingPrerenderingActivation(prerenderedRC, url => {
     const a = document.createElement("a");
     a.href = url;
     a.referrerPolicy = "unsafe-url";
diff --git a/speculation-rules/prerender/resources/utils.js b/speculation-rules/prerender/resources/utils.js
index f012d2d0e41ef6..0387f6dfd9b1b9 100644
--- a/speculation-rules/prerender/resources/utils.js
+++ b/speculation-rules/prerender/resources/utils.js
@@ -322,99 +322,68 @@ function test_prerender_defer(fn, label) {
   }, label);
 }
 
-/**
- * Starts prerendering a page from the given referrer `RemoteContextWrapper`,
- * using `<script type="speculationrules">`.
- *
- * See
- * /html/browsers/browsing-the-web/remote-context-helper/resources/remote-context-helper.js
- * for more details on the `RemoteContextWrapper` framework, and supported fields for extraConfig.
- *
- * The returned `RemoteContextWrapper` for the prerendered remote
- * context will have an extra `url` property, which is used by
- * @see activatePrerenderRC. (Most `RemoteContextWrapper` uses should not care
- * about the URL, but prerendering is unique in that you need to navigate to
- * a prerendered page after creating it.)
- *
- * @param {RemoteContextWrapper} referrerRemoteContext
- * @param {RemoteContextConfig|object} extraConfig
- * @returns {Promise<RemoteContextWrapper>}
- */
-async function addPrerenderRC(referrerRemoteContext, extraConfig) {
-  let savedURL;
-  const prerenderedRC = await referrerRemoteContext.helper.createContext({
-    executorCreator(url) {
-      // Save the URL which the remote context helper framework assembled for
-      // us, so that we can attach it to the returned `RemoteContextWrapper`.
-      savedURL = url;
-
-      return referrerRemoteContext.executeScript(url => {
-        const script = document.createElement("script");
-        script.type = "speculationrules";
-        script.textContent = JSON.stringify({
-          prerender: [
-            {
-              source: "list",
-              urls: [url]
-            }
-          ]
+// If you want access to these, be sure to include
+// /html/browsers/browsing-the-web/remote-context-helper/resources/remote-context-helper.js.
+// So as to avoid requiring everyone to do that, we only conditionally define this infrastructure.
+if (globalThis.RemoteContextHelper) {
+  class PrerenderingRemoteContextWrapper extends PreloadingRemoteContextHelper.RemoteContextWrapper {
+    /**
+    * Activates a prerendered page represented by `prerenderedRC` by
+    * navigating the page currently displayed in this
+    * `PrerenderingRemoteContextWrapper` to it. If the navigation does
+    * not result in a prerender activation, the returned promise will be
+    * rejected with a testharness.js AssertionError.
+    *
+    * See
+    * /html/browsers/browsing-the-web/remote-context-helper/resources/remote-context-helper.js
+    * for more on the RemoteContext helper framework.
+    *
+    * @param {PrerenderingRemoteContextWrapper} destinationRC - The
+    *     `PrerenderingRemoteContextWrapper` pointing to the prerendered
+    *     content. This is monitored to ensure the navigation results in
+    *     a prerendering activation.
+    * @param {(string) => Promise<undefined>} [navigateFn] - An optional
+    *     function to customize the navigation. It will be passed the
+    *     URL of the prerendered content, and will run as a script in
+    *     this  (see `RemoteContextWrapper.prototype.executeScript`). If
+    *     not given, navigation will be done via the `location.href`
+    *     setter (see `RemoteContextWrapper.prototype.navigateTo`).
+    * @returns {Promise<undefined>}
+    */
+    async navigateExpectingPrerenderingActivation(destinationRC, navigateFn) {
+      // Store a promise that will fulfill when the prerenderingchange event fires.
+      await destinationRC.executeScript(() => {
+        window.activatedPromise = new Promise(resolve => {
+          document.addEventListener("prerenderingchange", () => resolve("activated"));
         });
-        document.head.append(script);
-      }, [url]);
-    }, extraConfig
-  });
+      });
 
-  prerenderedRC.url = savedURL;
-  return prerenderedRC;
-}
+      if (navigateFn === undefined) {
+        this.navigateTo(destinationRC.url);
+      } else {
+        this.navigate(navigateFn, [destinationRC.url]);
+      }
 
-/**
- * Activates a prerendered RemoteContextWrapper `prerenderedRC` by navigating
- * the referrer RemoteContextWrapper `referrerRC` to it. If the navigation does
- * not result in a prerender activation, the returned
- * promise will be rejected with a testharness.js AssertionError.
- *
- * See
- * /html/browsers/browsing-the-web/remote-context-helper/resources/remote-context-helper.js
- * for more on the RemoteContext helper framework.
- *
- * @param {RemoteContextWrapper} referrerRC - The referrer
- *     `RemoteContextWrapper` in which the prerendering was triggered,
- *     probably via `addPrerenderRC()`.
- * @param {RemoteContextWrapper} prerenderedRC - The `RemoteContextWrapper`
- *     pointing to the prerendered content. This is monitored to ensure the
- *     navigation results in a prerendering activation.
- * @param {(string) => Promise<undefined>} [navigateFn] - An optional function
- *     to customize the navigation. It will be passed the URL of the prerendered
- *     content, and will run as a script in `referrerRC` (see
- *     `RemoteContextWrapper.prototype.executeScript`). If not given, navigation
- *     will be done via the `location.href` setter (see
- *     `RemoteContextWrapper.prototype.navigateTo`).
- * @returns {Promise<undefined>}
- */
-async function activatePrerenderRC(referrerRC, prerenderedRC, navigateFn) {
-  // Store a promise that will fulfill when the prerenderingchange event fires.
-  await prerenderedRC.executeScript(() => {
-    window.activatedPromise = new Promise(resolve => {
-      document.addEventListener("prerenderingchange", () => resolve("activated"));
-    });
-  });
+      // Wait until that event fires. If the activation fails and a
+      // normal navigation happens instead, then destinationRC will
+      // start pointing to that other page, where
+      // window.activatedPromise is undefined. In that case this assert
+      // will fail since undefined !== "activated".
+      assert_equals(
+        await destinationRC.executeScript(() => window.activatedPromise),
+        "activated",
+        "The prerendered page must be activated; instead a normal navigation happened."
+      );
+    }
 
-  if (navigateFn === undefined) {
-    referrerRC.navigateTo(prerenderedRC.url);
-  } else {
-    referrerRC.navigate(navigateFn, [prerenderedRC.url]);
+    createPrerenderedContext(options) {
+      return this.createPreloadedContext('prerender', options);
+    }
   }
 
-  // Wait until that event fires. If the activation fails and a normal
-  // navigation happens instead, then prerenderedRC will start pointing to that
-  // other page, where window.activatedPromise is undefined. In that case this
-  // assert will fail since undefined !== "activated".
-  assert_equals(
-    await prerenderedRC.executeScript(() => window.activatedPromise),
-    "activated",
-    "The prerendered page must be activated; instead a normal navigation happened."
-  );
+  globalThis.PrerenderingRemoteContextHelper = class extends PreloadingRemoteContextHelper {
+    static RemoteContextWrapper = PrerenderingRemoteContextWrapper;
+  };
 }
 
 async function getActivationStart(prerenderedRC) {
diff --git a/speculation-rules/prerender/visibility-state.html b/speculation-rules/prerender/visibility-state.html
index e9e8548c4f686b..5a76298456d1ae 100644
--- a/speculation-rules/prerender/visibility-state.html
+++ b/speculation-rules/prerender/visibility-state.html
@@ -14,13 +14,13 @@
 setup(() => assertSpeculationRulesIsSupported());
 
 promise_test(async t => {
-  const rcHelper = new RemoteContextHelper();
+  const rcHelper = new PrerenderingRemoteContextHelper();
   const referrerRC = await rcHelper.addWindow(undefined, { features: 'noopener' });
-  const prerenderedRC = await addPrerenderRC(referrerRC);
+  const prerenderedRC = await referrerRC.createPrerenderedContext();
 
   assert_equals(await prerenderedRC.executeScript(() => document.visibilityState), "hidden");
 
-  await activatePrerenderRC(referrerRC, prerenderedRC);
+  await referrerRC.navigateExpectingPrerenderingActivation(prerenderedRC);
 
   assert_equals(await prerenderedRC.executeScript(() => document.visibilityState), "visible");
 });
diff --git a/speculation-rules/resources/utils.js b/speculation-rules/resources/utils.js
index cb72f446813289..12d0d97f48597c 100644
--- a/speculation-rules/resources/utils.js
+++ b/speculation-rules/resources/utils.js
@@ -1,4 +1,4 @@
-window.assertSpeculationRulesIsSupported = () => {
+globalThis.assertSpeculationRulesIsSupported = () => {
   assert_implements(
       'supports' in HTMLScriptElement,
       'HTMLScriptElement.supports must be supported');
@@ -6,3 +6,62 @@ window.assertSpeculationRulesIsSupported = () => {
       HTMLScriptElement.supports('speculationrules'),
       '<script type="speculationrules"> must be supported');
 };
+
+// If you want access to these, be sure to include
+// /html/browsers/browsing-the-web/remote-context-helper/resources/remote-context-helper.js.
+// So as to avoid requiring everyone to do that, we only conditionally define this infrastructure.
+if (globalThis.RemoteContextHelper) {
+  class PreloadingRemoteContextWrapper extends RemoteContextHelper.RemoteContextWrapper {
+    async createPreloadedContext(preloadType, { extrasInSpeculationRule = {}, ...extraConfig } = {}) {
+      const referrerRemoteContext = this;
+
+      let savedURL;
+      const preloadedContext = await this.helper.createContext({
+        executorCreator(url) {
+          // Save the URL which the remote context helper framework assembled for
+          // us, so that we can attach it to the returned `RemoteContextWrapper`.
+          savedURL = url;
+
+          return referrerRemoteContext.executeScript((url, preloadType, extrasInSpeculationRule) => {
+            const script = document.createElement("script");
+            script.type = "speculationrules";
+            script.textContent = JSON.stringify({
+              [preloadType]: [
+                {
+                  source: "list",
+                  urls: [url],
+                  ...extrasInSpeculationRule
+                }
+              ]
+            });
+            document.head.append(script);
+          }, [url, preloadType, extrasInSpeculationRule]);
+        }, extraConfig
+      });
+
+      preloadedContext.url = savedURL;
+      return preloadedContext;
+    }
+
+    async getPreloadingStatusFromHeaders() {
+      const requestHeaders = await this.getRequestHeaders();
+      const secPurpose = requestHeaders['sec-purpose'];
+
+      assert_equals(requestHeaders.purpose, secPurpose, "Purpose header must equal Sec-Purpose header");
+
+      if (secPurpose === "prefetch") {
+        return "prefetched";
+      } else if (secPurpose === "prefetch;prerender") {
+        return "prerendered";
+      } else if (secPurpose === "absent") {
+        return "none";
+      } else {
+        assert_unreached("Unexpected Sec-Purpose header value: " + secPurpose);
+      }
+    }
+  }
+
+  globalThis.PreloadingRemoteContextHelper = class extends RemoteContextHelper {
+    static RemoteContextWrapper = PreloadingRemoteContextWrapper;
+  };
+}