@wenathlan/devthink 2.0.14 → 2.0.19

package/tests/torture-commands.test.ts

@@ -1,895 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  audiotabs,
-  advancedownload,
-  badgefromprogress,
-  batchopenlinks,
-  buildlayout,
-  checksafeurl,
-  capturefilename,
-  capturenames,
-  capturesteps,
-  clipentryof,
-  cliphash,
-  clonetabs,
-  closeselection,
-  concurrentwindow,
-  conflictfree,
-  deeplinkapp,
-  discardcandidates,
-  downloadfilename,
-  layoutrestoreplan,
-  mimeallowed,
-  navintent,
-  navratelimit,
-  netlogentry,
-  netlogforstep,
-  newquarantine,
-  normalizedtaburl,
-  openclipboardurl,
-  parsetabquery,
-  pausenavconsent,
-  prefetchpage,
-  preconnectorigin,
-  quarantinedpath,
-  querymatches,
-  redactheaders,
-  reopentab,
-  resumenavconsent,
-  restoretrail,
-  referencedartifacts,
-  regroupaftermoves,
-  renamegroup,
-  restorediscarded,
-  released,
-  scanresult,
-  scanverdictof,
-  searchtabmatches,
-  sweepplan,
-  switcherlist,
-  switchtarget,
-  tabpatternmatches,
-  tasktabsinwindow,
-  tasktabgauge,
-  transitionallowed,
-  verifybytes,
-  watchtabdispatch,
-  windowprofilegrants,
-  zoomstep,
-} from "../commands.js";
-import type {
-  closedtabrecord,
-  ratelimitwindow,
-  tabgrouprecord,
-  toolstep,
-  urlvisit,
-  artifactinventoryentry,
-  cleanuprule,
-} from "../types.js";
-
-const now = 1_800_000_000_000;
-
-/** Builds one live tab shape fixture. */
-function tab(
-  over: Partial<{
-    tabid: number;
-    url: string;
-    title: string;
-    index: number;
-    windowid: number;
-    active: boolean;
-    pinned: boolean;
-    audible: boolean;
-    muted: boolean;
-    discarded: boolean;
-  }> = {},
-) {
-  return {
-    tabid: 1,
-    url: "https://example.com/page",
-    title: "Example",
-    index: 0,
-    windowid: 1,
-    active: true,
-    pinned: false,
-    audible: false,
-    muted: false,
-    discarded: false,
-    ...over,
-  };
-}
-
-/** Builds one toolstep fixture. */
-function step(kind: toolstep["kind"], over: Partial<toolstep> = {}): toolstep {
-  return { id: "s1", kind, summary: "", risk: "interaction", ...over };
-}
-
-describe("torture: tab queries, patterns and the star storm", () => {
-  it("parses reviewed tab queries from step options and refuses malformed carriers", () => {
-    expect(
-      parsetabquery(
-        step("querytabs", {
-          options: JSON.stringify({
-            tabquery: { url: "https://example.com", title: "Example", id: 3, pattern: "https://example.com/*" },
-          }),
-        }),
-      ),
-    ).toEqual({ url: "https://example.com", title: "Example", id: 3, pattern: "https://example.com/*" });
-    expect(
-      parsetabquery(step("querytabs", { options: JSON.stringify({ tabquery: { id: -1, url: "", title: 5 } }) })),
-    ).toEqual({});
-    expect(parsetabquery(step("querytabs", { options: JSON.stringify({ tabquery: "nope" }) }))).toBeNull();
-    expect(parsetabquery(step("querytabs", { options: JSON.stringify({ tabquery: ["nope"] }) }))).toBeNull();
-    expect(parsetabquery(step("querytabs", { options: "not json" }))).toBeNull();
-    expect(parsetabquery(step("querytabs", {}))).toBeNull();
-  });
-
-  it("matches wildcard patterns with segment and subtree spans, regex metacharacters and empties", () => {
-    expect(tabpatternmatches("*", "anything")).toBe(true);
-    expect(tabpatternmatches("*", "a/b")).toBe(false);
-    expect(tabpatternmatches("**", "a/b/c")).toBe(true);
-    expect(tabpatternmatches("https://example.com/*", "https://example.com/pricing")).toBe(true);
-    expect(tabpatternmatches("https://example.com/*", "https://example.com/a/b")).toBe(false);
-    expect(tabpatternmatches("https://example.com/**", "https://example.com/a/b")).toBe(true);
-    expect(tabpatternmatches("https://example.com/**", "https://other.example/a")).toBe(false);
-    expect(tabpatternmatches("https://example.com/?q=1", "https://example.com/?q=1")).toBe(true);
-    expect(tabpatternmatches("https://example.com/?q=1", "https://example.com/xq=1")).toBe(false);
-    expect(tabpatternmatches("a.b", "axb")).toBe(false);
-    expect(tabpatternmatches("a*b*c", "a-b-c")).toBe(true);
-    expect(tabpatternmatches("", "")).toBe(true);
-    expect(tabpatternmatches("", "x")).toBe(false);
-    expect(tabpatternmatches("****", "a/b/c")).toBe(true);
-  });
-
-  it("stays linear on adversarial star storms instead of backtracking catastrophically", () => {
-    const started = Date.now();
-    expect(tabpatternmatches("*a".repeat(1500), "b".repeat(2000))).toBe(false);
-    expect(tabpatternmatches("a*".repeat(1500), "a".repeat(2000) + "/")).toBe(false);
-    expect(tabpatternmatches("*".repeat(3000), "https://example.com/" + "a/".repeat(1500))).toBe(true);
-    expect(tabpatternmatches(("ab*" + "a".repeat(20)).repeat(500), "ab" + "a".repeat(30))).toBe(false);
-    /* the linearity budget stays one second on native runners and scales with the same env the emulated arm64 container leg sets, because a qemu-interpreted second is not a native second while the linearity it proves is the same */
-    expect(Date.now() - started).toBeLessThan(Number(process.env.DEVTHINK_TEST_BUDGET_MS ?? 1000));
-  });
-
-  it("resolves tab queries where every matcher that exists must hold", () => {
-    const tabs = [
-      tab({ tabid: 1, url: "https://example.com/a", title: "Alpha" }),
-      tab({ tabid: 2, url: "https://example.com/b", title: "beta" }),
-      tab({ tabid: 3, url: "https://other.example/c", title: "Gamma" }),
-    ];
-    expect(querymatches({ url: "https://example.com/a" }, tabs)).toHaveLength(1);
-    expect(querymatches({ title: "ALPHA" }, tabs)).toHaveLength(1);
-    expect(querymatches({ id: 2 }, tabs).map((entry) => entry.tabid)).toEqual([2]);
-    expect(querymatches({ pattern: "https://example.com/*" }, tabs)).toHaveLength(2);
-    expect(querymatches({}, tabs)).toHaveLength(3);
-    expect(querymatches({ url: "https://example.com/a", title: "beta" }, tabs)).toHaveLength(0);
-  });
-
-  it("normalizes urls for clone comparison by dropping fragments and trailing slashes", () => {
-    expect(normalizedtaburl("https://example.com/page/")).toBe("https://example.com/page");
-    expect(normalizedtaburl("https://example.com/page///")).toBe("https://example.com/page");
-    expect(normalizedtaburl("https://example.com/page#frag")).toBe("https://example.com/page");
-    expect(normalizedtaburl("https://example.com/page#frag/more")).toBe("https://example.com/page");
-    expect(normalizedtaburl("/")).toBe("/");
-    expect(normalizedtaburl("")).toBe("");
-    const tabs = [
-      tab({ tabid: 1, url: "https://example.com/p" }),
-      tab({ tabid: 2, url: "https://example.com/p/" }),
-      tab({ tabid: 3, url: "https://example.com/p#x" }),
-      tab({ tabid: 4, url: "https://other.example" }),
-    ];
-    expect(clonetabs(tabs)).toEqual([{ url: "https://example.com/p", tabids: [1, 2, 3] }]);
-    expect(clonetabs([tab({ tabid: 9, url: "" }), tab({ tabid: 10, url: "" })])).toEqual([]);
-  });
-
-  it("searches, audio lists, discard candidates and restores across the live tab set", () => {
-    const tabs = [
-      tab({ tabid: 1, title: "Pricing table", url: "https://example.com/pricing" }),
-      tab({ tabid: 2, title: "Docs", url: "https://docs.example.org/guide", audible: true, active: false }),
-      tab({ tabid: 3, title: "Music", muted: true, audible: true, discarded: true, active: false }),
-    ];
-    expect(searchtabmatches(tabs, "  pricing ")).toHaveLength(1);
-    expect(searchtabmatches(tabs, "DOCS")).toHaveLength(1);
-    expect(searchtabmatches(tabs, " ")).toEqual([]);
-    expect(audiotabs(tabs).map((entry) => entry.tabid)).toEqual([2, 3]);
-    expect(discardcandidates(tabs).map((entry) => entry.tabid)).toEqual([2]);
-    expect(restorediscarded(tabs)).toEqual([{ tabid: 3, url: tabs[2]!.url }]);
-  });
-
-  it("captures layouts, restores only the closed urls and regroups membership through moves", () => {
-    const tabs = [
-      tab({ tabid: 1, index: 0, pinned: true }),
-      tab({ tabid: 2, index: 1 }),
-      tab({ tabid: 3, index: 2, windowid: 7 }),
-    ];
-    const windows = [
-      {
-        windowid: 1,
-        left: 0,
-        top: 0,
-        width: 800,
-        height: 600,
-        state: "normal" as const,
-        incognito: false,
-        focused: true,
-      },
-      {
-        windowid: 7,
-        left: 10,
-        top: 10,
-        width: 400,
-        height: 300,
-        state: "maximized" as const,
-        incognito: false,
-        focused: false,
-      },
-    ];
-    const groups: tabgrouprecord[] = [
-      { groupid: "g1", name: "Research", color: "blue", tabids: [3, 2, 99], collapsed: false, savedat: now - 10 },
-    ];
-    const layout = buildlayout("daily", tabs, windows, groups, [7], now);
-    expect(layout.name).toBe("daily");
-    expect(layout.tabs).toHaveLength(3);
-    expect(layout.groups[0]?.tabids).toEqual([3, 2]);
-    expect(layout.windows[1]?.state).toEqual({
-      bounds: { left: 10, top: 10, width: 400, height: 300 },
-      maximized: true,
-      profile: "scratch",
-    });
-    expect(layoutrestoreplan(layout, ["https://example.com/page/"])).toEqual([]);
-    expect(layoutrestoreplan(layout, ["https://other.example/x"])).toEqual([
-      "https://example.com/page",
-      "https://example.com/page",
-      "https://example.com/page",
-    ]);
-    const moved = regroupaftermoves(groups, [tab({ tabid: 2, index: 0 }), tab({ tabid: 3, index: 1 })], now);
-    expect(moved[0]?.tabids).toEqual([2, 3]);
-    expect(moved[0]?.savedat).toBe(now);
-    expect(renamegroup(groups, "Research", "Study", now)[0]?.name).toBe("Study");
-    expect(regroupaftermoves(groups, [], now)[0]?.tabids).toEqual([3, 2, 99]);
-  });
-
-  it("protects the session tab from closepattern selections and counts task tabs per window", () => {
-    const tabs = [tab({ tabid: 1 }), tab({ tabid: 2 }), tab({ tabid: 3 })];
-    const selection = closeselection({ pattern: "https://example.com/*" }, tabs, 2);
-    expect(selection.targets.map((entry) => entry.tabid)).toEqual([1, 3]);
-    expect(selection.refused.map((entry) => entry.tabid)).toEqual([2]);
-    expect(closeselection({ id: 9 }, tabs, 2).targets).toEqual([]);
-    expect(tasktabsinwindow(tabs, 1, [1, 3, 99])).toBe(2);
-    expect(tasktabsinwindow(tabs, 5, [1])).toBe(0);
-  });
-
-  it("zooms without crossing zero, switches with wraparound and orders the switcher by recency", () => {
-    expect(zoomstep(1, "in", 0.25)).toBe(1.25);
-    expect(zoomstep(0.1, "out", 0.2)).toBe(0.1);
-    expect(zoomstep(0.5, "in", 0)).toBe(0.5);
-    const tabs = [
-      tab({ tabid: 1, index: 0, title: "Alpha" }),
-      tab({ tabid: 2, index: 1, title: "Beta tab 2" }),
-      tab({ tabid: 3, index: 2, title: "Gamma" }),
-    ];
-    expect(switchtarget(tabs, "next", 2)).toBe(0);
-    expect(switchtarget(tabs, "previous", 0)).toBe(2);
-    expect(switchtarget([], "next", 0)).toBeUndefined();
-    const recency = [
-      { tabid: 3, at: now },
-      { tabid: 1, at: now - 100 },
-    ];
-    expect(switcherlist(tabs, recency, "").map((entry) => entry.tabid)).toEqual([3, 1, 2]);
-    expect(switcherlist(tabs, recency, "tab 2").map((entry) => entry.tabid)).toEqual([2]);
-    expect(switcherlist(tabs, recency, "nomatch")).toEqual([]);
-  });
-
-  it("dispatches watched tab events through filters and derives badges and tab budgets", () => {
-    const events = [
-      { watchid: "w1", event: "title" as const, tabid: 1, at: now },
-      { watchid: "w1", event: "closed" as const, tabid: 2, at: now + 1 },
-      { watchid: "w2", event: "title" as const, tabid: 3, at: now + 2 },
-    ];
-    expect(watchtabdispatch(events, "w1", ["title"])).toHaveLength(1);
-    expect(watchtabdispatch(events, "w1", [])).toHaveLength(2);
-    expect(watchtabdispatch(events, "w9", [])).toEqual([]);
-    expect(badgefromprogress(3, 0)).toEqual({ label: "idle", done: false });
-    expect(badgefromprogress(5, 5)).toEqual({ label: "done", done: true });
-    expect(badgefromprogress(2, 5)).toEqual({ label: "2/5", done: false });
-    expect(tasktabgauge(3, undefined)).toEqual({ used: 3, ceiling: undefined, over: false });
-    expect(tasktabgauge(3, 2)).toEqual({ used: 3, ceiling: 2, over: true });
-    expect(tasktabgauge(2, 2).over).toBe(false);
-    expect(windowprofilegrants("normal")).toBe(true);
-    expect(windowprofilegrants("scratch")).toBe(true);
-    expect(windowprofilegrants("incognito")).toBe(false);
-  });
-});
-
-describe("torture: download states, filenames, mime filters and quarantine routing", () => {
-  const record = {
-    id: "d1",
-    url: "https://example.com/file.bin",
-    filename: "file.bin",
-    state: "queued" as const,
-    at: now,
-    updatedat: now,
-  };
-
-  it("walks only the legal batch queue transitions and merges evidence", () => {
-    expect(transitionallowed("queued", "running")).toBe(true);
-    expect(transitionallowed("queued", "paused")).toBe(false);
-    expect(transitionallowed("complete", "failed")).toBe(false);
-    expect(transitionallowed("failed", "queued")).toBe(false);
-    const impossible = advancedownload({ ...record, state: "complete" }, "running", now + 1);
-    expect(impossible.state).toBe("complete");
-    expect(impossible.updatedat).toBe(now);
-    const running = advancedownload(record, "running", now + 1, {
-      bytes: 42,
-      checksum: "sha",
-      downloadid: 7,
-      path: "/tmp/file.bin",
-    });
-    expect(running).toMatchObject({
-      state: "running",
-      bytes: 42,
-      checksum: "sha",
-      downloadid: 7,
-      path: "/tmp/file.bin",
-    });
-    const kept = advancedownload(record, "running", now + 2);
-    expect(kept.path).toBeUndefined();
-    expect(concurrentwindow(3, undefined)).toBe(true);
-    expect(concurrentwindow(3, 3)).toBe(false);
-    expect(concurrentwindow(2, 3)).toBe(true);
-  });
-
-  it("resolves filename conflicts with sequence suffixes and keeps extensions", () => {
-    expect(conflictfree("report.pdf", ["other.pdf"])).toBe("report.pdf");
-    expect(conflictfree("report.pdf", ["report.pdf"])).toBe("report-2.pdf");
-    expect(conflictfree("report.pdf", ["report.pdf", "report-2.pdf"])).toBe("report-3.pdf");
-    expect(conflictfree("noext", ["noext"])).toBe("noext-2");
-    expect(conflictfree(".gitignore", [".gitignore"])).toBe(".gitignore-2");
-    expect(conflictfree("archive.tar.gz", ["archive.tar.gz", "archive.tar-2.gz"])).toBe("archive.tar-3.gz");
-  });
-
-  it("derives download filenames from urls with decoding, hostnames and reviewed rules", () => {
-    expect(downloadfilename("https://example.com/files/report.pdf", undefined)).toBe("report.pdf");
-    expect(downloadfilename("https://example.com/files/my%20file.txt", undefined)).toBe("my file.txt");
-    expect(downloadfilename("https://example.com/", undefined)).toBe("example.com");
-    expect(downloadfilename("https://example.com", undefined)).toBe("example.com");
-    expect(downloadfilename("not a url", undefined)).toBe("not a url");
-    expect(downloadfilename("https://example.com/x.bin", "  reviewed.bin  ")).toBe("reviewed.bin");
-    expect(downloadfilename("https://example.com/a/b/", undefined)).toBe("b");
-  });
-
-  it("verifies completed downloads against size and checksum expectations", () => {
-    const complete = { ...record, state: "complete" as const, bytes: 100, checksum: "sha-1" };
-    expect(verifybytes(complete, { bytes: 100, checksum: "sha-1" }).ok).toBe(true);
-    expect(verifybytes(complete, { bytes: 101 }).ok).toBe(false);
-    expect(verifybytes(complete, { checksum: "sha-2" }).ok).toBe(false);
-    expect(verifybytes(record, {}).ok).toBe(false);
-    expect(verifybytes(complete, {}).matches).toEqual({ state: true, size: true, checksum: true });
-    const { bytes: _bytes, ...unknownsize } = complete;
-    expect(verifybytes(unknownsize, { bytes: 5 }).summary).toContain("unknown");
-  });
-
-  it("filters mime types where exclude wins, then include, then the default", () => {
-    const filter = { include: ["image/*"], exclude: ["image/svg+xml"], default: "allow" as const };
-    expect(mimeallowed(filter, "image/png")).toBe(true);
-    expect(mimeallowed(filter, "image/svg+xml")).toBe(false);
-    expect(mimeallowed(filter, "text/html")).toBe(true);
-    expect(mimeallowed({ include: ["text/plain"], exclude: [], default: "deny" as const }, "text/html")).toBe(false);
-    expect(mimeallowed({ include: [], exclude: [], default: "deny" as const }, "text/html")).toBe(false);
-    expect(
-      mimeallowed({ include: ["application/json"], exclude: [], default: "deny" as const }, "application/json"),
-    ).toBe(true);
-    expect(mimeallowed({ include: ["exact"], exclude: [], default: "allow" as const }, "exact")).toBe(true);
-    expect(mimeallowed({ include: ["exact"], exclude: [], default: "allow" as const }, "exactly")).toBe(true);
-  });
-
-  it("redacts every header value, correlates netlog rows and hashes clipboard payloads", () => {
-    expect(redactheaders({ Authorization: "Bearer abc", "X-Safe": "1" })).toEqual({
-      Authorization: "[redacted]",
-      "X-Safe": "[redacted]",
-    });
-    const entries = [
-      netlogentry({
-        url: "https://example.com/a",
-        method: "GET",
-        status: 200,
-        timing: 12,
-        requestid: "r1",
-        stepid: "s1",
-        at: now,
-      }),
-      netlogentry({
-        url: "https://example.com/b",
-        method: "POST",
-        status: 500,
-        timing: 30,
-        requestid: "r2",
-        stepid: "s2",
-        at: now + 1,
-      }),
-    ];
-    expect(netlogforstep(entries, "s1")).toHaveLength(1);
-    expect(netlogforstep(entries, "s9")).toEqual([]);
-    expect(clipentryof("read", { hash: cliphash("payload"), length: 7 }, "https://example.com", "s1", now)).toEqual({
-      kind: "read",
-      hash: cliphash("payload"),
-      length: 7,
-      origin: "https://example.com",
-      stepid: "s1",
-      at: now,
-    });
-    expect(cliphash("a")).not.toBe(cliphash("b"));
-    expect(
-      JSON.stringify(clipentryof("write", { hash: "h", length: 2 }, "https://example.com", "s", now)),
-    ).not.toContain("payload");
-  });
-
-  it("routes quarantined paths that no traversal, backslash or absolute prefix escapes", () => {
-    expect(quarantinedpath("invoice.pdf")).toBe("devthink-quarantine/invoice.pdf");
-    expect(quarantinedpath("/absolute/path.bin")).toBe("devthink-quarantine/absolute/path.bin");
-    expect(quarantinedpath("../../etc/passwd")).toBe("devthink-quarantine/etc/passwd");
-    expect(quarantinedpath("..\\..\\windows\\evil.exe")).toBe("devthink-quarantine/windows/evil.exe");
-    expect(quarantinedpath("nested/../inner/./file.bin")).toBe("devthink-quarantine/nested/inner/file.bin");
-    expect(quarantinedpath("..")).toBe("devthink-quarantine/");
-    expect(quarantinedpath("")).toBe("devthink-quarantine/");
-    expect(newquarantine("q1", "../../etc/passwd", "reviewed quarantine", now).path).toBe(
-      "devthink-quarantine/etc/passwd",
-    );
-  });
-
-  it("maps scan hook verdicts onto quarantine entries and release refs", () => {
-    const entry = newquarantine("q1", "invoice.pdf", "reviewed quarantine", now);
-    expect(entry).toMatchObject({
-      id: "q1",
-      path: "devthink-quarantine/invoice.pdf",
-      scan: "pending",
-      at: now,
-      updatedat: now,
-    });
-    expect(scanresult(entry, "clean", now + 1)).toMatchObject({ scan: "clean", updatedat: now + 1 });
-    expect(scanresult(entry, "error", now + 1).scan).toBe("error");
-    expect(scanverdictof({ verdict: "clean" })).toBe("clean");
-    expect(scanverdictof({ verdict: "flagged" })).toBe("flagged");
-    expect(scanverdictof({ verdict: "error" })).toBe("error");
-    expect(scanverdictof({ verdict: "weird" })).toBe("pending");
-    expect(scanverdictof(null)).toBe("pending");
-    expect(scanverdictof("clean")).toBe("pending");
-    expect(scanverdictof({})).toBe("pending");
-    expect(released(entry, "user-9", now + 2)).toMatchObject({ release: "user-9", updatedat: now + 2 });
-  });
-
-  it("stamps capture filenames that slugs hostile task and step names into safe parts", () => {
-    expect(capturefilename({ task: "Order Run", step: "Snap Shot", sequence: 4 }, ".PNG")).toBe(
-      "order-run-snap-shot-4.png",
-    );
-    expect(capturefilename({ task: "../evil", step: "sh/../ot", sequence: 1 }, "png")).toBe("evil-sh-ot-1.png");
-    expect(capturefilename({ task: "TÄSK é", step: "!", sequence: 2 }, "png")).toBe("t-sk-capture-2.png");
-    expect(capturefilename({ task: "", step: "", sequence: 1 }, "")).toBe("capture-capture-1.png");
-    expect(capturefilename({ task: "a", step: "b", sequence: 0 }, "png")).toBe("a-b-0.png");
-    const stamped = capturenames({}, "task-1", ["snap", "peek", "snap"], "png");
-    expect(stamped.names).toEqual(["task-1-snap-1.png", "task-1-peek-1.png", "task-1-snap-2.png"]);
-    expect(stamped.counters).toEqual({ snap: 2, peek: 1 });
-  });
-
-  it("reads namecaptures step lists from options or the plan and sweeps cleanup rules", () => {
-    expect(capturesteps({ steps: ["a", " ", 5] }, { steps: [] } as unknown as { steps: toolstep[] })).toEqual(["a"]);
-    expect(
-      capturesteps({}, { steps: [step("observe", { id: "one", risk: "read" }), step("click", { id: "two" })] }),
-    ).toEqual(["one", "two"]);
-    expect(referencedartifacts(undefined, [])).toEqual([]);
-    const plan = {
-      steps: [
-        step("attachfile", { id: "af1", value: "invoice.pdf" }),
-        step("attachfile", { id: "af2", value: "gone.pdf" }),
-        step("attachfile", { id: "af3", value: " " }),
-        step("observe", { id: "o1" }),
-      ],
-    };
-    expect(referencedartifacts(plan, ["af1"])).toEqual(["gone.pdf"]);
-    const entries: artifactinventoryentry[] = [
-      { id: "a0", kind: "export-csv", name: "ancient.csv", size: 100, at: now - 9999 },
-      { id: "a1", kind: "export-csv", name: "old.csv", size: 100, at: now - 5000 },
-      { id: "a2", kind: "export-csv", name: "new.csv", size: 100, at: now - 1000 },
-      { id: "a3", kind: "screenshot", name: "shot.png", size: 100, at: now - 9999 },
-    ];
-    const rules: cleanuprule[] = [{ age: 2000, kind: "export-csv", keep: "latest" }];
-    expect(sweepplan(entries, rules, now, ["a0"]).remove).toEqual([]);
-    expect(sweepplan(entries, rules, now, []).remove).toEqual(["a0"]);
-    expect(sweepplan(entries, [{ age: 2000, kind: "any", keep: "all" }], now, []).remove).toEqual([]);
-    expect(sweepplan(entries, [{ age: 0, kind: "any", keep: "none" }], now, ["shot.png"]).keep).toContain("a3");
-    expect(sweepplan([], [{ age: 0, kind: "any", keep: "none" }], now, [])).toEqual({ remove: [], keep: [] });
-  });
-});
-
-describe("torture: navigation intent, prefetch and deep links", () => {
-  it("predicts nav intent from https step values with dedupe and history weighting", () => {
-    const steps = [
-      step("navigate", { value: "https://example.com/one" }),
-      step("navigate", { value: "https://example.com/one" }),
-      step("navigate", { value: "https://example.com/two" }),
-      step("navigate", { value: "http://insecure.example" }),
-      step("navigate", { value: "  " }),
-    ];
-    const visits: urlvisit[] = [
-      { url: "https://example.com/two", at: now - 100, runid: "run1" },
-      { url: "https://example.com/two", at: now - 50, runid: "run1" },
-    ];
-    const plan = navintent({ id: "pf1", steps, visits, now });
-    expect(plan.predictedurls.map((entry) => entry.url)).toEqual([
-      "https://example.com/two",
-      "https://example.com/one",
-    ]);
-    expect(plan.predictedurls[0]?.confidence).toBeGreaterThan(plan.predictedurls[1]?.confidence ?? 0);
-    expect(navintent({ id: "pf1", steps: [], now }).predictedurls).toEqual([]);
-    expect(() => navintent({ id: " ", steps, now })).toThrow(/needs its id/);
-    const bare = navintent({ id: "pf2", steps: [step("navigate", { value: "https://example.com/x" })], now });
-    expect(bare.predictedurls[0]?.confidence).toBeGreaterThan(0);
-    expect(bare.predictedurls[0]?.confidence).toBeLessThanOrEqual(1);
-  });
-
-  it("warms only the granted origins while a stale plan drops every prediction", () => {
-    const warmed = prefetchpage({
-      id: "w1",
-      planid: "plan1",
-      urls: ["https://example.com/a", "https://example.com/a", "https://other.example/b", "not a url"],
-      grants: ["https://example.com"],
-      now,
-    });
-    expect(warmed.allowed).toEqual(["https://example.com/a"]);
-    expect(warmed.refused).toEqual(["https://other.example/b", "not a url"]);
-    expect(warmed.plan.predictedurls).toHaveLength(1);
-    const stale = prefetchpage({
-      id: "w2",
-      planid: "plan2",
-      urls: ["https://example.com/a"],
-      grants: ["https://example.com"],
-      stored: {
-        id: "w1",
-        planid: "plan1",
-        predictedurls: [{ url: "https://example.com/old", confidence: 0.9 }],
-        createdat: now,
-      },
-      now,
-    });
-    expect(stale.dropped).toEqual(["https://example.com/old"]);
-    expect(() => prefetchpage({ id: " ", planid: "p", urls: [], grants: [], now })).toThrow(/needs its id/);
-    expect(() => prefetchpage({ id: "w", planid: " ", urls: [], grants: [], now })).toThrow(/names the plan/i);
-    expect(prefetchpage({ id: "w", planid: "p", urls: [], grants: [], now }).allowed).toEqual([]);
-  });
-
-  it("preconnects only granted, deduped, non empty origins", () => {
-    const result = preconnectorigin({
-      origins: ["https://example.com", "https://example.com", " ", "https://other.example"],
-      grants: ["https://example.com"],
-      now,
-    });
-    expect(result.targets).toEqual([{ origin: "https://example.com", expectedat: now, connected: true }]);
-    expect(result.refused).toEqual(["https://other.example"]);
-    expect(preconnectorigin({ origins: [], grants: [], now })).toEqual({ targets: [], refused: [] });
-  });
-
-  it("builds deep links with encoded parameters and refuses unknown apps and half parameters", () => {
-    expect(deeplinkapp({ app: "github", params: { owner: "wenathlan", repo: "extension" } }).url).toBe(
-      "https://github.com/wenathlan/extension",
-    );
-    expect(deeplinkapp({ app: "github", params: { owner: "wenathlan" } }).url).toBe("https://github.com/wenathlan");
-    expect(deeplinkapp({ app: "youtube", params: { id: "dQw4w9WgXcQ" } }).url).toBe(
-      "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
-    );
-    expect(deeplinkapp({ app: "youtube", params: { search: "dev think" } }).url).toBe(
-      "https://www.youtube.com/results?search_query=dev%20think",
-    );
-    expect(deeplinkapp({ app: "wikipedia", params: { title: "Ünicode" } }).url).toBe(
-      "https://en.wikipedia.org/wiki/%C3%9Cnicode",
-    );
-    expect(deeplinkapp({ app: "maps", params: { query: "a b&c" } }).url).toBe(
-      "https://www.google.com/maps/search/a%20b%26c",
-    );
-    expect(
-      deeplinkapp({
-        app: "custom",
-        params: { p: "v" },
-        patterns: [{ app: "custom", origin: "https://custom.example", route: "/{p}", params: ["p"] }],
-      }).url,
-    ).toBe("https://custom.example/v");
-    expect(() =>
-      deeplinkapp({
-        app: "custom",
-        params: {},
-        patterns: [{ app: "custom", origin: "https://custom.example", route: "/{p}", params: ["p"] }],
-      }),
-    ).toThrow(/needs its reviewed parameters/);
-    expect(
-      deeplinkapp({
-        app: "github",
-        params: { owner: "wenathlan" },
-        patterns: [
-          { app: "github", origin: "https://evil.example", route: "/{owner}/{repo}", params: ["owner", "repo"] },
-        ],
-      }).url,
-    ).toBe("https://github.com/wenathlan");
-    expect(() => deeplinkapp({ app: "", params: {} })).toThrow(/names its web app/);
-    expect(() => deeplinkapp({ app: "nope", params: {} })).toThrow(/not a known web app/);
-  });
-});
-
-describe("torture: reopening, trails and consent pauses", () => {
-  const records: closedtabrecord[] = [
-    { id: "c1", url: "https://example.com/a", title: "A", tabid: 1, windowid: 1, closedat: now },
-    { id: "c2", url: "https://example.com/b", title: "B", tabid: 2, windowid: 1, closedat: now - 100 },
-    { id: "c3", url: "https://other.example/c", title: "C", tabid: 3, windowid: 1, closedat: now - 50 },
-  ];
-
-  it("reopens the most recent fresh record under a grant recheck and refuses replayed records", () => {
-    const reopened = reopentab({ records, grants: ["https://example.com"], now: now + 10 });
-    expect(reopened.id).toBe("c1");
-    expect(reopened.reopenedat).toBe(now + 10);
-    const nextfresh = reopentab({
-      records: [{ ...records[0]!, reopenedat: now - 5 }, records[1]!, { ...records[2]!, reopenedat: now - 4 }],
-      grants: ["https://example.com"],
-      now: now + 10,
-    });
-    expect(nextfresh.id).toBe("c2");
-    expect(nextfresh.reopenedat).toBe(now + 10);
-    expect(() =>
-      reopentab({
-        records: [{ ...records[0]!, reopenedat: now - 5 }],
-        grants: ["https://example.com"],
-        url: "https://example.com/a",
-        now,
-      }),
-    ).toThrow(/already reopened/);
-    expect(() => reopentab({ records: [{ ...records[2]! }], grants: ["https://example.com"], now })).toThrow(
-      /lost its grant/,
-    );
-    expect(() => reopentab({ records: [], grants: [], now })).toThrow(/remembers none/);
-    const explicit = reopentab({ records, grants: ["https://other.example"], url: "https://other.example/c", now });
-    expect(explicit.id).toBe("c3");
-    expect(() => reopentab({ records, grants: [], url: "https://example.com/a", now })).toThrow(/lost its grant/);
-    expect(() => reopentab({ records, grants: [], url: "https://missing.example/z", now })).toThrow(
-      /No closed tab record/,
-    );
-  });
-
-  it("restores the navigation trail in visit order folding consecutive duplicates per run", () => {
-    const visits: urlvisit[] = [
-      { url: "https://example.com/a", at: now + 10, runid: "run1" },
-      { url: "https://example.com/b", at: now + 20, runid: "run1" },
-      { url: "https://example.com/b", at: now + 30, runid: "run1" },
-      { url: "https://example.com/c", at: now + 5, runid: "run2" },
-      { url: "https://example.com/a", at: now + 40, runid: "run2" },
-    ];
-    expect(restoretrail({ visits, runid: "run1" }).map((entry) => entry.url)).toEqual([
-      "https://example.com/a",
-      "https://example.com/b",
-    ]);
-    expect(restoretrail({ visits, runid: "run2" }).map((entry) => entry.url)).toEqual([
-      "https://example.com/c",
-      "https://example.com/a",
-    ]);
-    expect(restoretrail({ visits }).map((entry) => entry.runid)).toEqual([undefined, undefined, undefined, undefined]);
-    expect(restoretrail({ visits: [], runid: "run1" })).toEqual([]);
-    const ties: urlvisit[] = [
-      { url: "https://b.example", at: now, runid: "r" },
-      { url: "https://a.example", at: now, runid: "r" },
-    ];
-    expect(restoretrail({ visits: ties }).map((entry) => entry.url)).toEqual([
-      "https://a.example",
-      "https://b.example",
-    ]);
-  });
-
-  it("freezes navigation behind a consent prompt and hands the queued navigation back on resume", () => {
-    const paused = pausenavconsent({
-      reason: "a payment consent is open",
-      url: "https://example.com/pay",
-      stepid: "s9",
-      now,
-    });
-    expect(paused).toMatchObject({
-      pausedat: now,
-      reason: "a payment consent is open",
-      pendingurl: "https://example.com/pay",
-      pendingstepid: "s9",
-    });
-    const queued = pausenavconsent({ url: "https://example.com/next", stored: paused, now: now + 100 });
-    expect(queued.pausedat).toBe(now);
-    expect(queued.pendingurl).toBe("https://example.com/next");
-    const resumed = resumenavconsent({ stored: queued, now: now + 200 });
-    expect(resumed).toEqual({ resumed: true, queued });
-    expect(resumenavconsent({ now }).resumed).toBe(false);
-    expect(pausenavconsent({ now }).reason).toMatch(/consent prompt is open/);
-  });
-});
-
-describe("torture: navigation rate windows at their exact boundaries", () => {
-  it("counts with no configured window and ceiling while the sliding window ages hits exactly at the boundary", () => {
-    const manual = navratelimit({ url: "https://example.com/a", now });
-    expect(manual.allowed).toBe(true);
-    expect(manual.window.count).toBe(1);
-    expect(manual.window.window).toBeUndefined();
-    const boundary = navratelimit({
-      stored: { domain: "example.com", count: 2, resetat: now, hits: [now - 1000], window: 1000, ceiling: 2 },
-      url: "https://example.com/a",
-      now,
-    });
-    expect(boundary.allowed).toBe(true);
-    expect(boundary.window.count).toBe(1);
-    const onebefore = navratelimit({
-      stored: { domain: "example.com", count: 2, resetat: now, hits: [now - 1, now - 1], window: 1000, ceiling: 2 },
-      url: "https://example.com/a",
-      now,
-    });
-    expect(onebefore.allowed).toBe(false);
-    expect(onebefore.waitms).toBe(999);
-    expect(onebefore.reason).toMatch(/waits 999 milliseconds/);
-    const blocked = navratelimit({
-      stored: { domain: "example.com", count: 2, resetat: now, hits: [now - 500, now - 250], window: 1000, ceiling: 2 },
-      url: "https://example.com/a",
-      now,
-    });
-    expect(blocked.allowed).toBe(false);
-    expect(blocked.waitms).toBe(500);
-    expect(blocked.window.count).toBe(2);
-    const single = navratelimit({
-      stored: { domain: "example.com", count: 1, resetat: now, hits: [now - 250], window: 1000, ceiling: 1 },
-      url: "https://example.com/a",
-      now,
-    });
-    expect(single.allowed).toBe(false);
-    expect(single.reason).toMatch(/1 navigation/);
-    expect(() => navratelimit({ url: "not a url", now })).toThrow(/needs its url/);
-    expect(navratelimit({ url: "https://EXAMPLE.com/a", now }).window.domain).toBe("example.com");
-  });
-
-  it("opens clipboard urls only when https, parseable and granted", () => {
-    expect(openclipboardurl({ text: "https://example.com/notes", grants: ["https://example.com"] }).url).toBe(
-      "https://example.com/notes",
-    );
-    expect(() => openclipboardurl({ text: "  not a url  ", grants: [] })).toThrow(/no valid url/);
-    expect(() => openclipboardurl({ text: "http://example.com/notes", grants: ["http://example.com"] })).toThrow(
-      /HTTPS/,
-    );
-    expect(() => openclipboardurl({ text: "ftp://example.com/f", grants: [] })).toThrow(/HTTPS/);
-    expect(() => openclipboardurl({ text: "https://other.example/x", grants: ["https://example.com"] })).toThrow(
-      /outside the session grants/,
-    );
-  });
-});
-
-describe("torture: url safety with lookalikes, homographs and scheme tricks", () => {
-  it("refuses lookalike hosts that imitate granted origins", () => {
-    const granted = ["https://example.com"];
-    expect(checksafeurl({ url: "https://sub.example.com/x", granted, now }).safe).toBe(true);
-    expect(checksafeurl({ url: "https://example.com.evil.com/", granted, now }).safe).toBe(false);
-    expect(checksafeurl({ url: "https://example.com.evil.com/", granted, now }).reasons.join(" ")).toContain(
-      "imitates the granted origin",
-    );
-    expect(checksafeurl({ url: "https://evil-example.com/", granted, now }).safe).toBe(false);
-    expect(checksafeurl({ url: "https://notexample.com/", granted, now }).safe).toBe(false);
-    expect(checksafeurl({ url: "https://example.com/", granted, now }).safe).toBe(true);
-    expect(checksafeurl({ url: "https://example.com/", granted: ["https://sub.example.com"], now }).safe).toBe(true);
-  });
-
-  it("refuses punycode and unicode homograph hosts", () => {
-    expect(checksafeurl({ url: "https://xn--80ak6aa92e.com/", granted: [], now }).reasons.join(" ")).toContain(
-      "punycode",
-    );
-    expect(checksafeurl({ url: "https://аpple.com/", granted: ["https://apple.com"], now }).safe).toBe(false);
-    expect(
-      checksafeurl({ url: "https://аpple.com/", granted: ["https://apple.com"], now }).reasons.join(" "),
-    ).toContain("punycode");
-  });
-
-  it("refuses weak schemes, embedded credentials, private and raw hosts, and unparseable urls", () => {
-    expect(checksafeurl({ url: "http://example.com/", granted: [], now }).reasons).toContain("the url must use HTTPS");
-    expect(checksafeurl({ url: "data:text/html;base64,PHNjcmlwdD4=", granted: [], now }).safe).toBe(false);
-    expect(checksafeurl({ url: "blob:https://example.com/x", granted: [], now }).safe).toBe(false);
-    expect(checksafeurl({ url: "file:///etc/passwd", granted: [], now }).safe).toBe(false);
-    expect(checksafeurl({ url: "https://user:pass@example.com/", granted: [], now }).reasons.join(" ")).toContain(
-      "embedded credentials",
-    );
-    expect(checksafeurl({ url: "https://localhost/app", granted: [], now }).reasons.join(" ")).toContain(
-      "private network",
-    );
-    expect(checksafeurl({ url: "https://127.0.0.1/app", granted: [], now }).reasons.join(" ")).toContain(
-      "private network",
-    );
-    expect(checksafeurl({ url: "https://10.1.2.3/", granted: [], now }).reasons.join(" ")).toContain("private network");
-    expect(checksafeurl({ url: "https://192.168.0.9/", granted: [], now }).reasons.join(" ")).toContain(
-      "private network",
-    );
-    expect(checksafeurl({ url: "https://172.16.0.1/", granted: [], now }).reasons.join(" ")).toContain(
-      "private network",
-    );
-    expect(checksafeurl({ url: "https://172.99.0.1/", granted: [], now }).reasons.join(" ")).toContain("raw address");
-    expect(checksafeurl({ url: "https://[::1]/", granted: [], now }).reasons.join(" ")).toContain("private network");
-    expect(checksafeurl({ url: "https://8.8.8.8/", granted: [], now }).reasons.join(" ")).toContain("raw address");
-    expect(checksafeurl({ url: "not a url at all", granted: [], now })).toMatchObject({
-      safe: false,
-      reasons: ["the url does not parse"],
-    });
-    expect(checksafeurl({ url: "https://example.com/", granted: ["not a url"], now }).safe).toBe(true);
-  });
-});
-
-describe("torture: curated batch opening with size bounds and full rate windows", () => {
-  it("refuses the whole batch when one url is unsafe and never opens a tab", () => {
-    const batch = batchopenlinks({
-      id: "b1",
-      urls: ["https://example.com/a", "https://example.com.evil.com/"],
-      grants: ["https://example.com"],
-      windows: [],
-      now,
-    });
-    expect(batch.open).toEqual([]);
-    expect(batch.ordered).toEqual([]);
-    expect(batch.waits).toEqual([]);
-    expect(batch.refused).toHaveLength(1);
-    expect(batch.refused[0]?.reasons.join(" ")).toContain("imitates");
-    expect(batch.reason).toMatch(/refuses as a whole/);
-    expect(batch.batch.reviewedat).toBeUndefined();
-    expect(() => batchopenlinks({ id: " ", urls: [], grants: [], windows: [], now })).toThrow(/needs its id/);
-  });
-
-  it("refuses a batch that passes the user ceiling without a code cap", () => {
-    expect(() =>
-      batchopenlinks({
-        id: "b2",
-        urls: ["https://example.com/a", "https://example.com/b"],
-        grants: ["https://example.com"],
-        windows: [],
-        now,
-        sizelimit: 1,
-      }),
-    ).toThrow(/passes the user configured ceiling/);
-    expect(
-      batchopenlinks({
-        id: "b3",
-        urls: ["https://example.com/a", "https://example.com/b"],
-        grants: ["https://example.com"],
-        windows: [],
-        now,
-        sizelimit: 2,
-      }).open,
-    ).toHaveLength(2);
-    expect(batchopenlinks({ id: "b4", urls: [], grants: [], windows: [], now, sizelimit: 1 }).open).toEqual([]);
-  });
-
-  it("moves urls onto waits when the per domain window is full instead of dropping them", () => {
-    const full: ratelimitwindow = {
-      domain: "example.com",
-      count: 2,
-      resetat: now + 500,
-      hits: [now - 400, now - 300],
-      window: 1000,
-      ceiling: 2,
-    };
-    const batch = batchopenlinks({
-      id: "b5",
-      urls: ["https://example.com/a", "https://example.com/b", "https://other.example/c"],
-      grants: ["https://example.com", "https://other.example"],
-      windows: [full],
-      now,
-      window: 1000,
-    });
-    expect(batch.open.map((entry) => entry.url)).toEqual(["https://other.example/c"]);
-    expect(batch.waits).toEqual([
-      { url: "https://example.com/a", waitms: 600 },
-      { url: "https://example.com/b", waitms: 600 },
-    ]);
-    expect(batch.reason).toMatch(/never drops silently/);
-    expect(batch.windows.find((window) => window.domain === "example.com")?.count).toBe(2);
-  });
-
-  it("opens a thousand curated links with one tab per link under no ceiling", () => {
-    const urls = Array.from({ length: 1000 }, (_, index) => `https://example.com/item/${index}`);
-    const started = Date.now();
-    const batch = batchopenlinks({ id: "b6", urls, grants: ["https://example.com"], windows: [], now });
-    expect(batch.open).toHaveLength(1000);
-    expect(batch.ordered).toHaveLength(1000);
-    expect(batch.waits).toEqual([]);
-    expect(new Set(batch.windows.map((window) => window.domain))).toEqual(new Set(["example.com"]));
-    expect(Date.now() - started).toBeLessThan(2000);
-  });
-});