test: autofill layer — 13 vitest files integrated into src/content (smoke, detect, dismissal, field-icon, field-interaction, fill, initial-scan, interaction, message-routing, policy, save, selector-ui, totp-toast addendum); imports rewired ../../content→./, drop unused beforeAll; full suite 117 files/3468 green, 6 skipIf pending addenda (v3.9.9)

@@ -0,0 +1,25 @@1+// @vitest-environment jsdom2+//3+// Smoke test: proves the heavy content-script modules import cleanly under the4+// shared chrome mock. If this fails, every index.ts/inject.ts-dependent test5+// below it is unrunnable — so it gates the whole suite.6+7+import "./_setup";8+import { describe, expect, it } from "vitest";9+10+describe("AUTOFILL-TESTS harness smoke", () => {11+  it("imports index.ts seams without throwing", async () => {12+    const mod = await import("./index");13+    expect(typeof mod.handleFieldInteraction).toBe("function");14+    expect(typeof mod.initialScan).toBe("function");15+    expect(typeof mod.wasAlreadyFilled).toBe("function");16+    expect(mod._testSeam).toBeTruthy();17+    expect(typeof mod._testSeam.DISMISS_LOCK_MS).toBe("number");18+  });19+20+  it("imports inject.ts UI exports without throwing", async () => {21+    const mod = await import("./inject");22+    expect(typeof mod.showAutofillSelector).toBe("function");23+    expect(typeof mod.injectFieldIcon).toBe("function");24+  });25+});

@@ -0,0 +1,390 @@1+// @vitest-environment jsdom2+//3+// Test File 7 — detect.ts field detection (T-DT01–T-DT21).4+// Plus Addendum 1 — split-OTP grouping.5+//6+// detect.ts is the foundation of the whole autofill layer: every gate in7+// index.ts asks it "is this a login/signup/email-first/card/totp form?". A8+// false positive injects an icon onto a search box; a false negative means the9+// user's saved login never offers to fill. These tests pin the classification10+// boundaries against real HTML structures that production sites emit.11+12+import { beforeEach, describe, expect, it } from "vitest";13+14+import {15+  detectCardForm,16+  detectLoginFields,17+  findOTPDigitBoxGroup,18+  isAnyCredentialForm,19+  isEmailFirstForm,20+  isLoginForm,21+  isSignupForm,22+  isTOTPField,23+  isVisible,24+} from "./detect";25+import { makeFieldVisible, makeInput } from "./_setup";26+27+// detect.ts's querySelectorAllDeep re-queries every ancestor element, so a field28+// nested under html>body>form appears 3× in detectLoginFields() output. The29+// committed detect.test.ts copes the same way we do here: assert detection by30+// *membership* (fields.some) and gate "is this page fillable?" through31+// isAnyCredentialForm (the exact predicate index.ts uses — true via the signup32+// branch even when duplication inflates the password count). The precise33+// login-vs-signup classifier contract is exercised on clean, hand-built arrays.34+35+beforeEach(() => {36+  document.body.innerHTML = "";37+});38+39+// Build a form, append it, and return it. Children are added via makeInput so40+// every field gets a non-zero bounding rect (jsdom defaults to 0×0, which41+// detect.ts's isVisible() would reject).42+function form(): HTMLFormElement {43+  const f = document.createElement("form");44+  document.body.appendChild(f);45+  return f;46+}47+48+describe("T-DT01–T-DT03, T-DT06: form-shape classification", () => {49+  // T-DT01: a text + current-password pair is the canonical login form. If this50+  // regresses, saved logins stop offering on the most common form on the web.51+  it("T-DT01: text + password → detected as a fillable login form", () => {52+    const f = form();53+    const u = makeInput({ type: "text", name: "username", autocomplete: "username" }, f);54+    const p = makeInput({ type: "password", name: "password", autocomplete: "current-password" }, f);55+    const fields = detectLoginFields();56+    expect(fields.some((x) => x.el === u && x.type === "username")).toBe(true);57+    expect(fields.some((x) => x.el === p && x.type === "password")).toBe(true);58+    // The gate index.ts actually consults:59+    expect(isAnyCredentialForm(fields)).toBe(true);60+    // Classifier contract on a clean field set:61+    expect(isLoginForm([{ type: "username", el: u }, { type: "password", el: p }])).toBe(true);62+  });63+64+  // T-DT02: two password fields (password + confirm) is the signature of signup.65+  // Misclassifying it as login would offer the saved-password selector on an66+  // account-creation form.67+  it("T-DT02: text + new-password + confirm → isSignupForm true, isLoginForm false", () => {68+    const f = form();69+    makeInput({ type: "text", name: "username" }, f);70+    makeInput({ type: "password", name: "new-password", autocomplete: "new-password" }, f);71+    makeInput({ type: "password", name: "confirm", autocomplete: "new-password" }, f);72+    const fields = detectLoginFields();73+    expect(isSignupForm(fields)).toBe(true);74+    expect(isLoginForm(fields)).toBe(false);75+  });76+77+  // T-DT03: email-only step with an auth-intent submit button is the Google/MS78+  // "enter your email first" pattern. Requires an auth signal so newsletter79+  // boxes don't match.80+  it("T-DT03: email-only form with auth submit → isEmailFirstForm true", () => {81+    const f = form();82+    makeInput({ type: "email", name: "email", autocomplete: "email" }, f);83+    const btn = document.createElement("button");84+    btn.type = "submit";85+    btn.textContent = "Next";86+    f.appendChild(btn);87+    const fields = detectLoginFields();88+    expect(isEmailFirstForm(fields)).toBe(true);89+  });90+91+  // T-DT06: a search box (single text input, search submit) must NOT read as a92+  // login form. False positive here is the classic "icon on the search bar" bug.93+  it("T-DT06: search form → isLoginForm false", () => {94+    const f = form();95+    makeInput({ type: "search", name: "q", placeholder: "Search" }, f);96+    const fields = detectLoginFields();97+    expect(isLoginForm(fields)).toBe(false);98+    expect(isSignupForm(fields)).toBe(false);99+  });100+});101+102+describe("T-DT04: TOTP field detection", () => {103+  // T-DT04: autocomplete=one-time-code is the unambiguous TOTP marker. The TOTP104+  // selector path keys off this; losing it breaks 2FA autofill.105+  it("T-DT04: input[autocomplete=one-time-code] → isTotpField true", () => {106+    const f = form();107+    const otp = makeInput({ type: "text", autocomplete: "one-time-code", name: "code" }, f);108+    expect(isTOTPField(otp)).toBe(true);109+  });110+111+  it("T-DT04b: a plain password field is not a TOTP field", () => {112+    const f = form();113+    const pw = makeInput({ type: "password", name: "password" }, f);114+    expect(isTOTPField(pw)).toBe(false);115+  });116+});117+118+describe("T-DT05: credit-card form detection", () => {119+  // T-DT05: cc-number + cc-exp + cc-csc autocomplete tokens → card form. detect120+  // exposes detectCardForm (returns the field set or null), not a boolean.121+  it("T-DT05: cardnumber + expiry + cvc → detectCardForm returns the field set", () => {122+    const f = form();123+    const number = makeInput({ autocomplete: "cc-number", name: "cardnumber" }, f);124+    const exp = makeInput({ autocomplete: "cc-exp", name: "exp" }, f);125+    const cvc = makeInput({ autocomplete: "cc-csc", name: "cvc" }, f);126+    const card = detectCardForm();127+    expect(card).not.toBeNull();128+    expect(card!.number).toBe(number);129+    expect(card!.expiryCombo).toBe(exp);130+    expect(card!.cvc).toBe(cvc);131+  });132+133+  it("T-DT05b: a login form is not a card form", () => {134+    const f = form();135+    makeInput({ type: "text", name: "username" }, f);136+    makeInput({ type: "password", name: "password" }, f);137+    expect(detectCardForm()).toBeNull();138+  });139+});140+141+describe("T-DT07–T-DT09: isVisible branches", () => {142+  // isVisible gates every detection path. Each of its three rejection reasons143+  // (zero area, display:none, opacity:0) must independently return false, or144+  // off-screen/hidden honeypot fields would receive icons.145+146+  // T-DT07: a zero-area element (jsdom default, models an unrendered field).147+  it("T-DT07: zero-size rect → isVisible false", () => {148+    const el = makeInput({ type: "text" });149+    Object.defineProperty(el, "getBoundingClientRect", {150+      configurable: true,151+      value: () => ({ width: 0, height: 0, top: 0, left: 0, right: 0, bottom: 0, x: 0, y: 0, toJSON: () => ({}) }),152+    });153+    expect(isVisible(el)).toBe(false);154+  });155+156+  // T-DT08: display:none.157+  it("T-DT08: display:none → isVisible false", () => {158+    const el = makeInput({ type: "text" });159+    el.style.display = "none";160+    expect(isVisible(el)).toBe(false);161+  });162+163+  // T-DT09: opacity:0 (a common "hidden but laid out" honeypot technique).164+  it("T-DT09: opacity:0 → isVisible false", () => {165+    const el = makeInput({ type: "text" });166+    el.style.opacity = "0";167+    expect(isVisible(el)).toBe(false);168+  });169+170+  it("T-DT09b: a normally-laid-out field → isVisible true (control)", () => {171+    const el = makeInput({ type: "text" });172+    expect(isVisible(el)).toBe(true);173+  });174+});175+176+describe("T-DT10: deep (shadow DOM) detection", () => {177+  // T-DT10: web-component login forms render fields inside a shadow root.178+  // detectLoginFields walks shadow roots via querySelectorAllDeep; a regression179+  // to a flat querySelectorAll would miss every shadow-DOM login.180+  it("T-DT10: login fields inside an open shadow root are detected", () => {181+    const host = document.createElement("div");182+    document.body.appendChild(host);183+    const root = host.attachShadow({ mode: "open" });184+    // Real web-component login forms wrap fields in a container element inside185+    // the shadow root; querySelectorAllDeep collects inputs via each element's186+    // querySelectorAll, so the wrapper is what surfaces them.187+    const wrapper = document.createElement("div");188+    root.appendChild(wrapper);189+    const user = document.createElement("input");190+    user.type = "text";191+    user.setAttribute("name", "username");192+    user.setAttribute("autocomplete", "username");193+    const pass = document.createElement("input");194+    pass.type = "password";195+    pass.setAttribute("autocomplete", "current-password");196+    wrapper.append(user, pass);197+    makeFieldVisible(user);198+    makeFieldVisible(pass);199+200+    const fields = detectLoginFields();201+    expect(fields.some((f) => f.type === "password")).toBe(true);202+    expect(isAnyCredentialForm(fields)).toBe(true);203+  });204+});205+206+describe("T-DT11–T-DT12: PCH-01-025 CSS-special-char id resilience", () => {207+  // PCH-01-025: ids can contain CSS-special characters. detect.ts escapes them208+  // with CSS.escape AND wraps the label lookup in try/catch so a single weird id209+  // can never abort detection for the whole page.210+  //211+  // NOTE on the environment: jsdom's selector engine (nwsapi) actually THROWS on212+  // CSS.escape's output for these ids, so the *label-resolution* benefit cannot213+  // be observed here — it is verified in the Playwright e2e. What we pin in214+  // jsdom is the resilience invariant: a field whose id is hostile to215+  // querySelector must not throw out of detectLoginFields, and the other fields216+  // on the page must still be found. Reverting the try/catch makes T-DT12b throw.217+  it("T-DT11: id='user[email]' does not abort detection; the password is still found", () => {218+    const f = form();219+    makeInput({ type: "text", id: "user[email]", name: "user[email]" }, f);220+    makeInput({ type: "password", autocomplete: "current-password" }, f);221+    let fields: ReturnType<typeof detectLoginFields> = [];222+    expect(() => { fields = detectLoginFields(); }).not.toThrow();223+    expect(fields.some((x) => x.type === "password")).toBe(true);224+  });225+226+  it("T-DT12: id=\"it's-me\" does not abort detection", () => {227+    const f = form();228+    makeInput({ type: "text", id: "it's-me", name: "identifier" }, f);229+    makeInput({ type: "password", autocomplete: "current-password" }, f);230+    expect(() => detectLoginFields()).not.toThrow();231+  });232+233+  // T-DT12b: an id containing a double-quote genuinely throws inside a raw234+  // `label[for="..."]` selector. Only the try/catch keeps detection alive — this235+  // case fails the moment the catch is removed.236+  it("T-DT12b: id with an embedded double-quote does not abort detection", () => {237+    const f = form();238+    makeInput({ type: "text", id: 'a"quote', name: "weird" }, f);239+    makeInput({ type: "password", autocomplete: "current-password" }, f);240+    let fields: ReturnType<typeof detectLoginFields> = [];241+    expect(() => { fields = detectLoginFields(); }).not.toThrow();242+    expect(fields.some((x) => x.type === "password")).toBe(true);243+  });244+});245+246+describe("T-DT13–T-DT15: label / placeholder / aria-label classification", () => {247+  // T-DT13: a <label for=id> with a plain (escape-safe) id classifies an248+  // otherwise-unhinted text input as the username field.249+  it("T-DT13: label[for] resolves the field as username", () => {250+    const f = form();251+    const input = makeInput({ type: "text", id: "login_user" }, f);252+    const label = document.createElement("label");253+    label.setAttribute("for", "login_user");254+    label.textContent = "Username";255+    // Append AFTER the input so the previous-sibling heuristic cannot match —256+    // forcing the for-attribute path to be the one that resolves the label.257+    f.appendChild(label);258+    makeInput({ type: "password", autocomplete: "current-password" }, f);259+    const fields = detectLoginFields();260+    expect(fields.find((x) => x.el === input)?.type).toBe("username");261+  });262+263+  // T-DT14: placeholder text is a real-world classification signal.264+  it("T-DT14: placeholder='Username' → classified username", () => {265+    const f = form();266+    const input = makeInput({ type: "text", placeholder: "Username" }, f);267+    makeInput({ type: "password", autocomplete: "current-password" }, f);268+    const fields = detectLoginFields();269+    expect(fields.find((x) => x.el === input)?.type).toBe("username");270+  });271+272+  // T-DT15: aria-label is authoritative for accessibility-first forms.273+  it("T-DT15: aria-label='Email address' → classified", () => {274+    const f = form();275+    const input = makeInput({ type: "text", "aria-label": "Email address" }, f);276+    makeInput({ type: "password", autocomplete: "current-password" }, f);277+    const fields = detectLoginFields();278+    expect(fields.find((x) => x.el === input)?.type).toBe("username");279+  });280+});281+282+describe("T-DT16–T-DT17: edge form shapes", () => {283+  // T-DT16: many SPA login forms submit via JS and have no submit button. Field284+  // classification must not depend on a button existing.285+  it("T-DT16: form without a submit button is still a fillable login form", () => {286+    const f = form();287+    const u = makeInput({ type: "text", name: "username", autocomplete: "username" }, f);288+    const p = makeInput({ type: "password", autocomplete: "current-password" }, f);289+    const fields = detectLoginFields();290+    expect(fields.some((x) => x.el === u)).toBe(true);291+    expect(fields.some((x) => x.el === p && x.type === "password")).toBe(true);292+    expect(isAnyCredentialForm(fields)).toBe(true);293+    expect(isLoginForm([{ type: "username", el: u }, { type: "password", el: p }])).toBe(true);294+  });295+296+  // T-DT17: change-password forms have old + new + confirm. Three password297+  // fields must read as signup-shaped (>=2 passwords), never as login.298+  it("T-DT17: old + new + confirm passwords → signup-shaped, not login", () => {299+    const f = form();300+    makeInput({ type: "password", name: "old-password", autocomplete: "current-password" }, f);301+    makeInput({ type: "password", name: "new-password", autocomplete: "new-password" }, f);302+    makeInput({ type: "password", name: "confirm-password", autocomplete: "new-password" }, f);303+    const fields = detectLoginFields();304+    expect(isSignupForm(fields)).toBe(true);305+    expect(isLoginForm(fields)).toBe(false);306+  });307+});308+309+// ── Addendum 1 — split-OTP grouping ─────────────────────────────────────────310+// The existing detector is findOTPDigitBoxGroup: it returns the ordered set of311+// single-character boxes (4–10 of them) or null. index.ts uses it to open ONE312+// TOTP selector anchored on the first box instead of icon-spamming all six.313+describe("T-DT18–T-DT21 (existing findOTPDigitBoxGroup behavior)", () => {314+  // T-DT18: a 6-box numeric group resolves to the full ordered set, anchored so315+  // index.ts injects a single icon on box[0] rather than one per box.316+  it("T-DT18: 6× maxlength=1 numeric inputs → group of 6 returned, first is box[0]", () => {317+    const f = form();318+    const boxes: HTMLInputElement[] = [];319+    for (let i = 0; i < 6; i++) boxes.push(makeInput({ type: "text", maxlength: "1", inputmode: "numeric" }, f));320+    const group = findOTPDigitBoxGroup(boxes[2]!);321+    expect(group).not.toBeNull();322+    expect(group!.length).toBe(6);323+    expect(group![0]).toBe(boxes[0]);324+  });325+326+  // T-DT19: when a real one-time-code field exists, IT is the TOTP target; the327+  // single-char boxes elsewhere are a distinct concern. isTOTPField ignores328+  // maxlength=1 boxes, so the proper field is the one that classifies as TOTP.329+  it("T-DT19: a real one-time-code field classifies as TOTP; maxlength=1 boxes do not", () => {330+    const f = form();331+    const box = makeInput({ type: "text", maxlength: "1", inputmode: "numeric" }, f);332+    const real = makeInput({ type: "text", autocomplete: "one-time-code", name: "otp" }, f);333+    expect(isTOTPField(real)).toBe(true);334+    expect(isTOTPField(box)).toBe(false);335+  });336+337+  // T-DT21: a group below the 4-box floor is not an OTP group (existing338+  // threshold). Addendum 1 proposes a 3+ threshold for isSplitOtpGroup — see the339+  // skipped block below.340+  it("T-DT21: only 2 single-char boxes → not an OTP group (null)", () => {341+    const f = form();342+    const boxes = [343+      makeInput({ type: "text", maxlength: "1", inputmode: "numeric" }, f),344+      makeInput({ type: "text", maxlength: "1", inputmode: "numeric" }, f),345+    ];346+    expect(findOTPDigitBoxGroup(boxes[0]!)).toBeNull();347+  });348+});349+350+// Addendum 1 PROPOSED API — isSplitOtpGroup(field) with a 3+ threshold and a351+// numeric-only guard so an initials form (3 single-char *alpha* inputs) is not352+// treated as OTP. This function does not exist yet; these tests activate the353+// moment it is exported from detect.ts. They are the executable spec for the354+// addendum. See INTEGRATION-CONTRACT.md.355+import * as detectModule from "./detect";356+const hasIsSplitOtpGroup =357+  typeof (detectModule as unknown as { isSplitOtpGroup?: unknown }).isSplitOtpGroup === "function";358+359+describe.skipIf(!hasIsSplitOtpGroup)("Addendum 1 — proposed isSplitOtpGroup (requires detect.ts change)", () => {360+  const isSplitOtpGroup = (detectModule as unknown as {361+    isSplitOtpGroup: (f: HTMLInputElement) => boolean;362+  }).isSplitOtpGroup;363+364+  it("T-DT18 (proposed): 6 adjacent numeric single-char inputs → true", () => {365+    const f = form();366+    let first: HTMLInputElement | null = null;367+    for (let i = 0; i < 6; i++) {368+      const b = makeInput({ type: "text", maxlength: "1", inputmode: "numeric" }, f);369+      first ??= b;370+    }371+    expect(isSplitOtpGroup(first!)).toBe(true);372+  });373+374+  it("T-DT20 (proposed): 3 single-char ALPHA inputs (initials) → false", () => {375+    const f = form();376+    let first: HTMLInputElement | null = null;377+    for (let i = 0; i < 3; i++) {378+      const b = makeInput({ type: "text", maxlength: "1" }, f); // no numeric mode379+      first ??= b;380+    }381+    expect(isSplitOtpGroup(first!)).toBe(false);382+  });383+384+  it("T-DT21 (proposed): a 2-box group is below the 3+ threshold → false", () => {385+    const f = form();386+    const a = makeInput({ type: "text", maxlength: "1", inputmode: "numeric" }, f);387+    makeInput({ type: "text", maxlength: "1", inputmode: "numeric" }, f);388+    expect(isSplitOtpGroup(a)).toBe(false);389+  });390+});

@@ -0,0 +1,268 @@1+// @vitest-environment jsdom2+//3+// Test File 1 — index.ts 3-layer dismissal model (T-D01–T-D15).4+//5+// This is the most regression-prone logic in the project (v1.4.14 broke it6+// repeatedly). Three independent layers each prevent the selector reopening:7+//   Layer 1 — lastDismissedField: per-field lock until focus genuinely leaves.8+//   Layer 2 — dismissLock (DISMISS_LOCK_MS=800): global post-dismiss cooldown.9+//   Layer 3 — wasAlreadyFilled: filledForms (form-level, permanent) + pageFilledAt10+//             (page-level, PAGE_FILL_GRACE_MS=3000 window).11+//12+// All three short-circuit handleFieldInteraction BEFORE the ML race, so we drive13+// them through the exported seams: _testSeam (read/write lastDismissedField,14+// read dismissLock), the captured onDismiss callback (to fire a real dismiss →15+// startDismissLock), and the captured onFillFields callback (to fire a real fill16+// → recordFillSuccess). Fake timers are used ONLY for the expiry windows, per17+// the brief's quality bar.18+19+import { vi } from "vitest";20+21+const { predictBatch, dismissSpy } = vi.hoisted(() => ({22+  predictBatch: vi.fn(() => Promise.resolve([] as unknown[])),23+  dismissSpy: vi.fn(),24+}));25+26+vi.mock("./inject", () => ({27+  injectFieldIcon: vi.fn(() => vi.fn()),28+  showAutofillSelector: vi.fn(() => dismissSpy),29+  showTOTPSelector: vi.fn(() => dismissSpy),30+  showCardSelector: vi.fn(() => dismissSpy),31+  showRememberSiteToast: vi.fn(),32+  showPasskeyAvailable: vi.fn(),33+  showPasskeyProGate: vi.fn(),34+  showPasskeyRegistrationOffer: vi.fn(),35+}));36+vi.mock("./content-ml-detector", () => ({37+  contentMLDetector: { predictBatch },38+}));39+40+import { afterEach, beforeEach, describe, expect, it } from "vitest";41+import "./_setup";42+import { resetChromeMock, setMessageResponder, makeInput, createLoginForm } from "./_setup";43+import { handleFieldInteraction, wasAlreadyFilled, _testSeam } from "./index";44+import { showAutofillSelector } from "./inject";45+46+const showSelector = showAutofillSelector as unknown as ReturnType<typeof vi.fn>;47+const ENTRIES = [{ id: "e1", title: "Acme", username: "alice" }];48+49+function lastOptions(): any {50+  const calls = showSelector.mock.calls;51+  return calls.length ? calls[calls.length - 1]![3] : undefined;52+}53+54+function withEntries(): void {55+  setMessageResponder((msg) =>56+    msg.type === "AUTOFILL_QUERY" ? { ok: true, data: ENTRIES } : { ok: true, data: null }57+  );58+}59+60+let urlCounter = 0;61+62+beforeEach(async () => {63+  // index.ts has no public reset for pageFilledAt, but its url-watcher observer64+  // nulls it whenever location.href changes. Push a fresh URL and mutate the65+  // body so that observer fires — giving every test a clean fill-grace slate.66+  try {67+    history.pushState({}, "", `/t${++urlCounter}`);68+  } catch { /* jsdom history unavailable — fall through */ }69+  document.body.innerHTML = "";70+  await new Promise((r) => setTimeout(r, 0)); // let the url-watcher observer run71+72+  resetChromeMock();73+  showSelector.mockClear();74+  dismissSpy.mockClear();75+  predictBatch.mockReset();76+  predictBatch.mockReturnValue(Promise.resolve([]));77+  _testSeam.setLastDismissedField(null);78+});79+80+afterEach(async () => {81+  vi.useRealTimers();82+  await new Promise((r) => setTimeout(r, 0)); // flush index.ts's url-watcher observer83+});84+85+// ── Layer 1 — per-field lock (lastDismissedField) ────────────────────────────86+describe("T-D01–T-D04: Layer 1 per-field lock", () => {87+  // T-D01: a field whose selector was dismissed must not reopen on re-focus.88+  it("T-D01: re-focusing the dismissed field does NOT reopen the selector", async () => {89+    const { password } = createLoginForm();90+    withEntries();91+    _testSeam.setLastDismissedField(password); // simulate "user pressed Escape on this field"92+    await handleFieldInteraction(password);93+    await new Promise((r) => setTimeout(r, 20));94+    expect(showSelector).not.toHaveBeenCalled();95+  });96+97+  // T-D02 / T-D04: the lock is field-specific — focusing a DIFFERENT field opens,98+  // and doing so clears the stale per-field lock.99+  it("T-D02/T-D04: a different field opens (lock is field-specific)", async () => {100+    const { username, password } = createLoginForm();101+    withEntries();102+    _testSeam.setLastDismissedField(username);103+    await handleFieldInteraction(password);104+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());105+    expect(_testSeam.getLastDismissedField()).toBeNull(); // stale lock cleared106+  });107+108+  // T-D03: once the per-field lock is cleared (focus moved away and back), the109+  // same field opens again.110+  it("T-D03: clearing the lock lets the same field open again", async () => {111+    const { password } = createLoginForm();112+    withEntries();113+    _testSeam.setLastDismissedField(null);114+    await handleFieldInteraction(password);115+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());116+  });117+});118+119+// ── Layer 2 — global cooldown (DISMISS_LOCK_MS) ──────────────────────────────120+describe("T-D05–T-D07: Layer 2 post-dismiss global cooldown", () => {121+  // T-D05: immediately after a dismiss, focusing ANY other field is blocked by122+  // the global lock — not just the dismissed field.123+  it("T-D05: dismiss → focus a different field → blocked by global cooldown", async () => {124+    const { username, password } = createLoginForm();125+    withEntries();126+    await handleFieldInteraction(password);127+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());128+129+    const onDismiss = lastOptions().onDismiss as () => void;130+    vi.useFakeTimers();131+    onDismiss(); // real dismiss → startDismissLock()132+    expect(_testSeam.isDismissLocked()).toBe(true);133+134+    showSelector.mockClear();135+    await handleFieldInteraction(username); // different field, but cooldown active136+    expect(showSelector).not.toHaveBeenCalled();137+138+    // T-D06: after DISMISS_LOCK_MS the global lock clears.139+    vi.advanceTimersByTime(_testSeam.DISMISS_LOCK_MS + 1);140+    expect(_testSeam.isDismissLocked()).toBe(false);141+  });142+143+  // T-D06: with the cooldown expired, a fresh focus opens normally again.144+  it("T-D06: after the cooldown expires, the selector opens again", async () => {145+    const { password } = createLoginForm();146+    withEntries();147+    await handleFieldInteraction(password);148+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());149+    const onDismiss = lastOptions().onDismiss as () => void;150+151+    vi.useFakeTimers();152+    onDismiss();153+    vi.advanceTimersByTime(_testSeam.DISMISS_LOCK_MS + 1);154+    expect(_testSeam.isDismissLocked()).toBe(false);155+    vi.useRealTimers();156+157+    // New field after expiry → opens. (lastDismissedField was set to the old158+    // password element; a different element is unaffected.)159+    _testSeam.setLastDismissedField(null);160+    const fresh = makeInput({ type: "password", autocomplete: "current-password" });161+    showSelector.mockClear();162+    await handleFieldInteraction(fresh);163+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());164+  });165+166+  // T-D07: multiple rapid focuses during the cooldown all suppress — only the167+  // original (pre-dismiss) open ever happened.168+  it("T-D07: rapid focus events during cooldown are all suppressed", async () => {169+    const { username, password } = createLoginForm();170+    withEntries();171+    await handleFieldInteraction(password);172+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());173+    const onDismiss = lastOptions().onDismiss as () => void;174+175+    vi.useFakeTimers();176+    onDismiss();177+    showSelector.mockClear();178+    await handleFieldInteraction(username);179+    await handleFieldInteraction(password);180+    await handleFieldInteraction(username);181+    expect(showSelector).not.toHaveBeenCalled();182+    vi.advanceTimersByTime(_testSeam.DISMISS_LOCK_MS + 1);183+  });184+});185+186+// ── Layer 3 — fill-success grace (wasAlreadyFilled) ──────────────────────────187+describe("T-D08–T-D12: Layer 3 fill-success grace", () => {188+  // Drive a real fill by capturing the onFillFields callback the selector was189+  // opened with and invoking it — that calls recordFillSuccess internally.190+  async function openAndFill() {191+    const { form, username, password } = createLoginForm();192+    withEntries();193+    await handleFieldInteraction(password);194+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());195+    const onFill = lastOptions().onFillFields as (u: string, p: string, e?: string) => void;196+    onFill("alice", "s3cret");197+    return { form, username, password };198+  }199+200+  // T-D08 / T-D11: immediately after a fill, both the form-level and page-level201+  // checks report "already filled".202+  it("T-D08/T-D11: after fill, wasAlreadyFilled is true (form-level and page-level)", async () => {203+    const { password } = await openAndFill();204+    expect(wasAlreadyFilled(password)).toBe(true); // form-level (filledForms)205+    const formless = makeInput({ type: "password" }); // not in a <form>206+    expect(wasAlreadyFilled(formless)).toBe(true); // page-level grace window207+  });208+209+  // T-D09 / T-D12: once the page grace window expires, a formless field is no210+  // longer suppressed (a field still inside the filled form stays locked — that211+  // is the permanent form-level guard, documented below).212+  it("T-D09/T-D12: after the grace window, a formless field is no longer suppressed", async () => {213+    await openAndFill();214+    const formless = makeInput({ type: "password" });215+    expect(wasAlreadyFilled(formless)).toBe(true);216+    vi.useFakeTimers();217+    vi.advanceTimersByTime(5000); // well past PAGE_FILL_GRACE_MS218+    expect(wasAlreadyFilled(formless)).toBe(false);219+    vi.useRealTimers();220+  });221+222+  // T-D10: the brief expected the grace to be form-scoped (form B opens during223+  // form A's grace). The implementation's page-level grace is NOT form-scoped:224+  // for PAGE_FILL_GRACE_MS, EVERY field is suppressed. After the window, the225+  // filled form A's fields stay locked (filledForms is permanent) while a field226+  // in an unrelated form B opens. We pin the ACTUAL behavior. See227+  // INTEGRATION-CONTRACT.md.228+  it("T-D10: during the page grace every field is suppressed; after it, only the filled form stays locked", async () => {229+    const { password: aPassword } = await openAndFill();230+    // Build a second, independent form B.231+    const formB = document.createElement("form");232+    document.body.appendChild(formB);233+    const bPassword = makeInput({ type: "password", autocomplete: "current-password" }, formB);234+235+    // During grace: B is suppressed too (page-level grace is global).236+    expect(wasAlreadyFilled(bPassword)).toBe(true);237+238+    vi.useFakeTimers();239+    vi.advanceTimersByTime(5000);240+    // After grace: A's form is permanently locked, B is free.241+    expect(wasAlreadyFilled(aPassword)).toBe(true); // filledForms (permanent)242+    expect(wasAlreadyFilled(bPassword)).toBe(false);243+    vi.useRealTimers();244+  });245+});246+247+// ── Edge cases (T-D13–T-D15) ─────────────────────────────────────────────────248+describe("T-D13–T-D15: edge cases and documented boundaries", () => {249+  // T-D13: a second concurrent interaction on the same field is debounced by250+  // pendingInteractions, so a rapid focus/click pair cannot double-open (the251+  // visible "flicker" regression). (Mirrors T-F11 from the dedicated angle.)252+  it("T-D13: concurrent interactions on one field open it at most once (no flicker)", async () => {253+    const { password } = createLoginForm();254+    withEntries();255+    await Promise.all([handleFieldInteraction(password), handleFieldInteraction(password)]);256+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());257+    expect(showSelector).toHaveBeenCalledTimes(1);258+  });259+260+  // T-D14 (scroll-into-view) and T-D15 (isTrusted/programmatic focus): these are261+  // not decisions made inside handleFieldInteraction — the function is gesture-262+  // agnostic and is invoked by the focusin listener regardless of isTrusted.263+  // They belong to the Playwright e2e layer (real user gestures vs synthetic).264+  // Documented in INTEGRATION-CONTRACT.md rather than asserted with a false265+  // unit-level proxy that would always pass.266+  it.todo("T-D14: focus after scroll-into-view opens normally (e2e — real gesture)");267+  it.todo("T-D15: programmatic focus (isTrusted=false) suppressed (e2e — real gesture)");268+});

@@ -0,0 +1,128 @@1+// @vitest-environment jsdom2+//3+// Test File 6 — inject.ts injectFieldIcon (T-IC01–T-IC08).4+//5+// injectFieldIcon renders the small peach button into the LIGHT DOM (appended to6+// document.body, position:fixed), so unlike the selector it is fully observable7+// from a unit test. We import the REAL inject.ts and assert on the button it8+// produces: presence, accessibility, click wiring, teardown, and the9+// too-narrow-field hide rule. Where the brief assumed behavior that lives10+// elsewhere (idempotency, autocomplete policy), it is documented, not faked.11+12+import "./_setup"; // chrome mock + ResizeObserver polyfill (observeAnchorPosition needs it)13+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";14+import { injectFieldIcon } from "./inject";15+import { makeInput, makeFieldVisible } from "./_setup";16+17+const ICON_SELECTOR = 'button[aria-label="Peach autofill"]';18+19+beforeEach(() => {20+  document.body.innerHTML = "";21+});22+afterEach(() => {23+  document.body.innerHTML = "";24+});25+26+describe("T-IC01, T-IC08: rendering and accessibility", () => {27+  // T-IC01: the icon button is injected into the document for a normal field.28+  it("T-IC01: injects a position:fixed button into the document", () => {29+    const field = makeInput({ type: "password" });30+    const cleanup = injectFieldIcon(field, () => {});31+    const btn = document.querySelector<HTMLButtonElement>(ICON_SELECTOR);32+    expect(btn).not.toBeNull();33+    expect(btn!.style.position).toBe("fixed");34+    cleanup();35+  });36+37+  // T-IC08: the button carries an aria-label and title for screen readers.38+  it("T-IC08: button has an aria-label and title", () => {39+    const field = makeInput({ type: "password" });40+    const cleanup = injectFieldIcon(field, () => {});41+    const btn = document.querySelector<HTMLButtonElement>(ICON_SELECTOR)!;42+    expect(btn.getAttribute("aria-label")).toBe("Peach autofill");43+    expect(btn.title).toBeTruthy();44+    cleanup();45+  });46+});47+48+describe("T-IC02: click opens the selector", () => {49+  // T-IC02: clicking the icon invokes the onClick callback (which, in index.ts,50+  // is what summons the selector).51+  it("T-IC02: clicking the icon calls onClick exactly once", () => {52+    const field = makeInput({ type: "password" });53+    const onClick = vi.fn();54+    const cleanup = injectFieldIcon(field, onClick);55+    const btn = document.querySelector<HTMLButtonElement>(ICON_SELECTOR)!;56+    btn.dispatchEvent(new MouseEvent("click", { bubbles: true }));57+    expect(onClick).toHaveBeenCalledTimes(1);58+    cleanup();59+  });60+});61+62+describe("T-IC04: teardown", () => {63+  // T-IC04: the returned cleanup removes the button — index.ts calls it when the64+  // field leaves the DOM, so a stale icon never lingers.65+  it("T-IC04: cleanup() removes the injected button", () => {66+    const field = makeInput({ type: "password" });67+    const cleanup = injectFieldIcon(field, () => {});68+    expect(document.querySelector(ICON_SELECTOR)).not.toBeNull();69+    cleanup();70+    expect(document.querySelector(ICON_SELECTOR)).toBeNull();71+  });72+});73+74+describe("T-IC06: size / narrow-field hide rule", () => {75+  // T-IC06: on a field too narrow to host the icon cleanly (<40px wide), the76+  // button is hidden (opacity 0, pointer-events none) so it never overlaps a77+  // tiny input or an adjacent control.78+  it("T-IC06: a <40px-wide field hides the icon", () => {79+    const field = makeInput({ type: "password" });80+    Object.defineProperty(field, "getBoundingClientRect", {81+      configurable: true,82+      value: () => ({ width: 30, height: 24, top: 10, left: 10, right: 40, bottom: 34, x: 10, y: 10, toJSON: () => ({}) }),83+    });84+    const cleanup = injectFieldIcon(field, () => {});85+    const btn = document.querySelector<HTMLButtonElement>(ICON_SELECTOR)!;86+    // Read synchronously, before the post-mount requestAnimationFrame fires.87+    expect(btn.style.opacity).toBe("0");88+    expect(btn.style.pointerEvents).toBe("none");89+    cleanup();90+  });91+92+  it("T-IC06b: a normally-wide field shows the icon", () => {93+    const field = makeInput({ type: "password" });94+    makeFieldVisible(field); // 160×32 → wide enough95+    const cleanup = injectFieldIcon(field, () => {});96+    const btn = document.querySelector<HTMLButtonElement>(ICON_SELECTOR)!;97+    expect(btn.style.opacity).toBe("1");98+    cleanup();99+  });100+});101+102+// ── Documented scope boundaries (T-IC03, T-IC05, T-IC07) ─────────────────────103+describe("T-IC03 / T-IC05 / T-IC07: documented boundaries", () => {104+  // T-IC03: injectFieldIcon is NOT idempotent on its own — each call appends a105+  // button. Idempotency is enforced by the caller (index.ts processedInputs),106+  // covered by content.initial-scan.test.ts T-S10. We pin the real behavior so107+  // the contract is explicit.108+  it("T-IC03: injectFieldIcon itself is not idempotent (dedup is the caller's job)", () => {109+    const field = makeInput({ type: "password" });110+    const c1 = injectFieldIcon(field, () => {});111+    const c2 = injectFieldIcon(field, () => {});112+    expect(document.querySelectorAll(ICON_SELECTOR).length).toBe(2);113+    c1();114+    c2();115+  });116+117+  // T-IC05 (reposition on scroll) is driven by observeAnchorPosition via118+  // ResizeObserver + requestAnimationFrame + scroll listeners. The reflow is not119+  // deterministically observable under jsdom (no real layout); it is verified in120+  // the Playwright e2e.121+  it.todo("T-IC05: icon repositions on scroll (e2e — needs real layout)");122+123+  // T-IC07: injectFieldIcon does not inspect autocomplete; the "don't offer on124+  // current-password where the browser already does" policy, if desired, belongs125+  // to the detect/index gating layer, not the renderer. No such gate exists126+  // today — flagged in INTEGRATION-CONTRACT.md rather than asserted falsely.127+  it.todo("T-IC07: suppress on autocomplete=current-password (no such policy in inject today)");128+});

@@ -0,0 +1,194 @@1+// @vitest-environment jsdom2+//3+// Test File 2 — index.ts handleFieldInteraction core paths (T-F01–T-F12).4+//5+// handleFieldInteraction is the central decision: ML predict → suppression6+// layers → TOTP/OTP branch → vault query → which surface opens. We mock the7+// boundary it talks to — ./inject (so we can see WHICH surface opened) and8+// ./content-ml-detector (so we can control predict timing) — and drive the REAL9+// exported function with controlled DOM + chrome responses. Nothing about the10+// decision logic itself is mocked.11+12+import { vi } from "vitest";13+14+// Spies shared with the hoisted vi.mock factories must themselves be hoisted.15+const { predictBatch, dismissSpy } = vi.hoisted(() => ({16+  predictBatch: vi.fn(() => Promise.resolve([] as unknown[])),17+  dismissSpy: vi.fn(),18+}));19+20+// Observe which inject surface opens. showAutofillSelector returns a dismiss fn.21+vi.mock("./inject", () => ({22+  injectFieldIcon: vi.fn(() => vi.fn()),23+  showAutofillSelector: vi.fn(() => dismissSpy),24+  showTOTPSelector: vi.fn(() => dismissSpy),25+  showCardSelector: vi.fn(() => dismissSpy),26+  showRememberSiteToast: vi.fn(),27+  showPasskeyAvailable: vi.fn(),28+  showPasskeyProGate: vi.fn(),29+  showPasskeyRegistrationOffer: vi.fn(),30+}));31+32+// Control ML predict timing/result per test.33+vi.mock("./content-ml-detector", () => ({34+  contentMLDetector: { predictBatch },35+}));36+37+import { afterEach, beforeEach, describe, expect, it } from "vitest";38+import "./_setup";39+import { setMessageResponder, resetChromeMock, makeInput, createLoginForm, createEmailFirstForm } from "./_setup";40+import { handleFieldInteraction } from "./index";41+import { showAutofillSelector, showTOTPSelector } from "./inject";42+43+const showSelector = showAutofillSelector as unknown as ReturnType<typeof vi.fn>;44+const showTOTP = showTOTPSelector as unknown as ReturnType<typeof vi.fn>;45+46+// Reset module-private suppression state between tests by exercising the public47+// surface: a fresh DOM + cleared mocks. handleFieldInteraction reads live DOM48+// each call, so a clean body is a clean slate for everything except the global49+// dismiss lock — which we never trip in this file (no dismissals here).50+beforeEach(() => {51+  document.body.innerHTML = "";52+  resetChromeMock();53+  showSelector.mockClear();54+  showTOTP.mockClear();55+  predictBatch.mockReset();56+  predictBatch.mockReturnValue(Promise.resolve([]));57+});58+59+afterEach(async () => {60+  vi.useRealTimers();61+  // index.ts installs a url-watcher MutationObserver on document.body that62+  // reads location.href. Clearing the DOM each test queues its callback; flush63+  // it here so it runs while jsdom's globals still exist, instead of throwing64+  // "location is not defined" during environment teardown.65+  await new Promise((r) => setTimeout(r, 0));66+});67+68+// Last options object passed to showAutofillSelector (4th arg).69+function lastSelectorOptions(): any {70+  const calls = showSelector.mock.calls;71+  return calls.length ? calls[calls.length - 1]![3] : undefined;72+}73+74+describe("T-F01–T-F02: ML predict timeout race (150ms)", () => {75+  // T-F02: when ML resolves IN TIME with a non-credential verdict for a text76+  // field, handleFieldInteraction suppresses — the selector must NOT open.77+  it("T-F02: ML resolves fast with a suppressing prediction → no selector", async () => {78+    const { username } = createLoginForm();79+    predictBatch.mockReturnValue(Promise.resolve([{ type: "search", confidence: 0.9 }]));80+    await handleFieldInteraction(username); // passive (explicitSummon=false)81+    // give any stray microtasks a tick82+    await new Promise((r) => setTimeout(r, 20));83+    expect(showSelector).not.toHaveBeenCalled();84+  });85+86+  // T-F01: when ML is SLOWER than the 150ms cap, the timeout wins, the87+  // prediction is discarded (treated as null), and the heuristic path proceeds —88+  // so the very same suppressing verdict no longer blocks the selector. This is89+  // the regression that froze autofill on pages with a slow ML worker.90+  it("T-F01: ML slower than 150ms → timeout path taken, selector still opens", async () => {91+    const { username } = createLoginForm();92+    predictBatch.mockReturnValue(93+      new Promise((resolve) => setTimeout(() => resolve([{ type: "search", confidence: 0.9 }]), 250))94+    );95+    setMessageResponder((msg) =>96+      msg.type === "AUTOFILL_QUERY" ? { ok: true, data: [{ id: "e1", title: "Acme", username: "alice" }] } : { ok: true, data: null }97+    );98+    await handleFieldInteraction(username);99+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled(), { timeout: 1000 });100+  });101+});102+103+describe("T-F03–T-F05: vault state + form shape", () => {104+  // T-F03: a locked vault shows the inline unlock prompt (showAutofillSelector105+  // with {locked:true}), never the entry list.106+  it("T-F03: locked vault → selector opened in locked mode", async () => {107+    const { password } = createLoginForm();108+    setMessageResponder((msg) =>109+      msg.type === "AUTOFILL_QUERY" ? { ok: false, error: "vault_locked" } : { ok: true, data: null }110+    );111+    await handleFieldInteraction(password);112+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());113+    expect(lastSelectorOptions()?.locked).toBe(true);114+  });115+116+  // T-F04: unlocked vault with no entries for this domain → signup/identity117+  // surface (isSignup:true), not a credential list.118+  it("T-F04: no domain entries → signup/identity surface", async () => {119+    const { password } = createLoginForm();120+    setMessageResponder((msg) =>121+      msg.type === "AUTOFILL_QUERY" ? { ok: true, data: [] } : { ok: true, data: null }122+    );123+    await handleFieldInteraction(password);124+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());125+    expect(lastSelectorOptions()?.isSignup).toBe(true);126+    expect(lastSelectorOptions()?.locked).toBeFalsy();127+  });128+129+  // T-F05: an email-first form (no password on this step) still opens on the130+  // email field — the path must not bail just because there is no password.131+  it("T-F05: email-first form opens on the email field", async () => {132+    const { email } = createEmailFirstForm();133+    setMessageResponder((msg) =>134+      msg.type === "AUTOFILL_QUERY" ? { ok: true, data: [{ id: "e1", title: "Acme", username: "alice" }] } : { ok: true, data: null }135+    );136+    await handleFieldInteraction(email);137+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());138+  });139+});140+141+describe("T-F07: TOTP field path", () => {142+  // T-F07: a lone verification-code field (no login form present) routes to the143+  // TOTP selector, not the credential selector.144+  it("T-F07: standalone one-time-code field → TOTP selector", async () => {145+    const totp = makeInput({ type: "text", autocomplete: "one-time-code", name: "otp" });146+    setMessageResponder((msg) =>147+      msg.type === "AUTOFILL_QUERY" ? { ok: true, data: [{ id: "t1", title: "Acme 2FA" }] } : { ok: true, data: null }148+    );149+    await handleFieldInteraction(totp);150+    await vi.waitFor(() => expect(showTOTP).toHaveBeenCalled());151+    expect(showSelector).not.toHaveBeenCalled();152+  });153+});154+155+describe("T-F09: Peach respects the user, not the page's autocomplete=off", () => {156+  // T-F09: autocomplete="off" on the form must not stop Peach offering — the157+  // user installed Peach precisely to override the site's opt-out.158+  it("T-F09: form with autocomplete=off still offers", async () => {159+    const form = document.createElement("form");160+    form.setAttribute("autocomplete", "off");161+    document.body.appendChild(form);162+    makeInput({ type: "text", name: "username", autocomplete: "username" }, form);163+    const password = makeInput({ type: "password", autocomplete: "current-password" }, form);164+    setMessageResponder((msg) =>165+      msg.type === "AUTOFILL_QUERY" ? { ok: true, data: [{ id: "e1", title: "Acme", username: "alice" }] } : { ok: true, data: null }166+    );167+    await handleFieldInteraction(password);168+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());169+  });170+});171+172+describe("T-F10–T-F12: robustness", () => {173+  // T-F10: a field whose ownerDocument is a different (cross-origin-style)174+  // context must be handled without crashing. We approximate by anchoring a175+  // detached input — the function must abort cleanly, never throw.176+  it("T-F10/T-F12: detached field mid-interaction → clean abort, no throw, no selector", async () => {177+    const detached = document.createElement("input");178+    detached.type = "password"; // never attached → isVisible() false179+    await expect(handleFieldInteraction(detached)).resolves.toBeUndefined();180+    expect(showSelector).not.toHaveBeenCalled();181+  });182+183+  // T-F11: two concurrent calls for the SAME field (focusin + icon click racing)184+  // must not double-open — pendingInteractions debounces the second.185+  it("T-F11: concurrent calls for the same field → selector opens at most once", async () => {186+    const { password } = createLoginForm();187+    setMessageResponder((msg) =>188+      msg.type === "AUTOFILL_QUERY" ? { ok: true, data: [{ id: "e1", title: "Acme", username: "alice" }] } : { ok: true, data: null }189+    );190+    await Promise.all([handleFieldInteraction(password), handleFieldInteraction(password)]);191+    await vi.waitFor(() => expect(showSelector).toHaveBeenCalled());192+    expect(showSelector).toHaveBeenCalledTimes(1);193+  });194+});