diff --git a/src/imo/imo-impl.ts b/src/imo/imo-impl.ts
new file mode 100644
index 0000000..e52a227
--- /dev/null
+++ b/src/imo/imo-impl.ts
@@ -0,0 +1,246 @@
+/*
+Tasks:
+
+1. Collect all import maps in the HEAD element.
+    - Validate as they are picked up.
+    - Discard invalid ones with warnings.
+2. Merge the collected valid import maps.
+3. Save the merged import map to session storage.
+4. Apply active overrides from local storage to a copy of the merged import map.
+5. Inject the resulting import map into the document.
+6. Post the resulting import map to any Vite dev servers allowed in local storage
+that are mentioned in the resulting import map, plus the page's origin if applicable.
+
+*/
+import { validate } from "@collagejs/importmap";
+import { skDiscoveredViteServers, skFinalImportMap, skImportMap, skOverrides, skViteDevServers } from "../shared/storage-keys.js";
+import type { HttpOrigin, ImoOverride, MergedImportMap, ValidatedImportMap } from "../private-types.js";
+import type { ImPostingOptions } from "../types.js";
+import pRetry from "p-retry";
+import { ensureImoController, getInvolvedViteServers, getStoredDevServers, isHttpOrigin, isViteServer } from "../shared/common.js";
+import { readImPostingOptions } from "../shared/options.js";
+import { ensureGlobalCollageJs } from "@collagejs/core";
+import { Logger } from "./Logger.js";
+
+/**
+ * Searches for all overridable import maps in the document, validates them, and merges them into a
+ * single import map.
+ *
+ * Invalid overridable import maps are discarded as a whole before merging.
+ *
+ * The resulting import map is validated at the end of the merging process.
+ * @returns The resultant import map object and any validation errors that it may possess.
+ */
+function mergeAllImportMaps(): ValidatedImportMap<MergedImportMap> {
+    const mergedImportMap: MergedImportMap = {
+        imports: {},
+        scopes: {},
+        integrity: {},
+    };
+    const importMapElements = document.head.querySelectorAll('script[type="overridable-importmap"]');
+    logger.info(`Found ${importMapElements.length} import map source(s) in the document.`);
+    importMapElements.forEach((element) => {
+        try {
+            const importMap = JSON.parse(element.textContent || '{}');
+            const validInfo = validate(importMap);
+            if (!validInfo.valid) {
+                logger.warn(`Invalid import map detected! ${validInfo.errors.length} error(s):`);
+                for (const e of validInfo.errors) {
+                    logger.warn(` - ${e}`);
+                }
+                return;
+            }
+            if (importMap.imports && typeof importMap.imports === 'object') {
+                Object.assign(mergedImportMap.imports, importMap.imports);
+            }
+            if (importMap.scopes && typeof importMap.scopes === 'object') {
+                Object.entries(importMap.scopes).forEach(([scope, mappings]) => {
+                    if (!mergedImportMap.scopes[scope]) {
+                        mergedImportMap.scopes[scope] = {};
+                    }
+                    Object.assign(mergedImportMap.scopes[scope], mappings);
+                });
+            }
+            if (importMap.integrity && typeof importMap.integrity === 'object') {
+                Object.assign(mergedImportMap.integrity, importMap.integrity);
+            }
+        } catch (e) {
+            logger.warn(`Failed to parse import map: ${(e as Error).message}`);
+            logger.warn(`Discarding import map: ${element.textContent}`);
+        }
+    });
+    const validInfo = validate(mergedImportMap);
+    return { importMap: mergedImportMap, errors: validInfo.errors };
+}
+/**
+ * Applies any active overrides from local storage to the provided import map.
+ * @param importMap The merged import map object used as receptacle for overrides.
+ * @returns The resulting (overridden) import map object and its validation errors, if any.
+ */
+function applyImOverrides(importMap: MergedImportMap) {
+    importMap = structuredClone(importMap);
+    const configuredOverrides = JSON.parse(localStorage.getItem(skOverrides) || '[]') as ImoOverride[];
+    configuredOverrides.forEach((override) => {
+        if (!override.active) {
+            logger.info(`Skipping inactive override for ${override.bareIdentifier} in scope "${override.scope ?? 'global'}".`);
+            return;
+        }
+        const destination = override.scope ? (importMap.scopes[override.scope] = importMap.scopes[override.scope] || {}) : importMap.imports;
+        destination[override.bareIdentifier] = override.replacement;
+        logger.info(`Applied override for "${override.bareIdentifier}"${override.scope ? ` in scope "${override.scope}"` : ''}: ${override.replacement}.`);
+    });
+    const validInfo = validate(importMap);
+    if (!validInfo.valid) {
+        logger.warn(`Import map became invalid after applying overrides! (${validInfo.errors.length} error(s)):`);
+        for (const e of validInfo.errors) {
+            logger.warn(` - ${e}`);
+        }
+    }
+    return { importMap, errors: validInfo.errors };
+}
+/**
+ * Discovers Vite servers from the provided import map and auto-allow option.
+ * @param importMap The merged import map object to search for Vite servers.
+ * @param autoAllowOption The auto-allow option for localhost.
+ * @returns A map of Vite server origins and their allow status.
+ */
+function discoverViteServers(
+    importMap: MergedImportMap,
+    autoAllowOption: Required<ImPostingOptions>['autoAllowLocalhost']
+): Map<HttpOrigin, boolean> {
+    const servers = new Map<HttpOrigin, boolean>();
+    const allUrls = Object.values(importMap.imports);
+    // Also include the page's own URL at the top so it's the first receiving the import map.
+    allUrls.unshift(location.href);
+    Object.values(importMap.scopes).forEach((scopeMappings) => {
+        allUrls.push(...Object.values(scopeMappings));
+    });
+    allUrls.forEach((urlStr) => {
+        try {
+            const url = new URL(urlStr);
+            if (isHttpOrigin(url.origin)) {
+                servers.set(url.origin, isViteServer(url, autoAllowOption));
+            }
+            else {
+                logger.info(`Ignoring non-HTTP(S) origin: ${url.origin}`);
+            }
+        }
+        catch { } // Ignore invalid URLs or the ones without a valid origin.
+    });
+    return servers;
+}
+/**
+ * Saves the discovered Vite servers to local storage, merging with any existing entries.
+ * @param viteServers Discovered Vite servers.
+ */
+function saveDiscoveredViteServers(viteServers: Map<HttpOrigin, boolean>) {
+    const result = [] as [string, boolean][];
+    // Merge with existing list.
+    const existingServers = getStoredDevServers();
+    for (const [origin, allowPostImportMap] of existingServers.entries()) {
+        result.push([origin, allowPostImportMap]);
+    }
+    for (const [origin, isVite] of viteServers.entries()) {
+        if (isVite && !existingServers.has(origin)) {
+            result.push([origin, true]);
+        }
+    }
+    localStorage.setItem(skViteDevServers, JSON.stringify(result));
+    logger.info(`Saved discovered Vite servers to local storage: ${result.length} server(s).`);
+    sessionStorage.setItem(skDiscoveredViteServers, JSON.stringify([...viteServers.entries()]));
+    logger.info(`Saved discovered Vite servers to session storage: ${viteServers.size} server(s).`);
+}
+/**
+ * Injects the provided import map into the document's HEAD element as a script of type
+ * `"importmap"`.
+ * @param importMap Import map to inject to the page's HEAD element.
+ */
+function injectImportMap(importMap: MergedImportMap) {
+    const script = document.createElement('script');
+    script.type = 'importmap';
+    script.textContent = JSON.stringify(importMap, null, 2);
+    const currentScript = document.currentScript;
+    if (currentScript && currentScript.parentNode) {
+        currentScript.parentNode.insertBefore(script, currentScript);
+    } else {
+        document.head.appendChild(script);
+    }
+    logger.info("Injected final import map into the document.");
+}
+/**
+ * Posts the provided import map to all Vite servers that are allowed to receive it.
+ * @param importMap Import map to send.
+ * @param foundViteServers List of Vite servers that have been seen in the resultant import map.
+ * @param options Import map posting options.
+ */
+async function postImportMapToViteServers(importMap: MergedImportMap, foundViteServers: HttpOrigin[], options: Required<ImPostingOptions>) {
+    const postPromises = [] as Promise<void>[];
+    const body = JSON.stringify(importMap);
+    const [involvedViteServers, excludedViteServers] = getInvolvedViteServers(foundViteServers);
+    excludedViteServers.forEach((origin) => {
+        logger.info(`Vite server at ${origin} is not allowed to receive the import map. Skipping.`);
+    });
+    let serverCount = 0;
+    const postImportMaps = (serverUrl: string) => {
+        postPromises.push(pRetry(async (attemptNumber) => {
+            const response = await fetch(`${serverUrl}${options.importMapEndpoint}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body,
+            });
+            if (response.ok) {
+                ++serverCount;
+                logger.info(`Successfully posted import map to Vite server at ${serverUrl}.`);
+            }
+            else {
+                logger.warn(`Attempt #${attemptNumber}:  Failed to post import map to Vite server at ${serverUrl}: ${response.status} ${response.statusText}`);
+            }
+        }, {
+            ...options.retryOptions,
+            onFailedAttempt: (error) => {
+                if (error.retriesLeft > 0) {
+                    logger.warn(`Attempt ${error.attemptNumber} to post import map to ${serverUrl} failed. There are ${error.retriesLeft} retries left.`);
+                }
+                else {
+                    logger.error(`All attempts to post import map to Vite server at ${serverUrl} have failed.`);
+                }
+                logger.save();
+            },
+        }));
+    };
+    involvedViteServers.forEach((serverUrl) => {
+        postImportMaps(serverUrl);
+    });
+    await Promise.all(postPromises);
+    logger.info(`Import map posting complete. Posted successfully to ${serverCount} Vite server(s).`);
+}
+
+export async function main() {
+    ensureGlobalCollageJs();
+    ensureImoController();
+    logger.info("@collagejs/imo started!");
+    try {
+        const mergedImportMap = mergeAllImportMaps();
+        sessionStorage.setItem(skImportMap, JSON.stringify(mergedImportMap));
+        const finalImportMap = applyImOverrides(mergedImportMap.importMap);
+        sessionStorage.setItem(skFinalImportMap, JSON.stringify(finalImportMap));
+        if (finalImportMap.errors.length > 0) {
+            logger.warn(`The resulting import map turned out invalid.  Will not be injected or posted to Vite servers.`);
+            return;
+        }
+        injectImportMap(finalImportMap.importMap);
+        const options = await readImPostingOptions();
+        const foundViteServers = await discoverViteServers(finalImportMap.importMap, options.autoAllowLocalhost);
+        saveDiscoveredViteServers(foundViteServers);
+        logger.save();
+        await postImportMapToViteServers(finalImportMap.importMap, [...foundViteServers.keys()], options);
+    }
+    finally {
+        logger.info("@collagejs/imo completed.");
+        logger.save();
+    }
+}
+
+const logger = new Logger();
diff --git a/src/imo/imo.ts b/src/imo/imo.ts
index aaf4a6a..cded028 100644
--- a/src/imo/imo.ts
+++ b/src/imo/imo.ts
@@ -1,212 +1,3 @@
-/*
-Tasks:
+import { main } from "./imo-impl.js";
 
-1. Collect all import maps in the HEAD element.
-    - Validate as they are picked up.
-    - Discard invalid ones with warnings.
-2. Merge the collected valid import maps.
-3. Save the merged import map to session storage.
-4. Apply active overrides from local storage to a copy of the merged import map.
-5. Inject the resulting import map into the document.
-6. Post the resulting import map to any Vite dev servers allowed in local storage
-that are mentioned in the resulting import map, plus the page's origin if applicable.
-
-*/
-import { validate } from "@collagejs/importmap";
-import { skFinalImportMap, skImportMap, skOverrides, skViteDevServers } from "../shared/storage-keys.js";
-import type { ImoOverride, MergedImportMap, ValidatedImportMap } from "../private-types.js";
-import type { ImPostingOptions } from "../types.js";
-import pRetry from "p-retry";
-import { ensureImoController, getStoredDevServers, isViteServer } from "../shared/common.js";
-import { readImPostingOptions } from "../shared/options.js";
-import { ensureGlobalCollageJs } from "@collagejs/core";
-import { Logger } from "./Logger.js";
-
-function mergeAllImportMaps(): ValidatedImportMap<MergedImportMap> {
-    const mergedImportMap = {
-        imports: {} as Record<string, string>,
-        scopes: {} as Record<string, Record<string, string>>,
-        integrity: {} as Record<string, string>,
-    };
-    const importMapElements = document.head.querySelectorAll('script[type="overridable-importmap"]');
-    logger.info(`Found ${importMapElements.length} import map source(s) in the document.`);
-    importMapElements.forEach((element) => {
-        try {
-            const importMap = JSON.parse(element.textContent || '{}');
-            const validInfo = validate(importMap);
-            if (!validInfo.valid) {
-                logger.warn(`Invalid import map detected! ${validInfo.errors.length} error(s):`);
-                for (const e of validInfo.errors) {
-                    logger.warn(` - ${e}`);
-                }
-                return;
-            }
-            if (importMap.imports && typeof importMap.imports === 'object') {
-                Object.assign(mergedImportMap.imports, importMap.imports);
-            }
-            if (importMap.scopes && typeof importMap.scopes === 'object') {
-                Object.entries(importMap.scopes).forEach(([scope, mappings]) => {
-                    if (!mergedImportMap.scopes[scope]) {
-                        mergedImportMap.scopes[scope] = {};
-                    }
-                    Object.assign(mergedImportMap.scopes[scope], mappings);
-                });
-            }
-            if (importMap.integrity && typeof importMap.integrity === 'object') {
-                Object.assign(mergedImportMap.integrity, importMap.integrity);
-            }
-        } catch (e) {
-            logger.warn(`Failed to parse import map: ${(e as Error).message}`);
-            logger.warn(`Discarding import map: ${element.textContent}`);
-        }
-    });
-    const validInfo = validate(mergedImportMap);
-    return { importMap: mergedImportMap, errors: validInfo.errors };
-}
-
-function applyImOverrides(importMap: MergedImportMap) {
-    importMap = structuredClone(importMap);
-    const configuredOverrides = JSON.parse(localStorage.getItem(skOverrides) || '[]') as ImoOverride[];
-    configuredOverrides.forEach((override) => {
-        if (!override.active) {
-            logger.info(`Skipping inactive override for ${override.bareIdentifier} in scope "${override.scope ?? 'global'}".`);
-            return;
-        }
-        const destination = override.scope ? (importMap.scopes[override.scope] = importMap.scopes[override.scope] || {}) : importMap.imports;
-        destination[override.bareIdentifier] = override.replacement;
-        logger.info(`Applied override for "${override.bareIdentifier}"${override.scope ? ` in scope "${override.scope}"` : ''}: ${override.replacement}.`);
-    });
-    const validInfo = validate(importMap);
-    if (!validInfo.valid) {
-        logger.warn(`Import map after applying overrides is invalid! (${validInfo.errors.length} error(s)):`);
-        for (const e of validInfo.errors) {
-            logger.warn(` - ${e}`);
-        }
-    }
-    return { importMap, errors: validInfo.errors };
-}
-
-function discoverViteServers(importMap: MergedImportMap, autoAllowOption: Required<ImPostingOptions>['autoAllowLocalhost']): Map<string, boolean> {
-    const servers = new Map<string, boolean>();
-    const allUrls = Object.values(importMap.imports);
-    // Also include the page's own URL at the top so it's the first receiving the import map.
-    allUrls.unshift(location.href);
-    Object.values(importMap.scopes).forEach((scopeMappings) => {
-        allUrls.push(...Object.values(scopeMappings));
-    });
-    allUrls.forEach((urlStr) => {
-        try {
-            const url = new URL(urlStr);
-            servers.set(url.origin, isViteServer(url, autoAllowOption));
-        }
-        catch { } // Ignore invalid URLs or the ones without a valid origin.
-    });
-    return servers;
-}
-
-function saveDiscoveredViteServers(viteServers: Map<string, boolean>) {
-    const result = [] as [string, boolean][];
-    // Merge with existing list.
-    const existingServers = getStoredDevServers();
-    for (const [origin, allowPostImportMap] of existingServers.entries()) {
-        result.push([origin, allowPostImportMap]);
-    }
-    for (const [origin, allowPostImportMap] of viteServers.entries()) {
-        if (!existingServers.has(origin)) {
-            result.push([origin, allowPostImportMap]);
-        }
-    }
-    localStorage.setItem(skViteDevServers, JSON.stringify(result));
-    logger.info(`Saved discovered Vite servers to local storage: ${result.length} server(s).`);
-}
-
-function injectImportMap(importMap: MergedImportMap) {
-    const script = document.createElement('script');
-    script.type = 'importmap';
-    script.textContent = JSON.stringify(importMap, null, 2);
-    // const currentScript = document.currentScript || document.querySelector('script[src*="imo"]') || document.scripts[document.scripts.length - 1];
-    const currentScript = document.currentScript;
-    if (currentScript && currentScript.parentNode) {
-        currentScript.parentNode.insertBefore(script, currentScript);
-    } else {
-        document.head.appendChild(script);
-    }
-    logger.info("Injected final import map into the document.");
-}
-
-async function postImportMapToViteServers(importMap: MergedImportMap, foundViteServers: string[], options: Required<ImPostingOptions>) {
-    const viteServers = getStoredDevServers();
-    const postPromises = [] as Promise<void>[];
-    const body = JSON.stringify(importMap);
-    const involvedViteServers = new Set(foundViteServers ? Array.from(foundViteServers).filter((origin) => {
-        if (viteServers.get(origin)) {
-            return true;
-        }
-        logger.info(`Vite server at ${origin} is not allowed to receive the import map. Skipping.`);
-        return false;
-    }) : []);
-    let serverCount = 0;
-    const postImportMaps = (serverUrl: string) => {
-        postPromises.push(pRetry(async (attemptNumber) => {
-            const response = await fetch(`${serverUrl}${options.importMapEndpoint}`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body,
-            });
-            if (response.ok) {
-                ++serverCount;
-                logger.info(`Successfully posted import map to Vite server at ${serverUrl}.`);
-            }
-            else {
-                logger.warn(`Attempt #${attemptNumber}:  Failed to post import map to Vite server at ${serverUrl}: ${response.status} ${response.statusText}`);
-            }
-        }, {
-            ...options.retryOptions,
-            onFailedAttempt: (error) => {
-                if (error.retriesLeft > 0) {
-                    logger.warn(`Attempt ${error.attemptNumber} to post import map to ${serverUrl} failed. There are ${error.retriesLeft} retries left.`);
-                }
-                else {
-                    logger.error(`All attempts to post import map to Vite server at ${serverUrl} have failed.`);
-                }
-                logger.save();
-            },
-        }));
-    };
-    involvedViteServers.forEach((serverUrl) => {
-        postImportMaps(serverUrl);
-    });
-    await Promise.all(postPromises);
-    logger.info(`Import map posting complete. Posted successfully to ${serverCount} Vite server(s).`);
-}
-
-async function main() {
-    ensureGlobalCollageJs();
-    ensureImoController();
-    logger.info("@collagejs/imo started!");
-    try {
-        const mergedImportMap = mergeAllImportMaps();
-        sessionStorage.setItem(skImportMap, JSON.stringify(mergedImportMap));
-        const finalImportMap = applyImOverrides(mergedImportMap.importMap);
-        sessionStorage.setItem(skFinalImportMap, JSON.stringify(finalImportMap));
-        if (finalImportMap.errors.length > 0) {
-            logger.warn(`The resulting import map turned out invalid.  Will not be injected or posted to Vite servers.`);
-            return;
-        }
-        injectImportMap(finalImportMap.importMap);
-        const options = await readImPostingOptions();
-        const foundViteServers = await discoverViteServers(finalImportMap.importMap, options.autoAllowLocalhost);
-        saveDiscoveredViteServers(foundViteServers);
-        logger.save();
-        await postImportMapToViteServers(finalImportMap.importMap, [...foundViteServers.keys()], options);
-    }
-    finally {
-        logger.info("@collagejs/imo completed.");
-        logger.save();
-    }
-}
-
-const logger = new Logger();
 main();
diff --git a/src/lib/Imo/CurrentImportMap.svelte b/src/lib/Imo/CurrentImportMap.svelte
index 6269806..ab2f793 100644
--- a/src/lib/Imo/CurrentImportMap.svelte
+++ b/src/lib/Imo/CurrentImportMap.svelte
@@ -57,17 +57,17 @@
     ];
 
     function acceptOverrideChange(row: (typeof data)[number]) {
-        row.override.replacement = overrideInputs[row.id]?.value || "";
+        row.override.replacement = overrideInputs[row.id]?.value.trim() || "";
         row.override.active = true;
         row.editing = false;
-        overrideInputs[row.id].value = "";
+        overrideInputs[row.id].value = row.override.replacement || "";
         overrideInputs[row.id].history.push(row.override.replacement);
     }
 
     function startEdit(row: (typeof data)[number]) {
         row.editing = true;
         row.override.active = !!row.override.replacement || row.override.active;
-        overrideInputs[row.id].value = "";
+        overrideInputs[row.id].value = row.override.replacement || "";
     }
 </script>
 
diff --git a/src/lib/Imo/DeleteAndReload.svelte b/src/lib/Imo/DeleteAndReload.svelte
new file mode 100644
index 0000000..b36bf9c
--- /dev/null
+++ b/src/lib/Imo/DeleteAndReload.svelte
@@ -0,0 +1,130 @@
+<script lang="ts">
+    import type { HttpOrigin } from "../../private-types.js";
+    import {
+        getInvolvedViteServers,
+        getStoredDiscoveredDevServers,
+    } from "../../shared/common.js";
+    import { readImPostingOptions } from "../../shared/options.js";
+    import ServerActionProgress, {
+        type ActionResult,
+    } from "./ServerActionProgress.svelte";
+    import TimerMessage from "./TimerMessage.svelte";
+
+    const viteServers = [
+        ...getInvolvedViteServers(
+            getStoredDiscoveredDevServers().keys(),
+        )[0],
+    ];
+    const servers = viteServers.map((origin) => {
+        return {
+            origin,
+            actionPromise: deleteImFromServer(origin),
+        };
+    });
+    let deletionResults = $state<(ActionResult | undefined)[]>(
+        new Array(servers.length).fill(undefined),
+    );
+    let imDeleteDone = $state(false);
+    const failedDeletions = $derived(
+        imDeleteDone
+            ? deletionResults.reduce(
+                  (acc, result, index) => {
+                      if (!result?.success) {
+                          acc.push([servers[index].origin, result!.error]);
+                      }
+                      return acc;
+                  },
+                  [] as [HttpOrigin, string | undefined][],
+              )
+            : [],
+    );
+    let showTimedMessage = $state(false);
+    let timedMessage = $state<TimerMessage>();
+
+    async function deleteImFromServer(origin: HttpOrigin) {
+        const options = await readImPostingOptions();
+        try {
+            const response = await fetch(
+                new URL(options.importMapEndpoint, origin),
+                {
+                    method: "DELETE",
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                },
+            );
+            if (response.ok) {
+                return { success: true };
+            } else {
+                const errorText = await response.text();
+                return {
+                    success: false,
+                    error:
+                        errorText ||
+                        `Failed to delete import map from ${origin}`,
+                };
+            }
+        } catch (error) {
+            return {
+                success: false,
+                error:
+                    error instanceof Error ? error.message : error?.toString(),
+            };
+        }
+    }
+
+    // Effect that triggers reload or the timed message.
+    $effect(() => {
+        if (imDeleteDone && failedDeletions.length === 0) {
+            window?.location.reload();
+        } else if (imDeleteDone && failedDeletions.length > 0) {
+            showTimedMessage = true;
+        }
+    });
+</script>
+
+<ServerActionProgress
+    {servers}
+    action="delete"
+    bind:done={imDeleteDone}
+    results={deletionResults}
+/>
+{#if showTimedMessage}
+    <TimerMessage
+        bind:this={timedMessage}
+        time={Math.min(5 * failedDeletions.length, 60)}
+        onTimer={() => window?.location.reload()}
+    >
+        {#snippet children(timeLeft)}
+            <span>
+                Some deletions failed. Restarting in {timeLeft} second{timeLeft ===
+                1
+                    ? ""
+                    : "s"}...
+            </span>
+            <div class="cjs-btn-group cjs-m-3">
+                <button
+                    class="cjs-btn cjs-btn-primary cjs-btn-sm"
+                    onclick={() => window?.location.reload()}
+                >
+                    Reload Now
+                </button>
+                <button
+                    class="cjs-btn cjs-btn-secondary cjs-btn-sm"
+                    onclick={() => timedMessage?.stop()}
+                >
+                    Don't Reload
+                </button>
+            </div>
+        {/snippet}
+        {#snippet stopped()}
+            <span> Some deletions failed. </span>
+            <button
+                class="cjs-m-3 cjs-btn cjs-btn-primary cjs-btn-sm"
+                onclick={() => window?.location.reload()}
+            >
+                Reload Now
+            </button>
+        {/snippet}
+    </TimerMessage>
+{/if}
diff --git a/src/lib/Imo/DialogContent.svelte b/src/lib/Imo/DialogContent.svelte
new file mode 100644
index 0000000..82f5985
--- /dev/null
+++ b/src/lib/Imo/DialogContent.svelte
@@ -0,0 +1,52 @@
+<script lang="ts">
+    import { Bookmark, BookOpenText, PcCase } from "@lucide/svelte";
+    import Tabs from "../Tabs/Tabs.svelte";
+    import TabPanel from "../Tabs/TabPanel.svelte";
+    import CurrentImportMap from "./CurrentImportMap.svelte";
+    import OriginalImportMap from "./OriginalImportMap.svelte";
+    import DevServers from "./DevServers.svelte";
+    import {
+        mergeOverridesWithImportMap,
+    } from "./import-map-utils.svelte";
+
+    type Props = {
+        overrideData: ReturnType<typeof mergeOverridesWithImportMap>;
+    };
+
+    let { overrideData = $bindable() }: Props = $props();
+</script>
+
+<p class="first-content">
+    Manage your import map overrides using the tabs below.
+</p>
+<Tabs>
+    {#snippet tab_current()}
+        <span class="tab-title"><Bookmark size="1.2em" />Current</span>
+    {/snippet}
+    {#snippet tab_original()}
+        <span class="tab-title"><BookOpenText size="1.2em" />Original</span>
+    {/snippet}
+    {#snippet tab_viteServers()}
+        <span class="tab-title"><PcCase size="1.2em" />Dev Servers</span>
+    {/snippet}
+    <TabPanel id="current">
+        <CurrentImportMap bind:data={overrideData} />
+    </TabPanel>
+    <TabPanel id="original">
+        <OriginalImportMap />
+    </TabPanel>
+    <TabPanel id="viteServers">
+        <DevServers />
+    </TabPanel>
+</Tabs>
+
+<style>
+    span.tab-title {
+        display: inline-flex;
+        align-items: center;
+        gap: 0.25rem;
+    }
+    .first-content {
+        width: calc(100% - 64px + 1rem);
+    }
+</style>
diff --git a/src/lib/Imo/ImoDialog.svelte b/src/lib/Imo/ImoDialog.svelte
index 6b23057..bf624e9 100644
--- a/src/lib/Imo/ImoDialog.svelte
+++ b/src/lib/Imo/ImoDialog.svelte
@@ -1,45 +1,40 @@
 <script lang="ts">
-    import { Bookmark, BookOpenText, PcCase, RefreshCcw } from '@lucide/svelte';
-    import Dialog from '../Dialog.svelte';
-    import Tabs from '../Tabs/Tabs.svelte';
-    import TabPanel from '../Tabs/TabPanel.svelte';
-    import OriginalImportMap from './OriginalImportMap.svelte';
-    import DevServers from './DevServers.svelte';
-    import CurrentImportMap from './CurrentImportMap.svelte';
-    import { getFinalImportMap, mapImportMapToArray, mergeOverridesWithImportMap } from './import-map-utils.svelte';
-    import Button from '../Button.svelte';
-    import { importMapOverrides } from '../state/importMapOverrides.svelte';
+    import { BookOpenText, RefreshCcw } from "@lucide/svelte";
+    import Dialog from "../Dialog.svelte";
+    import Button from "../Button.svelte";
+    import DialogContent from "./DialogContent.svelte";
+    import { importMapOverrides } from "../state/importMapOverrides.svelte";
+    import { getFinalImportMap, mapImportMapToArray, mergeOverridesWithImportMap } from "./import-map-utils.svelte";
+    import DeleteAndReload from "./DeleteAndReload.svelte";
 
     type Props = {
         show?: boolean;
     };
 
     let { show = $bindable(false) }: Props = $props();
+
+    let reloadApp = $state(false);
     const importMapData = mapImportMapToArray(getFinalImportMap());
-    let overrideData = $derived.by(() => {
-        const result = $state(mergeOverridesWithImportMap(importMapData));
-        return result;
-    });
-    const pendingOverrides = $derived.by(() => {
-        return overrideData.some((item) => {
-            const savedOverride = importMapOverrides.current.find(
-                (ovr) => ovr.scope === item.scope && ovr.bareIdentifier === item.moduleId,
-            );
-            return (
-                (savedOverride &&
-                    (item.override.replacement !== savedOverride.replacement ||
-                        item.override.active !== savedOverride.active)) ||
-                (!savedOverride && item.override.replacement)
-            );
-        });
-    });
-    $inspect(overrideData);
+    let overrideData = $state(mergeOverridesWithImportMap(importMapData));
+    let pendingOverrides = $derived(overrideData.some((item) => {
+        const savedOverride = importMapOverrides.current.find(
+            (ovr) =>
+                ovr.scope === item.scope &&
+                ovr.bareIdentifier === item.moduleId,
+        );
+        return (
+            (savedOverride &&
+                (item.override.replacement !== savedOverride.replacement ||
+                    item.override.active !== savedOverride.active)) ||
+            (!savedOverride && item.override.replacement)
+        );
+    }));
 
     function saveOverrides() {
         importMapOverrides.current = overrideData
             .filter((item) => !!item.override.replacement)
             .map((item) => item.override);
-        location.reload();
+        reloadApp = true;
     }
 </script>
 
@@ -47,42 +42,19 @@
     {#snippet title()}
         <h2><BookOpenText /> Import Map Overrides</h2>
     {/snippet}
-    <p class="first-content">Manage your import map overrides using the tabs below.</p>
-    <Tabs>
-        {#snippet tab_current()}
-            <span class="tab-title"><Bookmark size="1.2em" />Current</span>
-        {/snippet}
-        {#snippet tab_original()}
-            <span class="tab-title"><BookOpenText size="1.2em" />Original</span>
-        {/snippet}
-        {#snippet tab_viteServers()}
-            <span class="tab-title"><PcCase size="1.2em" />Dev Servers</span>
-        {/snippet}
-        <TabPanel id="current">
-            <CurrentImportMap bind:data={overrideData} />
-        </TabPanel>
-        <TabPanel id="original">
-            <OriginalImportMap />
-        </TabPanel>
-        <TabPanel id="viteServers">
-            <DevServers />
-        </TabPanel>
-    </Tabs>
+    {#if reloadApp}
+        <DeleteAndReload />
+    {:else}
+        <DialogContent bind:overrideData />
+    {/if}
     {#snippet footer()}
         {#if pendingOverrides}
-            <Button variant="primary" onclick={saveOverrides}><RefreshCcw size="1.1em" /> Save Overrides & Reload</Button>
+            <Button variant="primary" onclick={saveOverrides}>
+                <RefreshCcw size="1.1em" /> Save Overrides & Reload
+            </Button>
         {/if}
-        <Button variant="secondary" onclick={() => (show = false)}>Close</Button>
+        <Button variant="secondary" onclick={() => (show = false)}>
+            Close
+        </Button>
     {/snippet}
 </Dialog>
-
-<style>
-    span.tab-title {
-        display: inline-flex;
-        align-items: center;
-        gap: 0.25rem;
-    }
-    .first-content {
-        width: calc(100% - 64px + 1rem);
-    }
-</style>
diff --git a/src/lib/Imo/ServerActionProgress.svelte b/src/lib/Imo/ServerActionProgress.svelte
new file mode 100644
index 0000000..3402333
--- /dev/null
+++ b/src/lib/Imo/ServerActionProgress.svelte
@@ -0,0 +1,82 @@
+<script lang="ts">
+    import { X, Check } from '@lucide/svelte';
+    import Spinner from './Spinner.svelte';
+
+    export type ActionResult = {
+        success: boolean;
+        error?: string;
+    };
+
+    type Props = {
+        servers: { origin: string; actionPromise: Promise<ActionResult> }[];
+        action: 'post' | 'delete';
+        done: boolean;
+        results: (ActionResult | undefined)[];
+    }
+
+    let { servers, action, done = $bindable(), results }: Props = $props();
+
+    let title = $derived(action === 'post' ? 'Sending Import Map to' : 'Deleting Import Map from');
+    let text = $derived(action === 'post' ? 'Sending' : 'Deleting');
+    // Calculation of "done":
+    $effect.pre(() => {
+        done = results.every((result) => result !== undefined);
+    });
+    // Done in an effect to satisfy Svelte tools, but the list of servers or the action promise should not change
+    // during the lifetime of this component.
+    $effect.pre(() => {
+        servers.forEach(async (server, index) => {
+            server.actionPromise.then((result) => {
+                results[index] = result;
+            });
+        });
+    });
+</script>
+
+<div>
+    <h4>{title} Development Servers</h4>
+    <p>
+        {#if done}
+            All operations have completed.
+        {:else}
+            {text} import map on {servers.length} server{servers.length === 1 ? '' : 's'}...
+        {/if}
+    </p>
+    <dl class="cjs-border cjs-rounded cjs-p-3">
+        {#each servers as server, index}
+            <dt>{server.origin}</dt>
+            <dd>
+                {#if results[index] === undefined}
+                    <Spinner size="1.1em" />
+                {:else if results[index].success}
+                    <Check class="status-icon cjs-text-success" />
+                {:else}
+                    <X class="status-icon cjs-text-error" />
+                    <span>{results[index].error}</span>
+                {/if}
+            </dd>
+        {/each}
+    </dl>
+</div>
+
+<style>
+    dl {
+        display: grid;
+        grid-template-columns: min-content auto;
+        gap: 0.25rem 1rem;
+        overflow-y: auto;
+        & > * {
+            margin: 0;
+        }
+
+        & dd {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+    }
+
+    :global .status-icon {
+        stroke-width: 3;
+    }
+</style>
diff --git a/src/lib/Imo/Spinner.svelte b/src/lib/Imo/Spinner.svelte
new file mode 100644
index 0000000..b1e9faf
--- /dev/null
+++ b/src/lib/Imo/Spinner.svelte
@@ -0,0 +1,51 @@
+<script>
+  let { size = '24px', color = 'currentColor' } = $props();
+</script>
+
+<div class="spinner" style="--size: {size}; --color: {color}" role="status" aria-live="polite" aria-label="Loading">
+  <div class="dot dot-1"></div>
+  <div class="dot dot-2"></div>
+  <div class="dot dot-3"></div>
+</div>
+
+<style>
+  .spinner {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 4px;
+    width: var(--size);
+    height: var(--size);
+  }
+
+  .dot {
+    width: 20%;
+    height: 20%;
+    background-color: var(--color);
+    border-radius: 50%;
+    animation: jump 0.8s ease-in-out infinite;
+  }
+
+  .dot-1 {
+    animation-delay: 0s;
+  }
+
+  .dot-2 {
+    animation-delay: 0.2s;
+  }
+
+  .dot-3 {
+    animation-delay: 0.4s;
+  }
+
+  @keyframes jump {
+    0%, 100% {
+      transform: translateY(0);
+      opacity: 1;
+    }
+    50% {
+      transform: translateY(-150%);
+      opacity: 0.6;
+    }
+  }
+</style>
diff --git a/src/lib/Imo/TimerMessage.svelte b/src/lib/Imo/TimerMessage.svelte
new file mode 100644
index 0000000..05251fb
--- /dev/null
+++ b/src/lib/Imo/TimerMessage.svelte
@@ -0,0 +1,42 @@
+<script lang="ts">
+    import { onMount, type Snippet } from "svelte";
+    import type { HTMLAttributes } from "svelte/elements";
+
+    type Props = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+        time: number;
+        children?: Snippet<[number]>;
+        stopped?: Snippet;
+        onTimer?: () => void;
+    };
+
+    let { time, children, stopped, onTimer, ...restProps }: Props = $props();
+
+    let timerStopped = $state(false);
+    // svelte-ignore state_referenced_locally
+    let timeLeft = $state(time);
+    let timer: ReturnType<typeof setTimeout>;
+
+    onMount(() => {
+        timer = setInterval(() => {
+            timeLeft -= 1;
+            if (timeLeft <= 0) {
+                clearInterval(timer);
+                onTimer?.();
+            }
+        }, 1000);
+        return () => clearInterval(timer);
+    });
+
+    export function stop() {
+        clearInterval(timer);
+        timerStopped = true;
+    }
+</script>
+
+<div {...restProps}>
+    {#if timerStopped}
+        {@render stopped?.()}
+    {:else}
+        {@render children?.(timeLeft)}
+    {/if}
+</div>
diff --git a/src/private-types.ts b/src/private-types.ts
index 69550d0..e263797 100644
--- a/src/private-types.ts
+++ b/src/private-types.ts
@@ -129,3 +129,7 @@ export type OverrideData = ImoEntry & {
      */
     editing: boolean;
 };
+/**
+ * Defines a branded string type for HTTP origins.
+ */
+export type HttpOrigin = string & { __brand: 'HttpOrigin' };
diff --git a/src/shared/common.ts b/src/shared/common.ts
index 58d6f3d..e094081 100644
--- a/src/shared/common.ts
+++ b/src/shared/common.ts
@@ -1,6 +1,7 @@
 import { ImoController } from "../ImoController.js";
+import type { HttpOrigin } from "../private-types.js";
 import type { ImPostingOptions } from "../types.js";
-import { skViteDevServers } from "./storage-keys.js";
+import { skDiscoveredViteServers, skViteDevServers } from "./storage-keys.js";
 
 export const eventImoLogsUpdated = 'imo-logs-updated';
 
@@ -73,7 +74,16 @@ export function isViteServer(url: URL, allowedType: Required<ImPostingOptions>['
 export function getStoredDevServers(): Map<string, boolean> {
     return new Map<string, boolean>(JSON.parse(localStorage.getItem(skViteDevServers) || '[]'));
 }
-
+/**
+ * Reads from session storage and returns the list of potential Vite servers that have been discovered.
+ *
+ * The list is stored in storage as an array of `[origin, boolean]` pairs, where the Boolean value indicates
+ * whether the server is truly a Vite server or not by this package's detection logic.
+ * @returns A map object containing the discovered Vite dev servers, or an empty map object.
+ */
+export function getStoredDiscoveredDevServers() {
+    return new Map<HttpOrigin, boolean>(JSON.parse(sessionStorage.getItem(skDiscoveredViteServers) || '[]'));
+}
 /**
  * Ensures that the `CollageJs.Imo` controller is initialized and available.  If it doesn't exist, it is created.
  */
@@ -83,3 +93,36 @@ export function ensureImoController(): void {
         CollageJs.Imo = new ImoController();
     }
 }
+
+/**
+ * Gets the subset of Vite servers that are allowed to receive the import map.
+ * @param foundViteServers Vite servers spotted in the resultant import map.
+ * @returns A tuple with 2 sets:  The first set contains the involved Vite servers that are allowed to receive the
+ * import map, and the second set contains the excluded Vite servers that are not allowed to receive the import map.
+ */
+export function getInvolvedViteServers(foundViteServers: Iterable<HttpOrigin>) {
+    const viteServers = getStoredDevServers();
+    const excludedViteServers = new Set<HttpOrigin>();
+    const involvedViteServers = new Set(foundViteServers ? Array.from(foundViteServers).filter((origin) => {
+        if (viteServers.get(origin)) {
+            return true;
+        }
+        excludedViteServers.add(origin);
+        return false;
+    }) : []);
+    return [involvedViteServers, excludedViteServers] as const;
+}
+
+/**
+ * Tests whether a value represents an HTTP origin.
+ * @param value Value to test.
+ * @returns `true` if the value represents an HTTP origin, or `false` otherwise.
+ */
+export function isHttpOrigin(value: string): value is HttpOrigin {
+    try {
+        const url = new URL(value);
+        return (url.protocol === 'http:' || url.protocol === 'https:') && value === url.origin;
+    } catch {
+        return false;
+    }
+}
diff --git a/src/shared/storage-keys.ts b/src/shared/storage-keys.ts
index aba170f..e819d37 100644
--- a/src/shared/storage-keys.ts
+++ b/src/shared/storage-keys.ts
@@ -59,6 +59,12 @@ export const skOverrideEntryHistoryPrefix = storageKey("oeh:");
  */
 export const skViteDevServers = storageKey("vds");
 
+/**
+ * Storage key for discovered Vite development servers.  This is stored in session storage and is
+ * currently only used to request import map deletion from Vite servers before applying overrides.
+ */
+export const skDiscoveredViteServers = storageKey("disc-vds");
+
 /**
  * Deletes the specified data entry from storage.
  * @param entry Data entry to delete.
@@ -96,6 +102,7 @@ export function deleteDataEntry(entry: DataEntry, name?: string): void {
             break;
         case 'vite-servers':
             localStorage.removeItem(skViteDevServers);
+            sessionStorage.removeItem(skDiscoveredViteServers);
             break;
         default:
             throw new Error(`Unknown data entry type: ${entry}`);
diff --git a/vite.config.ts b/vite.config.ts
index 4920ce4..a745173 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -12,6 +12,8 @@ export default defineConfig({
         projectId: 'cjs-imo',
         entryPoints: ['src/index.ts', 'src/const.ts', 'src/imo-ui.ts'],
         assetFileNames: 'assets/[name][extname]',
+    }, {
+        importMapTimeout: 200,
     }),
     viteTest(),
     viteIife({