Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

143 KB
Raw Blame
// @vitest-environment happy-dom

import { CalendarDateTime, resetLocalTimeZone, setLocalTimeZone } from "@internationalized/date";
import { createApp, defineComponent, h, KeepAlive, nextTick, ref, type ComponentPublicInstance } from "vue";
import { createI18n } from "vue-i18n";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { calendarDateTimeToUnixSeconds } from "@/components/ui/date-time-picker/dateTimePicker";
import type { RedisKeyInfo } from "@/lib/backend/api";

const mocks = vi.hoisted(() => ({
  redisScanKeysBatch: vi.fn(),
  redisScanValues: vi.fn(),
  redisKeyFilter: "",
  renamedKeyName: "",
  redisGetValue: vi.fn(),
  redisSetString: vi.fn(),
  redisJsonSet: vi.fn(),
  redisHashSet: vi.fn(),
  redisListPush: vi.fn(),
  redisSetAdd: vi.fn(),
  redisZadd: vi.fn(),
  redisStreamAdd: vi.fn(),
  redisSetTtl: vi.fn(),
  redisSetExpireAt: vi.fn(),
  redisSetKeysTtl: vi.fn(),
  redisSetKeysExpireAt: vi.fn(),
  redisCheckJsonModule: vi.fn(),
  redisDeleteKey: vi.fn(),
  redisDeleteKeys: vi.fn(),
  redisDeleteKeysByPattern: vi.fn(),
  redisExecuteCommand: vi.fn(),
  saveHistory: vi.fn(),
  canBuildRedisFuzzyTree: vi.fn((loadedKeyCount: number) => loadedKeyCount <= 200_000),
  buildRedisKeySnapshotCooperatively: vi.fn(),
  createRedisKeyTreeIndex: vi.fn(),
  flattenVisibleRedisKeyTree: vi.fn(),
  scrollerUpdateVisibleItems: vi.fn(),
  scrollerScrollToItem: vi.fn(),
  scrollerCallOrder: [] as string[],
  scrollerVisiblePositions: [] as number[],
  scrollerRefreshSnapshots: [] as Array<{ length: number; ids: Array<string | undefined>; hasHoles: boolean }>,
  scrollerItems: [] as unknown[][],
  scrollerVisibleStartIndex: 0,
  toast: vi.fn(),
  updateRedisDbKeyStats: vi.fn(),
  listRedisCompletionCommandDocs: vi.fn(),
  listRedisCompletionKeys: vi.fn(),
  redisScanPageSize: 100,
  infiniteScroll: false,
  queryResultMaxRowsEnabled: true,
  queryResultMaxRows: 5000,
  loadedTtl: -1,
  loadedKeyMissing: false,
}));

vi.mock("@/lib/backend/api", () => ({
  redisScanKeysBatch: mocks.redisScanKeysBatch,
  redisScanValues: mocks.redisScanValues,
  redisGetValue: mocks.redisGetValue,
  redisSetString: mocks.redisSetString,
  redisJsonSet: mocks.redisJsonSet,
  redisHashSet: mocks.redisHashSet,
  redisListPush: mocks.redisListPush,
  redisSetAdd: mocks.redisSetAdd,
  redisZadd: mocks.redisZadd,
  redisStreamAdd: mocks.redisStreamAdd,
  redisSetTtl: mocks.redisSetTtl,
  redisSetExpireAt: mocks.redisSetExpireAt,
  redisSetKeysTtl: mocks.redisSetKeysTtl,
  redisSetKeysExpireAt: mocks.redisSetKeysExpireAt,
  redisCheckJsonModule: mocks.redisCheckJsonModule,
  redisDeleteKey: mocks.redisDeleteKey,
  redisDeleteKeys: mocks.redisDeleteKeys,
  redisDeleteKeysByPattern: mocks.redisDeleteKeysByPattern,
  redisExecuteCommand: mocks.redisExecuteCommand,
  saveHistory: mocks.saveHistory,
}));

vi.mock("@/lib/redis/redisKeyTree", async (importOriginal) => {
  const actual = await importOriginal<typeof import("@/lib/redis/redisKeyTree")>();
  mocks.createRedisKeyTreeIndex.mockImplementation(actual.createRedisKeyTreeIndex);
  mocks.flattenVisibleRedisKeyTree.mockImplementation(actual.flattenVisibleRedisKeyTree);
  mocks.buildRedisKeySnapshotCooperatively.mockImplementation(actual.buildRedisKeySnapshotCooperatively);
  return {
    ...actual,
    canBuildRedisFuzzyTree: mocks.canBuildRedisFuzzyTree,
    buildRedisKeySnapshotCooperatively: mocks.buildRedisKeySnapshotCooperatively,
    createRedisKeyTreeIndex: mocks.createRedisKeyTreeIndex,
    flattenVisibleRedisKeyTree: mocks.flattenVisibleRedisKeyTree,
  };
});

vi.mock("@/stores/connectionStore", () => ({
  useConnectionStore: () => ({
    ensureConnected: vi.fn().mockResolvedValue(undefined),
    getConfig: () => ({ name: "Redis", redis_key_filter: mocks.redisKeyFilter, redis_key_separator: ":", redis_scan_page_size: mocks.redisScanPageSize }),
    updateRedisDbKeyStats: mocks.updateRedisDbKeyStats,
    listRedisCompletionCommandDocs: mocks.listRedisCompletionCommandDocs,
    listRedisCompletionKeys: mocks.listRedisCompletionKeys,
    invalidateCompletionCache: vi.fn(),
    refreshRedisDbKeyCounts: vi.fn(),
  }),
}));

vi.mock("@/stores/settingsStore", () => ({
  useSettingsStore: () => ({
    editorSettings: {
      infiniteScroll: mocks.infiniteScroll,
      queryResultMaxRowsEnabled: mocks.queryResultMaxRowsEnabled,
      queryResultMaxRows: mocks.queryResultMaxRows,
    },
  }),
}));

vi.mock("@/composables/useEditorFontFamilyStyle", () => ({
  useEditorFontFamilyStyle: () => ({}),
}));

vi.mock("@/composables/useToast", () => ({
  useToast: () => ({ toast: mocks.toast }),
}));

vi.mock("@/components/ui/button", async () => {
  const { defineComponent, h } = await import("vue");
  return {
    Button: defineComponent({
      inheritAttrs: false,
      props: { disabled: Boolean },
      setup(props, { attrs, slots }) {
        return () => h("button", { ...attrs, disabled: props.disabled }, slots.default?.());
      },
    }),
  };
});

vi.mock("@/components/ui/input", async () => {
  const { defineComponent, h, mergeProps } = await import("vue");
  return {
    Input: defineComponent({
      inheritAttrs: false,
      props: { modelValue: String, disabled: Boolean },
      emits: ["update:modelValue"],
      setup(props, { attrs, emit }) {
        return () =>
          h(
            "input",
            mergeProps(attrs, {
              value: props.modelValue ?? "",
              disabled: props.disabled,
              onInput: (event: Event) => emit("update:modelValue", (event.target as HTMLInputElement).value),
            }),
          );
      },
    }),
  };
});

vi.mock("@/components/ui/badge", async () => {
  const { defineComponent, h } = await import("vue");
  return {
    Badge: defineComponent({
      setup:
        (_, { attrs, slots }) =>
        () =>
          h("span", attrs, slots.default?.()),
    }),
  };
});

vi.mock("@/components/ui/dialog", async () => {
  const { defineComponent, h } = await import("vue");
  const slotContainer = defineComponent({
    setup:
      (_, { attrs, slots }) =>
      () =>
        h("div", attrs, slots.default?.()),
  });
  return {
    Dialog: defineComponent({
      props: { open: Boolean },
      setup(props, { slots }) {
        return () => (props.open ? h("div", { "data-test-dialog": "" }, slots.default?.()) : null);
      },
    }),
    DialogContent: slotContainer,
    DialogFooter: slotContainer,
    DialogHeader: slotContainer,
    DialogTitle: slotContainer,
  };
});

vi.mock("@/components/ui/select", async () => {
  const { defineComponent, h } = await import("vue");
  type SelectRoot = HTMLElement & { selectTestValue?: (value: string) => void };
  const slotContainer = defineComponent({
    setup:
      (_, { attrs, slots }) =>
      () =>
        h("div", attrs, slots.default?.()),
  });
  return {
    Select: defineComponent({
      inheritAttrs: false,
      props: { modelValue: String, disabled: Boolean },
      emits: ["update:modelValue", "update:open"],
      setup(props, { emit, slots }) {
        const selectValue = (value: string) => {
          if (!props.disabled) emit("update:modelValue", value);
        };
        return () =>
          h(
            "div",
            {
              "data-test-select-root": "",
              ref: (element: Element | ComponentPublicInstance | null) => {
                if (element instanceof HTMLElement) (element as SelectRoot).selectTestValue = selectValue;
              },
            },
            slots.default?.(),
          );
      },
    }),
    SelectContent: slotContainer,
    SelectItem: defineComponent({
      props: { value: String },
      setup(props, { slots }) {
        return () => h("button", { type: "button", "data-test-select-value": props.value }, slots.default?.());
      },
    }),
    SelectTrigger: slotContainer,
    SelectValue: slotContainer,
  };
});

vi.mock("@/components/ui/option-help-panel", async () => {
  const { defineComponent, h } = await import("vue");
  return { OptionHelpPanel: defineComponent({ setup: () => () => h("div") }) };
});

vi.mock("@/components/ui/tabs", async () => {
  const { defineComponent, h } = await import("vue");
  const slotContainer = defineComponent({
    setup:
      (_, { attrs, slots }) =>
      () =>
        h("div", attrs, slots.default?.()),
  });
  return { Tabs: slotContainer, TabsContent: slotContainer, TabsList: slotContainer, TabsTrigger: slotContainer };
});

vi.mock("@/components/ui/switch", async () => {
  const { defineComponent, h } = await import("vue");
  return { Switch: defineComponent({ setup: () => () => h("button", { type: "button" }) }) };
});

vi.mock("@/components/ui/date-time-picker/DateTimePicker.vue", async () => {
  const { CalendarDateTime } = await import("@internationalized/date");
  const { defineComponent, h } = await import("vue");
  return {
    default: defineComponent({
      props: { disabled: Boolean },
      emits: ["update:modelValue"],
      setup(props, { emit }) {
        return () =>
          h(
            "button",
            {
              type: "button",
              disabled: props.disabled,
              "data-test-absolute-date": "",
              onClick: () => emit("update:modelValue", new CalendarDateTime(2030, 1, 2, 3, 4, 5)),
            },
            "Set date",
          );
      },
    }),
  };
});

vi.mock("@/components/ui/CustomContextMenu.vue", async () => {
  const { defineComponent, h } = await import("vue");
  return {
    default: defineComponent({
      setup(_, { slots }) {
        return () => h("div", slots.default?.({ onContextMenu: () => undefined }));
      },
    }),
  };
});

vi.mock("@/components/editor/DangerConfirmDialog.vue", async () => {
  const { defineComponent, h } = await import("vue");
  return {
    default: defineComponent({
      props: { open: Boolean, loading: Boolean, details: String, detailsText: String, sql: String },
      emits: ["confirm"],
      setup(props, { emit }) {
        return () =>
          props.open
            ? h("div", { "data-test-danger-dialog": "" }, [
                h("div", { "data-test-danger-details": "" }, props.detailsText ?? props.details),
                h("div", { "data-test-danger-sql": "" }, props.sql),
                h(
                  "button",
                  {
                    type: "button",
                    disabled: props.loading,
                    "data-test-danger-confirm": "",
                    onClick: () => emit("confirm"),
                  },
                  "Confirm",
                ),
              ])
            : null;
      },
    }),
  };
});

vi.mock("./RedisValueViewer.vue", async () => {
  const { defineComponent, h } = await import("vue");
  return {
    default: defineComponent({
      props: { keyDisplay: String, keyRaw: String },
      emits: ["loaded", "renamed", "deleted"],
      setup(props, { emit }) {
        return () =>
          h("div", [
            h("button", {
              "data-test-emit-key-loaded": "",
              onClick: () =>
                emit("loaded", {
                  key_display: props.keyDisplay,
                  key_raw: props.keyRaw,
                  ttl: mocks.loadedTtl,
                  redis_type: mocks.loadedKeyMissing ? "none" : "hash",
                  data: { kind: "hash", items: [] },
                }),
            }),
            h("button", {
              "data-test-emit-key-renamed": "",
              onClick: () => emit("renamed", props.keyRaw, btoa(mocks.renamedKeyName), mocks.renamedKeyName),
            }),
            h("button", {
              "data-test-emit-key-deleted": "",
              onClick: () => emit("deleted", props.keyRaw),
            }),
          ]);
      },
    }),
  };
});

vi.mock("./RedisPubSubPanel.vue", async () => {
  const { defineComponent, h } = await import("vue");
  return { default: defineComponent({ setup: () => () => h("div") }) };
});

vi.mock("./RedisSlowlogPanel.vue", async () => {
  const { defineComponent, h } = await import("vue");
  return { default: defineComponent({ setup: () => () => h("div") }) };
});

vi.mock("vue-virtual-scroller", async () => {
  const { defineComponent, h, shallowRef, watch } = await import("vue");
  return {
    RecycleScroller: defineComponent({
      inheritAttrs: false,
      props: { items: { type: Array, default: () => [] } },
      setup(props, { attrs, slots, expose }) {
        // Mirror the real scroller: interaction tests should render a viewport,
        // not every row in a deliberately large result set.
        const visibleItemCount = 50;
        let layoutItemCount = props.items.length;
        const renderedItems = shallowRef<unknown[]>([]);
        const bindVisibleItems = () => {
          renderedItems.value = props.items.slice(mocks.scrollerVisibleStartIndex, mocks.scrollerVisibleStartIndex + visibleItemCount);
        };
        watch(() => props.items, bindVisibleItems, { immediate: true });
        expose({
          updateVisibleItems: (itemsChanged?: boolean) => {
            mocks.scrollerUpdateVisibleItems(itemsChanged);
            mocks.scrollerCallOrder.push(`update:${(props.items[mocks.scrollerVisibleStartIndex] as { id?: string } | undefined)?.id ?? "missing"}`);
            const viewportItems = props.items.slice(mocks.scrollerVisibleStartIndex, mocks.scrollerVisibleStartIndex + visibleItemCount) as Array<{ id?: string } | undefined>;
            mocks.scrollerRefreshSnapshots.push({
              length: props.items.length,
              ids: Array.from(viewportItems, (item) => item?.id),
              hasHoles: Array.from(viewportItems).some((item) => item === undefined),
            });
            // The real scroller keeps a keyed view pool when false. Rebind only
            // when callers identify in-place item changes explicitly.
            if (itemsChanged) bindVisibleItems();
            layoutItemCount = props.items.length;
          },
          getScroll: () => ({ start: mocks.scrollerVisibleStartIndex * 30, end: (mocks.scrollerVisibleStartIndex + visibleItemCount) * 30 }),
          findItemIndex: (offset: number) => Math.floor(offset / 30),
          scrollToItem: (index: number, options?: { align?: string }) => {
            mocks.scrollerScrollToItem(index, options);
            mocks.scrollerCallOrder.push(`scroll:${(props.items[index] as { id?: string } | undefined)?.id ?? "missing"}`);
            // A browser clamps scrollTop to the currently rendered spacer.
            // The scroller's reactive total size reaches the DOM only after
            // updateVisibleItems, so model that old-layout constraint here.
            mocks.scrollerVisibleStartIndex = Math.min(index, Math.max(0, layoutItemCount - 1));
            mocks.scrollerVisiblePositions.push(mocks.scrollerVisibleStartIndex);
            bindVisibleItems();
          },
        });
        return () => {
          mocks.scrollerItems.push(props.items as unknown[]);
          return h(
            "div",
            attrs,
            renderedItems.value.map((item) => slots.default?.({ item })),
          );
        };
      },
    }),
  };
});

vi.mock("splitpanes", async () => {
  const { defineComponent, h } = await import("vue");
  const slotContainer = defineComponent({
    setup:
      (_, { attrs, slots }) =>
      () =>
        h("div", attrs, slots.default?.()),
  });
  return { Splitpanes: slotContainer, Pane: slotContainer };
});

import RedisKeyBrowser from "./RedisKeyBrowser.vue";

const KEY_NAME = "new-key";
const KEY_RAW = "bmV3LWtleQ==";
const mountedApps: Array<{ unmount: () => void; host: HTMLElement }> = [];

type CreateType = "string" | "hash" | "list" | "set" | "zset" | "stream" | "json";
type TestSelectRoot = HTMLElement & { selectTestValue?: (value: string) => void };
function redisValue(keyRaw = KEY_RAW) {
  return {
    key_display: KEY_NAME,
    key_raw: keyRaw,
    ttl: 90,
    redis_type: "string" as const,
    data: { kind: "string" as const, content: { raw_base64: "dmFsdWU=", encoding: "utf8" as const } },
  };
}

function redisKeyInfo(keyType = "json") {
  return { key_display: KEY_NAME, key_raw: KEY_RAW, key_type: keyType, ttl: 90, size: 7, value_preview: "{}" };
}

function redisFlatRow(id: string, label: string, keyRaw = id) {
  return {
    id,
    depth: 0,
    node: {
      kind: "leaf" as const,
      id,
      label,
      fullKeyDisplay: label,
      keyRaw,
      db: 0,
      keyType: "string",
      ttl: -1,
      size: 0,
      valuePreview: "",
      pathSegments: [label],
    },
  };
}

const completionCommands = [
  { name: "GET", group: "string", arity: 2, keySpecs: [{ beginSearch: { type: "index" as const, index: 1 }, findKeys: { type: "range" as const, lastKey: 0, keyStep: 1, limit: 0 } }] },
  { name: "GETEX", group: "string", arity: -2, keySpecs: [{ beginSearch: { type: "index" as const, index: 1 }, findKeys: { type: "range" as const, lastKey: 0, keyStep: 1, limit: 0 } }] },
  { name: "GETSET", group: "string", arity: 3, keySpecs: [{ beginSearch: { type: "index" as const, index: 1 }, findKeys: { type: "range" as const, lastKey: 0, keyStep: 1, limit: 0 } }] },
  { name: "PING", group: "connection", arity: -1, keySpecs: [] },
  { name: "SET", group: "string", arity: -3, keySpecs: [{ beginSearch: { type: "index" as const, index: 1 }, findKeys: { type: "range" as const, lastKey: 0, keyStep: 1, limit: 0 } }] },
  { name: "VGET", group: "string", arity: 2, summary: "Reads a vendor key.", keySpecs: [{ beginSearch: { type: "index" as const, index: 1 }, findKeys: { type: "range" as const, lastKey: 0, keyStep: 1, limit: 0 } }] },
];

function deferred<T>() {
  let resolve!: (value: T) => void;
  let reject!: (reason?: unknown) => void;
  const promise = new Promise<T>((next, fail) => {
    resolve = next;
    reject = fail;
  });
  return { promise, resolve, reject };
}

function resetApiMocks() {
  vi.clearAllMocks();
  mocks.redisScanPageSize = 100;
  mocks.redisKeyFilter = "";
  mocks.renamedKeyName = "";
  mocks.redisScanValues.mockResolvedValue({ cursor: 0, keys: [], total_keys: 0 });
  mocks.infiniteScroll = false;
  mocks.queryResultMaxRowsEnabled = true;
  mocks.queryResultMaxRows = 5000;
  mocks.loadedTtl = -1;
  mocks.loadedKeyMissing = false;
  mocks.scrollerItems.length = 0;
  mocks.scrollerCallOrder.length = 0;
  mocks.scrollerVisiblePositions.length = 0;
  mocks.scrollerRefreshSnapshots.length = 0;
  mocks.scrollerVisibleStartIndex = 0;
  mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [], total_keys: 0 });
  mocks.redisGetValue.mockImplementation((_connectionId: string, _db: number, keyRaw: string) => Promise.resolve(redisValue(keyRaw)));
  mocks.redisSetString.mockResolvedValue(undefined);
  mocks.redisJsonSet.mockResolvedValue(undefined);
  mocks.redisHashSet.mockResolvedValue(undefined);
  mocks.redisListPush.mockResolvedValue(undefined);
  mocks.redisSetAdd.mockResolvedValue(undefined);
  mocks.redisZadd.mockResolvedValue(undefined);
  mocks.redisStreamAdd.mockResolvedValue(undefined);
  mocks.redisSetTtl.mockResolvedValue(undefined);
  mocks.redisSetExpireAt.mockResolvedValue(undefined);
  mocks.redisSetKeysTtl.mockResolvedValue({ applied: 0, missing_key_raws: [] });
  mocks.redisSetKeysExpireAt.mockResolvedValue({ applied: 0, missing_key_raws: [] });
  mocks.redisCheckJsonModule.mockResolvedValue(true);
  mocks.redisDeleteKey.mockResolvedValue(undefined);
  mocks.redisDeleteKeys.mockResolvedValue(0);
  mocks.redisDeleteKeysByPattern.mockResolvedValue(0);
  mocks.redisExecuteCommand.mockResolvedValue({ value: "OK" });
  mocks.saveHistory.mockResolvedValue(undefined);
  mocks.listRedisCompletionCommandDocs.mockResolvedValue(completionCommands);
  mocks.listRedisCompletionKeys.mockResolvedValue(["user:1"]);
  mocks.canBuildRedisFuzzyTree.mockImplementation((loadedKeyCount: number) => loadedKeyCount <= 200_000);
}

function resetScrollerObservations() {
  mocks.scrollerUpdateVisibleItems.mockClear();
  mocks.scrollerScrollToItem.mockClear();
  mocks.scrollerCallOrder.length = 0;
  mocks.scrollerVisiblePositions.length = 0;
  mocks.scrollerRefreshSnapshots.length = 0;
}

function mountBrowser(withDeleteDetails = false) {
  const host = document.createElement("div");
  document.body.append(host);
  const app = createApp(RedisKeyBrowser, { connectionId: "connection", db: 0, blockDangerousRedisCommands: false });
  const messages = {
    en: {
      redis: {
        deleteGroupDetails: withDeleteDetails ? "{target}\n{count} keys" : "redis.deleteGroupDetails",
        deleteGroupSubtreeDetails: "{target}\nall {count}",
        deleteGroupSubtreeSuccess: "deleted {count}",
        keys: "{count} keys",
        batchExpirySelected: "redis.batchExpirySelected",
        batchExpirySuccess: "applied {count}",
        batchExpiryPartial: "applied {success} failed {failed}",
      },
    },
  };
  app.use(createI18n({ legacy: false, locale: "en", messages, missingWarn: false, fallbackWarn: false }));
  app.mount(host);
  mountedApps.push({ unmount: () => app.unmount(), host });
  return host;
}

function mountScopedBrowser() {
  const connectionId = ref("connection");
  const db = ref(0);
  const host = document.createElement("div");
  document.body.append(host);
  const app = createApp(
    defineComponent({
      setup() {
        return () => h(RedisKeyBrowser, { connectionId: connectionId.value, db: db.value, blockDangerousRedisCommands: false });
      },
    }),
  );
  app.use(createI18n({ legacy: false, locale: "en", messages: { en: {} }, missingWarn: false, fallbackWarn: false }));
  app.mount(host);
  mountedApps.push({ unmount: () => app.unmount(), host });

  return {
    host,
    async setScope(nextConnectionId: string, nextDb: number) {
      connectionId.value = nextConnectionId;
      db.value = nextDb;
      await settle();
    },
  };
}

function mountKeptAliveBrowser() {
  const active = ref(true);
  const host = document.createElement("div");
  document.body.append(host);
  const app = createApp(
    defineComponent({
      setup() {
        return () =>
          h(KeepAlive, null, {
            default: () => (active.value ? h(RedisKeyBrowser, { connectionId: "connection", db: 0, blockDangerousRedisCommands: false }) : null),
          });
      },
    }),
  );
  app.use(createI18n({ legacy: false, locale: "en", messages: { en: {} }, missingWarn: false, fallbackWarn: false }));
  app.mount(host);
  mountedApps.push({ unmount: () => app.unmount(), host });

  return {
    async deactivate() {
      active.value = false;
      await settle();
    },
    async activate() {
      active.value = true;
      await settle();
    },
  };
}

async function settle() {
  await nextTick();
  await Promise.resolve();
  await nextTick();
  await Promise.resolve();
  await nextTick();
}

function requiredElement<T extends Element>(selector: string): T {
  const element = document.querySelector<T>(selector);
  expect(element, selector).not.toBeNull();
  return element!;
}

function clickButtonWithText(text: string) {
  const button = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).find((candidate) => candidate.textContent?.includes(text));
  expect(button, text).toBeDefined();
  button!.click();
}

async function setInput(selector: string, value: string) {
  const input = requiredElement<HTMLInputElement>(selector);
  input.value = value;
  input.dispatchEvent(new Event("input", { bubbles: true }));
  await settle();
}

async function submitKeySearch(value: string) {
  const input = requiredElement<HTMLInputElement>("[data-redis-search-input]");
  input.value = value;
  input.dispatchEvent(new Event("input", { bubbles: true }));
  input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
  await settle();
}

function groupRow(label: string): HTMLElement {
  const labelElement = Array.from(document.querySelectorAll<HTMLElement>(".dbx-editor-font-family")).find((element) => element.textContent === label);
  expect(labelElement, label).toBeDefined();
  const row = labelElement?.closest<HTMLElement>(".group");
  expect(row, label).toBeDefined();
  return row!;
}

function groupRowOrUndefined(label: string): HTMLElement | undefined {
  const labelElement = Array.from(document.querySelectorAll<HTMLElement>(".dbx-editor-font-family")).find((element) => element.textContent === label);
  return labelElement?.closest<HTMLElement>(".group") ?? undefined;
}

function redisCheckboxes(): HTMLElement[] {
  return Array.from(document.querySelectorAll<HTMLElement>('input[type="checkbox"]'));
}

function groupCheckbox(label: string): HTMLElement {
  const checkbox = groupRow(label).querySelector<HTMLElement>('input[type="checkbox"]');
  expect(checkbox, label).toBeDefined();
  return checkbox!;
}

function leafCheckbox(label: string): HTMLElement {
  const checkbox = redisCheckboxes().find((el) => el.closest(".group")?.querySelector(".dbx-editor-font-family")?.textContent === label);
  expect(checkbox, label).toBeDefined();
  return checkbox!;
}

function isCheckboxChecked(el: HTMLElement): boolean {
  return (el as HTMLInputElement).checked;
}

function isCheckboxMixed(el: HTMLElement): boolean {
  return (el as HTMLInputElement).indeterminate;
}

/** Select a folder via its left-side checkbox (same single-click path as leaf keys). */
async function selectGroup(label: string) {
  groupCheckbox(label).dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
  await settle();
}

async function select(value: string) {
  const item = requiredElement<HTMLButtonElement>(`[data-test-select-value="${value}"]`);
  const root = item.closest<TestSelectRoot>("[data-test-select-root]");
  expect(root).not.toBeNull();
  expect(root?.selectTestValue).toEqual(expect.any(Function));
  root!.selectTestValue!(value);
  await settle();
}

async function openCreateDialog() {
  requiredElement<HTMLButtonElement>('button[title="redis.createKey"]').click();
  await settle();
  await setInput('input[placeholder="redis.createKeyNamePlaceholder"]', KEY_NAME);
}

async function openCommandPanel() {
  const trigger = document.querySelector<HTMLElement>('[value="command"]');
  expect(trigger, "redis.commandLine trigger").toBeDefined();
  trigger!.click();
  await settle();
}

function commandCompletionLabels(): string[] {
  return Array.from(document.querySelectorAll<HTMLButtonElement>('[role="option"]')).map((item) => item.textContent?.trim() ?? "");
}

async function setCommandInput(value: string) {
  await setInput("[data-redis-command-input]", value);
}

async function fillCreateValue(type: CreateType) {
  if (type === "string") {
    const textarea = requiredElement<HTMLTextAreaElement>("textarea");
    textarea.value = "value";
    textarea.dispatchEvent(new Event("input", { bubbles: true }));
    await settle();
    return;
  }

  await select(type);
  if (type === "json") {
    const textarea = requiredElement<HTMLTextAreaElement>("textarea");
    textarea.value = '{"value":true}';
    textarea.dispatchEvent(new Event("input", { bubbles: true }));
    await settle();
    return;
  }

  if (type === "hash" || type === "stream") {
    await setInput('input[placeholder="redis.createFieldPlaceholder"]', "field");
    await setInput('input[placeholder="redis.createValuePlaceholder"]', "value");
    return;
  }

  if (type === "zset") {
    await setInput('input[placeholder="0"]', "1");
    await setInput('input[placeholder="redis.createMember"]', "member");
    return;
  }

  await setInput('input[placeholder="redis.createValuePlaceholder"]', "value");
}

async function submitCreate() {
  clickButtonWithText("redis.createKeySubmit");
  await settle();
}

function expectWriterBefore(mock: { mock: { invocationCallOrder: number[] } }, after: { mock: { invocationCallOrder: number[] } }) {
  expect(mock.mock.invocationCallOrder).toHaveLength(1);
  expect(after.mock.invocationCallOrder).toHaveLength(1);
  expect(mock.mock.invocationCallOrder[0]).toBeLessThan(after.mock.invocationCallOrder[0]!);
}

const writerForType = {
  string: mocks.redisSetString,
  hash: mocks.redisHashSet,
  list: mocks.redisListPush,
  set: mocks.redisSetAdd,
  zset: mocks.redisZadd,
  stream: mocks.redisStreamAdd,
  json: mocks.redisJsonSet,
} as const;

beforeEach(() => {
  resetApiMocks();
  setLocalTimeZone("UTC");
});

afterEach(() => {
  for (const { unmount, host } of mountedApps.splice(0)) {
    unmount();
    host.remove();
  }
  resetLocalTimeZone();
});

describe("RedisKeyBrowser scope changes", () => {
  it("reloads the new database and discards a late scan from the previous one", async () => {
    const previousDatabase = deferred<{ cursor: number; keys: RedisKeyInfo[]; total_keys: number }>();
    const currentKey = { key_display: "db1-key", key_raw: "ZGIxLWtleQ==", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, db: number) => {
      if (db === 0) return previousDatabase.promise;
      return Promise.resolve({ cursor: 0, keys: [currentKey], total_keys: 1 });
    });
    const browser = mountScopedBrowser();
    await settle();

    expect(mocks.redisScanKeysBatch).toHaveBeenCalledWith("connection", 0, 0, "*", 100, 8, true);

    await browser.setScope("connection", 1);

    expect(mocks.redisScanKeysBatch).toHaveBeenCalledWith("connection", 1, 0, "*", 100, 8, true);
    previousDatabase.resolve({
      cursor: 0,
      keys: [{ key_display: "db0-key", key_raw: "ZGIwLWtleQ==", key_type: "string", ttl: -1 }],
      total_keys: 1,
    });
    await settle();

    expect(browser.host.textContent).toContain("db1-key");
    expect(browser.host.textContent).not.toContain("db0-key");
  });
});

describe("RedisKeyBrowser TTL list badges and no-expiry filter", () => {
  it("refreshes one key's metadata without rebuilding the loaded tree", async () => {
    mocks.redisScanKeysBatch.mockResolvedValue({
      cursor: 0,
      keys: [{ ...redisKeyInfo("string"), ttl: -1 }],
      total_keys: 1,
    });
    mountBrowser();
    await settle();

    const keyCheckbox = requiredElement<HTMLInputElement>(`[data-redis-leaf="${KEY_RAW}"]`);
    const keyRow = keyCheckbox.parentElement?.parentElement?.parentElement;
    expect(keyRow).toBeInstanceOf(HTMLElement);
    keyRow?.click();
    await settle();

    const buildsBeforeDetailLoaded = mocks.createRedisKeyTreeIndex.mock.calls.length;
    const flattensBeforeDetailLoaded = mocks.flattenVisibleRedisKeyTree.mock.calls.length;
    requiredElement<HTMLButtonElement>("[data-test-emit-key-loaded]").click();
    await settle();

    expect(mocks.createRedisKeyTreeIndex).toHaveBeenCalledTimes(buildsBeforeDetailLoaded);
    expect(mocks.flattenVisibleRedisKeyTree).toHaveBeenCalledTimes(flattensBeforeDetailLoaded);
    expect(keyRow?.textContent).toContain("hash");
    expect(keyRow?.textContent).toContain("redis.noExpiry");
  });

  it("refreshes no-expiry membership when detail metadata changes TTL", async () => {
    mocks.redisScanKeysBatch.mockResolvedValue({
      cursor: 0,
      keys: [redisKeyInfo("string")],
      total_keys: 1,
    });
    mountBrowser();
    await settle();

    requiredElement<HTMLInputElement>(`[data-redis-leaf="${KEY_RAW}"]`).closest<HTMLElement>(".group")?.click();
    await settle();
    requiredElement<HTMLButtonElement>("[data-redis-no-expiry-filter]").click();
    await settle();
    expect(document.body.textContent).toContain("redis.noExpiryKeysEmpty");

    requiredElement<HTMLButtonElement>("[data-test-emit-key-loaded]").click();
    await settle();

    expect(document.querySelector(`[data-redis-leaf="${KEY_RAW}"]`)).not.toBeNull();
    expect(document.body.textContent).toContain("redis.noExpiry");
  });

  it("starts the local TTL countdown when detail metadata gains an expiry", async () => {
    vi.useFakeTimers();
    try {
      mocks.redisScanKeysBatch.mockResolvedValue({
        cursor: 0,
        keys: [{ ...redisKeyInfo("string"), ttl: -1 }],
        total_keys: 1,
      });
      mountBrowser();
      await settle();

      requiredElement<HTMLInputElement>(`[data-redis-leaf="${KEY_RAW}"]`).closest<HTMLElement>(".group")?.click();
      await settle();
      mocks.loadedTtl = 2;
      requiredElement<HTMLButtonElement>("[data-test-emit-key-loaded]").click();
      await settle();
      expect(document.body.textContent).toContain("redis.ttlSecond");

      await vi.advanceTimersByTimeAsync(3000);
      await settle();
      expect(document.body.textContent).toContain("redis.expired");
    } finally {
      vi.useRealTimers();
    }
  });

  it("renders TTL badges per row and filters rows to keys without expiry", async () => {
    mocks.redisScanKeysBatch.mockResolvedValue({
      cursor: 0,
      keys: [
        {
          key_display: "session:a",
          key_raw: "c2Vzc2lvbjph",
          key_type: "string",
          ttl: -1,
        },
        {
          key_display: "cache:b",
          key_raw: "Y2FjaGU6Yg==",
          key_type: "string",
          ttl: 3600,
        },
      ],
      total_keys: 2,
    });
    mountBrowser();
    await settle();
    // 初始 "*" 浏览是树模式且分组默认折叠;切到 key 搜索后走平铺行,leaf 直接可见
    await submitKeySearch("session");

    expect(document.body.textContent).toContain("session:a");
    // 永不过期(TTL = -1)显示为本地化的 redis.noExpiry 文案,
    // 剩余 3600 秒显示为加载时刻快照 redis.ttlHour(测试未配置 i18n 文案时回退为 key)
    expect(document.body.textContent).toContain("redis.noExpiry");
    expect(document.body.textContent).toContain("redis.ttlHour");

    requiredElement<HTMLButtonElement>("[data-redis-no-expiry-filter]").click();
    await settle();

    expect(document.body.textContent).toContain("session:a");
    expect(document.body.textContent).not.toContain("cache:b");
  });

  it("shows an empty hint when no loaded key is without expiry", async () => {
    mocks.redisScanKeysBatch.mockResolvedValue({
      cursor: 0,
      keys: [
        {
          key_display: "cache:b",
          key_raw: "Y2FjaGU6Yg==",
          key_type: "string",
          ttl: 60,
        },
      ],
      total_keys: 1,
    });
    mountBrowser();
    await settle();
    await submitKeySearch("cache");

    requiredElement<HTMLButtonElement>("[data-redis-no-expiry-filter]").click();
    await settle();

    expect(document.body.textContent).toContain("redis.noExpiryKeysEmpty");
  });

  it("counts down the list TTL locally without extra network requests", async () => {
    vi.useFakeTimers();
    try {
      mocks.redisScanKeysBatch.mockResolvedValue({
        cursor: 0,
        keys: [
          {
            key_display: "cache:b",
            key_raw: "Y2FjaGU6Yg==",
            key_type: "string",
            ttl: 60,
          },
        ],
        total_keys: 1,
      });
      mountBrowser();
      await settle();
      await submitKeySearch("cache");

      // 刚加载时流逝为 0,60 秒只展示分钟单位(未配置文案时回退为 key)
      expect(document.body.textContent).toContain("redis.ttlMinute");

      const scanCalls = mocks.redisScanKeysBatch.mock.calls.length;
      await vi.advanceTimersByTimeAsync(5000);
      await settle();

      // 倒计时是纯本地计算,不发额外请求;55 秒只展示秒单位
      expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCalls);
      expect(document.body.textContent).toContain("redis.ttlSecond");
      expect(document.body.textContent).not.toContain("redis.ttlMinute");
    } finally {
      vi.useRealTimers();
    }
  });

  it("shows an expired badge when the local countdown reaches zero", async () => {
    vi.useFakeTimers();
    try {
      mocks.redisScanKeysBatch.mockResolvedValue({
        cursor: 0,
        keys: [
          {
            key_display: "cache:b",
            key_raw: "Y2FjaGU6Yg==",
            key_type: "string",
            ttl: 1,
          },
        ],
        total_keys: 1,
      });
      mountBrowser();
      await settle();
      await submitKeySearch("cache");

      await vi.advanceTimersByTimeAsync(2000);
      await settle();

      // 倒计时归零后展示已过期文案,而不是停留在旧快照
      expect(document.body.textContent).toContain("redis.expired");
    } finally {
      vi.useRealTimers();
    }
  });
});

describe("RedisKeyBrowser command completion", () => {
  it("uses the connected server's module command docs and accepts the selection with Tab", async () => {
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput("VGE");

    expect(mocks.listRedisCompletionCommandDocs).toHaveBeenCalledWith("connection", "0");
    expect(commandCompletionLabels()).toEqual(expect.arrayContaining([expect.stringContaining("VGET")]));

    const input = requiredElement<HTMLInputElement>("[data-redis-command-input]");
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Tab", shiftKey: true, bubbles: true }));
    await settle();
    expect(input.value).toBe("VGE");

    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Tab", bubbles: true }));
    await settle();
    expect(input.value).toBe("VGET arg1");
  });

  it("completes known keys only at a documented key argument", async () => {
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput("VGET ");

    expect(mocks.listRedisCompletionKeys).toHaveBeenCalledWith("connection", "0");
    expect(commandCompletionLabels()).toContain("user:1key");

    const input = requiredElement<HTMLInputElement>("[data-redis-command-input]");
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Tab", bubbles: true }));
    await settle();
    expect(input.value).toBe("VGET user:1");
  });

  it("replaces an incomplete quoted key with the executable completion text", async () => {
    mocks.listRedisCompletionKeys.mockResolvedValueOnce(["user name"]);
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput('VGET "user');

    const input = requiredElement<HTMLInputElement>("[data-redis-command-input]");
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Tab", bubbles: true }));
    await settle();

    expect(input.value).toBe('VGET "user name"');
  });

  it("does not guess command candidates when server metadata is unavailable", async () => {
    mocks.listRedisCompletionCommandDocs.mockRejectedValueOnce(new Error("unknown subcommand 'DOCS'"));
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput("GE");

    expect(commandCompletionLabels()).toEqual([]);
  });

  it("keeps one selected completion while pointer and keyboard move it", async () => {
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput("GE");

    const options = Array.from(document.querySelectorAll<HTMLButtonElement>('[role="option"]'));
    const input = requiredElement<HTMLInputElement>("[data-redis-command-input]");
    const listbox = requiredElement<HTMLElement>('[role="listbox"]');
    expect(options.length).toBeGreaterThan(1);
    expect(options.filter((option) => option.getAttribute("aria-selected") === "true")).toEqual([options[0]]);
    expect(options.every((option) => !option.hasAttribute("title"))).toBe(true);
    expect(input.getAttribute("aria-controls")).toBe(listbox.id);
    expect(input.getAttribute("aria-activedescendant")).toBe(options[0]!.id);

    options[1]!.dispatchEvent(new Event("pointerenter", { bubbles: true }));
    await settle();
    expect(options.filter((option) => option.getAttribute("aria-selected") === "true")).toEqual([options[1]]);
    expect(input.getAttribute("aria-activedescendant")).toBe(options[1]!.id);

    listbox.scrollTop = 20;
    vi.spyOn(listbox, "getBoundingClientRect").mockReturnValue({ top: 100, bottom: 200 } as DOMRect);
    vi.spyOn(options[2]!, "getBoundingClientRect").mockReturnValue({ top: 180, bottom: 224 } as DOMRect);
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowDown", bubbles: true }));
    await settle();
    expect(options.filter((option) => option.getAttribute("aria-selected") === "true")).toEqual([options[2]]);
    expect(listbox.scrollTop).toBe(44);

    input.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowDown", bubbles: true }));
    await settle();
    expect(options.filter((option) => option.getAttribute("aria-selected") === "true")).toEqual([options[2]]);

    vi.spyOn(options[1]!, "getBoundingClientRect").mockReturnValue({ top: 76, bottom: 120 } as DOMRect);
    vi.spyOn(options[0]!, "getBoundingClientRect").mockReturnValue({ top: 100, bottom: 144 } as DOMRect);
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowUp", bubbles: true }));
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowUp", bubbles: true }));
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowUp", bubbles: true }));
    await settle();
    expect(options.filter((option) => option.getAttribute("aria-selected") === "true")).toEqual([options[0]]);
    expect(listbox.scrollTop).toBe(20);
  });

  it("accepts a documented argument keyword and advances to its value", async () => {
    mocks.listRedisCompletionCommandDocs.mockResolvedValueOnce([
      ...completionCommands,
      {
        name: "XREAD",
        group: "stream",
        arity: -4,
        keySpecs: [],
        arguments: [
          { name: "count", token: "COUNT", type: "integer", optional: true },
          { name: "streams", token: "STREAMS", type: "block", arguments: [{ name: "key", type: "key", multiple: true }] },
        ],
      },
    ]);
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput("XREAD C");

    const input = requiredElement<HTMLInputElement>("[data-redis-command-input]");
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Tab", bubbles: true }));
    await settle();

    expect(input.value).toBe("XREAD COUNT ");
    expect(commandCompletionLabels()).toEqual([]);
  });

  it("accepts the selected completion before executing on Enter", async () => {
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput("SE");

    const input = requiredElement<HTMLInputElement>("[data-redis-command-input]");
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    await settle();

    expect(input.value).toBe("SET arg1 arg2");
    expect(mocks.redisExecuteCommand).not.toHaveBeenCalled();
  });

  it("inserts documented Redis argument examples before executing on Enter", async () => {
    mocks.listRedisCompletionCommandDocs.mockResolvedValueOnce([
      {
        name: "GETBIT",
        group: "bitmap",
        arity: 3,
        keySpecs: [{ beginSearch: { type: "index" as const, index: 1 }, findKeys: { type: "range" as const, lastKey: 0, keyStep: 1, limit: 0 } }],
        arguments: [
          { name: "key", type: "key" },
          { name: "offset", type: "integer" },
        ],
      },
    ]);
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput("GETB");

    const input = requiredElement<HTMLInputElement>("[data-redis-command-input]");
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    await settle();

    expect(input.value).toBe("GETBIT key offset");
    expect(mocks.redisExecuteCommand).not.toHaveBeenCalled();
    expect(commandCompletionLabels()).toEqual([]);
  });

  it("waits for command metadata instead of sending a partial command on Enter", async () => {
    const docs = deferred<typeof completionCommands>();
    mocks.listRedisCompletionCommandDocs.mockReturnValueOnce(docs.promise);
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput("SE");

    const input = requiredElement<HTMLInputElement>("[data-redis-command-input]");
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    await settle();

    expect(input.value).toBe("SE");
    expect(mocks.redisExecuteCommand).not.toHaveBeenCalled();

    docs.resolve(completionCommands);
    await settle();
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    await settle();
    expect(input.value).toBe("SET arg1 arg2");
    expect(mocks.redisExecuteCommand).not.toHaveBeenCalled();
  });

  it("executes an exact command instead of completing it a second time", async () => {
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput("PING");

    const input = requiredElement<HTMLInputElement>("[data-redis-command-input]");
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    await settle();

    expect(mocks.redisExecuteCommand).toHaveBeenCalledWith("connection", 0, "PING", true);
    expect(input.value).toBe("");
  });
});

describe("RedisKeyBrowser command console echo", () => {
  it("echoes the submitted command to the terminal before the response arrives, then fills in the result", async () => {
    const pending = deferred<{ value: unknown }>();
    mocks.redisExecuteCommand.mockReturnValueOnce(pending.promise);
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput("PING");

    const input = requiredElement<HTMLInputElement>("[data-redis-command-input]");
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    await settle();

    // The command must show up in the terminal right away — while the
    // request is still in flight — not only once the response resolves.
    const terminal = requiredElement<HTMLElement>(".redis-command-terminal");
    expect(terminal.textContent).toContain("PING");
    expect(terminal.querySelectorAll(".mb-2")).toHaveLength(1);
    expect(terminal.textContent).not.toContain("PONG");

    pending.resolve({ value: "PONG" });
    await settle();

    expect(terminal.textContent).toContain("PONG");
    // The result fills in the same echoed entry rather than adding a second one.
    expect(terminal.querySelectorAll(".mb-2")).toHaveLength(1);
  });

  it("attaches a failed command's error to the same echoed entry", async () => {
    const pending = deferred<{ value: unknown }>();
    mocks.redisExecuteCommand.mockReturnValueOnce(pending.promise);
    mountBrowser();
    await settle();
    await openCommandPanel();
    await setCommandInput("PING");

    const input = requiredElement<HTMLInputElement>("[data-redis-command-input]");
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    await settle();

    const terminal = requiredElement<HTMLElement>(".redis-command-terminal");
    expect(terminal.textContent).toContain("PING");
    expect(terminal.querySelectorAll(".mb-2")).toHaveLength(1);

    pending.reject(new Error("ERR unknown command"));
    await settle();

    expect(terminal.textContent).toContain("ERR unknown command");
    expect(terminal.querySelectorAll(".mb-2")).toHaveLength(1);
  });
});

describe("RedisKeyBrowser expiry creation", () => {
  it("opens the create-key dialog with an empty key name", async () => {
    mountBrowser();
    await settle();

    requiredElement<HTMLButtonElement>('button[title="redis.createKey"]').click();
    await settle();

    expect(requiredElement<HTMLInputElement>('input[placeholder="redis.createKeyNamePlaceholder"]').value).toBe("");
  });

  it.each(["string", "hash", "list", "set", "zset", "stream", "json"] as const)("writes %s before applying one relative TTL", async (type) => {
    mountBrowser();
    await settle();
    await openCreateDialog();
    await fillCreateValue(type);
    await select("ttl");
    await setInput('input[placeholder="redis.createKeyTtlPlaceholder"]', "90");

    await submitCreate();

    const writer = writerForType[type];
    expect(mocks.redisSetTtl).toHaveBeenCalledWith("connection", 0, KEY_RAW, 90);
    expect(mocks.redisSetExpireAt).not.toHaveBeenCalled();
    expectWriterBefore(writer, mocks.redisSetTtl);
  });

  it("uses PERSIST after a String write when no expiry is selected", async () => {
    mountBrowser();
    await settle();
    await openCreateDialog();
    await fillCreateValue("string");

    await submitCreate();

    expect(mocks.redisSetTtl).toHaveBeenCalledWith("connection", 0, KEY_RAW, -1);
    expect(mocks.redisSetExpireAt).not.toHaveBeenCalled();
    expectWriterBefore(mocks.redisSetString, mocks.redisSetTtl);
  });

  it("uses EXPIREAT after a String write when an absolute time is selected", async () => {
    mountBrowser();
    await settle();
    await openCreateDialog();
    await fillCreateValue("string");
    await select("at");
    requiredElement<HTMLButtonElement>("[data-test-absolute-date]").click();
    await settle();

    await submitCreate();

    const expected = calendarDateTimeToUnixSeconds(new CalendarDateTime(2030, 1, 2, 3, 4, 5));
    expect(mocks.redisSetExpireAt).toHaveBeenCalledWith("connection", 0, KEY_RAW, expected);
    expect(mocks.redisSetTtl).not.toHaveBeenCalled();
    expectWriterBefore(mocks.redisSetString, mocks.redisSetExpireAt);
  });

  it("does not roll back a written key when its expiry command fails and refreshes it", async () => {
    mocks.redisSetTtl.mockRejectedValueOnce(new Error("TTL command failed"));
    mountBrowser();
    await settle();
    await openCreateDialog();
    await fillCreateValue("string");
    await select("ttl");
    await setInput('input[placeholder="redis.createKeyTtlPlaceholder"]', "90");

    await submitCreate();

    expectWriterBefore(mocks.redisSetString, mocks.redisSetTtl);
    expect(mocks.redisGetValue).toHaveBeenCalledWith("connection", 0, KEY_RAW, 65536);
    expect(mocks.redisDeleteKey).not.toHaveBeenCalled();
    expect(mocks.redisDeleteKeys).not.toHaveBeenCalled();
    expect(mocks.toast).toHaveBeenCalledWith("TTL command failed", 5000);
  });

  it("removes an existing RedisJSON key only after recovery confirms its deletion", async () => {
    mocks.redisScanKeysBatch.mockResolvedValueOnce({ cursor: 0, keys: [redisKeyInfo()], total_keys: 1 });
    mocks.redisSetTtl.mockRejectedValueOnce(new Error("TTL command failed"));
    mocks.redisGetValue.mockRejectedValueOnce(new Error("RedisJSON key no longer exists")).mockRejectedValueOnce(new Error("RedisJSON key no longer exists"));
    mountBrowser();
    await settle();
    await openCreateDialog();
    await fillCreateValue("json");
    await select("ttl");
    await setInput('input[placeholder="redis.createKeyTtlPlaceholder"]', "90");

    await submitCreate();
    await settle();

    expect(mocks.redisGetValue).toHaveBeenCalledTimes(2);
    expect(mocks.updateRedisDbKeyStats).toHaveBeenCalledWith("connection", 0, { loaded: 0, totalDelta: -1 });
    expect(mocks.toast).toHaveBeenCalledWith("TTL command failed", 5000);
  });

  it("keeps an existing RedisJSON key when retry cannot confirm its deletion", async () => {
    mocks.redisScanKeysBatch.mockResolvedValueOnce({ cursor: 0, keys: [redisKeyInfo()], total_keys: 1 });
    mocks.redisSetTtl.mockRejectedValueOnce(new Error("TTL command failed"));
    mocks.redisGetValue.mockRejectedValueOnce(new Error("RedisJSON key no longer exists")).mockRejectedValueOnce(new Error("network unavailable"));
    mountBrowser();
    await settle();
    await openCreateDialog();
    await fillCreateValue("json");
    await select("ttl");
    await setInput('input[placeholder="redis.createKeyTtlPlaceholder"]', "90");

    await submitCreate();
    await settle();

    expect(mocks.updateRedisDbKeyStats).not.toHaveBeenCalledWith("connection", 0, { loaded: 0, totalDelta: -1 });
    expect(mocks.toast).toHaveBeenCalledWith("TTL command failed", 5000);
  });
});

describe("RedisKeyBrowser batch expiration", () => {
  const batchKeys = [
    { key_display: "alpha", key_raw: "YWxwaGE=", key_type: "string", ttl: -1 },
    { key_display: "bravo", key_raw: "YnJhdm8=", key_type: "string", ttl: -1 },
  ];

  function batchExpiryButton(): HTMLButtonElement | null {
    return document.querySelector<HTMLButtonElement>("[data-redis-batch-expiry]");
  }

  async function openBatchExpiryDialog(rows = batchKeys) {
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: rows, total_keys: rows.length });
    mountBrowser();
    await settle();
    requiredElement<HTMLButtonElement>("[data-redis-select-all]").click();
    await settle();
    requiredElement<HTMLButtonElement>("[data-redis-batch-expiry]").click();
    await settle();
  }

  async function applyBatchExpiry() {
    requiredElement<HTMLButtonElement>("[data-redis-batch-expiry-apply]").click();
    await settle();
  }

  function rowTtlBadge(label: string): HTMLElement | null {
    return groupRow(label).querySelector<HTMLElement>("span[title]");
  }

  it("only offers the action for a non-empty selection and applies one TTL to every key", async () => {
    mocks.redisSetKeysTtl.mockResolvedValue({ applied: 2, missing_key_raws: [] });
    await openBatchExpiryDialog();

    expect(document.body.textContent).toContain("redis.batchExpirySelected");
    await select("ttl");
    await setInput("[data-redis-batch-expiry-ttl]", "3600");
    await applyBatchExpiry();

    // One request for the whole selection, never one call per key.
    expect(mocks.redisSetKeysTtl).toHaveBeenCalledTimes(1);
    expect(mocks.redisSetKeysTtl).toHaveBeenCalledWith("connection", 0, ["YWxwaGE=", "YnJhdm8="], 3600);
    expect(mocks.redisSetKeysExpireAt).not.toHaveBeenCalled();
    expect(mocks.toast).toHaveBeenCalledWith("applied 2", 3000);
    // A fully applied batch releases the selection like a completed batch delete does.
    expect(document.querySelector("[data-redis-batch-delete]")).toBeNull();
    expect(document.querySelector("[data-test-dialog]")).toBeNull();
  });

  it("applies PERSIST to every selected key when no expiry is chosen", async () => {
    mocks.redisSetKeysTtl.mockResolvedValue({ applied: 2, missing_key_raws: [] });
    await openBatchExpiryDialog();

    await applyBatchExpiry();

    expect(mocks.redisSetKeysTtl).toHaveBeenCalledWith("connection", 0, ["YWxwaGE=", "YnJhdm8="], -1);
    expect(mocks.redisSetKeysExpireAt).not.toHaveBeenCalled();
  });

  it("applies the same absolute expiration time to every selected key", async () => {
    mocks.redisSetKeysExpireAt.mockResolvedValue({ applied: 2, missing_key_raws: [] });
    await openBatchExpiryDialog();

    await select("at");
    requiredElement<HTMLButtonElement>("[data-test-absolute-date]").click();
    await settle();
    await applyBatchExpiry();

    const expireAt = calendarDateTimeToUnixSeconds(new CalendarDateTime(2030, 1, 2, 3, 4, 5));
    expect(mocks.redisSetKeysExpireAt).toHaveBeenCalledTimes(1);
    expect(mocks.redisSetKeysExpireAt).toHaveBeenCalledWith("connection", 0, ["YWxwaGE=", "YnJhdm8="], expireAt);
    expect(mocks.redisSetKeysTtl).not.toHaveBeenCalled();
  });

  it("rejects an invalid TTL before reaching the backend and keeps the dialog open", async () => {
    await openBatchExpiryDialog();

    await select("ttl");
    await setInput("[data-redis-batch-expiry-ttl]", "0");
    await applyBatchExpiry();

    expect(mocks.redisSetKeysTtl).not.toHaveBeenCalled();
    expect(mocks.toast).toHaveBeenCalledWith("redis.expiryTtlInvalid", 3000);
    expect(document.querySelector("[data-redis-batch-expiry-apply]")).not.toBeNull();
  });

  it("keeps only the keys the server did not update selected so they can be retried", async () => {
    mocks.redisSetKeysTtl.mockResolvedValueOnce({ applied: 1, missing_key_raws: ["YnJhdm8="] });
    mocks.redisSetKeysTtl.mockResolvedValueOnce({ applied: 1, missing_key_raws: [] });
    await openBatchExpiryDialog();

    await select("ttl");
    await setInput("[data-redis-batch-expiry-ttl]", "3600");
    await applyBatchExpiry();

    expect(mocks.toast).toHaveBeenCalledWith("applied 1 failed 1", 5000);
    expect(requiredElement<HTMLElement>("[data-redis-batch-delete]").textContent).toContain("1");

    // Retrying only targets the key the server missed.
    requiredElement<HTMLButtonElement>("[data-redis-batch-expiry]").click();
    await settle();
    await select("ttl");
    await setInput("[data-redis-batch-expiry-ttl]", "120");
    await applyBatchExpiry();

    expect(mocks.redisSetKeysTtl).toHaveBeenNthCalledWith(2, "connection", 0, ["YnJhdm8="], 120);
    expect(document.querySelector("[data-redis-batch-delete]")).toBeNull();
  });

  it("reports a failed chunk together with the keys an earlier chunk already updated", async () => {
    mocks.redisSetKeysTtl.mockResolvedValueOnce({ applied: 1_000, missing_key_raws: [] });
    mocks.redisSetKeysTtl.mockRejectedValueOnce(new Error("connection lost"));
    const rows = Array.from({ length: 1_001 }, (_, index) => ({
      key_display: `batch:${String(index).padStart(4, "0")}`,
      key_raw: `cmF3LWJhdGNoLS${index}`,
      key_type: "string",
      ttl: -1,
    }));
    await openBatchExpiryDialog(rows);

    await select("ttl");
    await setInput("[data-redis-batch-expiry-ttl]", "3600");
    await applyBatchExpiry();

    // Bounded chunks keep a 1001-key selection to two requests.
    expect(mocks.redisSetKeysTtl.mock.calls.map((call) => call[2].length)).toEqual([1_000, 1]);
    expect(mocks.toast).toHaveBeenCalledWith("applied 1000 failed 1", 5000);
    expect(mocks.toast).toHaveBeenCalledWith("connection lost", 5000);
    expect(requiredElement<HTMLElement>("[data-redis-batch-delete]").textContent).toContain("1");
  });

  it("does not start a second request while the batch is still running", async () => {
    const pending = deferred<{ applied: number; missing_key_raws: string[] }>();
    mocks.redisSetKeysTtl.mockReturnValue(pending.promise);
    await openBatchExpiryDialog();

    await select("ttl");
    await setInput("[data-redis-batch-expiry-ttl]", "3600");

    const applyButton = requiredElement<HTMLButtonElement>("[data-redis-batch-expiry-apply]");
    applyButton.click();
    await settle();
    applyButton.click();
    await settle();

    expect(mocks.redisSetKeysTtl).toHaveBeenCalledTimes(1);
    // A conflicting batch delete stays blocked while the expiry request owns the selection.
    expect(requiredElement<HTMLButtonElement>("[data-redis-batch-delete]").disabled).toBe(true);

    pending.resolve({ applied: 2, missing_key_raws: [] });
    await settle();
    expect(mocks.toast).toHaveBeenCalledWith("applied 2", 3000);
  });

  it("updates the loaded TTL badge without rescanning the key list", async () => {
    const rows = [{ key_display: "alpha", key_raw: "YWxwaGE=", key_type: "string", ttl: -1 }];
    mocks.redisSetKeysTtl.mockResolvedValue({ applied: 1, missing_key_raws: [] });
    await openBatchExpiryDialog(rows);

    expect(rowTtlBadge("alpha")?.textContent).toContain("redis.noExpiry");
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(1);

    await select("ttl");
    await setInput("[data-redis-batch-expiry-ttl]", "3600");
    await applyBatchExpiry();

    // The applied TTL is reflected locally instead of one refresh request per key.
    expect(rowTtlBadge("alpha")?.textContent).toContain("redis.ttlHour");
    expect(rowTtlBadge("alpha")?.textContent).not.toContain("redis.noExpiry");
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(1);

    // PERSIST flips the same badge back to the no-expiry label.
    requiredElement<HTMLButtonElement>("[data-redis-select-all]").click();
    await settle();
    requiredElement<HTMLButtonElement>("[data-redis-batch-expiry]").click();
    await settle();
    await applyBatchExpiry();

    expect(mocks.redisSetKeysTtl).toHaveBeenLastCalledWith("connection", 0, ["YWxwaGE="], -1);
    expect(rowTtlBadge("alpha")?.textContent).toContain("redis.noExpiry");
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(1);
  });

  it("hides the action while nothing is selected", async () => {
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: batchKeys, total_keys: batchKeys.length });
    mountBrowser();
    await settle();

    expect(batchExpiryButton()).toBeNull();
    expect(document.querySelector("[data-redis-batch-expiry-apply]")).toBeNull();
  });
});

describe("RedisKeyBrowser fuzzy key hierarchy", () => {
  it("deletes a leaf directly from the key list after confirmation", async () => {
    const key = { key_display: "session:current", key_raw: "c2Vzc2lvbjpjdXJyZW50", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [key], total_keys: 1 });
    mocks.redisDeleteKeys.mockResolvedValue(1);
    mountBrowser(true);
    await settle();

    groupRow("session").dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
    await settle();

    const deleteButton = requiredElement<HTMLButtonElement>('button[title="redis.deleteKey"]');
    deleteButton.click();
    await settle();

    expect(mocks.redisDeleteKeys).not.toHaveBeenCalled();
    expect(requiredElement<HTMLElement>("[data-test-danger-details]").textContent).toContain("session:current");
    expect(requiredElement<HTMLElement>("[data-test-danger-sql]").textContent).toBe("DEL session:current");
    requiredElement<HTMLButtonElement>("[data-test-danger-confirm]").click();
    await settle();

    expect(mocks.redisDeleteKeys).toHaveBeenCalledWith("connection", 0, [key.key_raw]);
    expect(document.body.textContent).not.toContain("session:current");
  });

  it("deletes every key under a group prefix instead of only the loaded rows (#10164)", async () => {
    const loaded = [
      { key_display: "MCP:AAA:1", key_raw: btoa("MCP:AAA:1"), key_type: "string", ttl: -1 },
      { key_display: "MCP:AAA:2", key_raw: btoa("MCP:AAA:2"), key_type: "string", ttl: -1 },
      { key_display: "OTHER:key1", key_raw: btoa("OTHER:key1"), key_type: "string", ttl: -1 },
    ];
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: loaded, total_keys: 3002 });
    mocks.redisDeleteKeysByPattern.mockResolvedValue(3001);
    mountBrowser();
    await settle();

    const groupDelete = groupRow("MCP").querySelector<HTMLButtonElement>('button[title="redis.deleteGroup"]');
    expect(groupDelete, "group delete button").not.toBeNull();
    groupDelete!.click();
    await settle();

    expect(mocks.redisDeleteKeys).not.toHaveBeenCalled();
    expect(requiredElement<HTMLElement>("[data-test-danger-details]").textContent).toContain("MCP");
    expect(requiredElement<HTMLElement>("[data-test-danger-sql]").textContent).toContain("python3");
    expect(requiredElement<HTMLElement>("[data-test-danger-sql]").textContent).toContain("SCAN COUNT 500");
    expect(requiredElement<HTMLElement>("[data-test-danger-sql]").textContent).toContain("MCP:*");
    requiredElement<HTMLButtonElement>("[data-test-danger-confirm]").click();
    await settle();

    // 整个前缀在服务端删除(未加载的子键也在内),不再按已加载行逐个删
    expect(mocks.redisDeleteKeysByPattern).toHaveBeenCalledWith("connection", 0, "MCP:*");
    expect(mocks.redisDeleteKeys).not.toHaveBeenCalled();
    // 整个 MCP 分组消失,前缀之外的分组保留
    expect(groupRowOrUndefined("MCP")).toBeUndefined();
    expect(groupRow("OTHER")).toBeDefined();
    expect(mocks.updateRedisDbKeyStats).toHaveBeenCalledWith("connection", 0, { loaded: 1, totalDelta: -3001 });
    expect(mocks.toast).toHaveBeenCalledWith("deleted 3001", 3000);
  });

  it("finds a sparse fuzzy match within the keyspace-aware budget without manual load-more (#12412)", async () => {
    mocks.redisScanPageSize = 1_000;
    mountBrowser();
    await settle();
    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    const target = { key_display: "issue5012:target", key_raw: "aXNzdWU1MDEyOnRhcmdldA==", key_type: "string", ttl: -1 };
    let batch = 0;
    mocks.redisScanKeysBatch.mockReset();
    mocks.redisScanKeysBatch.mockImplementation(() => {
      batch += 1;
      if (batch === 8) return Promise.resolve({ cursor: 801, keys: [target], total_keys: 0 });
      return Promise.resolve({ cursor: batch * 100, keys: [], total_keys: batch === 1 ? 200_000 : 0 });
    });

    // DBSIZE 200k → 200 SCAN iterations of keyspace-aware budget: the
    // automatic first page keeps scanning (8 backend calls) until the sparse
    // match at iteration 64 instead of stopping after the old 50-iteration
    // shared-budget slice (7 calls), so the match surfaces without a manual
    // load-more click (#12412).
    await submitKeySearch("issue5012:target");
    await vi.waitFor(() => expect(groupRowOrUndefined("issue5012")).toBeDefined());
    await settle();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(8);
    expect(document.body.textContent).not.toContain("target");

    groupRow("issue5012").dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
    await settle();
    await vi.waitFor(() => {
      const labels = Array.from(document.querySelectorAll<HTMLElement>(".dbx-editor-font-family")).map((element) => element.textContent);
      expect(labels).toContain("target");
    });

    // The cursor handed back with the matching page is preserved: the manual
    // continuation resumes from cursor 801 and scans its own keyspace-aware
    // page (200 iterations = 25 backend calls) past the end of the mock.
    clickButtonWithText("redis.loadMoreKeys");
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(33));
    await settle();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(33);
    expect(mocks.redisScanKeysBatch.mock.calls[8]?.[2]).toBe(801);
    expect(mocks.redisScanKeysBatch.mock.calls.every((call) => call[3] === "*issue5012:target*")).toBe(true);
  });

  it("bounds a large no-match keyspace and exposes the saved-cursor continuation", async () => {
    mocks.redisScanPageSize = 1_000;
    mountBrowser();
    await settle();
    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    let batch = 0;
    mocks.redisScanKeysBatch.mockReset();
    mocks.redisScanKeysBatch.mockImplementation(() => {
      batch += 1;
      return Promise.resolve({ cursor: batch, keys: [], total_keys: batch === 1 ? 5_000_000 : 0 });
    });

    // DBSIZE 5M → keyspace-aware budget = 1M COUNT = 1000 SCAN iterations, so
    // the automatic first page spends up to 1000 iterations (125 backend calls
    // at 8 iterations each) instead of the old shared 50-iteration slice (7
    // calls), then stops with the cursor saved (#12412).
    await submitKeySearch("missing-key");
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(125));
    await settle();

    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(125);
    expect(mocks.redisScanKeysBatch.mock.calls[124]?.[2]).toBe(124);
    expect(document.body.textContent).toContain("redis.noKeysInScanHint");
    expect(Array.from(document.querySelectorAll("button")).some((button) => button.textContent?.includes("redis.loadMoreKeys"))).toBe(true);

    // The manual continuation resumes from the saved cursor with the same
    // keyspace-aware per-page budget (another 1000 iterations) instead of
    // falling back to the old 50k COUNT floor.
    clickButtonWithText("redis.loadMoreKeys");
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(250));

    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(250);
    expect(mocks.redisScanKeysBatch.mock.calls[125]?.[2]).toBe(125);
    expect(document.body.textContent).toContain("redis.noKeysInScanHint");
  });

  it("keeps existing matches while continuing to the next sparse fuzzy result", async () => {
    mocks.redisScanPageSize = 1_000;
    mountBrowser();
    await settle();
    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    const first = { key_display: "issue5012:first", key_raw: "aXNzdWU1MDEyOmZpcnN0", key_type: "string", ttl: -1 };
    const next = { key_display: "issue5012:next", key_raw: "aXNzdWU1MDEyOm5leHQ=", key_type: "string", ttl: -1 };
    let continuationBatch = 0;
    mocks.redisScanKeysBatch.mockReset();
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => {
      if (cursor === 0) return Promise.resolve({ cursor: 1, keys: [first], total_keys: 200_000 });
      continuationBatch += 1;
      if (continuationBatch === 8) return Promise.resolve({ cursor: 0, keys: [next], total_keys: 0 });
      return Promise.resolve({ cursor: continuationBatch + 1, keys: [], total_keys: 0 });
    });

    await submitKeySearch("issue5012");
    await vi.waitFor(() => expect(groupRowOrUndefined("issue5012")).toBeDefined());
    expect(document.body.textContent).not.toContain("first");
    groupRow("issue5012").dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
    await settle();
    await vi.waitFor(() => expect(document.body.textContent).toContain("first"));
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1+ keys");

    // One continuation click now scans the keyspace-aware budget (200k keys →
    // 200 iterations) and reaches the next sparse match while keeping the
    // already found key; previously the same click was cut off at the old
    // 50-iteration slice just short of the match and needed a second click (#12412).
    clickButtonWithText("redis.loadMoreKeys");
    await vi.waitFor(() => expect(document.body.textContent).toContain("next"));

    expect(continuationBatch).toBe(8);
    expect(document.body.textContent).toContain("first");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("2 keys");
  });

  it("cancels a sparse scan immediately without searching until Enter", async () => {
    mocks.redisScanPageSize = 1_000;
    mountBrowser();
    await settle();
    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    const oldPage = deferred<{ cursor: number; keys: RedisKeyInfo[]; total_keys: number }>();
    const stale = { key_display: "old:result", key_raw: "b2xkOnJlc3VsdA==", key_type: "string", ttl: -1 };
    const fresh = { key_display: "new:result", key_raw: "bmV3OnJlc3VsdA==", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockReset();
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, _cursor: number, pattern: string) => {
      if (pattern === "*old*") return oldPage.promise;
      return Promise.resolve({ cursor: 0, keys: [fresh], total_keys: 1 });
    });

    await submitKeySearch("old");
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(1));

    await setInput("[data-redis-search-input]", "new");
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(1);
    mocks.updateRedisDbKeyStats.mockClear();

    oldPage.resolve({ cursor: 0, keys: [stale], total_keys: 1 });
    await settle();

    expect(mocks.updateRedisDbKeyStats).not.toHaveBeenCalled();
    expect(document.body.textContent).not.toContain("old:result");
    expect(document.body.textContent).not.toContain("new:result");
    expect(mocks.redisScanKeysBatch.mock.calls.filter((call) => call[3] === "*old*")).toHaveLength(1);
    expect(mocks.redisScanKeysBatch.mock.calls.map((call) => call[3])).toEqual(["*old*"]);

    requiredElement<HTMLInputElement>("[data-redis-search-input]").dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    await settle();

    expect(groupRowOrUndefined("old")).toBeUndefined();
    expect(groupRowOrUndefined("new")).toBeDefined();
    expect(document.body.textContent).not.toContain("result");
    groupRow("new").dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
    await settle();
    await vi.waitFor(() => expect(document.body.textContent).toContain("result"));
    expect(mocks.redisScanKeysBatch.mock.calls.map((call) => call[3])).toEqual(["*old*", "*new*"]);
  });

  it("keeps a current continuation locked when an older load-more request finishes", async () => {
    mocks.redisScanPageSize = 1_000;
    mountBrowser();
    await settle();
    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    const oldContinuation = deferred<{ cursor: number; keys: RedisKeyInfo[]; total_keys: number }>();
    const currentContinuation = deferred<{ cursor: number; keys: RedisKeyInfo[]; total_keys: number }>();
    const oldInitial = { key_display: "old:initial", key_raw: "b2xkOmluaXRpYWw=", key_type: "string", ttl: -1 };
    const currentInitial = { key_display: "new:initial", key_raw: "bmV3OmluaXRpYWw=", key_type: "string", ttl: -1 };
    const currentFirstPage = { key_display: "new:first-page", key_raw: "bmV3OmZpcnN0LXBhZ2U=", key_type: "string", ttl: -1 };
    const currentLastPage = { key_display: "new:last-page", key_raw: "bmV3Omxhc3QtcGFnZQ==", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockReset();
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number, pattern: string) => {
      if (pattern === "*old*") {
        if (cursor === 0) return Promise.resolve({ cursor: 11, keys: [oldInitial], total_keys: 100 });
        return oldContinuation.promise;
      }
      if (pattern === "*new*") {
        if (cursor === 0) return Promise.resolve({ cursor: 21, keys: [currentInitial], total_keys: 100 });
        if (cursor === 21) return Promise.resolve({ cursor: 22, keys: [currentFirstPage], total_keys: 0 });
        if (cursor === 22) return currentContinuation.promise;
      }
      return Promise.resolve({ cursor: 0, keys: [], total_keys: 0 });
    });

    await submitKeySearch("old");
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch.mock.calls.filter((call) => call[2] === 0 && call[3] === "*old*")).toHaveLength(1));
    clickButtonWithText("redis.loadMoreKeys");
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch.mock.calls.some((call) => call[2] === 11)).toBe(true));

    await submitKeySearch("new");
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch.mock.calls.filter((call) => call[2] === 0 && call[3] === "*new*")).toHaveLength(1));
    const firstCurrentLoadMore = await vi.waitFor(() => {
      const buttons = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).filter((candidate) => candidate.textContent?.includes("redis.loadMoreKeys"));
      const button = buttons.find((candidate) => !candidate.disabled);
      expect(button).toBeDefined();
      return button!;
    });
    firstCurrentLoadMore.click();
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch.mock.calls.filter((call) => call[2] === 21)).toHaveLength(1));
    const secondCurrentLoadMore = await vi.waitFor(() => {
      const button = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).find((candidate) => candidate.textContent?.includes("redis.loadMoreKeys") && !candidate.disabled);
      expect(button).toBeDefined();
      return button!;
    });
    secondCurrentLoadMore.click();
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch.mock.calls.filter((call) => call[2] === 22)).toHaveLength(1));

    oldContinuation.resolve({ cursor: 12, keys: [], total_keys: 0 });
    await settle();

    const loadMoreButtons = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).filter((button) => button.textContent?.includes("redis.loadMoreKeys"));
    expect(loadMoreButtons.length).toBeGreaterThan(0);
    expect(loadMoreButtons.every((button) => button.disabled)).toBe(true);
    loadMoreButtons[0]!.click();
    await settle();
    expect(mocks.redisScanKeysBatch.mock.calls.filter((call) => call[2] === 22)).toHaveLength(1);

    currentContinuation.resolve({ cursor: 0, keys: [currentLastPage], total_keys: 0 });
    await vi.waitFor(() => expect(Array.from(document.querySelectorAll<HTMLButtonElement>("button")).filter((button) => button.textContent?.includes("redis.loadMoreKeys"))).toHaveLength(0));
    const labels = Array.from(document.querySelectorAll<HTMLElement>(".dbx-editor-font-family")).map((element) => element.textContent);
    expect(labels).toContain("new");
    expect(labels).not.toContain("old");
  });

  it("keeps NUL-containing fuzzy groups isolated when selecting keys to delete", async () => {
    const firstKeyRaw = "cmF3LWZpcnN0";
    const secondKeyRaw = "cmF3LXNlY29uZA==";
    const keys = [
      { key_display: `a\0b:c:x`, key_raw: firstKeyRaw, key_type: "string", ttl: -1 },
      { key_display: `a:b\0c:y`, key_raw: secondKeyRaw, key_type: "string", ttl: -1 },
    ];
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys, total_keys: keys.length });
    mocks.redisDeleteKeys.mockResolvedValue(1);
    mountBrowser();
    await settle();

    await submitKeySearch("a");
    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    await selectGroup(`a\0b`);
    const deleteButton = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).find((button) => button.textContent?.trim() === "1");
    expect(deleteButton).toBeDefined();
    deleteButton!.click();
    await settle();
    requiredElement<HTMLButtonElement>("[data-test-danger-confirm]").click();
    await settle();

    expect(mocks.redisDeleteKeys).toHaveBeenCalledTimes(1);
    expect(mocks.redisDeleteKeys).toHaveBeenCalledWith("connection", 0, [firstKeyRaw]);
    expect(mocks.redisDeleteKeys.mock.calls[0]?.[2]).not.toContain(secondKeyRaw);
  });

  it("keeps regular key searches flat, then selects and deletes a loaded fuzzy branch", async () => {
    const keys = [
      { key_display: "user:profile:email", key_raw: "cmF3LWVtYWls", key_type: "string", ttl: -1 },
      { key_display: "user:profile:name", key_raw: "cmF3LW5hbWU=", key_type: "string", ttl: -1 },
      { key_display: "user:settings", key_raw: "cmF3LXNldHRpbmdz", key_type: "hash", ttl: -1 },
    ];
    // The first page is intentionally incomplete: branch selection must only
    // submit the currently loaded raw keys, never widen into a new SCAN.
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 7, keys, total_keys: 20 });
    mocks.redisDeleteKeys.mockResolvedValue(keys.length);
    mountBrowser();
    await settle();

    await submitKeySearch("user");
    // Regular glob search keeps the pre-existing flat, virtualized result path.
    expect(document.querySelectorAll('input[type="checkbox"]')).toHaveLength(keys.length);

    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    // New searches start collapsed; expanding each level reveals the original
    // leaf and group controls without broadening the loaded matching subset.
    expect(document.querySelectorAll('input[type="checkbox"]')).toHaveLength(1);
    expect(groupRowOrUndefined("profile")).toBeUndefined();
    const scanCallsBeforeExpand = mocks.redisScanKeysBatch.mock.calls.length;
    groupRow("user").dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
    await settle();
    expect(document.querySelectorAll('input[type="checkbox"]')).toHaveLength(3);
    groupRow("profile").dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
    await settle();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCallsBeforeExpand);
    expect(document.querySelectorAll('input[type="checkbox"]')).toHaveLength(keys.length + 2);
    await selectGroup("user");

    const deleteButton = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).find((button) => button.textContent?.trim() === String(keys.length));
    expect(deleteButton).toBeDefined();
    deleteButton!.click();
    await settle();
    requiredElement<HTMLButtonElement>("[data-test-danger-confirm]").click();
    await settle();

    expect(mocks.redisDeleteKeys).toHaveBeenCalledTimes(1);
    const [connectionId, db, deletedKeyRaws] = mocks.redisDeleteKeys.mock.calls[0] ?? [];
    expect(connectionId).toBe("connection");
    expect(db).toBe(0);
    expect(new Set(deletedKeyRaws)).toEqual(new Set(keys.map((key) => key.key_raw)));
    expect(document.querySelectorAll('input[type="checkbox"]')).toHaveLength(0);
  });

  it("selects hierarchy folders in the normal tree the same way as fuzzy groups", async () => {
    const keys = [
      { key_display: "course:incr_class_id-1004", key_raw: "Y291cnNlOjEwMDQ=", key_type: "string", ttl: -1 },
      { key_display: "course:incr_class_id-172", key_raw: "Y291cnNlOjE3Mg==", key_type: "string", ttl: -1 },
      { key_display: "other:item", key_raw: "b3RoZXI6aXRlbQ==", key_type: "string", ttl: -1 },
    ];
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys, total_keys: keys.length });
    mocks.redisDeleteKeys.mockResolvedValue(2);
    mountBrowser();
    await settle();

    // Single-click the folder checkbox (left side) selects all loaded keys under it.
    await selectGroup("course");
    expect(isCheckboxChecked(groupCheckbox("course"))).toBe(true);
    expect(document.querySelector("[data-redis-batch-delete]")?.textContent).toContain("2");

    // Expand and uncheck children — parent must clear (not stay checked).
    groupRow("course").dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
    await settle();
    for (const input of redisCheckboxes()) {
      const label = input.closest(".group")?.querySelector(".dbx-editor-font-family")?.textContent;
      if (label?.startsWith("incr_class_id-") && isCheckboxChecked(input)) {
        input.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
      }
    }
    await settle();
    expect(isCheckboxChecked(groupCheckbox("course"))).toBe(false);
    expect(isCheckboxMixed(groupCheckbox("course"))).toBe(false);
    expect(document.querySelector("[data-redis-batch-delete]")).toBeNull();

    // Re-select the folder and delete only its keys.
    await selectGroup("course");
    expect(isCheckboxChecked(groupCheckbox("course"))).toBe(true);
    requiredElement<HTMLButtonElement>("[data-redis-batch-delete]").click();
    await settle();
    requiredElement<HTMLButtonElement>("[data-test-danger-confirm]").click();
    await settle();

    expect(mocks.redisDeleteKeys).toHaveBeenCalledWith("connection", 0, expect.arrayContaining(["Y291cnNlOjEwMDQ=", "Y291cnNlOjE3Mg=="]));
    expect(mocks.redisDeleteKeys.mock.calls[0]?.[2]).not.toContain("b3RoZXI6aXRlbQ==");
  });

  it("falls back to flat rows at the fuzzy tree limit while retaining loaded-result delete wording", async () => {
    const keys = [
      { key_display: "user:profile:email", key_raw: "cmF3LWVtYWls", key_type: "string", ttl: -1 },
      { key_display: "user:profile:name", key_raw: "cmF3LW5hbWU=", key_type: "string", ttl: -1 },
    ];
    mocks.canBuildRedisFuzzyTree.mockReturnValue(false);
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys, total_keys: keys.length });
    mocks.redisDeleteKeys.mockResolvedValue(1);
    mountBrowser();
    await settle();

    await submitKeySearch("user");
    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    // The group controls disappear when the view falls back to virtualized rows.
    expect(document.querySelectorAll('input[type="checkbox"]')).toHaveLength(keys.length);
    expect(document.body.textContent).toContain("redis.fuzzyTreeLimit");

    requiredElement<HTMLElement>('input[type="checkbox"]').click();
    await settle();
    const deleteButton = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).find((button) => button.textContent?.trim() === "1");
    expect(deleteButton).toBeDefined();
    deleteButton!.click();
    await settle();
    expect(requiredElement<HTMLElement>("[data-test-danger-details]").textContent).toContain("redis.deleteLoadedSearchKeysDetails");
    requiredElement<HTMLButtonElement>("[data-test-danger-confirm]").click();
    await settle();

    expect(mocks.redisDeleteKeys).toHaveBeenCalledWith("connection", 0, [keys[0]!.key_raw]);
  });

  it("keeps a selected fuzzy group partial when a later SCAN page adds matching keys", async () => {
    const firstPageKeys = [{ key_display: "user:one", key_raw: "dXNlci1vbmU=", key_type: "string", ttl: -1 }];
    const laterPageKeys = [{ key_display: "user:two", key_raw: "dXNlci10d28=", key_type: "string", ttl: -1 }];
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => Promise.resolve(cursor === 0 ? { cursor: 7, keys: firstPageKeys, total_keys: 2 } : { cursor: 0, keys: laterPageKeys, total_keys: 0 }));
    mocks.redisDeleteKeys.mockResolvedValue(1);
    mountBrowser();
    await settle();

    await submitKeySearch("user");
    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    await selectGroup("user");
    clickButtonWithText("redis.loadMoreKeys");
    await settle();

    const updatedUserCheckbox = groupCheckbox("user");
    expect(isCheckboxChecked(updatedUserCheckbox)).toBe(false);
    expect(isCheckboxMixed(updatedUserCheckbox)).toBe(true);
    const deleteButton = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).find((button) => button.textContent?.trim() === "1");
    expect(deleteButton).toBeDefined();
    deleteButton!.click();
    await settle();
    requiredElement<HTMLButtonElement>("[data-test-danger-confirm]").click();
    await settle();

    expect(mocks.redisDeleteKeys).toHaveBeenCalledWith("connection", 0, [firstPageKeys[0]!.key_raw]);
  });

  it("sends a large selected fuzzy group in bounded delete batches", async () => {
    const keys = Array.from({ length: 1_001 }, (_, index) => ({
      key_display: `batch:${String(index).padStart(4, "0")}`,
      key_raw: `cmF3LWJhdGNoLS${index}`,
      key_type: "string",
      ttl: -1,
    }));
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys, total_keys: keys.length });
    mocks.redisDeleteKeys.mockImplementation(async (_connectionId: string, _db: number, keyRaws: string[]) => keyRaws.length);
    mountBrowser();
    await settle();

    await submitKeySearch("batch");
    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    await selectGroup("batch");
    const deleteButton = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).find((button) => button.textContent?.trim() === String(keys.length));
    expect(deleteButton).toBeDefined();
    deleteButton!.click();
    await settle();
    requiredElement<HTMLButtonElement>("[data-test-danger-confirm]").click();
    await settle();
    await settle();

    expect(mocks.redisDeleteKeys.mock.calls.map((call) => call[2]?.length)).toEqual([1_000, 1]);
    expect(new Set(mocks.redisDeleteKeys.mock.calls.flatMap((call) => call[2] ?? []))).toEqual(new Set(keys.map((key) => key.key_raw)));
  });

  it("reloads the result set when a later delete batch fails after an earlier batch succeeds", async () => {
    const keys = Array.from({ length: 1_001 }, (_, index) => ({
      key_display: `batch:${String(index).padStart(4, "0")}`,
      key_raw: `cmF3LWJhdGNoLS${index}`,
      key_type: "string",
      ttl: -1,
    }));
    const freshKeys = [{ key_display: "fresh:remaining", key_raw: "ZnJlc2gtcmVtYWluaW5n", key_type: "string", ttl: -1 }];
    let returnFreshResults = false;
    mocks.redisScanKeysBatch.mockImplementation(() => Promise.resolve(returnFreshResults ? { cursor: 0, keys: freshKeys, total_keys: 1 } : { cursor: 0, keys, total_keys: keys.length }));
    mocks.redisDeleteKeys.mockResolvedValueOnce(1_000).mockImplementationOnce(async () => {
      returnFreshResults = true;
      throw new Error("second batch failed");
    });
    mountBrowser();
    await settle();

    await submitKeySearch("batch");
    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    await selectGroup("batch");
    const deleteButton = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).find((button) => button.textContent?.trim() === String(keys.length));
    expect(deleteButton).toBeDefined();
    deleteButton!.click();
    await settle();
    requiredElement<HTMLButtonElement>("[data-test-danger-confirm]").click();
    await settle();
    await settle();

    expect(mocks.redisDeleteKeys.mock.calls.map((call) => call[2]?.length)).toEqual([1_000, 1]);
    expect(mocks.toast).toHaveBeenCalledWith("second batch failed", 5000);
    expect(document.body.textContent).toContain("fresh");
    expect(document.body.textContent).not.toContain("0000");
  });

  it("reloads after a later delete batch fails while the browser is deactivated", async () => {
    const keys = Array.from({ length: 1_001 }, (_, index) => ({
      key_display: `batch:${String(index).padStart(4, "0")}`,
      key_raw: `cmF3LWJhdGNoLS${index}`,
      key_type: "string",
      ttl: -1,
    }));
    const freshKeys = [{ key_display: "fresh:remaining", key_raw: "ZnJlc2gtcmVtYWluaW5n", key_type: "string", ttl: -1 }];
    const laterDelete = deferred<number>();
    let returnFreshResults = false;
    mocks.redisScanKeysBatch.mockImplementation(() => Promise.resolve(returnFreshResults ? { cursor: 0, keys: freshKeys, total_keys: 1 } : { cursor: 0, keys, total_keys: keys.length }));
    mocks.redisDeleteKeys.mockResolvedValueOnce(1_000).mockImplementationOnce(() => laterDelete.promise);
    const browser = mountKeptAliveBrowser();
    await settle();

    await submitKeySearch("batch");
    clickButtonWithText("redis.fuzzyMatch");
    await settle();

    await selectGroup("batch");
    const deleteButton = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).find((button) => button.textContent?.trim() === String(keys.length));
    expect(deleteButton).toBeDefined();
    deleteButton!.click();
    await settle();
    requiredElement<HTMLButtonElement>("[data-test-danger-confirm]").click();
    await settle();

    expect(mocks.redisDeleteKeys.mock.calls.map((call) => call[2]?.length)).toEqual([1_000, 1]);
    await browser.deactivate();
    returnFreshResults = true;
    laterDelete.reject(new Error("second batch failed while inactive"));
    await settle();
    const scanCountBeforeActivation = mocks.redisScanKeysBatch.mock.calls.length;

    await browser.activate();
    await settle();

    expect(mocks.toast).toHaveBeenCalledWith("second batch failed while inactive", 5000);
    expect(mocks.redisScanKeysBatch.mock.calls.length).toBeGreaterThan(scanCountBeforeActivation);
    expect(document.body.textContent).toContain("fresh");
    expect(document.body.textContent).not.toContain("0000");
  });
});

describe("RedisKeyBrowser KeepAlive scan budget (issue #7779)", () => {
  it("does not replenish an exhausted automatic budget after deactivate/reactivate and resize", async () => {
    const originalClientHeight = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "clientHeight");
    const originalScrollHeight = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "scrollHeight");
    Object.defineProperty(HTMLElement.prototype, "clientHeight", {
      configurable: true,
      get(this: HTMLElement) {
        return this.classList.contains("redis-key-scroller") ? 1000 : 0;
      },
    });
    Object.defineProperty(HTMLElement.prototype, "scrollHeight", {
      configurable: true,
      get(this: HTMLElement) {
        return this.classList.contains("redis-key-scroller") ? 90 : 0;
      },
    });

    try {
      mocks.infiniteScroll = true;
      mocks.redisScanPageSize = 1000;
      let call = 0;
      mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => {
        call++;
        return Promise.resolve({ cursor: cursor + 1, keys: call === 1 ? [{ key_display: "seed", key_raw: "c2VlZA==", key_type: "string", ttl: -1 }] : [], total_keys: 5_000_000 });
      });

      const browser = mountKeptAliveBrowser();
      await vi.waitFor(() => expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(8));
      await settle();
      const callsAtBudget = mocks.redisScanKeysBatch.mock.calls.length;

      await browser.deactivate();
      await browser.activate();
      requiredElement<HTMLElement>(".redis-key-scroller").dispatchEvent(new Event("resize"));
      await settle();

      expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(callsAtBudget);
    } finally {
      if (originalClientHeight) Object.defineProperty(HTMLElement.prototype, "clientHeight", originalClientHeight);
      if (originalScrollHeight) Object.defineProperty(HTMLElement.prototype, "scrollHeight", originalScrollHeight);
    }
  });
});

describe("RedisKeyBrowser interrupted Fetch All", () => {
  it("keeps the complete snapshot when a group is opened during preparation", async () => {
    const initial = { key_display: "group:first", key_raw: btoa("group:first"), key_type: "string", ttl: -1 };
    const buffered = { key_display: "group:second", key_raw: btoa("group:second"), key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: [initial], total_keys: 2 } : { cursor: 0, keys: [buffered], total_keys: 0 }));
    const buildStarted = deferred<void>();
    const releaseBuild = deferred<void>();
    const buildSnapshot = mocks.buildRedisKeySnapshotCooperatively.getMockImplementation()!;
    mocks.buildRedisKeySnapshotCooperatively.mockImplementationOnce(async (...args) => {
      buildStarted.resolve();
      await releaseBuild.promise;
      return buildSnapshot(...args);
    });
    mountBrowser();
    await settle();
    clickButtonWithText("redis.fetchAllKeys");
    await buildStarted.promise;
    groupRow("group").click();
    releaseBuild.resolve();
    await settle();
    await vi.waitFor(() => expect(document.body.textContent).not.toContain("redis.stopFetchAll"));
    await submitKeySearch("group:second");

    expect(document.querySelector(`[data-redis-leaf="${buffered.key_raw}"]`)).not.toBeNull();
    // The first footer click continues from the current cursor, so the sweep
    // costs the same round trip as before.
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(2);
    // The sweep completed, so the action bar keeps offering the full reload
    // instead of disappearing together with the exhausted button.
    expect(document.body.textContent).toContain("redis.refetchAllKeys");
  });

  it("filters a completed Fetch All snapshot while editing a key search", async () => {
    const unrelated = { key_display: "session:unrelated", key_raw: "c2Vzc2lvbjp1bnJlbGF0ZWQ=", key_type: "string", ttl: -1 };
    const target = { key_display: "prod:login_fail_count", key_raw: "cHJvZDpsb2dpbl9mYWlsX2NvdW50", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: [unrelated], total_keys: 2 } : { cursor: 0, keys: [target], total_keys: 0 }));
    mountBrowser();
    await settle();

    clickButtonWithText("redis.fetchAllKeys");
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(2));
    await vi.waitFor(() => expect(document.body.textContent).not.toContain("redis.stopFetchAll"));
    const scanCalls = mocks.redisScanKeysBatch.mock.calls.length;

    await setInput("[data-redis-search-input]", "prod:login_fail_count");

    expect(document.body.textContent).toContain(target.key_display);
    expect(document.body.textContent).not.toContain(unrelated.key_display);
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCalls);
    const input = requiredElement<HTMLInputElement>("[data-redis-search-input]");
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    await settle();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCalls);
    expect(document.body.textContent).toContain(target.key_display);
    requiredElement<HTMLButtonElement>("[data-redis-select-all]").click();
    await settle();
    expect(document.querySelector("[data-redis-batch-delete]")?.textContent).toContain("1");
    expect(document.querySelector("[data-redis-select-all]")).toBeNull();

    await setInput("[data-redis-search-input]", "");
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCalls);
    expect(mocks.scrollerItems[mocks.scrollerItems.length - 1]).toHaveLength(2);
  });

  it("publishes Fetch All rows through one stable Array facade and explicitly refreshes its viewport", async () => {
    const initial = { key_display: "initial", key_raw: "aW5pdGlhbA==", key_type: "string", ttl: -1 };
    const buffered = { key_display: "buffered", key_raw: "YnVmZmVyZWQ=", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: [initial], total_keys: 2 } : { cursor: 0, keys: [buffered], total_keys: 0 }));
    mountBrowser();
    await settle();
    const itemsBeforeFetchAll = mocks.scrollerItems[mocks.scrollerItems.length - 1];
    resetScrollerObservations();

    clickButtonWithText("redis.fetchAllKeys");
    await vi.waitFor(() => expect(mocks.scrollerUpdateVisibleItems).toHaveBeenCalled());

    const publishedItems = mocks.scrollerItems[mocks.scrollerItems.length - 1];
    expect(publishedItems).toBe(itemsBeforeFetchAll);
    expect(Array.isArray(publishedItems)).toBe(true);
    expect(publishedItems).toHaveLength(2);
    expect((publishedItems[0] as { id?: string } | undefined)?.id).toBeTruthy();
    expect([...(publishedItems as Array<{ node: { label: string } }>)].map((row) => row.node.label).sort()).toEqual(["buffered", "initial"]);
    expect(mocks.scrollerUpdateVisibleItems).toHaveBeenCalledWith(true);
    expect((publishedItems as Array<{ node: { label: string } }>).some((row) => row.node.label === "buffered")).toBe(true);
    expect(document.body.textContent).toContain("initial");
    expect(document.body.textContent).not.toContain("redis.stopFetchAll");
  });

  it("rebinds rendered labels from a complete large facade source without exposing holes", async () => {
    const initial = { key_display: "initial", key_raw: "aW5pdGlhbA==", key_type: "string", ttl: -1 };
    const buffered = { key_display: "buffered", key_raw: "YnVmZmVyZWQ=", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: [initial], total_keys: 2 } : { cursor: 0, keys: [buffered], total_keys: 0 }));
    mountBrowser();
    await settle();
    resetScrollerObservations();

    const visibleRows = Array.from({ length: 25_001 }, (_, index) => {
      const label = `next-${String(index).padStart(5, "0")}`;
      return {
        id: `leaf:0:${label}`,
        depth: 0,
        node: {
          kind: "leaf" as const,
          id: `leaf:0:${label}`,
          label,
          fullKeyDisplay: label,
          keyRaw: label,
          db: 0,
          keyType: "string",
          ttl: -1,
          size: 0,
          valuePreview: "",
          pathSegments: [label],
        },
      };
    });
    mocks.buildRedisKeySnapshotCooperatively.mockResolvedValueOnce({
      flatKeys: [initial, buffered],
      flatKeyByRaw: new Map([
        [initial.key_raw, initial],
        [buffered.key_raw, buffered],
      ]),
      loadedKeyRaws: new Set([initial.key_raw, buffered.key_raw]),
      filteredKeyCount: 2,
      treeIndex: null,
      expandedGroupIds: new Set(),
      visibleRows,
    });

    clickButtonWithText("redis.fetchAllKeys");
    await vi.waitFor(() => expect(document.body.textContent).toContain("next-00000"));
    await vi.waitFor(() => expect(document.body.textContent).not.toContain("redis.stopFetchAll"));

    expect(mocks.scrollerUpdateVisibleItems).toHaveBeenCalledTimes(1);
    expect(mocks.scrollerUpdateVisibleItems.mock.calls.every(([itemsChanged]) => itemsChanged === true)).toBe(true);
    expect(mocks.scrollerRefreshSnapshots[0]).toMatchObject({ length: 25_001, hasHoles: false });
    expect(document.body.textContent).toContain("next-00049");
    expect(document.body.textContent).not.toContain("initial");
  });

  it("restores a visible row by stable ID when final ordering moves it across publication chunks", async () => {
    const initialKeys = [
      { key_display: "a-before", key_raw: "YS1iZWZvcmU=", key_type: "string", ttl: -1 },
      { key_display: "m-anchor", key_raw: "bS1hbmNob3I=", key_type: "string", ttl: -1 },
      { key_display: "z-after", key_raw: "ei1hZnRlcg==", key_type: "string", ttl: -1 },
    ];
    const buffered = { key_display: "buffered", key_raw: "YnVmZmVyZWQ=", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: initialKeys, total_keys: 4 } : { cursor: 0, keys: [buffered], total_keys: 0 }));
    mountBrowser();
    await settle();
    resetScrollerObservations();

    const initialRows = mocks.scrollerItems[mocks.scrollerItems.length - 1] as Array<{ id: string }>;
    const anchorRowId = initialRows[1]?.id;
    expect(anchorRowId).toBeTruthy();
    mocks.scrollerVisibleStartIndex = 1;
    const visibleRows = Array.from({ length: 25_001 }, (_, index) => redisFlatRow(`next:${index}`, `next-${index}`));
    visibleRows[25_000] = redisFlatRow(anchorRowId!, "m-anchor", initialKeys[1]!.key_raw);
    mocks.buildRedisKeySnapshotCooperatively.mockResolvedValueOnce({
      flatKeys: [...initialKeys, buffered],
      flatKeyByRaw: new Map([...initialKeys, buffered].map((key) => [key.key_raw, key])),
      loadedKeyRaws: new Set([...initialKeys, buffered].map((key) => key.key_raw)),
      filteredKeyCount: 4,
      treeIndex: null,
      expandedGroupIds: new Set(),
      visibleRows,
    });

    clickButtonWithText("redis.fetchAllKeys");
    await vi.waitFor(() => expect(mocks.scrollerScrollToItem).toHaveBeenCalled());

    expect(mocks.scrollerScrollToItem).toHaveBeenCalledWith(25_000, { align: "start" });
    expect(mocks.scrollerVisiblePositions).toEqual([2, 25_000]);
    expect(mocks.scrollerCallOrder).toEqual([`scroll:${anchorRowId}`, "update:next:2", `scroll:${anchorRowId}`, `update:${anchorRowId}`]);
    expect(document.body.textContent).toContain("m-anchor");
  });

  it("does not move the viewport when its stable row anchor is absent from the final projection", async () => {
    const initialKeys = [
      { key_display: "a-before", key_raw: "YS1iZWZvcmU=", key_type: "string", ttl: -1 },
      { key_display: "m-missing", key_raw: "bS1taXNzaW5n", key_type: "string", ttl: -1 },
    ];
    const buffered = { key_display: "buffered", key_raw: "YnVmZmVyZWQ=", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: initialKeys, total_keys: 3 } : { cursor: 0, keys: [buffered], total_keys: 0 }));
    mountBrowser();
    await settle();
    resetScrollerObservations();
    mocks.scrollerVisibleStartIndex = 1;
    mocks.buildRedisKeySnapshotCooperatively.mockResolvedValueOnce({
      flatKeys: [...initialKeys, buffered],
      flatKeyByRaw: new Map([...initialKeys, buffered].map((key) => [key.key_raw, key])),
      loadedKeyRaws: new Set([...initialKeys, buffered].map((key) => key.key_raw)),
      filteredKeyCount: 3,
      treeIndex: null,
      expandedGroupIds: new Set(),
      visibleRows: [redisFlatRow("replacement", "replacement")],
    });

    clickButtonWithText("redis.fetchAllKeys");
    await vi.waitFor(() => expect(mocks.scrollerUpdateVisibleItems).toHaveBeenCalled());

    expect(mocks.scrollerScrollToItem).not.toHaveBeenCalled();
  });

  it("prefers the latest visible stable row when the user scrolls between publication chunks", async () => {
    const initialKeys = Array.from({ length: 20 }, (_, index) => ({
      key_display: `initial-${String(index).padStart(2, "0")}`,
      key_raw: `initial-raw-${index}`,
      key_type: "string",
      ttl: -1,
    }));
    const buffered = { key_display: "buffered", key_raw: "YnVmZmVyZWQ=", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: initialKeys, total_keys: 21 } : { cursor: 0, keys: [buffered], total_keys: 0 }));
    mountBrowser();
    await settle();
    resetScrollerObservations();

    const initialRows = mocks.scrollerItems[mocks.scrollerItems.length - 1] as Array<{ id: string }>;
    const initialRowId = initialRows[0]!.id;
    const latestAnchorRowId = initialRows[10]!.id;
    const visibleRows = Array.from({ length: 25_001 }, (_, index) => redisFlatRow(`next:${index}`, `next-${index}`));
    visibleRows[5] = redisFlatRow(latestAnchorRowId, "initial-10", initialKeys[10]!.key_raw);
    visibleRows[25_000] = redisFlatRow(initialRowId, "initial-00", initialKeys[0]!.key_raw);
    mocks.buildRedisKeySnapshotCooperatively.mockResolvedValueOnce({
      flatKeys: [...initialKeys, buffered],
      flatKeyByRaw: new Map([...initialKeys, buffered].map((key) => [key.key_raw, key])),
      loadedKeyRaws: new Set([...initialKeys, buffered].map((key) => key.key_raw)),
      filteredKeyCount: 21,
      treeIndex: null,
      expandedGroupIds: new Set(),
      visibleRows,
    });
    const pendingFrames: FrameRequestCallback[] = [];
    const originalRequestAnimationFrame = window.requestAnimationFrame;
    window.requestAnimationFrame = (callback: FrameRequestCallback) => {
      pendingFrames.push(callback);
      return pendingFrames.length;
    };

    try {
      clickButtonWithText("redis.fetchAllKeys");
      await vi.waitFor(() => expect(pendingFrames).toHaveLength(1));
      expect(mocks.scrollerUpdateVisibleItems).not.toHaveBeenCalled();
      mocks.scrollerVisibleStartIndex = 10;
      requiredElement<HTMLElement>(".redis-key-scroller").dispatchEvent(new Event("scroll"));
      pendingFrames[0]!(0);
      await vi.waitFor(() => expect(mocks.scrollerUpdateVisibleItems).toHaveBeenCalledTimes(2));

      expect(mocks.scrollerScrollToItem).toHaveBeenCalledTimes(2);
      expect(mocks.scrollerScrollToItem).toHaveBeenCalledWith(5, { align: "start" });
      expect(mocks.scrollerCallOrder).toEqual([`scroll:${latestAnchorRowId}`, `update:${latestAnchorRowId}`, `scroll:${latestAnchorRowId}`, `update:${latestAnchorRowId}`]);
    } finally {
      window.requestAnimationFrame = originalRequestAnimationFrame;
    }
  });

  it("keeps stable Fetch All rows for metadata-only detail updates and exits them for no-expiry membership changes", async () => {
    const initial = { key_display: "initial", key_raw: "aW5pdGlhbA==", key_type: "string", ttl: -1 };
    const buffered = { key_display: "buffered", key_raw: "YnVmZmVyZWQ=", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: [initial], total_keys: 2 } : { cursor: 0, keys: [buffered], total_keys: 0 }));
    mountBrowser();
    await settle();
    resetScrollerObservations();
    requiredElement<HTMLButtonElement>("[data-redis-no-expiry-filter]").click();
    await settle();
    resetScrollerObservations();

    clickButtonWithText("redis.fetchAllKeys");
    await vi.waitFor(() => expect(mocks.scrollerUpdateVisibleItems).toHaveBeenCalled());
    const stableItems = mocks.scrollerItems[mocks.scrollerItems.length - 1];
    expect((stableItems as Array<{ node: { keyRaw?: string } }>).some((row) => row.node.keyRaw === buffered.key_raw)).toBe(true);
    requiredElement<HTMLElement>(`[data-redis-leaf="${initial.key_raw}"]`).closest<HTMLElement>(".group")?.click();
    await settle();

    mocks.loadedTtl = -1;
    requiredElement<HTMLButtonElement>("[data-test-emit-key-loaded]").click();
    await settle();
    expect(mocks.scrollerItems[mocks.scrollerItems.length - 1]).toBe(stableItems);

    mocks.loadedTtl = 60;
    requiredElement<HTMLButtonElement>("[data-test-emit-key-loaded]").click();
    await settle();
    expect(mocks.scrollerItems[mocks.scrollerItems.length - 1]).toBe(stableItems);
    expect(document.querySelector(`[data-redis-leaf="${initial.key_raw}"]`)).toBeNull();
    expect((mocks.scrollerItems[mocks.scrollerItems.length - 1] as Array<{ node: { keyRaw?: string } }>).some((row) => row.node.keyRaw === buffered.key_raw)).toBe(true);
  });

  it("keeps the previously published rows when Fetch All is stopped during cooperative preparation", async () => {
    const initial = { key_display: "initial", key_raw: "aW5pdGlhbA==", key_type: "string", ttl: -1 };
    const buffered = { key_display: "buffered", key_raw: "YnVmZmVyZWQ=", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: [initial], total_keys: 2 } : { cursor: 0, keys: [buffered], total_keys: 0 }));
    const buildStarted = deferred<void>();
    const releaseBuild = deferred<void>();
    const buildSnapshot = mocks.buildRedisKeySnapshotCooperatively.getMockImplementation();
    expect(buildSnapshot).toBeDefined();
    mocks.buildRedisKeySnapshotCooperatively.mockImplementationOnce(async (...args) => {
      buildStarted.resolve();
      await releaseBuild.promise;
      return buildSnapshot!(...args);
    });
    mountBrowser();
    await settle();
    resetScrollerObservations();

    clickButtonWithText("redis.fetchAllKeys");
    await buildStarted.promise;
    clickButtonWithText("redis.stopFetchAll");
    releaseBuild.resolve();
    await settle();

    expect(document.body.textContent).toContain("initial");
    expect(document.body.textContent).not.toContain("buffered");
    expect(document.body.textContent).toContain("redis.fetchAllKeys");
    expect(mocks.scrollerScrollToItem).not.toHaveBeenCalled();
    expect((mocks.scrollerItems[mocks.scrollerItems.length - 1] as Array<{ node: { label: string } }>).map((row) => row.node.label)).toEqual(["initial"]);
  });

  it("keeps the old facade source when Fetch All is stopped during cooperative anchor resolution", async () => {
    const initial = { key_display: "initial", key_raw: "aW5pdGlhbA==", key_type: "string", ttl: -1 };
    const buffered = { key_display: "buffered", key_raw: "YnVmZmVyZWQ=", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: [initial], total_keys: 2 } : { cursor: 0, keys: [buffered], total_keys: 0 }));
    mountBrowser();
    await settle();
    resetScrollerObservations();

    const row = {
      id: "leaf:0:buffered",
      depth: 0,
      node: {
        kind: "leaf" as const,
        id: "leaf:0:buffered",
        label: "buffered",
        fullKeyDisplay: "buffered",
        keyRaw: buffered.key_raw,
        db: 0,
        keyType: "string",
        ttl: -1,
        size: 0,
        valuePreview: "",
        pathSegments: ["buffered"],
      },
    };
    mocks.buildRedisKeySnapshotCooperatively.mockResolvedValueOnce({
      flatKeys: [initial, buffered],
      flatKeyByRaw: new Map([
        [initial.key_raw, initial],
        [buffered.key_raw, buffered],
      ]),
      loadedKeyRaws: new Set([initial.key_raw, buffered.key_raw]),
      filteredKeyCount: 2,
      treeIndex: null,
      expandedGroupIds: new Set(),
      visibleRows: Array.from({ length: 25_001 }, () => row),
    });
    const pendingFrames: FrameRequestCallback[] = [];
    const originalRequestAnimationFrame = window.requestAnimationFrame;
    window.requestAnimationFrame = (callback: FrameRequestCallback) => {
      pendingFrames.push(callback);
      return pendingFrames.length;
    };

    try {
      clickButtonWithText("redis.fetchAllKeys");
      await vi.waitFor(() => expect(pendingFrames).toHaveLength(1));
      expect(mocks.scrollerUpdateVisibleItems).not.toHaveBeenCalled();
      clickButtonWithText("redis.stopFetchAll");
      expect(pendingFrames).toHaveLength(1);
      pendingFrames[0](0);
      await settle();

      expect(document.body.textContent).toContain("initial");
      expect(document.body.textContent).not.toContain("buffered");
      expect(document.body.textContent).toContain("redis.fetchAllKeys");
      expect(mocks.scrollerScrollToItem).not.toHaveBeenCalled();
      expect((mocks.scrollerItems[mocks.scrollerItems.length - 1] as Array<{ node: { label: string } }>).map((item) => item.node.label)).toEqual(["initial"]);
      expect(mocks.scrollerRefreshSnapshots.every((snapshot) => !snapshot.ids.includes(row.id))).toBe(true);
    } finally {
      window.requestAnimationFrame = originalRequestAnimationFrame;
    }
  });

  it("reloads instead of advancing past an uncommitted buffered page after reactivation", async () => {
    const bufferedPage = deferred<{ cursor: number; keys: Array<{ key_display: string; key_raw: string; key_type: string; ttl: number }>; total_keys: number }>();
    let returnFreshPage = false;
    let freshPageRequests = 0;
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => {
      if (cursor === 1) return bufferedPage.promise;
      if (returnFreshPage) freshPageRequests++;
      return Promise.resolve(returnFreshPage ? { cursor: 0, keys: [{ key_display: "fresh:key", key_raw: "ZnJlc2gta2V5", key_type: "string", ttl: -1 }], total_keys: 2 } : { cursor: 1, keys: [{ key_display: "initial:key", key_raw: "aW5pdGlhbC1rZXk=", key_type: "string", ttl: -1 }], total_keys: 2 });
    });
    const browser = mountKeptAliveBrowser();
    await settle();

    clickButtonWithText("redis.fetchAllKeys");
    await settle();

    await browser.deactivate();
    returnFreshPage = true;
    bufferedPage.resolve({ cursor: 0, keys: [{ key_display: "buffered:key", key_raw: "YnVmZmVyZWQta2V5", key_type: "string", ttl: -1 }], total_keys: 0 });
    await settle();
    await browser.activate();
    await settle();

    expect(document.body.textContent).toContain("fresh");
    expect(document.body.textContent).not.toContain("buffered");
    expect(freshPageRequests).toBeGreaterThan(0);
  });

  it("selects all loaded keys from the toolbar and clears the multi-selection", async () => {
    const keys = [
      { key_display: "alpha", key_raw: "YWxwaGE=", key_type: "string", ttl: -1 },
      { key_display: "bravo", key_raw: "YnJhdm8=", key_type: "string", ttl: -1 },
      { key_display: "charlie", key_raw: "Y2hhcmxpZQ==", key_type: "string", ttl: -1 },
    ];
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys, total_keys: keys.length });
    mountBrowser();
    await settle();

    const selectAll = requiredElement<HTMLButtonElement>("[data-redis-select-all]");
    selectAll.click();
    await settle();

    const checkboxes = Array.from(document.querySelectorAll<HTMLElement>('input[type="checkbox"]'));
    expect(checkboxes).toHaveLength(keys.length);
    expect(checkboxes.every((checkbox) => isCheckboxChecked(checkbox as HTMLElement))).toBe(true);
    expect(document.querySelector("[data-redis-select-all]")).toBeNull();
    expect(document.querySelector("[data-redis-batch-delete]")?.textContent).toContain(String(keys.length));
    expect(document.activeElement).toBe(document.querySelector(".redis-key-pane"));

    requiredElement<HTMLButtonElement>("[data-redis-deselect-all]").click();
    await settle();
    expect(Array.from(document.querySelectorAll<HTMLElement>('input[type="checkbox"]')).every((checkbox) => !isCheckboxChecked(checkbox))).toBe(true);
    expect(document.querySelector("[data-redis-batch-delete]")).toBeNull();
    expect(document.querySelector("[data-redis-select-all]")).not.toBeNull();
    expect(document.activeElement).toBe(document.querySelector(".redis-key-pane"));
  });

  it("fetches remaining scan pages before selecting all keys", async () => {
    const first = { key_display: "first", key_raw: "Zmlyc3Q=", key_type: "string", ttl: -1 };
    const second = { key_display: "second", key_raw: "c2Vjb25k", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => {
      if (cursor === 0) return Promise.resolve({ cursor: 1, keys: [first], total_keys: 2 });
      return Promise.resolve({ cursor: 0, keys: [second], total_keys: 0 });
    });
    mountBrowser();
    await settle();

    expect(document.body.textContent).toContain("redis.loadMoreKeys");
    const keyPane = requiredElement<HTMLElement>(".redis-key-pane");
    keyPane.focus();
    keyPane.dispatchEvent(new KeyboardEvent("keydown", { key: "a", ctrlKey: true, bubbles: true, cancelable: true }));
    await vi.waitFor(() => expect(document.querySelector("[data-redis-batch-delete]")?.textContent).toContain("2"));

    expect(document.body.textContent).toContain("second");
    expect(Array.from(document.querySelectorAll<HTMLElement>('input[type="checkbox"]')).every(isCheckboxChecked)).toBe(true);
    expect(document.querySelector("[data-redis-select-all]")).toBeNull();
  });

  it("does not select stale keys when a search changes during select-all scanning", async () => {
    const oldPage = deferred<{ cursor: number; keys: RedisKeyInfo[]; total_keys: number }>();
    const oldKey = { key_display: "old", key_raw: "b2xk", key_type: "string", ttl: -1 };
    const lateOldKey = { key_display: "late-old", key_raw: "bGF0ZS1vbGQ=", key_type: "string", ttl: -1 };
    const freshKey = { key_display: "fresh", key_raw: "ZnJlc2g=", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number, pattern: string) => {
      if (pattern === "*" && cursor === 0) return Promise.resolve({ cursor: 1, keys: [oldKey], total_keys: 2 });
      if (pattern === "*") return oldPage.promise;
      return Promise.resolve({ cursor: 0, keys: [freshKey], total_keys: 1 });
    });
    mountBrowser();
    await settle();

    requiredElement<HTMLButtonElement>("[data-redis-select-all]").click();
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch.mock.calls.length).toBeGreaterThan(1));
    await setInput("[data-redis-search-input]", "fresh");
    oldPage.resolve({ cursor: 0, keys: [lateOldKey], total_keys: 0 });
    await settle();

    expect(document.body.textContent).not.toContain("late-old");
    expect(document.body.textContent).not.toContain("redis.stopFetchAll");
    expect(mocks.redisScanKeysBatch.mock.calls.every((call) => call[3] === "*")).toBe(true);
    expect(document.querySelector("[data-redis-batch-delete]")).toBeNull();

    requiredElement<HTMLInputElement>("[data-redis-search-input]").dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    await settle();

    await vi.waitFor(() => expect(document.body.textContent).toContain("fresh"));
    expect(document.body.textContent).not.toContain("old");
    expect(document.querySelector("[data-redis-batch-delete]")).toBeNull();
  });

  it("does not downgrade Ctrl+A to a partial selection when fetch-all is stopped", async () => {
    const continuation = deferred<{ cursor: number; keys: RedisKeyInfo[]; total_keys: number }>();
    const first = { key_display: "first", key_raw: "Zmlyc3Q=", key_type: "string", ttl: -1 };
    mocks.redisScanKeysBatch.mockImplementation((_connectionId: string, _db: number, cursor: number) => {
      if (cursor === 0) return Promise.resolve({ cursor: 1, keys: [first], total_keys: 2 });
      return continuation.promise;
    });
    mountBrowser();
    await settle();

    requiredElement<HTMLButtonElement>("[data-redis-select-all]").click();
    await vi.waitFor(() => expect(document.body.textContent).toContain("redis.stopFetchAll"));
    clickButtonWithText("redis.stopFetchAll");
    continuation.resolve({ cursor: 1, keys: [], total_keys: 0 });
    await settle();

    expect(document.querySelector("[data-redis-batch-delete]")).toBeNull();
    expect(document.querySelector("[data-redis-select-all]")).not.toBeNull();
  });

  it("shows a native checked mark after selecting a single leaf key", async () => {
    const keys = [
      { key_display: "solo-a", key_raw: "c29sby1h", key_type: "string", ttl: -1 },
      { key_display: "solo-b", key_raw: "c29sby1i", key_type: "string", ttl: -1 },
    ];
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys, total_keys: keys.length });
    mountBrowser();
    await settle();

    const leafA = leafCheckbox("solo-a");
    expect(leafA.className).toContain("accent-primary");
    expect(leafA.className).toContain("h-3.5");
    leafA.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
    await settle();
    expect(isCheckboxChecked(leafCheckbox("solo-a"))).toBe(true);
    expect(document.querySelector("[data-redis-batch-delete]")?.textContent).toContain("1");
  });

  it("keeps parent and child checkbox DOM state in sync", async () => {
    const keys = [
      { key_display: "pack:user_select", key_raw: "cGFjazp1c2VyX3NlbGVjdA==", key_type: "string", ttl: -1 },
      { key_display: "other:item", key_raw: "b3RoZXI6aXRlbQ==", key_type: "string", ttl: -1 },
    ];
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys, total_keys: keys.length });
    mountBrowser();
    await settle();

    // Select parent folder → child leaf must also appear checked.
    await selectGroup("pack");
    groupRow("pack").dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
    await settle();

    const child = leafCheckbox("user_select");
    expect(isCheckboxChecked(groupCheckbox("pack"))).toBe(true);
    expect(isCheckboxChecked(child)).toBe(true);

    // Uncheck child → parent must clear.
    child.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
    await settle();
    expect(isCheckboxChecked(leafCheckbox("user_select"))).toBe(false);
    expect(isCheckboxChecked(groupCheckbox("pack"))).toBe(false);
    expect(isCheckboxMixed(groupCheckbox("pack"))).toBe(false);
  });

  it("supports Shift multi-line selection and Ctrl/Cmd+A on the key list", async () => {
    const keys = [
      { key_display: "k1", key_raw: "azE=", key_type: "string", ttl: -1 },
      { key_display: "k2", key_raw: "azI=", key_type: "string", ttl: -1 },
      { key_display: "k3", key_raw: "azM=", key_type: "string", ttl: -1 },
      { key_display: "k4", key_raw: "azQ=", key_type: "string", ttl: -1 },
    ];
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys, total_keys: keys.length });
    mountBrowser();
    await settle();

    const checkboxes = Array.from(document.querySelectorAll<HTMLElement>('input[type="checkbox"]'));
    expect(checkboxes).toHaveLength(keys.length);

    checkboxes[0]!.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
    await settle();
    expect(isCheckboxChecked(checkboxes[0]!)).toBe(true);

    checkboxes[2]!.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true, shiftKey: true }));
    await settle();
    expect(checkboxes.map((checkbox) => isCheckboxChecked(checkbox as HTMLElement))).toEqual([true, true, true, false]);
    expect(document.querySelector("[data-redis-batch-delete]")?.textContent).toContain("3");

    const keyPane = requiredElement<HTMLElement>(".redis-key-pane");
    keyPane.focus();
    keyPane.dispatchEvent(new KeyboardEvent("keydown", { key: "a", ctrlKey: true, bubbles: true, cancelable: true }));
    await settle();
    expect(checkboxes.every((checkbox) => isCheckboxChecked(checkbox as HTMLElement))).toBe(true);
    expect(document.querySelector("[data-redis-batch-delete]")?.textContent).toContain("4");

    keyPane.dispatchEvent(new KeyboardEvent("keydown", { key: "a", metaKey: true, bubbles: true, cancelable: true }));
    await settle();
    expect(checkboxes.every((checkbox) => !isCheckboxChecked(checkbox as HTMLElement))).toBe(true);
  });
});

describe("RedisKeyBrowser connection default key scope", () => {
  const key = (name: string): RedisKeyInfo => ({ key_display: name, key_raw: btoa(name), key_type: "string", ttl: -1 });
  const first = key("order:region01:pending");
  const second = key("order:region02:paid");
  const outside = key("session:pending");

  beforeEach(() => {
    mocks.redisKeyFilter = "order:*";
  });

  it("keeps the input and history empty while browsing a collapsed, scoped hierarchy", async () => {
    localStorage.removeItem("dbx-redis-key-search-history");
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [first, second, outside], total_keys: 1305 });
    mountBrowser();
    await settle();

    expect(requiredElement<HTMLInputElement>("[data-redis-search-input]").value).toBe("");
    expect(mocks.redisScanKeysBatch.mock.calls[0]?.[3]).toBe("order:*");
    expect(groupRowOrUndefined("order")).toBeDefined();
    expect(groupRowOrUndefined("region01")).toBeUndefined();
    expect(groupRowOrUndefined("session")).toBeUndefined();
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("2 keys");
    requiredElement<HTMLButtonElement>("[data-redis-search-history-toggle]").click();
    await settle();
    expect(document.querySelectorAll("[data-redis-search-history-item]")).toHaveLength(0);
  });

  it.each([
    ["exact", "session:pending", false, "session:pending", [outside], 0],
    ["glob", "order:region*", false, "order:region*", [first, second], 2],
    ["fuzzy", "pending", true, "*pending*", [first, outside], 1],
  ] as const)("intersects %s user search with the default scope and restores the scope on clearing", async (_kind, query, fuzzy, pattern, results, count) => {
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [first, second], total_keys: 1305 });
    mountBrowser();
    await settle();
    if (fuzzy) {
      clickButtonWithText("redis.fuzzyMatch");
      await settle();
    }
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: results, total_keys: 1305 });
    await submitKeySearch(query);
    expect(mocks.redisScanKeysBatch.mock.calls[mocks.redisScanKeysBatch.mock.calls.length - 1]?.[3]).toBe(pattern);
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe(`${count} keys`);
    expect(document.querySelector(`[data-redis-leaf="${outside.key_raw}"]`)).toBeNull();
    if (fuzzy) {
      expect(groupRowOrUndefined("order")).toBeDefined();
      expect(groupRowOrUndefined("region01")).toBeUndefined();
    } else if (count) {
      expect(document.querySelector(`[data-redis-leaf="${first.key_raw}"]`)).not.toBeNull();
    }
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [first, second], total_keys: 1305 });
    await submitKeySearch("");
    expect(mocks.redisScanKeysBatch.mock.calls[mocks.redisScanKeysBatch.mock.calls.length - 1]?.[3]).toBe("order:*");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("2 keys");
    expect(groupRowOrUndefined("region01")).toBeUndefined();
  });

  it.each(["value", "all"] as const)("passes the default scope through %s search and its Fetch All continuation", async (mode) => {
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [first], total_keys: 1305 });
    mocks.redisScanValues.mockImplementation((_id, _db, cursor) => Promise.resolve(cursor === 0 ? { cursor: 7, keys: [first, outside], total_keys: 1305 } : { cursor: 0, keys: [second, outside], total_keys: 0 }));
    mountBrowser();
    await settle();
    clickButtonWithText(mode === "value" ? "redis.searchByValue" : "redis.searchByAll");
    await settle();
    expect(mocks.redisScanValues).not.toHaveBeenCalled();
    expect(groupRowOrUndefined("order")).toBeDefined();
    await submitKeySearch("value-needle");
    expect(mocks.redisScanValues).toHaveBeenCalledWith("connection", 0, 0, "order:*", "value-needle", 100, mode === "all");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1+ keys");
    clickButtonWithText("redis.fetchAllKeys");
    await settle();
    await vi.waitFor(() => expect(document.body.textContent).not.toContain("redis.stopFetchAll"));
    expect(mocks.redisScanValues).toHaveBeenLastCalledWith("connection", 0, 7, "order:*", "value-needle", 100, mode === "all");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("2 keys");
    expect(groupRowOrUndefined("session")).toBeUndefined();
    await submitKeySearch("");
    expect(mocks.redisScanKeysBatch.mock.calls[mocks.redisScanKeysBatch.mock.calls.length - 1]?.[3]).toBe("order:*");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1 keys");
  });

  it("retains a cursor and bounded continuation when every backend match is outside the scope", async () => {
    mocks.redisScanPageSize = 1000;
    mountBrowser();
    await settle();
    let batch = 0;
    mocks.redisScanKeysBatch.mockReset();
    mocks.redisScanKeysBatch.mockImplementation(() => {
      batch += 1;
      return Promise.resolve(batch === 8 ? { cursor: 0, keys: [first], total_keys: 0 } : { cursor: batch, keys: [outside], total_keys: 5_000_000 });
    });
    await submitKeySearch("*pending*");
    await vi.waitFor(() => expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(7));
    await vi.waitFor(() => expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("0+ keys"));
    clickButtonWithText("redis.loadMoreKeys");
    await vi.waitFor(() => expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1 keys"));
    expect(mocks.redisScanKeysBatch.mock.calls[7]?.[2]).toBe(7);
    expect(document.querySelector(`[data-redis-leaf="${outside.key_raw}"]`)).toBeNull();
  });

  it("caches only the completed default scope for local searches and clearing", async () => {
    mocks.redisScanKeysBatch.mockImplementation((_id, _db, cursor) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: [first], total_keys: 1305 } : { cursor: 0, keys: [second, outside], total_keys: 0 }));
    mountBrowser();
    await settle();
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1+ keys");
    clickButtonWithText("redis.fetchAllKeys");
    await settle();
    await vi.waitFor(() => expect(document.body.textContent).not.toContain("redis.stopFetchAll"));
    const scanCalls = mocks.redisScanKeysBatch.mock.calls.length;
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("2 keys");
    await submitKeySearch("session:*");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("0 keys");
    await submitKeySearch(first.key_display);
    expect(document.querySelector(`[data-redis-leaf="${first.key_raw}"]`)).not.toBeNull();
    await submitKeySearch("");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("2 keys");
    expect(groupRowOrUndefined("region01")).toBeUndefined();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCalls);
  });

  it("does not treat a completed user-filtered Fetch All as the complete scope", async () => {
    mountBrowser();
    await settle();
    mocks.redisScanKeysBatch.mockImplementation((_id, _db, cursor, pattern) => Promise.resolve(pattern === "order:region01:*" ? { cursor: cursor === 0 ? 1 : 0, keys: [first], total_keys: 1305 } : { cursor: 0, keys: [first, second], total_keys: 1305 }));
    await submitKeySearch("order:region01:*");
    clickButtonWithText("redis.fetchAllKeys");
    await settle();
    await vi.waitFor(() => expect(document.body.textContent).not.toContain("redis.stopFetchAll"));
    const scanCalls = mocks.redisScanKeysBatch.mock.calls.length;
    await submitKeySearch("");
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCalls + 1);
    expect(mocks.redisScanKeysBatch.mock.calls[mocks.redisScanKeysBatch.mock.calls.length - 1]?.[3]).toBe("order:*");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("2 keys");
  });

  it("preserves expanded groups on refresh without subtree scans or whole-prefix deletion", async () => {
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [first, second], total_keys: 1305 });
    mocks.redisDeleteKeys.mockResolvedValue(2);
    mountBrowser();
    await settle();
    groupRow("order").click();
    await settle();
    groupRow("region01").click();
    await settle();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(1);
    expect(document.querySelector('button[title="redis.deleteGroup"]')).toBeNull();
    const refresh = Array.from(document.querySelectorAll<HTMLButtonElement>("button")).find((button) => button.className.includes("h-6 w-6") && !button.hasAttribute("title"));
    expect(refresh).toBeDefined();
    refresh!.click();
    await settle();
    expect(document.querySelector(`[data-redis-leaf="${first.key_raw}"]`)).not.toBeNull();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(2);
    await selectGroup("order");
    requiredElement<HTMLButtonElement>("[data-redis-batch-delete]").click();
    await settle();
    requiredElement<HTMLButtonElement>("[data-test-danger-confirm]").click();
    await settle();
    expect(mocks.redisDeleteKeys).toHaveBeenCalledWith("connection", 0, [first.key_raw, second.key_raw]);
    expect(mocks.redisDeleteKeysByPattern).not.toHaveBeenCalled();
  });

  it("discards a late scoped scan after the user changes the query", async () => {
    const stale = deferred<{ cursor: number; keys: RedisKeyInfo[]; total_keys: number }>();
    mocks.redisScanKeysBatch.mockReturnValueOnce(stale.promise);
    mountBrowser();
    await settle();
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [second], total_keys: 1305 });
    await submitKeySearch(second.key_display);
    stale.resolve({ cursor: 0, keys: [first], total_keys: 1305 });
    await settle();
    expect(document.querySelector(`[data-redis-leaf="${first.key_raw}"]`)).toBeNull();
    expect(document.querySelector(`[data-redis-leaf="${second.key_raw}"]`)).not.toBeNull();
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1 keys");
  });

  it.each(["cached-key", "key", "value", "all"] as const)("reapplies %s search after creating an in-scope nonmatching key", async (mode) => {
    const created = key("order:region03:new");
    mocks.redisScanKeysBatch.mockImplementation((_id, _db, cursor) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: [first], total_keys: 1305 } : { cursor: 0, keys: [second], total_keys: 0 }));
    mountBrowser();
    await settle();
    if (mode === "cached-key") {
      clickButtonWithText("redis.fetchAllKeys");
      await settle();
      await vi.waitFor(() => expect(document.body.textContent).not.toContain("redis.stopFetchAll"));
    }
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [first], total_keys: 1305 });
    mocks.redisScanValues.mockResolvedValue({ cursor: 0, keys: [first], total_keys: 1305 });
    const valueSearch = mode === "value" || mode === "all";
    if (valueSearch) {
      clickButtonWithText(mode === "value" ? "redis.searchByValue" : "redis.searchByAll");
      await settle();
    }
    const query = valueSearch ? "value-needle" : first.key_display;
    await submitKeySearch(query);
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1 keys");
    const scanCalls = valueSearch ? mocks.redisScanValues.mock.calls.length : mocks.redisScanKeysBatch.mock.calls.length;
    mocks.redisGetValue.mockResolvedValue({ ...redisValue(created.key_raw), key_display: created.key_display });
    await openCreateDialog();
    await setInput('input[placeholder="redis.createKeyNamePlaceholder"]', created.key_display);
    await fillCreateValue("string");
    await submitCreate();
    expect(mocks.redisSetString).toHaveBeenCalledWith("connection", 0, created.key_raw, "value");
    expect(requiredElement<HTMLInputElement>("[data-redis-search-input]").value).toBe(query);
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1 keys");
    expect(document.querySelector(`[data-redis-leaf="${created.key_raw}"]`)).toBeNull();
    if (valueSearch) {
      expect(mocks.redisScanValues).toHaveBeenCalledTimes(scanCalls + 1);
      expect(mocks.redisScanValues).toHaveBeenLastCalledWith("connection", 0, 0, "order:*", query, 100, mode === "all");
    } else {
      expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCalls + 1);
      expect(mocks.redisScanKeysBatch.mock.calls[mocks.redisScanKeysBatch.mock.calls.length - 1]?.[3]).toBe(query);
      expect(document.querySelector(`[data-redis-leaf="${first.key_raw}"]`)).not.toBeNull();
      expect(document.querySelector(`[data-redis-leaf="${second.key_raw}"]`)).toBeNull();
    }

    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [first, second, created, outside], total_keys: 1306 });
    await submitKeySearch("");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("3 keys");
    expect(mocks.redisScanKeysBatch.mock.calls[mocks.redisScanKeysBatch.mock.calls.length - 1]?.[3]).toBe("order:*");
    expect(groupRowOrUndefined("session")).toBeUndefined();
    groupRow("order").click();
    await settle();
    groupRow("region03").click();
    await settle();
    expect(document.querySelector(`[data-redis-leaf="${created.key_raw}"]`)).not.toBeNull();
  });

  it.each(["deleted", "missing"] as const)("reapplies local search when the selected key is %s", async (event) => {
    mocks.redisScanKeysBatch.mockImplementation((_id, _db, cursor) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: [first], total_keys: 1305 } : { cursor: 0, keys: [second], total_keys: 0 }));
    mountBrowser();
    await settle();
    clickButtonWithText("redis.fetchAllKeys");
    await settle();
    await vi.waitFor(() => expect(document.body.textContent).not.toContain("redis.stopFetchAll"));
    await submitKeySearch(first.key_display);
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1 keys");
    requiredElement<HTMLElement>(`[data-redis-leaf="${first.key_raw}"]`).closest<HTMLElement>(".group")!.click();
    await settle();
    const scanCalls = mocks.redisScanKeysBatch.mock.calls.length;
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [], total_keys: 1304 });
    mocks.loadedKeyMissing = event === "missing";
    requiredElement<HTMLButtonElement>(event === "missing" ? "[data-test-emit-key-loaded]" : "[data-test-emit-key-deleted]").click();
    await settle();
    expect(requiredElement<HTMLInputElement>("[data-redis-search-input]").value).toBe(first.key_display);
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("0 keys");
    expect(document.querySelector(`[data-redis-leaf="${second.key_raw}"]`)).toBeNull();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCalls + 1);
    expect(mocks.redisScanKeysBatch.mock.calls[mocks.redisScanKeysBatch.mock.calls.length - 1]?.[3]).toBe(first.key_display);

    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [second, outside], total_keys: 1304 });
    await submitKeySearch("");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1 keys");
    groupRow("order").click();
    await settle();
    groupRow("region02").click();
    await settle();
    expect(document.querySelector(`[data-redis-leaf="${second.key_raw}"]`)).not.toBeNull();
    expect(groupRowOrUndefined("session")).toBeUndefined();
  });

  it("preserves local search and the completed scope after creating an out-of-scope key", async () => {
    mocks.redisScanKeysBatch.mockImplementation((_id, _db, cursor) => Promise.resolve(cursor === 0 ? { cursor: 1, keys: [first], total_keys: 1305 } : { cursor: 0, keys: [second], total_keys: 0 }));
    mountBrowser();
    await settle();
    clickButtonWithText("redis.fetchAllKeys");
    await settle();
    await vi.waitFor(() => expect(document.body.textContent).not.toContain("redis.stopFetchAll"));
    const scanCalls = mocks.redisScanKeysBatch.mock.calls.length;
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("2 keys");

    await submitKeySearch(first.key_display);
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1 keys");
    await openCreateDialog();
    await fillCreateValue("string");
    await submitCreate();
    expect(mocks.redisSetString).toHaveBeenCalled();
    expect(requiredElement<HTMLInputElement>("[data-redis-search-input]").value).toBe(first.key_display);
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1 keys");
    expect(document.querySelector(`[data-redis-leaf="${first.key_raw}"]`)).not.toBeNull();
    expect(document.querySelector(`[data-redis-leaf="${second.key_raw}"]`)).toBeNull();
    expect(document.querySelector(`[data-redis-leaf="${KEY_RAW}"]`)).toBeNull();

    await submitKeySearch("");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("2 keys");
    groupRow("order").click();
    await settle();
    groupRow("region01").click();
    groupRow("region02").click();
    await settle();
    expect(document.querySelector(`[data-redis-leaf="${first.key_raw}"]`)).not.toBeNull();
    expect(document.querySelector(`[data-redis-leaf="${second.key_raw}"]`)).not.toBeNull();
    expect(document.querySelector(`[data-redis-leaf="${KEY_RAW}"]`)).toBeNull();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCalls);
  });

  it("does not insert a newly created out-of-scope key into the list", async () => {
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [first], total_keys: 1305 });
    mountBrowser();
    await settle();
    await openCreateDialog();
    await fillCreateValue("string");
    await submitCreate();
    expect(mocks.redisSetString).toHaveBeenCalled();
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("1 keys");
    expect(document.querySelector(`[data-redis-leaf="${KEY_RAW}"]`)).toBeNull();
    expect(groupRowOrUndefined("order")).toBeDefined();
  });

  it.each(["order:region01:renamed", "session:renamed"])("reloads the scoped tab on activation after a background rename to %s", async (newName) => {
    const renamed = key(newName);
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [first, second], total_keys: 1305 });
    const browser = mountKeptAliveBrowser();
    await settle();
    groupRow("order").click();
    await settle();
    groupRow("region01").click();
    await settle();
    requiredElement<HTMLElement>(`[data-redis-leaf="${first.key_raw}"]`).closest<HTMLElement>(".group")!.click();
    await settle();
    const renameButton = requiredElement<HTMLButtonElement>("[data-test-emit-key-renamed]");
    const scanCalls = mocks.redisScanKeysBatch.mock.calls.length;
    await browser.deactivate();
    mocks.renamedKeyName = newName;
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [second, renamed], total_keys: 1305 });
    // Simulate the rename response arriving after KeepAlive paused the tab.
    renameButton.click();
    await settle();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCalls);

    await browser.activate();
    await settle();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(scanCalls + 1);
    expect(mocks.redisScanKeysBatch.mock.calls[mocks.redisScanKeysBatch.mock.calls.length - 1]?.[3]).toBe("order:*");
    expect(requiredElement<HTMLInputElement>("[data-redis-search-input]").value).toBe("");
    expect(document.querySelector(`[data-redis-leaf="${first.key_raw}"]`)).toBeNull();
    expect(document.querySelector("[data-test-emit-key-renamed]")).toBeNull();
    expect(groupRowOrUndefined("session")).toBeUndefined();
    if (newName.startsWith("order:")) {
      expect(document.querySelector(`[data-redis-leaf="${renamed.key_raw}"]`)).not.toBeNull();
    } else {
      expect(document.querySelector(`[data-redis-leaf="${renamed.key_raw}"]`)).toBeNull();
    }
    groupRow("region02").click();
    await settle();
    expect(document.querySelector(`[data-redis-leaf="${second.key_raw}"]`)).not.toBeNull();
  });

  it("rescans and clears selection when a key is renamed outside the scope", async () => {
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [first], total_keys: 1305 });
    mocks.redisGetValue.mockResolvedValue({ ...redisValue(first.key_raw), key_display: first.key_display });
    mountBrowser();
    await settle();
    groupRow("order").click();
    await settle();
    groupRow("region01").click();
    await settle();
    requiredElement<HTMLInputElement>(`[data-redis-leaf="${first.key_raw}"]`).closest<HTMLElement>(".group")!.click();
    await settle();
    await selectGroup("order");
    mocks.renamedKeyName = outside.key_display;
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [outside], total_keys: 1305 });
    requiredElement<HTMLButtonElement>("[data-test-emit-key-renamed]").click();
    await settle();
    expect(mocks.redisScanKeysBatch).toHaveBeenCalledTimes(2);
    expect(document.querySelector("[data-test-emit-key-renamed]")).toBeNull();
    expect(mocks.redisScanKeysBatch.mock.calls[mocks.redisScanKeysBatch.mock.calls.length - 1]?.[3]).toBe("order:*");
    expect(requiredElement<HTMLElement>(".redis-key-count").textContent).toBe("0 keys");
    expect(document.querySelector("[data-redis-batch-delete]")).toBeNull();
  });

  it.each(["", "*"])("retains unscoped browsing when the default is %j", async (filter) => {
    mocks.redisKeyFilter = filter;
    mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [first, outside], total_keys: 1305 });
    mountBrowser();
    await settle();
    expect(requiredElement<HTMLInputElement>("[data-redis-search-input]").value).toBe("");
    expect(mocks.redisScanKeysBatch.mock.calls[0]?.[3]).toBe("*");
    expect(groupRowOrUndefined("session")).toBeDefined();
    expect(groupRow("order").querySelector('button[title="redis.deleteGroup"]')).not.toBeNull();
  });
});