@wenathlan/devthink 2.0.15 → 2.0.20

package/tests/siteprefs.test.ts

@@ -1,228 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { readFile } from "node:fs/promises";
-import { sessionmemory } from "../memory.js";
-import {
-  applycontrasttheme,
-  contrasttokensof,
-  darklighttokensof,
-  highcontrasttokens,
-  localebundles,
-  localeformat,
-  localestring,
-  resolveappearance,
-  siteprofileactive,
-  siteprofilefor,
-  siteprofileof,
-  supportedlanguages,
-} from "../views.js";
-import { siteprofilegate } from "../policy.js";
-
-const now = 1_800_000_000_000;
-
-/** The in memory adapter the memory seam tests ride: every record lands in a map so the layout round trip reads back exactly what the toggle wrote. */
-class fakeadapter {
-  private readonly data = new Map<string, unknown>();
-  async get<T>(key: string): Promise<T | undefined> {
-    return this.data.get(key) as T | undefined;
-  }
-  async set<T>(key: string, value: T): Promise<void> {
-    this.data.set(key, value);
-  }
-}
-
-/** Parses one hex color into its linear rgb channels the WCAG relative luminance arithmetic needs. */
-function channelsof(hex: string): number[] {
-  const digits = hex.replace("#", "");
-  const parts = [0, 2, 4].map((index) => Number.parseInt(digits.slice(index, index + 2), 16) / 255);
-  return parts.map((value) => (value <= 0.03928 ? value / 12.92 : Math.pow((value + 0.055) / 1.055, 2.4)));
-}
-
-/** Computes the WCAG relative luminance of one hex color. */
-function luminanceof(hex: string): number {
-  const channels = channelsof(hex);
-  return 0.2126 * (channels[0] ?? 0) + 0.7152 * (channels[1] ?? 0) + 0.0722 * (channels[2] ?? 0);
-}
-
-/** Computes the WCAG contrast ratio of a foreground over a background. */
-function contrastof(foreground: string, background: string): number {
-  const one = luminanceof(foreground);
-  const two = luminanceof(background);
-  const [light, dark] = one > two ? [one, two] : [two, one];
-  return (light + 0.05) / (dark + 0.05);
-}
-
-describe("siteprofiles, darklight themes and locales", () => {
-  it("stores the per site interface preferences beside the originprofiles family", () => {
-    const profile = siteprofileof({ origin: "https://example.com", theme: "dark", defaultview: "review", at: now });
-    expect(profile.theme).toBe("dark");
-    expect(siteprofileactive(profile, "https://example.com")).toBe(true);
-    expect(siteprofileactive(profile, "https://other.example")).toBe(false);
-    expect(siteprofilefor([profile], "https://example.com")?.defaultview).toBe("review");
-    expect(siteprofilefor([profile], "https://other.example")).toBeUndefined();
-    expect(() => siteprofileof({ origin: "http://insecure.example", at: now })).toThrow(/https/);
-    expect(siteprofilegate({ origin: "https://example.com" }).allowed).toBe(true);
-    expect(siteprofilegate({ origin: "ftp://example.com" }).reason).toMatch(/https origin shape/);
-  });
-
-  it("resolves the appearance with the siteprofile first, the user override next and the os preference last", () => {
-    const siteprofile = siteprofileof({ origin: "https://example.com", theme: "light", at: now });
-    expect(resolveappearance({ ospreference: "dark", siteprofile }).source).toBe("site");
-    expect(resolveappearance({ ospreference: "dark", siteprofile }).mode).toBe("light");
-    expect(resolveappearance({ ospreference: "dark", useroverride: "light" }).source).toBe("user");
-    expect(resolveappearance({ ospreference: "dark", useroverride: "system" }).mode).toBe("dark");
-    expect(resolveappearance({ ospreference: "light" }).source).toBe("os");
-    const tokens = darklighttokensof("dark");
-    expect(tokens.tokens.surface).not.toBe(darklighttokensof("light").tokens.surface);
-    expect(Object.keys(tokens.tokens)).toContain("surface");
-    expect(Object.keys(tokens.tokens)).toContain("elevated");
-  });
-
-  it("falls back to english for missing strings and covers every supported language", () => {
-    const bundles = localebundles();
-    expect(supportedlanguages(bundles)).toEqual(["en", "pt"]);
-    expect(localestring(bundles, "pt", "popup.recent.title")).toBe("Execuções recentes");
-    expect(localestring(bundles, "pt", "stepapprove.approve")).toBe("Aprovar");
-    expect(localestring(bundles, "en", "popup.recent.title")).toBe("Recent runs");
-    expect(localestring(bundles, "pt", "unknown.key")).toBe("unknown.key");
-    const ptmissing = { language: "pt", strings: { "popup.title": "Devthink" } };
-    expect(localestring([ptmissing, ...bundles], "pt", "popup.recent.title")).toBe("Recent runs");
-  });
-
-  it("formats dates, numbers and durations per language", () => {
-    const at = Date.UTC(2025, 0, 5, 8, 6);
-    expect(localeformat({ language: "en", value: at, kind: "date" })).toBe("2025-01-05 08:06");
-    expect(localeformat({ language: "pt", value: at, kind: "date" })).toBe("05/01/2025 08:06");
-    expect(localeformat({ language: "en", value: 1234.5, kind: "number" })).toBe("1,234.5");
-    expect(localeformat({ language: "pt", value: 1234.5, kind: "number" })).toBe("1.234,5");
-    expect(localeformat({ language: "en", value: 125_000, kind: "duration" })).toBe("2m 5s");
-    expect(localeformat({ language: "pt", value: 125_000, kind: "duration" })).toBe("2 min 5 s");
-  });
-
-  it("keeps the default darklight sets unchanged while the high contrast set answers WCAG AA", () => {
-    /* the 2.0.2 high contrast fix of the rc.2 final polish: the default darklight token sets stay byte identical to the shipped family so the wcag sweep of the default tokens keeps its ratios, while the high contrast variant retunes the same token names */
-    expect(darklighttokensof("dark").tokens).toEqual({
-      surface: "#1f1f1f",
-      elevated: "#2b2b2b",
-      text: "#e3e3e3",
-      muted: "#9aa0a6",
-      accent: "#8ab4f8",
-      border: "#3c4043",
-      focus: "#aecbfa",
-      error: "#f28b82",
-      success: "#81c995",
-      warning: "#fdd663",
-    });
-    expect(darklighttokensof("light").tokens).toEqual({
-      surface: "#ffffff",
-      elevated: "#f8f9fa",
-      text: "#202124",
-      muted: "#5f6368",
-      accent: "#1a73e8",
-      border: "#dadce0",
-      focus: "#174ea6",
-      error: "#b3261e",
-      success: "#188038",
-      warning: "#e37400",
-    });
-    for (const mode of ["dark", "light"] as const) {
-      const tokens = highcontrasttokens(mode);
-      expect(tokens.mode).toBe(mode);
-      expect(Object.keys(tokens.tokens).sort()).toEqual([
-        "accent",
-        "border",
-        "elevated",
-        "error",
-        "focus",
-        "muted",
-        "success",
-        "surface",
-        "text",
-        "warning",
-      ]);
-      const surface = tokens.tokens.surface!;
-      /* the reading tokens of the high contrast set answer at least 4.5:1 against their surface */
-      for (const name of ["text", "muted", "error", "success", "warning"]) {
-        const ratio = contrastof(tokens.tokens[name]!, surface);
-        expect(ratio).toBeGreaterThanOrEqual(4.5);
-      }
-      /* the accent and the border answer at least 3:1 so controls and edges stay perceivable */
-      for (const name of ["accent", "border"]) {
-        const ratio = contrastof(tokens.tokens[name]!, surface);
-        expect(ratio).toBeGreaterThanOrEqual(3);
-      }
-      /* the resolution keeps the default preference exactly the darklight set of the same mode while the high preference swaps the variant in */
-      expect(contrasttokensof({ mode, contrast: "default" }).tokens).toEqual(darklighttokensof(mode).tokens);
-      expect(contrasttokensof({ mode, contrast: "high" }).tokens).toEqual(highcontrasttokens(mode).tokens);
-    }
-    /* the write path the darklight family already uses lands every --theme-* custom property while the body carries its data-contrast marker */
-    const written: Record<string, string> = {};
-    const attributes: Record<string, string> = {};
-    applycontrasttheme(
-      {
-        style: {
-          setProperty: (name, value) => {
-            written[name] = value;
-          },
-        },
-      },
-      {
-        setAttribute: (name, value) => {
-          attributes[name] = value;
-        },
-      },
-      highcontrasttokens("dark"),
-      "high",
-    );
-    expect(written["--theme-surface"]).toBe("#000000");
-    expect(written["--theme-text"]).toBe("#ffffff");
-    expect(written["color-scheme"]).toBe("dark");
-    expect(attributes["data-contrast"]).toBe("high");
-    applycontrasttheme(
-      {
-        style: {
-          setProperty: (name, value) => {
-            written[name] = value;
-          },
-        },
-      },
-      {
-        setAttribute: (name, value) => {
-          attributes[name] = value;
-        },
-      },
-      darklighttokensof("light"),
-      "default",
-    );
-    expect(attributes["data-contrast"]).toBe("default");
-  });
-
-  it("persists the contrastpreference toggle through the surface layout seam", async () => {
-    const store = new sessionmemory(new fakeadapter());
-    await store.setsurfacelayout({
-      surface: "optionspage",
-      preferences: { contrastpreference: "high" },
-      updatedat: now,
-    });
-    expect((await store.getsurfacelayout("optionspage"))?.preferences.contrastpreference).toBe("high");
-    /* the optionspage toggle reads and writes the preference through the same seam for every themed surface, and the themed surfaces resolve the high contrast variant from their own layout record */
-    const optionspage = await readFile("web/optionspage.ts", "utf8");
-    expect(optionspage).toContain('document.querySelector<HTMLSelectElement>("#contrastpreference")');
-    expect(optionspage).toContain('const contrastsurfaces = ["optionspage", "sidepanel", "dashboardpage"] as const;');
-    expect(optionspage).toContain("await savecontrastpreference(contrast);");
-    expect(optionspage).toContain('layout: { get: { surface: "optionspage" } }');
-    expect(optionspage).toContain("for (const surface of contrastsurfaces) {");
-    expect(optionspage).toContain('await request({ kind: "surface", layout: { set: { surface, preferences } } });');
-    const design = await readFile("web/design.html", "utf8");
-    expect(design).toContain(
-      '<select id="contrastpreference" aria-label="Contrast preference"><option value="default">Default contrast</option><option value="high">High contrast (WCAG AA)</option></select>',
-    );
-    expect(design).toContain('body[data-contrast="high"]');
-    for (const source of ["web/sidepanel.ts", "web/dashboardpage.ts"]) {
-      const text = await readFile(source, "utf8");
-      expect(text).toContain("layout: { get: { surface: ");
-      expect(text).toContain(
-        'applycontrasttheme(document.documentElement, document.body, contrasttokensof({ mode: theme.appearance.mode, contrast: "high" }), "high")',
-      );
-    }
-  });
-});

package/tests/snapshotdelta.test.ts

@@ -1,165 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  deltachangesof,
-  isemptydelta,
-  regionfingerprint,
-  skipsrecomputation,
-  snapshotbaserecord,
-  snapshotdeltaof,
-} from "../perf.js";
-import { incrsnapshotgate } from "../policy.js";
-import { recorddeltas, recordperf } from "../progress.js";
-import { perfrecordof } from "../perf.js";
-
-const now = 1_800_000_000_000;
-const base = [
-  { region: "header", content: "Example header" },
-  { region: "table", content: "one two three" },
-  { region: "footer", content: "Example footer" },
-];
-
-describe("incrsnapshot delta computation", () => {
-  it("computes only the changed regions with stable fingerprints", () => {
-    const fingerprint = regionfingerprint("table", "one two three");
-    expect(fingerprint).toBe(regionfingerprint("table", "one two three"));
-    expect(fingerprint).not.toBe(regionfingerprint("table", "one two four"));
-    const delta = snapshotdeltaof({
-      baseref: "base:1",
-      runid: "run1",
-      base,
-      current: [...base, { region: "modal", content: "new" }],
-      now,
-    });
-    expect(delta.baseref).toBe("base:1");
-    expect(delta.runid).toBe("run1");
-    expect(delta.full).toBe(false);
-    expect(delta.changes).toEqual([{ region: "modal", fingerprint: regionfingerprint("modal", "new"), kind: "added" }]);
-    const changed = snapshotdeltaof({
-      baseref: "base:1",
-      runid: "run1",
-      base,
-      current: [
-        { region: "header", content: "Example header" },
-        { region: "table", content: "one two four" },
-        { region: "footer", content: "Example footer" },
-      ],
-      now,
-    });
-    expect(changed.changes.map((change) => change.kind)).toEqual(["changed"]);
-    const removed = snapshotdeltaof({
-      baseref: "base:1",
-      runid: "run1",
-      base,
-      current: [
-        { region: "header", content: "Example header" },
-        { region: "footer", content: "Example footer" },
-      ],
-      now,
-    });
-    expect(removed.changes.map((change) => change.kind)).toEqual(["removed"]);
-    expect(removed.changes[0]?.region).toBe("table");
-  });
-
-  it("returns the empty delta that lets the executor skip the recomputation in full", () => {
-    const delta = snapshotdeltaof({ baseref: "base:1", runid: "run1", base, current: base, now });
-    expect(delta.changes).toHaveLength(0);
-    expect(isemptydelta(delta)).toBe(true);
-    expect(skipsrecomputation(delta)).toBe(true);
-    const changed = snapshotdeltaof({
-      baseref: "base:1",
-      runid: "run1",
-      base,
-      current: [
-        { region: "header", content: "changed" },
-        { region: "table", content: "one two three" },
-        { region: "footer", content: "Example footer" },
-      ],
-      now,
-    });
-    expect(isemptydelta(changed)).toBe(false);
-    expect(skipsrecomputation(changed)).toBe(false);
-  });
-
-  it("keeps the full snapshot cadence as a user choice and refuses baseless deltas", () => {
-    expect(() => snapshotdeltaof({ baseref: " ", runid: "run1", base: [], current: [], now })).toThrow(
-      /base snapshot ref/i,
-    );
-    const full = snapshotdeltaof({
-      baseref: "base:1",
-      runid: "run1",
-      base,
-      current: base,
-      deltasince: 5,
-      cadence: 5,
-      now,
-    });
-    expect(full.full).toBe(true);
-    expect(full.changes).toHaveLength(0);
-    expect(full.fingerprint).toBe("full:base:1");
-    expect(isemptydelta(full)).toBe(false);
-    const notdue = snapshotdeltaof({
-      baseref: "base:1",
-      runid: "run1",
-      base,
-      current: base,
-      deltasince: 4,
-      cadence: 5,
-      now,
-    });
-    expect(notdue.full).toBe(false);
-  });
-
-  it("gates the delta on its same run base and keeps base records", () => {
-    const delta = snapshotdeltaof({ baseref: "base:1", runid: "run1", base, current: base, now });
-    expect(incrsnapshotgate({ delta, runid: "run1", baseexists: true }).allowed).toBe(true);
-    expect(incrsnapshotgate({ delta, runid: "run1", baseexists: false }).allowed).toBe(false);
-    expect(incrsnapshotgate({ delta, runid: "run2", baseexists: true }).allowed).toBe(false);
-    expect(incrsnapshotgate({ delta, runid: "run2", baseexists: true }).reason).toMatch(/never crosses runs/i);
-    const record = snapshotbaserecord({ runid: "run1", ref: "base:1", now });
-    expect(record.runid).toBe("run1");
-    expect(() => snapshotbaserecord({ runid: " ", ref: "base:1", now })).toThrow(/run id/i);
-    expect(() => snapshotbaserecord({ runid: "run1", ref: " ", now })).toThrow(/ref/i);
-    expect(deltachangesof(delta)).toEqual([]);
-  });
-
-  it("records the perf data and the delta change set beside the step outcomes in progress", () => {
-    const perf = perfrecordof({
-      runid: "run1",
-      stepid: "s1",
-      duration: 12,
-      queries: 3,
-      cachehits: 2,
-      delta: true,
-      now,
-      provenance: { origin: "https://example.com" },
-    });
-    let progress = recordperf(undefined, "run1", "s1", perf, now);
-    progress = recorddeltas(
-      progress,
-      "run1",
-      "s1",
-      [{ region: "table", fingerprint: "abc12345", kind: "changed" }],
-      now,
-    );
-    expect((progress.perf ?? {}).s1?.cachehits).toBe(2);
-    expect((progress.deltas ?? {}).s1).toEqual([{ region: "table", fingerprint: "abc12345", kind: "changed" }]);
-    const latest = recordperf(
-      progress,
-      "run1",
-      "s1",
-      perfrecordof({
-        runid: "run1",
-        stepid: "s1",
-        duration: 20,
-        queries: 1,
-        cachehits: 1,
-        delta: false,
-        now: now + 10,
-        provenance: {},
-      }),
-      now + 10,
-    );
-    expect((latest.perf ?? {}).s1?.duration).toBe(20);
-    expect((latest.deltas ?? {}).s1).toHaveLength(1);
-  });
-});

package/tests/statusviews.test.ts

@@ -1,237 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  badgetextof,
-  badgecolorof,
-  countlabel,
-  notifyattentionof,
-  notifydoneof,
-  notificationrespectsdnd,
-  pluralize,
-  recenttrayactions,
-  recenttrayafter,
-  recenttrayentryof,
-  statusbadgeof,
-  stetoasthistory,
-  stetoastof,
-  stetoaststackafter,
-} from "../views.js";
-import { notificationcontentgate } from "../policy.js";
-
-const now = 1_800_000_000_000;
-
-describe("statusbadge, notifications, recenttray and stetoasts", () => {
-  it("derives the statusbadge states and counts the waiting gates", () => {
-    expect(statusbadgeof({ waitingcount: 0 }).state).toBe("idle");
-    expect(statusbadgeof({ planstate: "approved", waitingcount: 0, runid: "run-1" }).state).toBe("running");
-    expect(statusbadgeof({ planstate: "pending", waitingcount: 0 }).state).toBe("waiting");
-    const attention = statusbadgeof({ planstate: "approved", waitingcount: 2, runid: "run-1" });
-    expect(attention.state).toBe("attention");
-    expect(attention.waitingcount).toBe(2);
-    expect(badgetextof(attention)).toBe("2");
-    expect(badgetextof(statusbadgeof({ planstate: "approved", waitingcount: 0 }))).toBe("run");
-    expect(badgetextof(statusbadgeof({ waitingcount: 0 }))).toBe("");
-    expect(badgecolorof(attention)).toBe(badgecolorof({ ...attention }));
-  });
-
-  it("builds the done and attention payloads with deep links and gates the page content", () => {
-    const done = notifydoneof({
-      runid: "run-1",
-      origin: "https://example.com",
-      summary: "The pricing table landed in 8 steps.",
-      at: now,
-    });
-    expect(done.kind).toBe("done");
-    expect(done.deeplink).toBe("#run-run-1");
-    expect(done.content).toBe(false);
-    const attention = notifyattentionof({
-      runid: "run-1",
-      stepid: "step-3",
-      cause: "gatewait",
-      reason: "The fillform step waits for its consent.",
-      at: now,
-    });
-    expect(attention.kind).toBe("attention");
-    expect(attention.deeplink).toBe("#step-step-3");
-    expect(attention.content).toBe(false);
-    expect(() =>
-      notifyattentionof({ runid: "run-1", stepid: " ", cause: "gatewait", reason: "waits", at: now }),
-    ).toThrow(/waiting step/);
-    expect(notificationcontentgate({ content: false, consent: false }).allowed).toBe(true);
-    expect(notificationcontentgate({ content: true, consent: false }).reason).toMatch(
-      /never shows without its consent/,
-    );
-    expect(notificationcontentgate({ content: true, consent: true }).allowed).toBe(true);
-    expect(() =>
-      notifyattentionof({
-        runid: "run-1",
-        stepid: "s",
-        cause: "phishguard",
-        reason: "r",
-        content: true,
-        consent: false,
-        at: now,
-      }),
-    ).toThrow(/consent/);
-    expect(
-      notifyattentionof({
-        runid: "run-1",
-        stepid: "s",
-        cause: "phishguard",
-        reason: "r",
-        content: true,
-        consent: true,
-        at: now,
-      }).content,
-    ).toBe(true);
-    /* the 2.0.2 plural fix of the rc.2 final polish: the counted fallback bodies read their own grammar while the composers without counts keep their exact legacy sentences */
-    const singular = notifydoneof({
-      runid: "run-2",
-      origin: "https://example.com",
-      summary: "",
-      steps: 1,
-      captures: 1,
-      at: now,
-    });
-    expect(singular.body).toContain("of the 1 step beside 1 capture");
-    const plural = notifydoneof({
-      runid: "run-2",
-      origin: "https://example.com",
-      summary: "",
-      steps: 8,
-      captures: 4,
-      at: now,
-    });
-    expect(plural.body).toContain("of the 8 steps beside 4 captures");
-    const countsless = notifydoneof({ runid: "run-2", origin: "https://example.com", summary: "", at: now });
-    expect(countsless.body).toBe("The run of https://example.com completed; the runsummary holds every step outcome.");
-    const localized = notifydoneof({
-      runid: "run-2",
-      origin: "https://example.com",
-      summary: "",
-      steps: 8,
-      language: "pt",
-      at: now,
-    });
-    expect(localized.body).toContain("of the 8 etapas");
-    const waits = notifyattentionof({
-      runid: "run-1",
-      stepid: "step-3",
-      cause: "gatewait",
-      reason: "The fillform step waits for its consent.",
-      at: now,
-    });
-    expect(waits.body).toBe("The fillform step waits for its consent.");
-    expect(
-      notifyattentionof({
-        runid: "run-1",
-        stepid: "step-3",
-        cause: "gatewait",
-        reason: "one gate holds.",
-        waitinggates: 1,
-        at: now,
-      }).body,
-    ).toContain("(1 gate waiting)");
-    expect(
-      notifyattentionof({
-        runid: "run-1",
-        stepid: "step-3",
-        cause: "gatewait",
-        reason: "three gates hold.",
-        waitinggates: 3,
-        at: now,
-      }).body,
-    ).toContain("(3 gates waiting)");
-  });
-
-  it("pluralizes the counted nouns of the notification texts in english and the shipped pt bundle", () => {
-    expect(pluralize(1, "step")).toBe("step");
-    expect(pluralize(3, "step")).toBe("steps");
-    expect(pluralize(0, "step")).toBe("steps");
-    expect(pluralize(1, "capture")).toBe("capture");
-    expect(pluralize(4, "capture")).toBe("captures");
-    expect(pluralize(2, "run")).toBe("runs");
-    expect(pluralize(2, "gate")).toBe("gates");
-    expect(pluralize(1, "step", "pt")).toBe("etapa");
-    expect(pluralize(3, "step", "pt")).toBe("etapas");
-    expect(pluralize(1, "capture", "pt")).toBe("captura");
-    expect(pluralize(4, "capture", "pt")).toBe("capturas");
-    expect(pluralize(2, "run", "pt")).toBe("execuções");
-    expect(pluralize(2, "gate", "pt")).toBe("verificações");
-    expect(pluralize(1, "selector", "pt")).toBe("selector");
-    expect(countlabel(1, "step")).toBe("1 step");
-    expect(countlabel(3, "step")).toBe("3 steps");
-    expect(countlabel(1, "capture")).toBe("1 capture");
-    expect(countlabel(4, "capture")).toBe("4 captures");
-    expect(countlabel(0, "run")).toBe("0 runs");
-    expect(countlabel(3, "step", "pt")).toBe("3 etapas");
-    expect(countlabel(4, "capture", "pt")).toBe("4 capturas");
-  });
-
-  it("respects the os do not disturb state while the deep link stays in the history", () => {
-    const done = notifydoneof({ runid: "run-1", origin: "https://example.com", summary: "done", at: now });
-    const quiet = notificationrespectsdnd(done, true);
-    expect(quiet.show).toBe(false);
-    expect(quiet.reason).toMatch(/do not disturb/);
-    expect(notificationrespectsdnd(done, false).show).toBe(true);
-  });
-
-  it("lists the latest runs in the recenttray with resume and reopen offers", () => {
-    const halted = recenttrayentryof({
-      runid: "run-1",
-      origin: "https://example.com",
-      outcome: "halted",
-      title: "Pricing pass",
-      at: now,
-    });
-    const completed = recenttrayentryof({
-      runid: "run-2",
-      origin: "https://example.com",
-      outcome: "completed",
-      title: "Invoice sweep",
-      at: now + 1,
-    });
-    const running = recenttrayentryof({
-      runid: "run-3",
-      origin: "https://example.com",
-      outcome: "running",
-      title: "Live pass",
-      at: now + 2,
-    });
-    expect(recenttrayactions(halted)).toEqual(["resume"]);
-    expect(recenttrayactions(completed)).toEqual(["reopen"]);
-    expect(recenttrayactions(running)).toEqual([]);
-    const unbounded = recenttrayafter([halted, completed], running, undefined);
-    expect(unbounded.map((entry) => entry.runid)).toEqual(["run-3", "run-1", "run-2"]);
-    const bounded = recenttrayafter([halted, completed], running, 2);
-    expect(bounded.map((entry) => entry.runid)).toEqual(["run-3", "run-1"]);
-    expect(
-      recenttrayafter(
-        [halted],
-        recenttrayentryof({
-          runid: "run-1",
-          origin: "https://example.com",
-          outcome: "completed",
-          title: "again",
-          at: now,
-        }),
-        undefined,
-      ),
-    ).toHaveLength(1);
-    expect(() =>
-      recenttrayentryof({ runid: " ", origin: "https://example.com", outcome: "halted", title: "t", at: now }),
-    ).toThrow(/run id/);
-  });
-
-  it("confirms step completion with stetoasts that stack inside the user live count", () => {
-    const first = stetoastof({ stepid: "step-1", kind: "readtable", durationms: 250, at: now });
-    const second = stetoastof({ stepid: "step-2", kind: "click", durationms: 90, at: now + 1 });
-    expect(second.kind).toBe("click");
-    const unbounded = stetoaststackafter([first], second, undefined);
-    expect(unbounded.live).toHaveLength(2);
-    const bounded = stetoaststackafter([first], second, 1);
-    expect(bounded.live).toEqual([second]);
-    expect(bounded.history).toHaveLength(2);
-    expect(stetoasthistory(bounded.history)[0]?.stepid).toBe("step-2");
-    expect(() => stetoastof({ stepid: " ", kind: "click", durationms: 1, at: now })).toThrow(/step/);
-  });
-});