diff --git a/src/book-navigation-interceptor-sw.js b/src/book-navigation-interceptor-sw.js
new file mode 100644
index 00000000..a78a7cad
--- /dev/null
+++ b/src/book-navigation-interceptor-sw.js
@@ -0,0 +1,140 @@
+import { getDataSourceForHostname } from "./connection/DataSource";
+import { createParseConnection } from "./connection/ParseConnectionConfig";
+import {
+    getUrlOfHtmlOfDigitalVersion,
+    getHarvesterBaseUrlFromBaseUrl,
+} from "./model/BookUrlUtils";
+
+const bloomPlayerPath = "/bloom-player/bloomplayer.htm";
+
+// Activate a newly installed interceptor immediately for the current read session.
+self.addEventListener("install", (event) => {
+    event.waitUntil(self.skipWaiting());
+});
+
+// Take control of already-open matching pages so /book/... requests are intercepted right away.
+self.addEventListener("activate", (event) => {
+    event.waitUntil(self.clients.claim());
+});
+
+self.addEventListener("fetch", (event) => {
+    const requestUrl = new URL(event.request.url);
+    if (
+        event.request.method !== "GET" ||
+        !requestUrl.pathname.includes("/book/")
+    ) {
+        return;
+    }
+
+    event.respondWith(interceptBookRequest(event));
+});
+
+async function interceptBookRequest(event) {
+    if (!(await requestCameFromBloomPlayer(event))) {
+        return fetch(event.request);
+    }
+    const requestUrl = new URL(event.request.url);
+    const requestInfo = parseBookRequest(requestUrl);
+    if (!requestInfo) {
+        console.error("Failed to parse book request URL");
+        return new Response("Invalid book request URL", { status: 400 });
+    }
+    try {
+        const query = constructParseBookQuery(requestInfo.bookInstanceId);
+        const bookData = await retrieveBookData(query);
+        if (
+            !bookData ||
+            bookData.harvestState !== "Done" ||
+            !bookData.baseUrl
+        ) {
+            console.error("Book not found or not ready for reading", {
+                bookInstanceId: requestInfo.bookInstanceId,
+                harvestState: bookData?.harvestState,
+                hasBaseUrl: !!bookData?.baseUrl,
+            });
+            return new Response("Book not found or not ready for reading", {
+                status: 404,
+            });
+        }
+        const harvesterBaseUrl = getHarvesterBaseUrlFromBaseUrl(
+            bookData.baseUrl,
+            self.location.hostname === "localhost"
+        );
+        if (!harvesterBaseUrl) {
+            console.error("Failed to construct harvester base URL");
+            return new Response("Failed to construct book URL", {
+                status: 500,
+            });
+        }
+
+        const redirectUrl = `${getUrlOfHtmlOfDigitalVersion(
+            harvesterBaseUrl,
+            requestInfo.filePath
+        )}${requestUrl.search}`;
+        // e.g. http://localhost:5174/s3/bloomharvest-sandbox/TkG1dWsW40%2f1768316502115/bloomdigital%2f${filePath}
+        return Response.redirect(redirectUrl, 302);
+    } catch (error) {
+        console.error("Failed to redirect Bloom Player book request", error);
+        return new Response("Failed to load book: " + error.message, {
+            status: 500,
+        });
+    }
+}
+
+function parseBookRequest(requestUrl) {
+    // e.g. http://localhost:5174/book/36befbb8-8201-42cc-8faa-5c9432a985dd/index.htm
+    const requestPath = requestUrl.pathname.split("/book/")[1];
+    if (!requestPath) {
+        return undefined;
+    }
+
+    const firstSlashIndex = requestPath.indexOf("/");
+    if (firstSlashIndex < 0 || firstSlashIndex === requestPath.length - 1) {
+        return undefined;
+    }
+
+    return {
+        bookInstanceId: decodeURIComponent(
+            requestPath.substring(0, firstSlashIndex)
+        ),
+        filePath: requestPath.substring(firstSlashIndex + 1),
+    };
+}
+
+function constructParseBookQuery(bookInstanceId) {
+    return new URLSearchParams({
+        where: JSON.stringify({ bookInstanceId }),
+        limit: "1",
+        keys: "baseUrl,harvestState,bookInstanceId",
+    });
+}
+
+async function retrieveBookData(query) {
+    // The main app caches the X-Parse-Session-Token, but as of March 2026 we don't need that in the service worker
+    // anyway so we can just create a parse connection object
+    const connection = createParseConnection(
+        getDataSourceForHostname(self.location.hostname)
+    );
+    const response = await fetch(`${connection.url}classes/books?${query}`, {
+        headers: connection.headers,
+    });
+
+    if (!response.ok) {
+        throw new Error(`Parse lookup failed: ${response.status}`);
+    }
+
+    const data = await response.json();
+    return data.results?.[0];
+}
+
+async function requestCameFromBloomPlayer(event) {
+    const clientId = event.clientId || event.resultingClientId;
+    if (clientId) {
+        const client = await self.clients.get(clientId);
+        if (client && client.url.includes(bloomPlayerPath)) {
+            return true;
+        }
+    }
+
+    return event.request.referrer.includes(bloomPlayerPath);
+}
diff --git a/src/components/BookDetail/ArtifactHelper.ts b/src/components/BookDetail/ArtifactHelper.ts
index 2b5422f1..65566e84 100644
--- a/src/components/BookDetail/ArtifactHelper.ts
+++ b/src/components/BookDetail/ArtifactHelper.ts
@@ -223,9 +223,3 @@ function getDownloadUrl(book: Book, fileType: string): string | undefined {
     }
     return undefined;
 }
-export function getUrlOfHtmlOfDigitalVersion(book: Book) {
-    const harvesterBaseUrl = Book.getHarvesterBaseUrl(book);
-    // use this if you are are working on bloom-player and are using the bloom-player npm script tobloomlibrary
-    // bloomPlayerUrl = "http://localhost:3000/bloomplayer-for-developing.htm";
-    return harvesterBaseUrl + "bloomdigital%2findex.htm";
-}
diff --git a/src/components/ReadBookPage.tsx b/src/components/ReadBookPage.tsx
index 8c55b3ef..504c27eb 100644
--- a/src/components/ReadBookPage.tsx
+++ b/src/components/ReadBookPage.tsx
@@ -9,7 +9,7 @@ import React, {
 } from "react";
 import { useGetBookDetail } from "../connection/LibraryQueryHooks";
 import { Book } from "../model/Book";
-import { getUrlOfHtmlOfDigitalVersion } from "./BookDetail/ArtifactHelper";
+import { getUrlOfHtmlOfDigitalVersion } from "../model/BookUrlUtils";
 import { useHistory, useLocation } from "react-router-dom";
 import { useTrack } from "../analytics/Analytics";
 import { getBookAnalyticsInfo } from "../analytics/BookAnalyticsInfo";
@@ -27,6 +27,137 @@ import { useMediaQuery } from "@material-ui/core";
 import { OSFeaturesContext } from "./OSFeaturesContext";
 import { IReadBookPageProps } from "./ReadBookPageCodeSplit";
 
+// To make links in books able to open other books, we need to intercept requests from the Bloom Player iframe to our
+// /book/... URLs. To do that, we register a service worker that intercepts those requests
+// instead of trying to load them as pages. This file is the service worker that does that interception.
+// It is registered in ReadBookPage.tsx and bundled into our build by vite.config.ts.
+const bookNavigationInterceptorServiceWorkerUrl =
+    "/book-navigation-interceptor-sw.js";
+
+// Let's not risk totally blocking the page if something goes wrong
+// with the service worker, since most books won't have links anyway
+const serviceWorkerRegistrationTimeoutMs = 5000;
+
+function waitForServiceWorkerActivation(
+    worker: ServiceWorker,
+    timeoutMs = serviceWorkerRegistrationTimeoutMs
+) {
+    if (worker.state === "activated") {
+        return Promise.resolve();
+    }
+
+    return new Promise<void>((resolve, reject) => {
+        const timeoutId = window.setTimeout(() => {
+            worker.removeEventListener("statechange", onStateChange);
+            console.error(
+                "Book navigation interceptor service worker activation timed out",
+                { state: worker.state, timeoutMs }
+            );
+            reject(new Error("Service worker activation timed out"));
+        }, timeoutMs);
+
+        const onStateChange = () => {
+            if (worker.state === "activated") {
+                window.clearTimeout(timeoutId);
+                worker.removeEventListener("statechange", onStateChange);
+                resolve();
+            } else if (worker.state === "redundant") {
+                window.clearTimeout(timeoutId);
+                worker.removeEventListener("statechange", onStateChange);
+                console.error(
+                    "Book navigation interceptor service worker became redundant"
+                );
+                reject(new Error("Service worker became redundant"));
+            }
+        };
+
+        worker.addEventListener("statechange", onStateChange);
+    });
+}
+
+function waitForServiceWorkerReady(
+    timeoutMs = serviceWorkerRegistrationTimeoutMs
+) {
+    return new Promise<ServiceWorkerRegistration>((resolve, reject) => {
+        const timeoutId = window.setTimeout(() => {
+            console.error(
+                "Timed out waiting for book navigation interceptor service worker readiness",
+                { timeoutMs }
+            );
+            reject(new Error("Timed out waiting for service worker readiness"));
+        }, timeoutMs);
+
+        navigator.serviceWorker.ready
+            .then((registration) => {
+                window.clearTimeout(timeoutId);
+                resolve(registration);
+            })
+            .catch((error) => {
+                window.clearTimeout(timeoutId);
+                console.error(
+                    "Failed while waiting for book navigation interceptor service worker readiness",
+                    error
+                );
+                reject(error);
+            });
+    });
+}
+
+function waitForServiceWorkerControl(
+    timeoutMs = serviceWorkerRegistrationTimeoutMs
+) {
+    if (navigator.serviceWorker.controller) {
+        return Promise.resolve();
+    }
+
+    return new Promise<void>((resolve) => {
+        const timeoutId = window.setTimeout(() => {
+            navigator.serviceWorker.removeEventListener(
+                "controllerchange",
+                onControllerChange
+            );
+            console.error(
+                "Book navigation interceptor service worker did not take control before timeout",
+                { timeoutMs }
+            );
+            resolve();
+        }, timeoutMs);
+
+        const onControllerChange = () => {
+            window.clearTimeout(timeoutId);
+            navigator.serviceWorker.removeEventListener(
+                "controllerchange",
+                onControllerChange
+            );
+            resolve();
+        };
+
+        navigator.serviceWorker.addEventListener(
+            "controllerchange",
+            onControllerChange
+        );
+    });
+}
+
+async function ensureBookNavigationInterceptorRegistered() {
+    if (!("serviceWorker" in navigator)) {
+        return;
+    }
+
+    const registration = await navigator.serviceWorker.register(
+        bookNavigationInterceptorServiceWorkerUrl,
+        { scope: "/" }
+    );
+    const worker =
+        registration.installing || registration.waiting || registration.active;
+    if (worker) {
+        await waitForServiceWorkerActivation(worker);
+    }
+
+    await waitForServiceWorkerReady();
+    await waitForServiceWorkerControl();
+}
+
 const ReadBookPage: React.FunctionComponent<IReadBookPageProps> = (props) => {
     const id = props.id;
     const history = useHistory();
@@ -34,6 +165,9 @@ const ReadBookPage: React.FunctionComponent<IReadBookPageProps> = (props) => {
     const { mobile } = useContext(OSFeaturesContext);
     const widerThanPhone = useMediaQuery("(min-width:450px)"); // a bit more than the largest phone width in the chrome debugger (411px)
     const higherThanPhone = useMediaQuery("(min-height:450px)");
+    const [iframeInterceptionReady, setIframeInterceptionReady] = useState(
+        !("serviceWorker" in navigator)
+    );
 
     // If either dimension is smaller than a phone, we'll guess we are on one
     // and go full screen automatically.
@@ -103,6 +237,19 @@ const ReadBookPage: React.FunctionComponent<IReadBookPageProps> = (props) => {
     }, [history]);
     useEffect(() => startingBook(), [id]);
 
+    useEffect(() => {
+        ensureBookNavigationInterceptorRegistered()
+            .catch((error) => {
+                console.error(
+                    "Unable to register book navigation interceptor service worker",
+                    error
+                );
+            })
+            .finally(() => {
+                setIframeInterceptionReady(true);
+            });
+    }, []);
+
     // We don't use rotateParams here, because one caller wants to call it
     // immediately after calling setRotateParams, when the new values won't be
     // available.
@@ -193,7 +340,12 @@ const ReadBookPage: React.FunctionComponent<IReadBookPageProps> = (props) => {
         getBookAnalyticsInfo(book, contextLangTag, "read"),
         !!book
     );
-    const url = book ? getUrlOfHtmlOfDigitalVersion(book) : "working"; // url=working shows a loading icon
+    const url = book
+        ? getUrlOfHtmlOfDigitalVersion(
+              Book.getHarvesterBaseUrl(book),
+              "index.htm"
+          ) || "working"
+        : "working"; // url=working shows a loading icon
 
     // use the bloomplayer.htm we copy into our public/ folder, where CRA serves from
     // TODO: this isn't working with react-router, but I don't know how RR even gets run inside of this iframe
@@ -304,7 +456,7 @@ const ReadBookPage: React.FunctionComponent<IReadBookPageProps> = (props) => {
     // });
     return (
         <React.Fragment>
-            {url === "working" || (
+            {url === "working" || !iframeInterceptionReady || (
                 <iframe
                     title="bloom player"
                     css={css`
@@ -339,32 +491,5 @@ function exitFullscreen() {
     }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function getHarvesterBaseUrl(book: Book) {
-    // typical input url:
-    // https://s3.amazonaws.com/BloomLibraryBooks-Sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d%2fsign+language+test%2f
-    // want:
-    // https://s3.amazonaws.com/bloomharvest-sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d/
-    // We come up with that URL by
-    //  (a) changing BloomLibraryBooks{-Sandbox} to bloomharvest{-sandbox}
-    //  (b) strip off everything after the next-to-final slash
-    let folderWithoutLastSlash = book.baseUrl;
-    if (book.baseUrl.endsWith("%2f")) {
-        folderWithoutLastSlash = book.baseUrl.substring(
-            0,
-            book.baseUrl.length - 3
-        );
-    }
-    const index = folderWithoutLastSlash.lastIndexOf("%2f");
-    const pathWithoutBookName = folderWithoutLastSlash.substring(0, index);
-    return (
-        pathWithoutBookName
-            .replace("BloomLibraryBooks-Sandbox", "bloomharvest-sandbox")
-            .replace("BloomLibraryBooks", "bloomharvest") + "/"
-    );
-    // Using slash rather than %2f at the end helps us download as the filename we want.
-    // Otherwise, the filename can be something like ken@example.com_007b3c03-52b7-4689-80bd-06fd4b6f9f28_Fox+and+Frog.bloompub
-}
-
 // though we normally don't like to export defaults, this is required for react.lazy (code splitting)
 export default ReadBookPage;
diff --git a/src/connection/DataSource.ts b/src/connection/DataSource.ts
index b6236474..57bbec0e 100644
--- a/src/connection/DataSource.ts
+++ b/src/connection/DataSource.ts
@@ -1,17 +1,21 @@
 export enum DataSource {
-    Prod,
-    Dev,
-    Local,
+    Prod = "prod",
+    Dev = "dev",
+    Local = "local",
 }
 
-export function getDataSource(): DataSource {
+export function getDataSourceForHostname(hostname: string): DataSource {
     //Uncomment to test dev or local data explicitly
     //return DataSource.Dev;
     //return DataSource.Local;
 
-    if (window.location.hostname.startsWith("dev")) {
+    if (hostname.startsWith("dev")) {
         return DataSource.Dev;
     }
 
     return DataSource.Prod;
 }
+
+export function getDataSource(): DataSource {
+    return getDataSourceForHostname(window.location.hostname);
+}
diff --git a/src/connection/ParseConnectionConfig.ts b/src/connection/ParseConnectionConfig.ts
new file mode 100644
index 00000000..f28ffb56
--- /dev/null
+++ b/src/connection/ParseConnectionConfig.ts
@@ -0,0 +1,46 @@
+import { DataSource } from "./DataSource";
+
+export interface IParseConnection {
+    headers: {
+        "Content-Type": string;
+        "X-Parse-Application-Id"?: string;
+        "X-Parse-Session-Token"?: string;
+    };
+    url: string;
+}
+
+const parseConnectionTemplates: Record<DataSource, IParseConnection> = {
+    [DataSource.Prod]: {
+        headers: {
+            "Content-Type": "text/json",
+            "X-Parse-Application-Id":
+                "R6qNTeumQXjJCMutAJYAwPtip1qBulkFyLefkCE5",
+        },
+        url: "https://server.bloomlibrary.org/parse/",
+    },
+    [DataSource.Dev]: {
+        headers: {
+            "Content-Type": "text/json",
+            "X-Parse-Application-Id":
+                "yrXftBF6mbAuVu3fO6LnhCJiHxZPIdE7gl1DUVGR",
+        },
+        url: "https://dev-server.bloomlibrary.org/parse/",
+    },
+    [DataSource.Local]: {
+        headers: {
+            "Content-Type": "text/json",
+            "X-Parse-Application-Id": "myAppId",
+        },
+        url: "http://localhost:1337/parse/",
+    },
+};
+
+export function createParseConnection(
+    connectionName: DataSource
+): IParseConnection {
+    const template = parseConnectionTemplates[connectionName];
+    return {
+        url: template.url,
+        headers: { ...template.headers },
+    };
+}
diff --git a/src/connection/ParseServerConnection.ts b/src/connection/ParseServerConnection.ts
index 2bb3cc6a..2d986a28 100644
--- a/src/connection/ParseServerConnection.ts
+++ b/src/connection/ParseServerConnection.ts
@@ -3,58 +3,24 @@ import { LoggedInUser, User } from "./LoggedInUser";
 import * as Sentry from "@sentry/browser";
 import { informEditorOfSuccessfulLogin, isForEditor } from "../editor";
 import { DataSource, getDataSource } from "./DataSource";
+import {
+    createParseConnection,
+    IParseConnection,
+} from "./ParseConnectionConfig";
 
 // This file exports a function getConnection(), which returns the headers
 // needed to talk to our Parse Server backend db.
 // It keeps track of whether we're working with dev/staging or production or
 // (via a one-line code change) a local database, and also stores and returns
 // the token we get from parse-server when authorized as a particular user.
-interface IConnection {
-    headers: {
-        "Content-Type": string;
-        "X-Parse-Application-Id"?: string;
-        "X-Parse-Session-Token"?: string;
-    };
-    url: string;
-}
-const prod: IConnection = {
-    headers: {
-        "Content-Type": "text/json",
-        "X-Parse-Application-Id": "R6qNTeumQXjJCMutAJYAwPtip1qBulkFyLefkCE5",
-    },
-    url: "https://server.bloomlibrary.org/parse/",
-};
-
-const dev: IConnection = {
-    headers: {
-        "Content-Type": "text/json",
-        "X-Parse-Application-Id": "yrXftBF6mbAuVu3fO6LnhCJiHxZPIdE7gl1DUVGR",
-    },
-    url: "https://dev-server.bloomlibrary.org/parse/",
+const connectionsByDataSource: Record<DataSource, IParseConnection> = {
+    [DataSource.Prod]: createParseConnection(DataSource.Prod),
+    [DataSource.Dev]: createParseConnection(DataSource.Dev),
+    [DataSource.Local]: createParseConnection(DataSource.Local),
 };
 
-const local: IConnection = {
-    headers: {
-        "Content-Type": "text/json",
-        "X-Parse-Application-Id": "myAppId",
-    },
-    url: "http://localhost:1337/parse/",
-};
-
-export function getConnection(): IConnection {
-    let result: IConnection;
-    switch (getDataSource()) {
-        default:
-        case DataSource.Prod:
-            result = prod;
-            break;
-        case DataSource.Dev:
-            result = dev;
-            break;
-        case DataSource.Local:
-            result = local;
-            break;
-    }
+export function getConnection(): IParseConnection {
+    const result = connectionsByDataSource[getDataSource()];
 
     // The browser will not allow us to provide this key here if we're running on
     // Bloom Reader, which intercepts web requests in order to enable zipping data
diff --git a/src/index.tsx b/src/index.tsx
index 4d8854f4..e11c68f4 100644
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -3,7 +3,7 @@ import ReactDOM from "react-dom";
 import "./index.css";
 import * as Sentry from "@sentry/browser";
 import App from "./App";
-import * as serviceWorker from "./serviceWorker";
+// import * as serviceWorker from "./serviceWorker";
 import { createBrowserHistory } from "history";
 import { isEmbedded } from "./components/Embedding/EmbeddingHost";
 import { initializeFirebase } from "./authentication/firebase/firebase";
@@ -113,4 +113,8 @@ ReactDOM.render(<App />, document.getElementById("root"));
 // If you want your app to work offline and load faster, you can change
 // unregister() to register() below. Note this comes with some pitfalls.
 // Learn more about service workers: https://bit.ly/CRA-PWA
-serviceWorker.unregister();
+
+// As of March 2026, we are adding another service worker (book-navigation-interceptor) and this line is causing problems
+// by sporadically unregistering that one. If we ever want to use this service worker in the future, we need to make sure
+// everything is scoped currently
+// serviceWorker.unregister();
diff --git a/src/model/Book.ts b/src/model/Book.ts
index 51fe1316..ffccf427 100644
--- a/src/model/Book.ts
+++ b/src/model/Book.ts
@@ -11,6 +11,7 @@ import {
     getDefaultBookStat,
 } from "../components/statistics/StatsInterfaces";
 import { ArtifactType } from "../components/BookDetail/ArtifactHelper";
+import { getHarvesterBaseUrlFromBaseUrl } from "./BookUrlUtils";
 import stem from "wink-porter2-stemmer";
 
 export function createBookFromParseServerData(pojo: any): Book {
@@ -551,32 +552,9 @@ export class Book {
         if (!Book.isHarvested(book)) {
             return undefined;
         }
-
-        // typical input url:
-        // https://s3.amazonaws.com/BloomLibraryBooks-Sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d%2fsign+language+test%2f
-        // want:
-        // https://s3.amazonaws.com/bloomharvest-sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d/
-        // We come up with that URL by
-        //  (a) changing BloomLibraryBooks{-Sandbox} to bloomharvest{-sandbox}
-        //  (b) strip off everything after the next-to-final slash
-        let folderWithoutLastSlash = baseUrl;
-
-        if (baseUrl.endsWith("%2f")) {
-            folderWithoutLastSlash = baseUrl.substring(0, baseUrl.length - 3);
-        }
-        if (window.location.hostname === "localhost") {
-            folderWithoutLastSlash = folderWithoutLastSlash.replace(
-                "https://s3.amazonaws.com",
-                "/s3" // vite proxy server can use this to overcome CORS
-            );
-        }
-
-        const index = folderWithoutLastSlash.lastIndexOf("%2f");
-        const pathWithoutBookName = folderWithoutLastSlash.substring(0, index);
-        return (
-            pathWithoutBookName
-                .replace("BloomLibraryBooks-Sandbox", "bloomharvest-sandbox")
-                .replace("BloomLibraryBooks", "bloomharvest") + "/"
+        return getHarvesterBaseUrlFromBaseUrl(
+            baseUrl,
+            window.location.hostname === "localhost"
         );
         // Using slash rather than %2f at the end helps us download as the filename we want.
         // Otherwise, the filename can be something like ken@example.com_007b3c03-52b7-4689-80bd-06fd4b6f9f28_Fox+and+Frog.bloompub
diff --git a/src/model/BookUrlUtils.test.ts b/src/model/BookUrlUtils.test.ts
new file mode 100644
index 00000000..c4703a97
--- /dev/null
+++ b/src/model/BookUrlUtils.test.ts
@@ -0,0 +1,77 @@
+import { getHarvesterBaseUrlFromBaseUrl } from "./BookUrlUtils";
+import { getUrlOfHtmlOfDigitalVersion } from "./BookUrlUtils";
+
+describe("getHarvesterBaseUrlFromBaseUrl", () => {
+    // Note these tests were written by copilot during a refactor, long after the original code was in use.
+    // I haven't checked if they actually reflect our intended usage of the function, but thought we might as well keep
+    // them around to detect any behavior changes
+
+    it("converts a sandbox book base url to the harvester base url", () => {
+        expect(
+            getHarvesterBaseUrlFromBaseUrl(
+                "https://s3.amazonaws.com/BloomLibraryBooks-Sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d%2fsign+language+test%2f",
+                false
+            )
+        ).toBe(
+            "https://s3.amazonaws.com/bloomharvest-sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d/"
+        );
+    });
+
+    it("converts a production book base url to the harvester base url", () => {
+        expect(
+            getHarvesterBaseUrlFromBaseUrl(
+                "https://s3.amazonaws.com/BloomLibraryBooks/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d%2fBook+Title%2f",
+                false
+            )
+        ).toBe(
+            "https://s3.amazonaws.com/bloomharvest/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d/"
+        );
+    });
+
+    it("uses the local s3 proxy when requested", () => {
+        expect(
+            getHarvesterBaseUrlFromBaseUrl(
+                "https://s3.amazonaws.com/BloomLibraryBooks-Sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d%2fsign+language+test%2f",
+                true
+            )
+        ).toBe(
+            "/s3/bloomharvest-sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d/"
+        );
+    });
+
+    it("handles a base url without a trailing encoded slash", () => {
+        expect(
+            getHarvesterBaseUrlFromBaseUrl(
+                "https://s3.amazonaws.com/BloomLibraryBooks-Sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d%2fsign+language+test",
+                false
+            )
+        ).toBe(
+            "https://s3.amazonaws.com/bloomharvest-sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d/"
+        );
+    });
+
+    it("returns undefined for malformed base urls without an encoded path separator", () => {
+        expect(
+            getHarvesterBaseUrlFromBaseUrl(
+                "https://s3.amazonaws.com/BloomLibraryBooks-Sandbox/no-encoded-slashes",
+                false
+            )
+        ).toBeUndefined();
+    });
+});
+
+describe("book URL helpers", () => {
+    // Note these tests were written by copilot during a refactor, long after the original code was in use.
+    // I haven't checked if they actually reflect our intended usage of the function, but thought we might as well keep
+    // them around to detect any behavior changes
+    it("builds bloom digital file urls from a harvester base url", () => {
+        expect(
+            getUrlOfHtmlOfDigitalVersion(
+                "https://s3.amazonaws.com/bloomharvest/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d/",
+                "index.htm"
+            )
+        ).toBe(
+            "https://s3.amazonaws.com/bloomharvest/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d/bloomdigital%2findex.htm"
+        );
+    });
+});
diff --git a/src/model/BookUrlUtils.ts b/src/model/BookUrlUtils.ts
new file mode 100644
index 00000000..8e00b01c
--- /dev/null
+++ b/src/model/BookUrlUtils.ts
@@ -0,0 +1,60 @@
+// typical input url:
+// https://s3.amazonaws.com/BloomLibraryBooks-Sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d%2fsign+language+test%2f
+// want:
+// https://s3.amazonaws.com/bloomharvest-sandbox/ken%40example.com%2faa647178-ed4d-4316-b8bf-0dc94536347d/
+// We come up with that URL by
+//  (a) changing BloomLibraryBooks{-Sandbox} to bloomharvest{-sandbox}
+//  (b) strip off everything after the next-to-final slash
+export function getHarvesterBaseUrlFromBaseUrl(
+    baseUrl: string | undefined,
+    isLocalhost: boolean
+): string | undefined {
+    if (!baseUrl) {
+        return undefined;
+    }
+
+    let folderWithoutLastSlash = baseUrl;
+
+    if (baseUrl.endsWith("%2f")) {
+        folderWithoutLastSlash = baseUrl.substring(0, baseUrl.length - 3);
+    }
+
+    if (isLocalhost) {
+        folderWithoutLastSlash = folderWithoutLastSlash.replace(
+            "https://s3.amazonaws.com",
+            "/s3"
+        );
+    }
+
+    const index = folderWithoutLastSlash.lastIndexOf("%2f");
+    if (index < 0) {
+        return undefined;
+    }
+
+    const pathWithoutBookName = folderWithoutLastSlash.substring(0, index);
+    return (
+        pathWithoutBookName
+            .replace("BloomLibraryBooks-Sandbox", "bloomharvest-sandbox")
+            .replace("BloomLibraryBooks", "bloomharvest") + "/"
+    );
+}
+
+export function getUrlOfHtmlOfDigitalVersion(
+    harvesterBaseUrl: string | undefined,
+    filePath: string
+): string | undefined {
+    // TODO update comment
+    // use this if you are are working on bloom-player and are using the bloom-player npm script tobloomlibrary
+    // bloomPlayerUrl = "http://localhost:3000/bloomplayer-for-developing.htm";
+
+    if (!harvesterBaseUrl) {
+        return undefined;
+    }
+
+    const encodedFilePath = filePath
+        .split("/")
+        .map((segment) => encodeURIComponent(decodeURIComponent(segment)))
+        .join("%2f");
+
+    return `${harvesterBaseUrl}bloomdigital%2f${encodedFilePath}`;
+}
diff --git a/vite.config.ts b/vite.config.ts
index ed30aa25..aa08d92b 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -1,6 +1,7 @@
 import { defineConfig, Plugin } from "vite";
 import react from "@vitejs/plugin-react";
 import svgr from "vite-plugin-svgr";
+import { build as esbuild } from "esbuild";
 import fs from "fs";
 import path from "path";
 
@@ -33,6 +34,7 @@ export default defineConfig(() => {
         },
 
         plugins: [
+            bundleBookNavigationInterceptorPlugin(), // For when Bloom Player needs to follow links in books
             serveTranslationsPlugin(),
             copyTranslationsPlugin(),
             // if you import an svg file with this ?react at the end, it will be converted to a React component
@@ -44,6 +46,70 @@ export default defineConfig(() => {
     };
 });
 
+function bundleBookNavigationInterceptorPlugin(): Plugin {
+    const serviceWorkerPath = "/book-navigation-interceptor-sw.js";
+    const sourceFilePath = path.resolve(
+        __dirname,
+        "src/book-navigation-interceptor-sw.js"
+    );
+
+    return {
+        name: "bundle-book-navigation-interceptor",
+        configureServer(server) {
+            // The book-navigation interceptor must be served from the site root so it can
+            // register with scope "/" and intercept /book/... requests to make book navigation/links inside books work
+            server.middlewares.use(
+                serviceWorkerPath,
+                async (_req, res, next) => {
+                    try {
+                        // During dev, bundle the worker to a single file so it keeps
+                        // working as a classic service worker even though its source
+                        // imports shared modules from src.
+                        const bundledWorker = await bundleBookNavigationInterceptor(
+                            sourceFilePath
+                        );
+
+                        res.setHeader("Content-Type", "application/javascript");
+                        res.end(bundledWorker);
+                    } catch (error) {
+                        next(error as Error);
+                    }
+                }
+            );
+        },
+        async writeBundle({ dir }) {
+            const buildDir = dir || path.join(__dirname, "build");
+            const bundledWorker = await bundleBookNavigationInterceptor(
+                sourceFilePath
+            );
+            fs.writeFileSync(
+                path.join(buildDir, "book-navigation-interceptor-sw.js"),
+                bundledWorker
+            );
+        },
+    };
+}
+
+async function bundleBookNavigationInterceptor(entryPoint: string) {
+    const result = await esbuild({
+        entryPoints: [entryPoint],
+        bundle: true,
+        format: "iife",
+        platform: "browser",
+        target: "es2020",
+        write: false,
+    });
+
+    const outputFile = result.outputFiles?.[0];
+    if (!outputFile) {
+        throw new Error(
+            "Failed to bundle book-navigation interceptor service worker"
+        );
+    }
+
+    return outputFile.text;
+}
+
 // Copies translation files from src to build
 function copyTranslationsPlugin(): Plugin {
     // BloomLibrary.org is where the source (English) files are. We don't need them in the build.