@lotics/ui 20.0.0 → 20.0.2

package/src/file_intake.test.ts

@@ -1,124 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { matchesAccept, filesFromTransfer, selectPasteSink, type FileTransferLike, type PasteSinkEntry } from "./file_intake";
-
-const file = (name: string, type: string) => new File([new Uint8Array([1])], name, { type });
-
-/** A clipboard/drag payload that surfaces its files only through `items` —
- *  what a pasted screenshot looks like on the engines that do that. */
-const itemsOnly = (files: File[]): FileTransferLike => ({
-  files: [],
-  items: files.map((f) => ({ kind: "file" as const, getAsFile: () => f })),
-});
-
-describe("matchesAccept", () => {
-  it("accepts everything when the list is absent or empty", () => {
-    expect(matchesAccept(file("a.pdf", "application/pdf"), undefined)).toBe(true);
-    expect(matchesAccept(file("a.pdf", "application/pdf"), "")).toBe(true);
-    expect(matchesAccept(file("a.pdf", "application/pdf"), " , ")).toBe(true);
-  });
-
-  it("matches an exact MIME, case-insensitively", () => {
-    expect(matchesAccept(file("a.pdf", "APPLICATION/PDF"), "application/pdf")).toBe(true);
-    expect(matchesAccept(file("a.png", "image/png"), "application/pdf")).toBe(false);
-  });
-
-  it("matches a wildcard type", () => {
-    expect(matchesAccept(file("a.png", "image/png"), "image/*")).toBe(true);
-    expect(matchesAccept(file("a.pdf", "application/pdf"), "image/*")).toBe(false);
-  });
-
-  it("matches an extension pattern by filename when the MIME is unknown", () => {
-    expect(matchesAccept(file("Report.CSV", ""), ".csv")).toBe(true);
-    expect(matchesAccept(file("report.csvx", ""), ".csv")).toBe(false);
-  });
-
-  it("accepts a file matching ANY pattern in the list", () => {
-    expect(matchesAccept(file("a.png", "image/png"), "application/pdf, image/*")).toBe(true);
-    expect(matchesAccept(file("a.zip", "application/zip"), "application/pdf, image/*")).toBe(false);
-  });
-});
-
-describe("filesFromTransfer", () => {
-  it("returns [] for a missing transfer", () => {
-    expect(filesFromTransfer(null)).toEqual([]);
-    expect(filesFromTransfer(undefined)).toEqual([]);
-    expect(filesFromTransfer({})).toEqual([]);
-  });
-
-  it("reads the direct file list", () => {
-    const a = file("a.pdf", "application/pdf");
-    expect(filesFromTransfer({ files: [a] })).toEqual([a]);
-  });
-
-  it("falls back to clipboard items when the file list is empty", () => {
-    const shot = file("image.png", "image/png");
-    expect(filesFromTransfer(itemsOnly([shot]))).toEqual([shot]);
-  });
-
-  it("never doubles a file present in BOTH files and items", () => {
-    const a = file("a.png", "image/png");
-    expect(filesFromTransfer({ files: [a], items: [{ kind: "file", getAsFile: () => a }] })).toEqual([a]);
-  });
-
-  it("skips non-file clipboard items and null getAsFile results", () => {
-    const a = file("a.png", "image/png");
-    const transfer: FileTransferLike = {
-      items: [
-        { kind: "string", getAsFile: () => null },
-        { kind: "file", getAsFile: () => null },
-        { kind: "file", getAsFile: () => a },
-      ],
-    };
-    expect(filesFromTransfer(transfer)).toEqual([a]);
-  });
-
-  it("filters by accept", () => {
-    const pdf = file("a.pdf", "application/pdf");
-    const zip = file("a.zip", "application/zip");
-    expect(filesFromTransfer({ files: [pdf, zip] }, { accept: "application/pdf" })).toEqual([pdf]);
-    expect(filesFromTransfer(itemsOnly([pdf, zip]), { accept: "application/pdf" })).toEqual([pdf]);
-  });
-
-  it("keeps every file by default and caps at one when multiple is false", () => {
-    const a = file("a.pdf", "application/pdf");
-    const b = file("b.pdf", "application/pdf");
-    expect(filesFromTransfer({ files: [a, b] })).toEqual([a, b]);
-    expect(filesFromTransfer({ files: [a, b] }, { multiple: false })).toEqual([a]);
-  });
-
-  it("caps AFTER filtering, so a rejected first file does not eat the slot", () => {
-    const zip = file("a.zip", "application/zip");
-    const pdf = file("b.pdf", "application/pdf");
-    expect(filesFromTransfer({ files: [zip, pdf] }, { accept: "application/pdf", multiple: false })).toEqual([pdf]);
-  });
-});
-
-describe("selectPasteSink", () => {
-  const entry = (sink: string, focused: boolean): PasteSinkEntry<string> => ({ sink, focused });
-
-  it("returns undefined for an empty stack", () => {
-    expect(selectPasteSink<string>([])).toBeUndefined();
-  });
-
-  it("falls back to the TOP of the stack when nothing is focused", () => {
-    expect(selectPasteSink([entry("a", false), entry("b", false), entry("c", false)])).toBe("c");
-  });
-
-  it("routes to a focused region over the (later-mounted) top of the stack", () => {
-    // b holds focus; c is on top but unfocused — b wins.
-    expect(selectPasteSink([entry("a", false), entry("b", true), entry("c", false)])).toBe("b");
-  });
-
-  it("picks the TOP-MOST focused region when several are focused", () => {
-    // Nested regions can both contain activeElement; the innermost/last wins.
-    expect(selectPasteSink([entry("a", true), entry("b", true), entry("c", false)])).toBe("b");
-  });
-
-  it("a single region-less sink still gets the paste (byte-for-byte old behavior)", () => {
-    expect(selectPasteSink([entry("only", false)])).toBe("only");
-  });
-
-  it("a focused region beats an unfocused one mounted after it", () => {
-    expect(selectPasteSink([entry("focused", true), entry("later", false)])).toBe("focused");
-  });
-});

package/src/format_date.test.ts

@@ -1,138 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { formatDate, parseDate, toISODate } from "./format_date";
-
-describe("formatDate", () => {
-  test("formats an ISO date in the home market (dd/MM/yyyy)", () => {
-    expect(formatDate("2026-05-22", { locale: "vi-VN" })).toBe("22/05/2026");
-  });
-
-  test("formats a Date object, not just an ISO string", () => {
-    expect(formatDate(new Date(2026, 4, 22), { locale: "vi-VN" })).toBe("22/05/2026");
-  });
-
-  test("compact drops the year (dd/MM)", () => {
-    expect(formatDate("2026-05-22", { locale: "vi-VN", compact: true })).toBe("22/05");
-  });
-
-  test("time prepends the 24h time, then the locale date", () => {
-    expect(formatDate("2026-05-22T14:30", { locale: "vi-VN", time: true })).toBe("14:30 22/05/2026");
-  });
-
-  test("time + compact is time-first and drops the year", () => {
-    expect(formatDate("2026-05-22T09:05", { locale: "vi-VN", time: true, compact: true })).toBe("09:05 22/05");
-  });
-
-  test("time composes with a readable style — the orthogonal axis", () => {
-    expect(formatDate("2026-09-22T14:30", { format: "long", time: true, locale: "en-US" })).toBe("14:30 September 22, 2026");
-  });
-
-  test("medium — readable, abbreviated month", () => {
-    expect(formatDate("2026-05-22", { format: "medium", locale: "en-US" })).toBe("May 22, 2026");
-    // vi word output is ICU-dependent; assert the day + year are present (day-first locale).
-    expect(formatDate("2026-05-22", { format: "medium", locale: "vi-VN" })).toMatch(/22.*2026/);
-  });
-
-  test("long — readable, full month name", () => {
-    expect(formatDate("2026-09-22", { format: "long", locale: "en-US" })).toBe("September 22, 2026");
-    expect(formatDate("2026-09-22", { format: "long", locale: "vi-VN" })).toMatch(/22.*2026/);
-  });
-
-  test("dayMonth — day + abbreviated month, no year", () => {
-    expect(formatDate("2026-09-22", { format: "dayMonth", locale: "en-US" })).toBe("Sep 22");
-    expect(formatDate("2026-09-22", { format: "dayMonth", locale: "vi-VN" })).not.toMatch(/2026/);
-  });
-
-  test("monthYear — a period label, sentence-cased", () => {
-    expect(formatDate("2026-05-22", { format: "monthYear", locale: "en-US" })).toBe("May 2026");
-    // Leading character is upper-cased even where the locale lowercases the month name.
-    const vi = formatDate("2026-05-22", { format: "monthYear", locale: "vi-VN" });
-    expect(vi.charAt(0)).toBe(vi.charAt(0).toUpperCase());
-    expect(vi).toMatch(/2026/);
-  });
-
-  test("date-only ISO does not drift across local timezone (wall-clock parse)", () => {
-    // `new Date('2026-01-01')` is UTC midnight; in negative-offset zones it formats as Dec 31.
-    expect(formatDate("2026-01-01", { locale: "vi-VN" })).toBe("01/01/2026");
-  });
-
-  test("empty input returns the empty label", () => {
-    expect(formatDate(null)).toBe("");
-    expect(formatDate("")).toBe("");
-    expect(formatDate(undefined, { emptyLabel: "—" })).toBe("—");
-    expect(formatDate("not-a-date", { emptyLabel: "—" })).toBe("—");
-  });
-});
-
-describe("formatDate — reduced precision", () => {
-  test("month value renders MM/YYYY (numeric, locale order), no fabricated day", () => {
-    expect(formatDate("2026-05", { locale: "vi-VN" })).toBe("05/2026");
-    expect(formatDate("2026-05", { locale: "en-US" })).toBe("05/2026");
-  });
-
-  test("year value renders just the year", () => {
-    expect(formatDate("2026", { locale: "vi-VN" })).toBe("2026");
-    expect(formatDate("2026", { format: "medium", locale: "en-US" })).toBe("2026");
-    expect(formatDate("2026", { format: "monthYear", locale: "en-US" })).toBe("2026");
-  });
-
-  test("compact drops the year on a month value", () => {
-    expect(formatDate("2026-05", { locale: "vi-VN", compact: true })).toBe("05");
-  });
-
-  test("readable styles drop the day for a month value", () => {
-    expect(formatDate("2026-05", { format: "monthYear", locale: "en-US" })).toBe("May 2026");
-    expect(formatDate("2026-05", { format: "medium", locale: "en-US" })).toBe("May 2026");
-    expect(formatDate("2026-05", { format: "long", locale: "en-US" })).toBe("May 2026");
-    expect(formatDate("2026-05", { format: "dayMonth", locale: "en-US" })).toBe("May");
-  });
-
-  test("time is ignored for a reduced-precision value (a period has no clock)", () => {
-    expect(formatDate("2026-05", { locale: "vi-VN", time: true })).toBe("05/2026");
-  });
-});
-
-describe("parseDate", () => {
-  test("parses an ISO datetime to local wall-clock", () => {
-    const d = parseDate("2026-05-22T14:30");
-    expect(d).not.toBeNull();
-    expect(d?.getFullYear()).toBe(2026);
-    expect(d?.getMonth()).toBe(4);
-    expect(d?.getDate()).toBe(22);
-    expect(d?.getHours()).toBe(14);
-    expect(d?.getMinutes()).toBe(30);
-  });
-
-  test("passes a valid Date through and rejects an invalid one", () => {
-    const d = new Date(2026, 0, 1);
-    expect(parseDate(d)).toBe(d);
-    expect(parseDate(new Date("nonsense"))).toBeNull();
-    expect(parseDate(null)).toBeNull();
-    expect(parseDate("")).toBeNull();
-  });
-
-  test("parses a reduced-precision value to its period start", () => {
-    const month = parseDate("2026-05");
-    expect(month?.getFullYear()).toBe(2026);
-    expect(month?.getMonth()).toBe(4);
-    expect(month?.getDate()).toBe(1);
-    const year = parseDate("2026");
-    expect(year?.getFullYear()).toBe(2026);
-    expect(year?.getMonth()).toBe(0);
-    expect(year?.getDate()).toBe(1);
-  });
-});
-
-describe("toISODate", () => {
-  test("Date or ISO value → yyyy-MM-dd", () => {
-    expect(toISODate(new Date(2026, 4, 22))).toBe("2026-05-22");
-    expect(toISODate("2026-05-22T14:30")).toBe("2026-05-22");
-    expect(toISODate(null)).toBe("");
-  });
-
-  test("PRESERVES reduced precision verbatim — never fabricates a day", () => {
-    expect(toISODate("2026-05")).toBe("2026-05");
-    expect(toISODate("2026")).toBe("2026");
-    // Whitespace-trimmed but otherwise unchanged.
-    expect(toISODate("  2026-05  ")).toBe("2026-05");
-  });
-});

package/src/format_date_negative_zone.test.ts

@@ -1,26 +0,0 @@
-// Pin a NEGATIVE-offset zone (UTC-5) before importing the formatter. The old
-// fall-through `new Date("2026-05")` parses as UTC midnight, which in a
-// negative-offset zone lands on the PREVIOUS month ("2026-04-30T19:00"), drifting
-// a month-precision value back a month. The naive part-based construction must
-// keep "2026-05" on May regardless of the runtime zone.
-process.env.TZ = "America/New_York";
-
-import { describe, expect, test } from "vitest";
-import { formatDate, toISODate } from "./format_date";
-
-describe("formatDate — reduced precision in a negative-offset zone", () => {
-  test("a month value does not drift to the previous month", () => {
-    expect(formatDate("2026-05", { locale: "en-US" })).toBe("05/2026");
-    // January is the adversarial case — a backward drift would land in Dec 2025.
-    expect(formatDate("2026-01", { locale: "en-US" })).toBe("01/2026");
-  });
-
-  test("a year value stays on its year", () => {
-    expect(formatDate("2026", { locale: "en-US" })).toBe("2026");
-  });
-
-  test("toISODate preserves the partial (no drift, no fabricated day)", () => {
-    expect(toISODate("2026-01")).toBe("2026-01");
-    expect(toISODate("2026")).toBe("2026");
-  });
-});

package/src/gantt/scale.test.ts

@@ -1,47 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { axisRange, barGeometry, buildTicks, pxPerDay } from "./scale";
-import type { GanttTask } from "./types";
-
-const AXIS = new Date(2026, 0, 1); // Jan 1 2026
-const task = (id: string, s: [number, number], e?: [number, number]): GanttTask => ({
-  id,
-  label: id,
-  start: new Date(2026, s[0], s[1]),
-  end: e ? new Date(2026, e[0], e[1]) : null,
-});
-
-describe("gantt scale", () => {
-  it("zoom widths shrink as the scale widens", () => {
-    expect(pxPerDay("day")).toBeGreaterThan(pxPerDay("week"));
-    expect(pxPerDay("week")).toBeGreaterThan(pxPerDay("month"));
-  });
-
-  it("positions a bar by day offset and inclusive span", () => {
-    // Jan 3 → Jan 5 inclusive = 3 days, 2 days after the axis start.
-    const b = barGeometry(task("a", [0, 3], [0, 5]), AXIS, "day");
-    expect(b.left).toBe(2 * 40);
-    expect(b.width).toBe(3 * 40);
-  });
-
-  it("gives a single-day task one day of width (floored)", () => {
-    const b = barGeometry(task("m", [0, 10]), AXIS, "day");
-    expect(b.width).toBe(40);
-    const tiny = barGeometry(task("m", [0, 10]), AXIS, "month"); // 1 * 5px → floored to 8
-    expect(tiny.width).toBe(8);
-  });
-
-  it("derives a padded axis window from the tasks", () => {
-    const { start, end } = axisRange([task("a", [0, 5], [0, 8]), task("b", [0, 3], [0, 20])], new Date(2026, 0, 1), 3);
-    expect(start).toEqual(new Date(2026, 0, 0)); // Jan 3 - 3 = Dec 31 (= Jan 0)
-    expect(end).toEqual(new Date(2026, 0, 23)); // Jan 20 + 3
-  });
-
-  it("emits one day-tick per day and flags month starts", () => {
-    const ticks = buildTicks(new Date(2026, 0, 30), new Date(2026, 1, 2), "day");
-    expect(ticks.map((t) => t.label)).toEqual(["30", "31", "1", "2"]);
-    expect(ticks.find((t) => t.label === "1")?.monthStart).toBe(true);
-    expect(ticks.find((t) => t.label === "30")?.monthStart).toBe(false);
-    expect(ticks[0].left).toBe(0);
-    expect(ticks[1].left).toBe(40); // one day across at day scale
-  });
-});

package/src/inline_focus.test.ts

@@ -1,49 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect } from "vitest";
-import { ensureModalityListeners, getInteractionModality } from "./interaction_modality";
-import { FOCUS_OPEN_SUPPRESS_MS, shouldOpenOnFocus, shouldRestoreFocusOnClose } from "./inline_focus";
-
-describe("shouldRestoreFocusOnClose — no scroll jump on a pointer close", () => {
-  it("restores focus on a keyboard close (Enter/Escape) — preserves Tab order", () => {
-    expect(shouldRestoreFocusOnClose("keyboard")).toBe(true);
-  });
-
-  it("does NOT restore on a pointer close (click ✓/✕ or click away) — a bare focus() would scroll the page", () => {
-    expect(shouldRestoreFocusOnClose("pointer")).toBe(false);
-  });
-});
-
-describe("shouldOpenOnFocus — the inline keyboard-entry gate", () => {
-  it("keyboard focus opens the editor", () => {
-    expect(shouldOpenOnFocus("keyboard", null, 1_000)).toBe(true);
-  });
-
-  it("pointer focus never opens the editor — the click path stays press-driven", () => {
-    expect(shouldOpenOnFocus("pointer", null, 1_000)).toBe(false);
-    // …even outside any suppression window.
-    expect(shouldOpenOnFocus("pointer", 100, 100_000)).toBe(false);
-  });
-
-  it("a programmatic focus restore inside the suppression window does not re-open", () => {
-    const restoredAt = 5_000;
-    expect(shouldOpenOnFocus("keyboard", restoredAt, restoredAt)).toBe(false);
-    expect(shouldOpenOnFocus("keyboard", restoredAt, restoredAt + FOCUS_OPEN_SUPPRESS_MS - 1)).toBe(false);
-  });
-
-  it("suppression expires — a later Tab arrival opens again", () => {
-    const restoredAt = 5_000;
-    expect(shouldOpenOnFocus("keyboard", restoredAt, restoredAt + FOCUS_OPEN_SUPPRESS_MS)).toBe(true);
-  });
-});
-
-describe("interaction modality tracker", () => {
-  it("records keyboard on keydown and pointer on mousedown (Tab-vs-click focus)", () => {
-    ensureModalityListeners();
-    document.dispatchEvent(new KeyboardEvent("keydown", { key: "Tab" }));
-    expect(getInteractionModality()).toBe("keyboard");
-    document.dispatchEvent(new MouseEvent("mousedown"));
-    expect(getInteractionModality()).toBe("pointer");
-    document.dispatchEvent(new KeyboardEvent("keydown", { key: "a" }));
-    expect(getInteractionModality()).toBe("keyboard");
-  });
-});

package/src/matrix.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { matrixTotals, type MatrixAxisItem } from "./matrix_totals";
-
-const rows: MatrixAxisItem[] = [
-  { key: "msc", label: "MSC" },
-  { key: "one", label: "ONE" },
-];
-const cols: MatrixAxisItem[] = [
-  { key: "20", label: "20ft" },
-  { key: "40", label: "40ft" },
-];
-
-// MSC: 20→5, 40→3 ; ONE: 20→0, 40→7
-const grid: Record<string, Record<string, number>> = {
-  msc: { "20": 5, "40": 3 },
-  one: { "20": 0, "40": 7 },
-};
-const value = (r: string, c: string) => grid[r]?.[c] ?? 0;
-
-describe("matrixTotals", () => {
-  it("sums each row across its columns", () => {
-    const { rowTotals } = matrixTotals(rows, cols, value);
-    expect(rowTotals.get("msc")).toBe(8);
-    expect(rowTotals.get("one")).toBe(7);
-  });
-
-  it("sums each column across its rows", () => {
-    const { colTotals } = matrixTotals(rows, cols, value);
-    expect(colTotals.get("20")).toBe(5);
-    expect(colTotals.get("40")).toBe(10);
-  });
-
-  it("grand total equals the sum of every cell", () => {
-    expect(matrixTotals(rows, cols, value).grandTotal).toBe(15);
-  });
-
-  it("max is the largest single cell, for the heat scale", () => {
-    expect(matrixTotals(rows, cols, value).max).toBe(7);
-  });
-
-  it("is all-zero for an empty axis", () => {
-    const r = matrixTotals([], cols, value);
-    expect(r.grandTotal).toBe(0);
-    expect(r.max).toBe(0);
-    expect(r.colTotals.get("20")).toBeUndefined();
-  });
-
-  it("counts a fully-empty grid as zero without dividing by it", () => {
-    const zero = matrixTotals(rows, cols, () => 0);
-    expect(zero.grandTotal).toBe(0);
-    expect(zero.max).toBe(0);
-    expect(zero.rowTotals.get("msc")).toBe(0);
-  });
-});

package/src/pending_commits.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { pendingCommits, trackCommit } from "./pending_commits";
-
-/** A field write that lands in `stored` after `ms`, like a save round trip. */
-const commit = (stored: { value: string }, next: string, ms: number) =>
-  new Promise<void>((resolve) =>
-    setTimeout(() => {
-      stored.value = next;
-      resolve();
-    }, ms),
-  );
-
-/** Let the registry's own settle callback run before asserting on it. */
-const tick = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
-
-describe("pendingCommits", () => {
-  it("is null with nothing in flight — a press keeps its synchronous path", () => {
-    expect(pendingCommits()).toBeNull();
-  });
-
-  it("holds until a commit still in flight has landed", async () => {
-    const stored = { value: "BKG CŨ: " };
-    void trackCommit(commit(stored, "BKG CŨ:  SGNA52926200", 20));
-    const gate = pendingCommits();
-    expect(gate).not.toBeNull();
-    await gate;
-    expect(stored.value).toBe("BKG CŨ:  SGNA52926200");
-  });
-
-  it("holds for EVERY commit in flight, not just the first", async () => {
-    const landed: string[] = [];
-    const land = (name: string, ms: number) =>
-      new Promise<void>((resolve) =>
-        setTimeout(() => {
-          landed.push(name);
-          resolve();
-        }, ms),
-      );
-    void trackCommit(land("slow", 30));
-    void trackCommit(land("fast", 5));
-    await pendingCommits();
-    expect([...landed].sort()).toEqual(["fast", "slow"]);
-  });
-
-  it("releases again once the commits have landed", async () => {
-    await trackCommit(Promise.resolve());
-    await tick();
-    expect(pendingCommits()).toBeNull();
-  });
-
-  it("is released by a FAILED commit too — a stuck gate would wedge every action", async () => {
-    const failed = trackCommit(Promise.reject(new Error("Save failed")));
-    // The caller owns the error: the inline editor keeps the edit and shows it.
-    await expect(failed).rejects.toThrow("Save failed");
-    await expect(pendingCommits() ?? Promise.resolve()).resolves.toBeUndefined();
-    await tick();
-    expect(pendingCommits()).toBeNull();
-  });
-
-  it("ignores a commit started AFTER the gate was taken — it holds the press for the edit that caused it, not later work", async () => {
-    const stored = { value: "before" };
-    void trackCommit(commit(stored, "first", 5));
-    const gate = pendingCommits();
-    void trackCommit(commit(stored, "later", 40));
-    await gate;
-    expect(stored.value).toBe("first");
-  });
-});

package/src/popover_layers.test.ts

@@ -1,113 +0,0 @@
-// @vitest-environment jsdom
-import { describe, expect, test, beforeEach } from "vitest";
-import {
-  hasModalLayerAbove,
-  isInLayerAbove,
-  snapshotOpenModalLayers,
-} from "./popover_layers";
-
-function addModal(): HTMLElement {
-  const modal = document.createElement("div");
-  modal.setAttribute("aria-modal", "true");
-  const inner = document.createElement("button");
-  modal.appendChild(inner);
-  document.body.appendChild(modal);
-  return modal;
-}
-
-function addPopover(level: number): HTMLElement {
-  const popover = document.createElement("div");
-  popover.setAttribute("data-popover", "true");
-  popover.setAttribute("data-popover-level", String(level));
-  const inner = document.createElement("button");
-  popover.appendChild(inner);
-  document.body.appendChild(popover);
-  return popover;
-}
-
-beforeEach(() => {
-  document.body.innerHTML = "";
-});
-
-describe("isInLayerAbove", () => {
-  test("plain page node is not above", () => {
-    const el = document.createElement("div");
-    document.body.appendChild(el);
-    expect(isInLayerAbove(el, 0, new Set())).toBe(false);
-  });
-
-  test("document itself (page scroll target) is not above", () => {
-    expect(isInLayerAbove(document, 0, new Set())).toBe(false);
-  });
-
-  test("text node resolves through its parent element", () => {
-    const modal = addModal();
-    const text = document.createTextNode("hello");
-    modal.appendChild(text);
-    expect(isInLayerAbove(text, 0, new Set())).toBe(true);
-  });
-
-  test("node inside a deeper nested popover is above", () => {
-    const nested = addPopover(1);
-    expect(isInLayerAbove(nested.firstChild as Node, 0, new Set())).toBe(true);
-  });
-
-  test("node inside a same-level popover is not above", () => {
-    const sibling = addPopover(0);
-    expect(isInLayerAbove(sibling.firstChild as Node, 0, new Set())).toBe(false);
-  });
-
-  test("node inside a modal opened AFTER the popover is above (file preview)", () => {
-    const snapshot = snapshotOpenModalLayers(document);
-    const preview = addModal();
-    expect(isInLayerAbove(preview.firstChild as Node, 0, snapshot)).toBe(true);
-  });
-
-  test("node inside the modal the popover LIVES IN is not above (drawer scroll dismisses)", () => {
-    const drawer = addModal();
-    const snapshot = snapshotOpenModalLayers(document);
-    expect(isInLayerAbove(drawer.firstChild as Node, 0, snapshot)).toBe(false);
-  });
-
-  test("stacked modals: only the one opened after the popover is above", () => {
-    const drawer = addModal();
-    const snapshot = snapshotOpenModalLayers(document);
-    const preview = addModal();
-    expect(isInLayerAbove(drawer.firstChild as Node, 0, snapshot)).toBe(false);
-    expect(isInLayerAbove(preview.firstChild as Node, 0, snapshot)).toBe(true);
-  });
-
-  test("null snapshot treats any modal ancestor as above", () => {
-    const modal = addModal();
-    expect(isInLayerAbove(modal.firstChild as Node, 0, null)).toBe(true);
-  });
-});
-
-describe("hasModalLayerAbove", () => {
-  test("false with no modals", () => {
-    expect(hasModalLayerAbove(document, new Set())).toBe(false);
-  });
-
-  test("false while only pre-existing modals are open (popover in a drawer)", () => {
-    addModal();
-    const snapshot = snapshotOpenModalLayers(document);
-    expect(hasModalLayerAbove(document, snapshot)).toBe(false);
-  });
-
-  test("true while a modal opened after the popover is open, false after it closes", () => {
-    addModal();
-    const snapshot = snapshotOpenModalLayers(document);
-    const preview = addModal();
-    expect(hasModalLayerAbove(document, snapshot)).toBe(true);
-    preview.remove();
-    expect(hasModalLayerAbove(document, snapshot)).toBe(false);
-  });
-
-  test("a reopened modal is a NEW element and counts as above", () => {
-    const snapshot = snapshotOpenModalLayers(document);
-    const first = addModal();
-    first.remove();
-    addModal();
-    expect(hasModalLayerAbove(document, snapshot)).toBe(true);
-  });
-});