gloomberb 0.15.2 → 0.15.3

package/src/plugins/builtin/cloud/device-signin.test.ts

@@ -1,217 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { AuthUser, DeviceAuthStartResponse, DeviceAuthTokenResponse } from "../../../api-client";
-import {
-  DeviceSignInController,
-  parseDeviceCodeExpiryMs,
-  type DeviceSignInPhase,
-  type DeviceSignInSnapshot,
-} from "./device-signin";
-
-const user = { id: "u1", email: "user@example.com", emailVerified: true } as AuthUser;
-
-function startResponse(overrides: Partial<DeviceAuthStartResponse> = {}): DeviceAuthStartResponse {
-  return {
-    deviceCode: "device-1",
-    userCode: "ABCD-EFGH",
-    expiresAt: new Date(Date.now() + 600_000).toISOString(),
-    verificationUri: "https://gloom.sh/link/ABCD-EFGH",
-    pollIntervalMs: 1_000,
-    ...overrides,
-  };
-}
-
-function waitForPhase(controller: DeviceSignInController, phase: DeviceSignInPhase): Promise<DeviceSignInSnapshot> {
-  return new Promise((resolve, reject) => {
-    if (controller.getSnapshot().phase === phase) {
-      resolve(controller.getSnapshot());
-      return;
-    }
-    const timeout = setTimeout(() => reject(new Error(`timed out waiting for phase ${phase}`)), 1_000);
-    const unsubscribe = controller.subscribe((snapshot) => {
-      if (snapshot.phase !== phase) return;
-      clearTimeout(timeout);
-      unsubscribe();
-      resolve(snapshot);
-    });
-  });
-}
-
-describe("DeviceSignInController", () => {
-  test("polls through pending and adopts the session on approval", async () => {
-    const polls: DeviceAuthTokenResponse[] = [
-      { status: "pending" },
-      { status: "pending" },
-      { status: "approved", sessionToken: "token-1", user },
-    ];
-    const adopted: string[] = [];
-    let pollCalls = 0;
-    const controller = new DeviceSignInController({
-      io: {
-        start: async () => startResponse(),
-        poll: async () => {
-          pollCalls += 1;
-          return polls.shift() ?? { status: "pending" };
-        },
-        adoptSession: async (sessionToken) => {
-          adopted.push(sessionToken);
-        },
-        delay: async () => {},
-      },
-    });
-
-    controller.start();
-    const snapshot = await waitForPhase(controller, "approved");
-    expect(snapshot.user).toEqual(user);
-    expect(snapshot.userCode).toBe("ABCD-EFGH");
-    expect(snapshot.verificationUri).toBe("https://gloom.sh/link/ABCD-EFGH");
-    expect(adopted).toEqual(["token-1"]);
-    expect(pollCalls).toBe(3);
-  });
-
-  test("stops on denial without adopting a session", async () => {
-    let adoptCalls = 0;
-    let pollCalls = 0;
-    const controller = new DeviceSignInController({
-      io: {
-        start: async () => startResponse(),
-        poll: async () => {
-          pollCalls += 1;
-          return { status: "denied" };
-        },
-        adoptSession: async () => {
-          adoptCalls += 1;
-        },
-        delay: async () => {},
-      },
-    });
-
-    controller.start();
-    await waitForPhase(controller, "denied");
-    expect(adoptCalls).toBe(0);
-    expect(pollCalls).toBe(1);
-  });
-
-  test("restarts with a fresh code when the server reports expiry", async () => {
-    let startCalls = 0;
-    const controller = new DeviceSignInController({
-      io: {
-        start: async () => {
-          startCalls += 1;
-          return startResponse({ deviceCode: `device-${startCalls}`, userCode: `CODE-000${startCalls}` });
-        },
-        poll: async (deviceCode) =>
-          deviceCode === "device-1"
-            ? { status: "expired" }
-            : { status: "approved", sessionToken: "token-2", user },
-        adoptSession: async () => {},
-        delay: async () => {},
-      },
-    });
-
-    controller.start();
-    const snapshot = await waitForPhase(controller, "approved");
-    expect(startCalls).toBe(2);
-    expect(snapshot.userCode).toBe("CODE-0002");
-  });
-
-  test("restarts at the local TTL even if the server never reports expiry", async () => {
-    let nowMs = 0;
-    let startCalls = 0;
-    const controller = new DeviceSignInController({
-      io: {
-        start: async () => {
-          startCalls += 1;
-          return startResponse({
-            deviceCode: `device-${startCalls}`,
-            expiresAt: startCalls === 1 ? "not-a-date" : new Date(nowMs + 600_000).toISOString(),
-          });
-        },
-        poll: async (deviceCode) =>
-          deviceCode === "device-1"
-            ? { status: "pending" }
-            : { status: "approved", sessionToken: "token-3", user },
-        adoptSession: async () => {},
-        delay: async () => {
-          nowMs += 400_000;
-        },
-        now: () => nowMs,
-      },
-    });
-
-    controller.start();
-    await waitForPhase(controller, "approved");
-    expect(startCalls).toBe(2);
-  });
-
-  test("cancel stops polling", async () => {
-    let pollCalls = 0;
-    let release: (() => void) | null = null;
-    const controller = new DeviceSignInController({
-      io: {
-        start: async () => startResponse(),
-        poll: async () => {
-          pollCalls += 1;
-          return { status: "pending" };
-        },
-        adoptSession: async () => {},
-        delay: () =>
-          new Promise((resolve) => {
-            release = resolve;
-          }),
-      },
-    });
-
-    controller.start();
-    await waitForPhase(controller, "waiting");
-    controller.cancel();
-    release!();
-    await Bun.sleep(0);
-    expect(pollCalls).toBe(0);
-    expect(controller.getSnapshot().phase).toBe("idle");
-  });
-
-  test("retries transport failures with backoff instead of crashing", async () => {
-    const delays: number[] = [];
-    let startAttempts = 0;
-    let pollAttempts = 0;
-    const controller = new DeviceSignInController({
-      io: {
-        start: async () => {
-          startAttempts += 1;
-          if (startAttempts === 1) throw new Error("offline");
-          return startResponse();
-        },
-        poll: async () => {
-          pollAttempts += 1;
-          if (pollAttempts <= 2) throw new Error("bad gateway");
-          return { status: "approved", sessionToken: "token-4", user };
-        },
-        adoptSession: async () => {},
-        delay: async (ms) => {
-          delays.push(ms);
-        },
-      },
-    });
-
-    controller.start();
-    const errored = await waitForPhase(controller, "error");
-    expect(errored.error).toBe("offline");
-    const snapshot = await waitForPhase(controller, "approved");
-    expect(snapshot.error).toBeNull();
-    expect(startAttempts).toBe(2);
-    // Start retry, then poll at the base interval with doubling on each failure.
-    expect(delays).toEqual([2_000, 1_000, 2_000, 4_000]);
-  });
-});
-
-describe("parseDeviceCodeExpiryMs", () => {
-  test("falls back to a bounded TTL for unparseable values", () => {
-    expect(parseDeviceCodeExpiryMs("not-a-date", 1_000)).toBe(601_000);
-    expect(parseDeviceCodeExpiryMs(undefined, 0)).toBe(600_000);
-  });
-
-  test("accepts ISO timestamps and epoch milliseconds", () => {
-    expect(parseDeviceCodeExpiryMs(new Date(5_000).toISOString(), 1_000)).toBe(5_000);
-    expect(parseDeviceCodeExpiryMs(5_000, 1_000)).toBe(5_000);
-  });
-});

package/src/plugins/builtin/cloud/reveal-in-scroll-box.ts

@@ -1,34 +0,0 @@
-import type { BoxRenderable, ScrollBoxRenderable } from "../../../ui";
-
-/**
- * Scrolls the least distance that brings `node` inside `scrollBox`'s viewport,
- * so the control the keyboard just moved to is on screen. The desktop measures
- * pixel rects; the terminal compares absolute cell rows with the viewport's.
- */
-export function revealInScrollBox(scrollBox: ScrollBoxRenderable | null, node: BoxRenderable | null): void {
-  if (!scrollBox || !node) return;
-  const boxRect = scrollBox.getBoundingClientRect?.();
-  const nodeRect = node.getBoundingClientRect?.();
-  if (boxRect && nodeRect && scrollBox.scrollToPixels && typeof scrollBox.scrollTopPx === "number" && scrollBox.viewportPx) {
-    const top = scrollBox.scrollTopPx + nodeRect.y - boxRect.y;
-    const bottom = top + nodeRect.height;
-    const viewport = scrollBox.viewportPx.height;
-    if (top < scrollBox.scrollTopPx) scrollBox.scrollToPixels(Math.max(0, top));
-    else if (bottom > scrollBox.scrollTopPx + viewport) scrollBox.scrollToPixels(Math.max(0, Math.min(top, bottom - viewport)));
-    return;
-  }
-  const viewport = scrollBox.viewport as { y?: unknown; height: number } | undefined;
-  if (typeof node.y !== "number" || typeof viewport?.y !== "number" || viewport.height <= 0) return;
-  const offset = node.y - viewport.y;
-  const height = Math.max(1, node.height ?? 1);
-  if (offset < 0) scrollBox.scrollTo(Math.max(0, scrollBox.scrollTop + offset));
-  else if (offset + height > viewport.height) {
-    scrollBox.scrollTo(Math.max(0, scrollBox.scrollTop + Math.min(offset, offset + height - viewport.height)));
-  }
-}
-
-/** Runs once the host has laid out the change that moved the keyboard. */
-export function afterLayout(callback: () => void): () => void {
-  const timer = setTimeout(callback, 0);
-  return () => clearTimeout(timer);
-}

package/src/plugins/builtin/cloud/team/collections.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { TeamCollection, TeamCollectionItem } from "../../../../api-client";
-import { createDefaultConfig } from "../../../../types/config";
-import type { TickerRecord } from "../../../../types/ticker";
-import {
-  applyMembership,
-  blankTickerRecord,
-  diffMembership,
-  localMembership,
-  parseCollectionRef,
-  reconcileConfigCollections,
-  teamCollectionLocalId,
-} from "./collections";
-
-function collection(overrides: Partial<TeamCollection>): TeamCollection {
-  return {
-    id: "c1",
-    teamId: "org-1",
-    kind: "watchlist",
-    name: "Rates names",
-    currency: null,
-    createdBy: "u1",
-    createdAt: "2026-09-14T12:00:00.000Z",
-    updatedAt: "2026-09-14T12:00:00.000Z",
-    itemCount: 0,
-    ...overrides,
-  };
-}
-
-function item(symbol: string, quantity: number | null = null): TeamCollectionItem {
-  return {
-    collectionId: "c1",
-    symbol,
-    exchange: "",
-    quantity,
-    note: null,
-    addedBy: "u1",
-    addedAt: "2026-09-14T12:00:00.000Z",
-    updatedAt: "2026-09-14T12:00:00.000Z",
-  };
-}
-
-describe("scoped collection references", () => {
-  test("bare ids are personal, team ids carry the team", () => {
-    expect(parseCollectionRef("main")).toEqual({ scope: "user", id: "main" });
-    expect(parseCollectionRef(teamCollectionLocalId("org-1", "c1"))).toEqual({ scope: "team", teamId: "org-1", id: "c1" });
-    expect(parseCollectionRef("team:broken")).toEqual({ scope: "user", id: "team:broken" });
-    expect(parseCollectionRef("team:org-1:")).toEqual({ scope: "user", id: "team:org-1:" });
-  });
-});
-
-describe("reconcileConfigCollections", () => {
-  test("replaces a team's entries and leaves personal and other teams alone", () => {
-    const config = {
-      ...createDefaultConfig("/tmp/gloomberb-team-collections"),
-      watchlists: [
-        { id: "mine", name: "Mine" },
-        { id: teamCollectionLocalId("org-2", "x"), name: "Other team", teamId: "org-2" },
-        { id: teamCollectionLocalId("org-1", "stale"), name: "Stale", teamId: "org-1" },
-      ],
-      portfolios: [{ id: "main", name: "Main", currency: "USD" }],
-    };
-    const next = reconcileConfigCollections(config, ["org-1"], [
-      collection({ id: "c1", name: "Rates names" }),
-      collection({ id: "c2", kind: "portfolio", name: "Paper book", currency: "EUR" }),
-    ]);
-    expect(next.watchlists).toEqual([
-      { id: "mine", name: "Mine" },
-      { id: "team:org-2:x", name: "Other team", teamId: "org-2" },
-      { id: "team:org-1:c1", name: "Rates names", teamId: "org-1" },
-    ]);
-    expect(next.portfolios).toEqual([
-      { id: "main", name: "Main", currency: "USD" },
-      { id: "team:org-1:c2", name: "Paper book", currency: "EUR", teamId: "org-1" },
-    ]);
-    expect(reconcileConfigCollections(next, ["org-1"], [
-      collection({ id: "c1", name: "Rates names" }),
-      collection({ id: "c2", kind: "portfolio", name: "Paper book", currency: "EUR" }),
-    ])).toBe(next);
-  });
-});
-
-describe("membership", () => {
-  const localId = teamCollectionLocalId("org-1", "c1");
-  const aapl: TickerRecord = blankTickerRecord("AAPL", "NASDAQ", "USD");
-
-  test("applies watchlist adds and removes only when something changes", () => {
-    const added = applyMembership(aapl, localId, "watchlist", item("AAPL"), "USD");
-    expect(added?.metadata.watchlists).toEqual([localId]);
-    expect(applyMembership(added!, localId, "watchlist", item("AAPL"), "USD")).toBeNull();
-    const removed = applyMembership(added!, localId, "watchlist", null, "USD");
-    expect(removed?.metadata.watchlists).toEqual([]);
-    expect(applyMembership(aapl, localId, "watchlist", null, "USD")).toBeNull();
-  });
-
-  test("paper portfolio items carry a manual position with the quantity", () => {
-    const added = applyMembership(aapl, localId, "portfolio", item("AAPL", 10), "EUR");
-    expect(added?.metadata.portfolios).toEqual([localId]);
-    expect(added?.metadata.positions).toEqual([
-      { portfolio: localId, shares: 10, avgCost: 0, currency: "EUR", broker: "manual" },
-    ]);
-    const updated = applyMembership(added!, localId, "portfolio", item("AAPL", 12), "EUR");
-    expect(updated?.metadata.positions[0]?.shares).toBe(12);
-    expect(applyMembership(updated!, localId, "portfolio", item("AAPL", 12), "EUR")).toBeNull();
-    const cleared = applyMembership(updated!, localId, "portfolio", null, "EUR");
-    expect(cleared?.metadata.portfolios).toEqual([]);
-    expect(cleared?.metadata.positions).toEqual([]);
-  });
-
-  test("reads local membership and diffs it against the known server set", () => {
-    const inList = applyMembership(aapl, localId, "portfolio", item("AAPL", 10), "USD")!;
-    const msft = applyMembership(blankTickerRecord("MSFT", "", "USD"), localId, "portfolio", item("MSFT", 3), "USD")!;
-    const tickers = new Map<string, TickerRecord>([["AAPL", inList], ["MSFT", msft], ["TSLA", blankTickerRecord("TSLA", "", "USD")]]);
-    const local = localMembership(tickers, localId, "portfolio");
-    expect([...local.keys()]).toEqual(["AAPL", "MSFT"]);
-    expect(local.get("AAPL")?.quantity).toBe(10);
-
-    const known = new Map([["AAPL", item("AAPL", 10)], ["NVDA", item("NVDA", 1)]]);
-    expect(diffMembership(local, known)).toEqual({
-      add: [{ symbol: "MSFT", quantity: 3 }],
-      remove: ["NVDA"],
-    });
-    const knownStale = new Map([["AAPL", item("AAPL", 8)]]);
-    expect(diffMembership(local, knownStale).add.map((entry) => entry.symbol)).toEqual(["AAPL", "MSFT"]);
-  });
-});

package/src/plugins/builtin/cloud/team/model.test.ts

@@ -1,174 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { TeamNotification, TeamSummary } from "../../../../api-client";
-import {
-  canInviteToTeam,
-  canManageTeam,
-  countTeamUpdates,
-  deriveTeamShortName,
-  describeExpiry,
-  describeTeamNotification,
-  findTeam,
-  isTeamChannelId,
-  normalizeTeamChannelName,
-  normalizeTeamShortName,
-  sortTeamChannels,
-  teamChannelId,
-  teamIdFromChannelId,
-  teamLabel,
-  teamPrefix,
-} from "./model";
-
-function team(overrides: Partial<TeamSummary>): TeamSummary {
-  return {
-    id: "org-1",
-    name: "Macro Desk",
-    slug: "macro-desk-abc123",
-    accentColor: "magenta",
-    shortName: "MD",
-    allowMemberInvites: false,
-    channelId: "team:org-1",
-    createdAt: "2026-09-14T12:00:00.000Z",
-    role: "member",
-    memberCount: 3,
-    ...overrides,
-  };
-}
-
-describe("team markers", () => {
-  test("prefix and label use the short name", () => {
-    expect(teamPrefix(team({}))).toBe("MD·");
-    expect(teamLabel(team({}))).toBe("MD· Macro Desk");
-  });
-
-  test("channel ids round-trip", () => {
-    expect(teamChannelId("org-1")).toBe("team:org-1");
-    expect(teamIdFromChannelId("team:org-1")).toBe("org-1");
-    expect(teamIdFromChannelId("everyone")).toBeNull();
-    expect(teamIdFromChannelId("team:")).toBeNull();
-  });
-});
-
-describe("roles", () => {
-  test("owners and admins manage; members invite only when allowed", () => {
-    expect(canManageTeam("owner")).toBe(true);
-    expect(canManageTeam("admin")).toBe(true);
-    expect(canManageTeam("member")).toBe(false);
-    expect(canInviteToTeam(team({ role: "member" }))).toBe(false);
-    expect(canInviteToTeam(team({ role: "member", allowMemberInvites: true }))).toBe(true);
-    expect(canInviteToTeam(team({ role: "admin" }))).toBe(true);
-  });
-});
-
-describe("findTeam", () => {
-  const teams = [
-    team({ id: "a", name: "Macro Desk", shortName: "MD", slug: "macro-desk-1" }),
-    team({ id: "b", name: "Rates", shortName: "RT", slug: "rates-2" }),
-    team({ id: "c", name: "Rates Desk", shortName: "RD", slug: "rates-desk-3" }),
-  ];
-
-  test("matches id, short name, slug, and name exactly, ignoring case and markers", () => {
-    expect(findTeam(teams, "a")?.id).toBe("a");
-    expect(findTeam(teams, "md")?.id).toBe("a");
-    expect(findTeam(teams, "MD·")?.id).toBe("a");
-    expect(findTeam(teams, "#rates-2")?.id).toBe("b");
-    expect(findTeam(teams, "rates desk")?.id).toBe("c");
-  });
-
-  test("exact wins over prefix and ambiguous prefixes return nothing", () => {
-    expect(findTeam(teams, "rates")?.id).toBe("b");
-    expect(findTeam(teams, "rat")).toBeNull();
-    expect(findTeam(teams, "mac")?.id).toBe("a");
-    expect(findTeam(teams, "")).toBeNull();
-    expect(findTeam(teams, "nothing")).toBeNull();
-  });
-});
-
-describe("notifications", () => {
-  const base = { id: "n1", channelId: "team:org-1", createdAt: "2026-09-14T12:00:00.000Z" };
-  const teamCard = { id: "org-1", name: "Macro Desk", accentColor: "magenta" as const, shortName: "MD" };
-
-  test("describes each kind for a toast", () => {
-    const invite: TeamNotification = {
-      ...base,
-      type: "team-invite",
-      data: {
-        kind: "team-invite",
-        team: teamCard,
-        invitationId: "inv-1",
-        expiresAt: "2026-09-21T12:00:00.000Z",
-        inviter: { id: "u1", username: "vince", displayName: "Vince" },
-      },
-    };
-    expect(describeTeamNotification(invite)).toEqual({
-      title: "MD· Macro Desk",
-      body: "@vince invited you to Macro Desk. Run TEAM to accept.",
-    });
-
-    const joined: TeamNotification = {
-      ...base,
-      id: "n2",
-      type: "team-joined",
-      data: { kind: "team-joined", team: teamCard, member: { id: "u2", username: null, displayName: "Bob Jones" } },
-    };
-    expect(describeTeamNotification(joined).body).toBe("Bob Jones joined Macro Desk.");
-
-    const layout: TeamNotification = {
-      ...base,
-      id: "n3",
-      type: "layout-updated",
-      data: {
-        kind: "layout-updated",
-        team: teamCard,
-        layoutId: "l1",
-        layoutName: "Morning",
-        revision: 4,
-        author: { id: "u1", username: "vince", displayName: "Vince" },
-      },
-    };
-    expect(describeTeamNotification(layout).body).toBe("@vince published Morning r4.");
-    expect(countTeamUpdates([invite, joined, layout])).toEqual(new Map([["org-1", 3]]));
-  });
-});
-
-describe("team channels and names", () => {
-  test("channel ids carry the team id, with or without a channel name", () => {
-    expect(teamChannelId("org-1")).toBe("team:org-1");
-    expect(teamChannelId("org-1", "general")).toBe("team:org-1");
-    expect(teamChannelId("org-1", "trades")).toBe("team:org-1:trades");
-    expect(teamIdFromChannelId("team:org-1:trades")).toBe("org-1");
-    expect(teamIdFromChannelId("team:org-1")).toBe("org-1");
-    expect(teamIdFromChannelId("everyone")).toBeNull();
-    expect(isTeamChannelId("team:x")).toBe(true);
-  });
-
-  test("#general leads, the rest sort by name", () => {
-    const sorted = sortTeamChannels([
-      { id: "team:o:zeta", name: "zeta" },
-      { id: "team:o:alpha", name: "alpha" },
-      { id: "team:o", name: "general" },
-    ]);
-    expect(sorted.map((channel) => channel.name)).toEqual(["general", "alpha", "zeta"]);
-  });
-
-  test("channel names normalize the way the server keeps them", () => {
-    expect(normalizeTeamChannelName("Earnings Season")).toBe("earnings-season");
-    expect(normalizeTeamChannelName("#Trades")).toBe("trades");
-    expect(normalizeTeamChannelName("!!!")).toBe("");
-  });
-
-  test("short names derive like the server: initials or the first three letters", () => {
-    expect(deriveTeamShortName("Macro Desk")).toBe("MD");
-    expect(deriveTeamShortName("Options")).toBe("OPT");
-    expect(deriveTeamShortName("a b c d e")).toBe("ABCD");
-    expect(deriveTeamShortName("!!!")).toBe("TM");
-    expect(normalizeTeamShortName("m-d x1")).toBe("MDX1");
-  });
-
-  test("expiry reads as a short relative time", () => {
-    const now = Date.parse("2026-09-15T12:00:00.000Z");
-    expect(describeExpiry("2026-09-21T12:00:00.000Z", now)).toBe("in 6d");
-    expect(describeExpiry("2026-09-15T20:00:00.000Z", now)).toBe("in 8h");
-    expect(describeExpiry("2026-09-15T12:10:00.000Z", now)).toBe("in minutes");
-    expect(describeExpiry("2026-09-14T12:00:00.000Z", now)).toBe("expired");
-  });
-});

package/src/plugins/builtin/cloud/team/pane-model.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { TeamMember, TeamSummary } from "../../../../api-client";
-import {
-  cycleAccent,
-  draftChanges,
-  draftFromTeam,
-  draftProblem,
-  emptyTeamDraft,
-  nextFieldId,
-  nextNonTextFieldId,
-  restingFieldId,
-  sectionFieldIds,
-  setDraftName,
-  setDraftShortName,
-} from "./pane-model";
-
-const team: TeamSummary = {
-  id: "org-1",
-  name: "Macro Desk",
-  slug: "macro-desk",
-  accentColor: "magenta",
-  shortName: "MD",
-  allowMemberInvites: false,
-  channelId: "team:org-1",
-  createdAt: "2026-09-14T12:00:00.000Z",
-  role: "owner",
-  memberCount: 3,
-};
-
-const members: TeamMember[] = [
-  { id: "m-1", role: "owner", joinedAt: "", user: { id: "u0", username: "vince", displayName: "Vince" } },
-  { id: "m-2", role: "admin", joinedAt: "", user: { id: "u2", username: "lucas", displayName: "Lucas" } },
-  { id: "m-3", role: "member", joinedAt: "", user: { id: "u3", username: "mika", displayName: "Mika" } },
-];
-
-describe("team draft", () => {
-  test("the short name follows the name until edited by hand", () => {
-    let draft = emptyTeamDraft(0);
-    draft = setDraftName(draft, "Rates Desk");
-    expect(draft.shortName).toBe("RD");
-    draft = setDraftName(draft, "Options");
-    expect(draft.shortName).toBe("OPT");
-    draft = setDraftShortName(draft, "op-x!");
-    expect(draft.shortName).toBe("OPX");
-    draft = setDraftName(draft, "Something Else");
-    expect(draft.shortName).toBe("OPX");
-    draft = setDraftShortName(draft, "");
-    draft = setDraftName(draft, "Back To Auto");
-    expect(draft.shortName).toBe("BTA");
-  });
-
-  test("problems and changes", () => {
-    expect(draftProblem(emptyTeamDraft(0))).toBe("Give the team a name.");
-    const draft = draftFromTeam(team);
-    expect(draftProblem(draft)).toBeNull();
-    expect(draftChanges(team, draft)).toEqual({});
-    expect(draftChanges(team, { ...draft, name: "Macro Desk ", accentColor: "blue" })).toEqual({ accentColor: "blue" });
-    expect(draftChanges(team, { ...draft, allowMemberInvites: true, shortName: "MX" })).toEqual({
-      allowMemberInvites: true,
-      shortName: "MX",
-    });
-  });
-
-  test("accent cycles around the palette", () => {
-    expect(cycleAccent("amber", -1)).toBe("violet");
-    expect(cycleAccent("violet", 1)).toBe("amber");
-    expect(cycleAccent("blue", 1)).toBe("cyan");
-  });
-});
-
-describe("keyboard ring", () => {
-  const base = { team, members, invitationIds: ["inv-1"], linkTokens: ["tok"], channelIds: ["team:org-1", "team:org-1:trades"], selfUserId: "u0" };
-
-  test("owners reach every control; members only what they may use", () => {
-    expect(sectionFieldIds({ ...base, section: "members" })).toEqual(["role:m-2", "remove:m-2", "role:m-3", "remove:m-3"]);
-    expect(sectionFieldIds({ ...base, section: "invites" })).toEqual([
-      "invite-username", "invite-send", "cancel-invitation:inv-1", "new-link", "copy-link:tok", "revoke-link:tok",
-    ]);
-    expect(sectionFieldIds({ ...base, section: "channels" })).toEqual([
-      "open-channel:team:org-1", "open-channel:team:org-1:trades", "delete-channel:team:org-1:trades", "channel-name", "channel-create",
-    ]);
-    expect(sectionFieldIds({ ...base, section: "settings" })).toEqual(["name", "shortName", "accent", "allowMemberInvites", "save", "delete"]);
-
-    const member = { ...base, team: { ...team, role: "member" as const } };
-    expect(sectionFieldIds({ ...member, section: "members" })).toEqual([]);
-    expect(sectionFieldIds({ ...member, section: "invites" })).toEqual([]);
-    expect(sectionFieldIds({ ...member, team: { ...member.team, allowMemberInvites: true }, section: "invites" })).toEqual([
-      "new-link", "copy-link:tok", "revoke-link:tok",
-    ]);
-    expect(sectionFieldIds({ ...member, section: "settings" })).toEqual(["leave"]);
-    expect(sectionFieldIds({ ...base, section: "create", team: null })).toEqual(["name", "shortName", "accent", "create"]);
-  });
-
-  test("an invitation's answers lead the ring, which never rests in a text field outside the create form", () => {
-    const invited = sectionFieldIds({ ...base, section: "create", team: null, receivedInvitationIds: ["inv-9"] });
-    expect(invited.slice(0, 3)).toEqual(["accept:inv-9", "decline:inv-9", "name"]);
-    expect(restingFieldId(invited, true)).toBe("accept:inv-9");
-    expect(restingFieldId(sectionFieldIds({ ...base, section: "create", team: null }), true)).toBe("name");
-    expect(restingFieldId(sectionFieldIds({ ...base, section: "invites" }), false)).toBeNull();
-    expect(restingFieldId(sectionFieldIds({ ...base, section: "members" }), false)).toBe("role:m-2");
-    const settings = sectionFieldIds({ ...base, section: "settings" });
-    expect(nextNonTextFieldId(settings, "name")).toBe("accent");
-    expect(nextNonTextFieldId(settings, "shortName")).toBe("accent");
-  });
-
-  test("walks the ring in both directions and wraps", () => {
-    const ids = ["a", "b", "c"];
-    expect(nextFieldId(ids, null, 1)).toBe("a");
-    expect(nextFieldId(ids, null, -1)).toBe("c");
-    expect(nextFieldId(ids, "c", 1)).toBe("a");
-    expect(nextFieldId(ids, "a", -1)).toBe("c");
-    expect(nextFieldId([], "a", 1)).toBeNull();
-  });
-});