diff --git a/index.html b/index.html
index f28c6fe2..690d6267 100644
--- a/index.html
+++ b/index.html
@@ -20,7 +20,7 @@
     <body style="margin:0;">
         <script id="socket.io" src="dist/client/vendor/socket.io.js"></script>
         <datalist id="public-game-hosts-list">
-            <!-- <option value="localhost"> -->
+            <!-- default protocol is http -->
         </datalist>
         <script>
         { // Load up last used colour scheme (or default):
diff --git a/src/client/TopLevel.ts b/src/client/TopLevel.ts
index 12f4a802..fe28b456 100644
--- a/src/client/TopLevel.ts
+++ b/src/client/TopLevel.ts
@@ -41,6 +41,11 @@ export class TopLevel {
         + " color:white; background-color:#3f5e77; border-radius:0.7em; ");
     }
 
+    public toast(message: string): void {
+        // TODO.impl
+        console.info(message);
+    }
+
     public get socketIo(): Promise<typeof import("socket.io-client")> {
         // return this.#socketIoChunk
         // || (this.#socketIoChunk = import(
diff --git a/src/client/screen/impl/GroupJoiner.ts b/src/client/screen/impl/GroupJoiner.ts
index 459a967e..e126509e 100644
--- a/src/client/screen/impl/GroupJoiner.ts
+++ b/src/client/screen/impl/GroupJoiner.ts
@@ -27,27 +27,15 @@ export class GroupJoinerScreen extends SkScreen<SkScreen.Id.GROUP_JOINER> {
      * @override
      */
     protected __lazyLoad(): void {
-        const OMHC = OmHooks.Screen.Impl.GroupJoiner.Class;
         this.baseElem.classList.add(
             OmHooks.General.Class.CENTER_CONTENTS,
-            OMHC.BASE,
+            OmHooks.Screen.Impl.GroupJoiner.Class.BASE,
         );
         const contentWrapper = this.__initializeFormContents();
-        this.__initializeHostUrlHandlers();
-
-        this.groupNameInput.oninput  = (ev) => {
-            // TODO.fix we also need to switch back to the joiner namespace!!!
-            this.__setFormState(State.CHOOSING_GROUP);
-        }
-        this.groupNameInput.onchange = (ev) => {
-            const input = this.groupNameInput;
-            if (input.value && input.validity.valid) {
-                this.passphraseInput.focus();
-            }
-        };
+        const huiSubmit = this.__initializeHostUrlHandlers();
+        this.__initializeGroupNameHandlers(huiSubmit);
         this.__initializePassphraseHandlers();
 
-        this.__setFormState(State.CHOOSING_HOST);
         contentWrapper.onsubmit = (ev) => {
             // TODO change the screen nav flow to use the correct (commented out) values.
             if (false /* TODO this.isGroupOwner */) {
@@ -58,6 +46,7 @@ export class GroupJoinerScreen extends SkScreen<SkScreen.Id.GROUP_JOINER> {
                 //this.requestGoToScreen(SkScreen.Id.GROUP_LOBBY, {});
             }
         }
+        this.__setFormState(State.CHOOSING_HOST);
         this.baseElem.appendChild(contentWrapper);
     }
 
@@ -92,6 +81,7 @@ export class GroupJoinerScreen extends SkScreen<SkScreen.Id.GROUP_JOINER> {
             if (this.state !== State.CHOOSING_GROUP) {
                 throw new Error("never"); // Illegal state transition.
             }
+            this.passphraseInput.disabled = true;
             this.nextButton.disabled = false;
             this.nextButton.focus();
 
@@ -99,10 +89,9 @@ export class GroupJoinerScreen extends SkScreen<SkScreen.Id.GROUP_JOINER> {
             this.nextButton.disabled = true;
 
             if (newState === State.CHOOSING_HOST) {
-                this.socket = undefined;
                 this.groupNameInput.disabled    = true;
                 this.groupNameInput.value       = "";
-                Array.from(this.groupNameDataList.children).forEach((child) => child.remove());
+                this.groupNameDataList.replaceWith(this.groupNameDataList.cloneNode());
                 this.passphraseInput.disabled   = true;
                 this.passphraseInput.value      = "";
                 this.hostUrlInput.focus();
@@ -110,7 +99,6 @@ export class GroupJoinerScreen extends SkScreen<SkScreen.Id.GROUP_JOINER> {
             } else if (newState === State.CHOOSING_GROUP) {
                 this.groupNameInput.disabled    = false;
                 this.passphraseInput.disabled   = false;
-                this.passphraseInput.value      = "";
                 this.groupNameInput.focus();
             }
         }
@@ -120,24 +108,33 @@ export class GroupJoinerScreen extends SkScreen<SkScreen.Id.GROUP_JOINER> {
     /**
      *
      */
-    private __initializeHostUrlHandlers(): void {
+    private __initializeHostUrlHandlers(): () => Promise<void> {
         const top = this.toplevel;
         const input = this.hostUrlInput;
-        input.oninput = (ev) => this.__setFormState(State.CHOOSING_HOST);
-        input.onkeydown = (ev) => {
-            if (ev.key === "Enter"
-            && (this.socket ? this.socket.connected : true)
-            ) input.dispatchEvent(new Event("change"));
-            // Force the change event on pressing enter, but don't
-            // do it if we are currently trying to connect to a host.
-        };
-        input.onchange = async (ev) => {
+        const submitInput = async () => {
+            // Minor cleaning: default the protocol and only use the origin:
+            if (!input.value.startsWith(SkServer.PROTOCOL)) {
+                input.value = new URL(SkServer.PROTOCOL + input.value).origin;
+            }
+            // Short-circuit on invalid input:
             if (!input.value || !input.validity.valid) return;
-            if (!input.value.match(/^https?:\/\//)) {
-                input.value = SkServer.PROTOCOL + input.value;
+
+            // Short-circuit when no change has occurred:
+            const targetSocketUri = new URL(input.value + SkServer.Nsps.GROUP_JOINER);
+            if (this.socket
+            && this.socket.nsp === SkServer.Nsps.GROUP_JOINER
+            && this.socket.io.opts.hostname === targetSocketUri.hostname
+            ) {
+                if (this.socket!.connected) {
+                    this.__setFormState(State.CHOOSING_GROUP);
+                    this.groupNameInput.focus(); // No changes have occurred.
+                    return;
+                } else {
+                    return; // Impatient client is spamming.
+                }
             }
             this.socket?.close();
-            this.socket = (await top.socketIo)(input.value + SkServer.Nsps.GROUP_JOINER, {
+            this.socket = (await top.socketIo)(targetSocketUri.toString(), {
                 reconnectionAttempts: Group.JoinerReconnectionAttempts,
             });
             this.socket.on("connect", () => {
@@ -145,70 +142,122 @@ export class GroupJoinerScreen extends SkScreen<SkScreen.Id.GROUP_JOINER> {
                 // Listen for group creation / deletion events.
                 this.socket!.on(Group.Exist.EVENT_NAME, this.onNotifyGroupExist.bind(this));
             });
-            this.socket.on("connect_error", this.onHostConnectionFailure.bind(this));
+            this.socket.on("connect_error", (error: object) => {
+                this.socket = undefined;
+                this.toplevel.toast("Unable to connected to the specified server.");
+            });
+            this.socket.on("disconnect", (reason: string) => {
+                if (reason === "io server disconnect") {
+                    this.socket = undefined;
+                    this.__setFormState(State.CHOOSING_HOST);
+                    input.value = "";
+                    top.toast("The server disconnected you from the group joiner.");
+                }
+            });
         };
+        // Link handler to events:
+        input.oninput = (ev) => this.__setFormState(State.CHOOSING_HOST);
+        input.onkeydown = (ev) => { if (ev.key === "Enter") {
+            submitInput();
+        }};
+        input.onpaste = (ev) => {
+            window.setTimeout(() => submitInput(), 0);
+        };
+        input.onchange = () => {
+            submitInput();
+        };
+        return submitInput;
     }
+    /**
+     *
+     */
     private onNotifyGroupExist(response: Group.Exist.NotifyStatus): void {
         if (response === Group.Exist.RequestCreate.Response.NOPE) {
-            // TODO.design what to do here
-            console.info(`server rejected request to create new group \`${this.groupNameInput.value}\`.`);
-        } else {
-            for (const [groupName, status,] of Object.entries(response)) {
-                const optElem
-                    = (Array.from(this.groupNameDataList.children) as HTMLOptionElement[])
-                    .find((opt: HTMLOptionElement) => opt.value === groupName)
-                    || (() => {
-                        const newOpt = document.createElement("option");
-                        newOpt.value = groupName;
-                        this.groupNameDataList.appendChild(newOpt);
-                        return newOpt;
-                    })();
-                switch (status) {
-                case Group.Exist.Status.IN_LOBBY:
-                    optElem.remove(); break;
-                case Group.Exist.Status.IN_GAME:
-                    optElem.textContent = "In Game";
-                    break;
-                case Group.Exist.Status.DELETE:
-                    optElem.textContent = "In Lobby";
-                    break;
-                }
-            }
-            if (response === Group.Exist.RequestCreate.Response.OKAY) {
-                console.info(`server accepted request to create new group \`${this.groupNameInput.value}\`.`);
-                console.log("connecting to new group...");
-                this.attemptToJoinExistingGroup();
+            this.toplevel.toast(`The server rejected your request to`
+            + ` create a new group \"${this.groupNameInput.value}\".`);
+            return;
+        }
+        const dataList = this.groupNameDataList;
+        const dataListArr = Array.from(dataList.children) as HTMLOptionElement[];
+        for (const [groupName, status,] of Object.entries(response)) {
+            const optElem
+                = dataListArr.find((opt: HTMLOptionElement) => opt.value === groupName)
+                || (() => {
+                    // If we didn't know about this group yet, create a new
+                    // option for it (Insert into list in alphabetical order):
+                    const newOpt = document.createElement("option");
+                    newOpt.value = groupName;
+                    for (const otherOpt of dataListArr) {
+                        if (newOpt.value.localeCompare(otherOpt.value) < 0) {
+                            dataList.insertBefore(newOpt, otherOpt);
+                            break;
+                        }
+                    }
+                    if (!newOpt.parentElement) {
+                        dataList.appendChild(newOpt);
+                    }
+                    return newOpt;
+                })();
+            switch (status) {
+            case Group.Exist.Status.IN_LOBBY:
+                optElem.remove();
+                break;
+            case Group.Exist.Status.IN_GAME:
+                optElem.textContent = "In Game";
+                break;
+            case Group.Exist.Status.DELETE:
+                optElem.textContent = "In Lobby";
+                break;
             }
         }
+        if (response === Group.Exist.RequestCreate.Response.OKAY) {
+            console.info(`server accepted request to create new group \`${this.groupNameInput.value}\`.`);
+            console.log("connecting to new group...");
+            this.attemptToJoinExistingGroup();
+        }
     }
-    private onHostConnectionFailure(): void {
-        this.socket = undefined;
-        // TODO.impl make some visual indication.
+
+    private __initializeGroupNameHandlers(huiSubmit: () => Promise<void>): void {
+        const input = this.groupNameInput;
+        const submitInput = () => {
+            if (!input.value || !input.validity.valid) return;
+            if (this.state === State.IN_GROUP) {
+                this.nextButton.focus();
+            } else {
+                this.passphraseInput.focus();
+            }
+        }
+        this.groupNameInput.oninput = async (ev) => {
+            if (this.state === State.IN_GROUP) {
+                await huiSubmit();
+                // ^This will take us back to the state `CHOOSING_GROUP`.
+            }
+            this.passphraseInput.value = "";
+        }
+        input.onkeydown = (ev) => { if (ev.key === "Enter") {
+            submitInput();
+        }};
+        input.onchange = (ev) => {
+            submitInput();
+        };
     }
 
+    /**
+     *
+     */
     private __initializePassphraseHandlers(): void {
-        this.passphraseInput.onkeydown = (ev) => { if (ev.key === "Enter") {
-            const socket = this.socket!;
-            const inputNsps = SkServer.Nsps.GROUP_LOBBY_PREFIX + this.groupNameInput.value;
-            if (socket.nsp === inputNsps) {
-                if (socket.connected) {
-                    // The client (for some reason) reselected the passphrase
-                    // input, made no changes, and then pressed enter again.
-                    this.nextButton.focus();
+        const submitInput = async () => {
+            if (!this.passphraseInput.validity.valid) return;
+            // Short-circuit when no change has occurred:
+            if (this.socket!.nsp === SkServer.Nsps.GROUP_LOBBY_PREFIX + this.groupNameInput.value) {
+                if (this.socket!.connected) {
+                    this.__setFormState(State.IN_GROUP);
+                    this.nextButton.focus(); // No changes have occurred.
                     return;
                 } else {
-                    // The client is impatient and is spamming the enter button
-                    // while we are trying to connect to the group.
-                    return;
+                    return; // Impatient client is spamming.
                 }
             }
-            this.passphraseInput.dispatchEvent(new Event("change"));
-            // Force the change event on pressing enter, but don't
-            // do it if we are currently trying to connect to a host.
-        }}
-        this.passphraseInput.onchange = async (ev) => {
-            const input = this.passphraseInput;
-            if (!input.validity.valid) return;
 
             const groupExists = (Array.from(this.groupNameDataList.children) as HTMLOptionElement[])
                 .some((opt) => opt.value === this.groupNameInput.value);
@@ -223,6 +272,9 @@ export class GroupJoinerScreen extends SkScreen<SkScreen.Id.GROUP_JOINER> {
                 );
             }
         };
+        this.passphraseInput.onkeydown = (ev) => { if (ev.key === "Enter") {
+            submitInput();
+        }};
     }
 
     /**
@@ -230,27 +282,28 @@ export class GroupJoinerScreen extends SkScreen<SkScreen.Id.GROUP_JOINER> {
      */
     private async attemptToJoinExistingGroup(): Promise<void> {
         const url = (() => {
-            const url = new window.URL(this.hostUrlInput.value);
+            const url = new URL(this.hostUrlInput.value);
             url.pathname = SkServer.Nsps.GROUP_LOBBY_PREFIX + this.groupNameInput.value;
             return url.toString();
         })();
-        const passphrase = this.passphraseInput.value;
-        if (this.state !== State.CHOOSING_GROUP) {
-            throw new Error("never");
-        }
         this.socket?.close();
         const top = this.toplevel;
         this.socket = (await top.socketIo)(url, {
-            query: { passphrase, },
+            query: { passphrase: this.passphraseInput.value, },
         });
         this.socket.on("connect", () => {
             this.__setFormState(State.IN_GROUP);
         });
-        this.socket.on("connect_error", () => this.onGroupJoinFailure.bind(this));
-    }
-    private onGroupJoinFailure(): void {
-        this.socket = undefined;
-        // TODO.impl make some visual indication.
+        this.socket.on("connect_error", (error: object) => {
+            this.socket = undefined;
+            top.toast("Unable to connect to the specified group.");
+        });
+        this.socket.on("disconnect", (reason: string) => {
+            if (reason === "io server disconnect") {
+                this.socket = undefined;
+                top.toast("The server disconnected you from your group.");
+            }
+        });
     }
 
     private get socket(): SocketIOClient.Socket | undefined {
@@ -289,22 +342,16 @@ export class GroupJoinerScreen extends SkScreen<SkScreen.Id.GROUP_JOINER> {
             hostUrl.type = "url";
             hostUrl.classList.add(OMHC.HOST_URL);
             hostUrl.autocomplete = "on";
-            const suggestedHost = GroupJoinerScreen.SUGGEST_LAN_HOST_URL(this.toplevel.webpageHostType);
-            if (suggestedHost) {
-                const suggestedHostOption = document.createElement("option");
-                suggestedHostOption.value = suggestedHost;
-                document.getElementById(OmHooks.GLOBAL_IDS.PUBLIC_GAME_HOST_URLS)!.appendChild(
-                    suggestedHostOption,
-                );
+            const suggestedHostDesc = GroupJoinerScreen.SUGGEST_HOST(this.toplevel.webpageHostType);
+            if (suggestedHostDesc) {
+                const suggestOpt = document.createElement("option");
+                suggestOpt.value = suggestedHostDesc.value;
+                suggestOpt.textContent = suggestedHostDesc.description;
+                document.getElementById(OmHooks.GLOBAL_IDS.PUBLIC_GAME_HOST_URLS)!
+                    .insertAdjacentElement("afterbegin", suggestOpt);
             }
             hostUrl.setAttribute("list", OmHooks.GLOBAL_IDS.PUBLIC_GAME_HOST_URLS);
             hostUrl.maxLength = 128;
-        }{
-            const nspsList
-                = (this.groupNameDataList as HTMLElement)
-                = document.createElement("datalist");
-            nspsList.id = OmHooks.GLOBAL_IDS.CURRENT_HOST_GROUPS;
-            this.baseElem.appendChild(nspsList);
         }{
             const nspsName
                 = (this.groupNameInput as HTMLElement)
@@ -312,7 +359,12 @@ export class GroupJoinerScreen extends SkScreen<SkScreen.Id.GROUP_JOINER> {
             nspsName.classList.add(OMHC.GROUP_NAME);
             nspsName.pattern   = Group.Name.REGEXP.source;
             nspsName.maxLength = Group.Name.MaxLength;
-            nspsName.setAttribute("list", OmHooks.GLOBAL_IDS.CURRENT_HOST_GROUPS);
+            const nspsList
+                = (this.groupNameDataList as HTMLElement)
+                = document.createElement("datalist");
+            nspsList.id = OmHooks.GLOBAL_IDS.CURRENT_HOST_GROUPS;
+            this.baseElem.appendChild(nspsList);
+            nspsName.setAttribute("list", nspsList.id);
         }{
             const pass
                 = (this.passphraseInput as HTMLElement)
@@ -344,26 +396,36 @@ export namespace GroupJoinerScreen {
     /**
      *
      */
-    export function SUGGEST_LAN_HOST_URL(webpageHostType: TopLevel.WebpageHostType): string {
+    export function SUGGEST_HOST(webpageHostType: TopLevel.WebpageHostType): ({
+        readonly value: string;
+        readonly description: string;
+    } | undefined) {
         switch (webpageHostType) {
             case "github":
                 // Use case: production. Load page resources from GitHub
                 // Pages to reduce load on the game server, which is on
                 // on the LAN. Only use the server for game management.
-                return "";
+                return undefined;
             case "filesystem":
                 // Use case: development. Load page resources directly from
                 // the local filesystem. Server only used as a game manager.
                 // In this case, suggest connecting to `localhost`.
-                return "localhost:" + SkServer.DEFAULT_PORT;
+                return {
+                    value: "localhost:" + SkServer.DEFAULT_PORT,
+                    description: "dev shortcut :)",
+                };
             case "lan-server":
                 // Use case: production. Page resources are probably being
                 // served by the LAN server already. Suggest connecting
                 // Socket.IO to that same host. Just give origin (exclude
                 // the URI's path, since Socket.IO interprets the path as
                 // a namespace specifier).
-                return window.location.origin;
-            default: return "";
+                return {
+                    value: window.location.origin,
+                    description: "this page's server",
+                };
+            default:
+                return undefined;
         }
     }
 }
diff --git a/src/server/Group.ts b/src/server/Group.ts
index 031f8fda..fe7ba0c5 100644
--- a/src/server/Group.ts
+++ b/src/server/Group.ts
@@ -18,7 +18,8 @@ export { ServerGame } from "./ServerGame";
 export class Group extends __Group {
 
     public readonly namespace: io.Namespace;
-    public readonly passphrase: string;
+    public readonly name: Group.Name;
+    public readonly passphrase: Group.Passphrase;
     #currentGame: ServerGame<any> | undefined;
     private sessionHost: io.Socket;
 
@@ -38,23 +39,24 @@ export class Group extends __Group {
      * If no sockets connect to this `GameSession` in this many seconds,
      * it will close and clean itself up.
      */
-    public constructor(
+    public constructor(desc: Readonly<{
         namespace: io.Namespace,
+        name: Group.Name,
         passphrase: Group.Passphrase,
         deleteExternalRefs: VoidFunction,
         initialTtl: number,
-    ) {
+    }>) {
         super();
-        this.namespace   = namespace;
-        this.passphrase  = passphrase;
+        this.namespace   = desc.namespace;
+        this.passphrase  = desc.passphrase;
         this.#currentGame = undefined;
 
         this.initialTtlTimeout = setTimeout(() => {
             if (Object.keys(this.namespace.connected).length === 0) {
                 this.terminate();
             }
-        }, (initialTtl * 1000)).unref();
-        this.deleteExternalRefs = deleteExternalRefs;
+        }, (desc.initialTtl * 1000)).unref();
+        this.deleteExternalRefs = desc.deleteExternalRefs;
 
         // Call the connection-event handler:
         this.namespace.use((socket, next) => {
@@ -71,7 +73,7 @@ export class Group extends __Group {
      * @param socket -
      */
     protected onConnection(socket: Group.Socket): void {
-        console.log(`socket ${socket.id} connected.`);
+        console.log(`socket    connect: ${socket.id}`);
         socket.username = undefined;
         socket.teamId   = undefined;
         socket.updateId = 0;
@@ -83,6 +85,9 @@ export class Group extends __Group {
             (this.initialTtlTimeout as NodeJS.Timeout) = undefined!;
             this.sessionHost = socket;
             // TODO.impl set socket.isPrivileged
+            socket.broadcast.emit(Group.Exist.EVENT_NAME, {
+                [this.name]: Group.Exist.Status.IN_LOBBY,
+            });
         }
 
         socket.on("disconnect", (...args: any[]): void => {
@@ -113,15 +118,17 @@ export class Group extends __Group {
     protected terminate(): void {
         // TODO.impl notify clients?
         this.#currentGame = undefined;
-        const nsps: io.Namespace = this.namespace;
+        const nsps = this.namespace;
         nsps.removeAllListeners("connect");
         nsps.removeAllListeners("connection");
         Object.values(nsps.connected).forEach((socket) => {
-            socket.disconnect();
+            socket.disconnect(); // TODO.learn should we pass `true` here?
         });
         nsps.removeAllListeners();
         delete nsps.server.nsps[nsps.name];
+        (this.namespace as io.Namespace) = undefined!;
         (this.deleteExternalRefs)();
+        console.log(`terminated group: \`${this.name}\``);
     }
 
 
diff --git a/src/server/SnakeyServer.ts b/src/server/SnakeyServer.ts
index f6652ab5..d29555ff 100644
--- a/src/server/SnakeyServer.ts
+++ b/src/server/SnakeyServer.ts
@@ -6,7 +6,7 @@ import io       = require("socket.io");
 import type * as net from "net";
 
 import { Group } from "./Group";
-import { SkServer as __SnakeyServer } from "defs/OnlineDefs";
+import { SkServer as __SnakeyServer, SkServer } from "defs/OnlineDefs";
 
 
 /**
@@ -59,10 +59,11 @@ export class SnakeyServer extends __SnakeyServer {
 
         this.http.listen(<net.ListenOptions>{ port, host, }, (): void => {
             const info = <net.AddressInfo>this.http.address();
-            console.log(`Server mounted to: \`${info.address}${info.port}\` using ${info.family}.\n`);
-            console.log("This host can be reached at any of the following addresses:");
-            SnakeyServer.chooseIPAddress().forEach((address) => {
-                console.log(`- ${address}`);
+            console.log(`\n\nServer mounted to: \`${info.address}${info.port}\` using ${info.family}.\n`);
+            console.log("This host can be reached at any of the following addresses:\n");
+            SnakeyServer.chooseIPAddress().sort().forEach((address) => {
+                console.log(/* ${SkServer.PROTOCOL} */`${address}:${port}`);
+                // ^We can exclude the protocol since it will get defaulted by the client side.
             });
             console.log("");
         });
@@ -74,20 +75,20 @@ export class SnakeyServer extends __SnakeyServer {
     /**
      * Other sockets connected to this namespace will not be notified
      * of a newly existing group until the creator of that group has
-     * successfully connected to it. This simplifies the implementation
-     * of ensuring that we can assume that lsjdhfaklsdjhflaskdhf
+     * successfully connected to it. This allows us to know that the
+     * first socket that joins that group is its creator. (Even if a
+     * sneaky friend )
      *
      * @param socket - The socket from the game host.
      */
     protected onJoinerNspsConnection(socket: io.Socket): void {
-        console.log(`socket \`${socket.id}\` connected.`);
+        console.log(`socket    connect: ${socket.id}`);
         // Upon connection, immediately send a list of existing groups:
         socket.emit(
             Group.Exist.EVENT_NAME,
             (() => {
                 const build: Group.Query.NotifyStatus = {};
-                Array.from(this.allGroups).map((entry) => {
-                    const [groupName, group,] = entry;
+                Array.from(this.allGroups).forEach(([groupName, group,]) => {
                     build[groupName] = (group.isCurrentlyPlayingAGame)
                     ? Group.Exist.Status.IN_GAME
                     : Group.Exist.Status.IN_LOBBY;
@@ -111,20 +112,17 @@ export class SnakeyServer extends __SnakeyServer {
 
             this.allGroups.set(
                 desc.groupName,
-                new Group(
-                    this.io.of(SnakeyServer.Nsps.GROUP_LOBBY_PREFIX + desc.groupName), // <-- create a namespace.
-                    desc.passphrase,
-                    () => this.allGroups.delete(desc.groupName),
-                    Group.DEFAULT_TTL,
-                ),
+                new Group(Object.freeze({
+                    namespace:  this.io.of(SnakeyServer.Nsps.GROUP_LOBBY_PREFIX + desc.groupName),
+                    name:       desc.groupName,
+                    passphrase: desc.passphrase,
+                    deleteExternalRefs: () => this.allGroups.delete(desc.groupName),
+                    initialTtl: Group.DEFAULT_TTL,
+                })),
             );
             // Notify all sockets connected to the joiner namespace
             // of the new namespace created for the new group session:
             socket.emit(Group.Exist.EVENT_NAME, Group.Exist.RequestCreate.Response.OKAY);
-            // TODO.impl don't notify others until the creator has joined.
-            socket.broadcast.emit(Group.Exist.EVENT_NAME, {
-                [desc.groupName]: Group.Exist.Status.IN_LOBBY,
-            });
         });
     }
 }
@@ -137,11 +135,18 @@ export namespace SnakeyServer {
      * TODO: change to return a map from each of "public" and "private" to a list of addresses
      * https://en.wikipedia.org/wiki/Private_network
      */
-    export const chooseIPAddress = (): TU.RoArr<string> => {
+    export const chooseIPAddress = (): Array<string> => {
         return (Object.values(os.networkInterfaces()).flat() as os.NetworkInterfaceInfo[])
         .filter((info) => {
             return !(info.internal) /* && info.family === "IPv4" */;
-        }).map((info) => info.address);
+        })
+        .map((info) => {
+            if (info.family === "IPv6") {
+                return `[${info.address}]`;
+            } else {
+                return info.address;
+            }
+        });
     };
 }
 Object.freeze(SnakeyServer);
