chore: version bump 3.9.9 → 4.0.0 (manifest.json + manifest.firefox.json + package.json) + build Chrome/Firefox/Mobile; trash now-integrated AUTOFILL-TESTS draft files (kept INTEGRATION-CONTRACT.md as reference). Final: tsc no new errors (27 pre-existing), vitest 117 files/3474 passed/0 skipped/40 todo (v4.0.0)

@@ -1,272 +0,0 @@1-// Shared test harness for the AUTOFILL-TESTS draft suite.2-//3-// Two responsibilities:4-//   1. SIDE EFFECT — installing a chrome extension API mock onto globalThis the5-//      moment this module is evaluated. index.ts and inject.ts touch6-//      `chrome.runtime.*` at module-evaluation time (inject.ts line 41 fires a7-//      GET_SETTINGS call; index.ts registers a runtime.onMessage listener and8-//      runs an async init IIFE). ES module imports are evaluated in source9-//      order, so a test file that does `import "./_setup"` BEFORE10-//      `import "../../content/index"` guarantees chrome exists first.11-//   2. HELPERS — DOM factories and a jsdom visibility shim. jsdom reports a 0x012-//      getBoundingClientRect for every element, which would make detect.ts's13-//      isVisible() return false for everything. makeFieldVisible() patches the14-//      rect the same way the existing content tests do.15-//16-// Nothing here mocks the functions under test — only the browser/extension17-// boundary. Tests drive the real exported functions with controlled DOM input.18-19-import { vi } from "vitest";20-21-// ── Chrome message plumbing ──────────────────────────────────────────────────22-// A test can install its own responder to control what the background "replies"23-// for a given message, and inspect every message that was sent.24-25-export type MessageResponder = (msg: any) => any;26-27-let messageResponder: MessageResponder = (msg) => {28-  // Sane defaults so module-load-time calls (GET_SETTINGS, GET_VAULT_STATUS)29-  // resolve to a harmless shape instead of undefined.30-  switch (msg?.type) {31-    case "GET_SETTINGS":32-      return { ok: true, data: { accentColor: "#ff9776", theme: "dark" } };33-    case "GET_VAULT_STATUS":34-      return { ok: true, data: { unlocked: false } };35-    default:36-      return { ok: true, data: null };37-  }38-};39-40-/** Messages sent via chrome.runtime.sendMessage, in order. */41-export const sentMessages: any[] = [];42-/** Listeners registered via chrome.runtime.onMessage.addListener. */43-export const messageListeners: Array<44-  (msg: any, sender: any, sendResponse: (r?: any) => void) => unknown45-> = [];46-47-/** Override the reply for subsequent sendMessage calls. */48-export function setMessageResponder(fn: MessageResponder): void {49-  messageResponder = fn;50-}51-52-/** Deliver a message to every registered onMessage listener (e.g. VAULT_UNLOCKED). */53-export function dispatchRuntimeMessage(54-  msg: any,55-  sender: any = { id: "peach-test-extension-id" }56-): Array<unknown> {57-  const responses: unknown[] = [];58-  for (const listener of messageListeners) {59-    responses.push(listener(msg, sender, (r?: any) => responses.push(r)));60-  }61-  return responses;62-}63-64-const sendMessage = vi.fn((msg: any, maybeCb?: (resp: any) => void) => {65-  sentMessages.push(msg);66-  const result = messageResponder(msg);67-  const resolved = Promise.resolve(result);68-  if (typeof maybeCb === "function") {69-    resolved.then((r) => maybeCb(r));70-    return undefined as unknown as Promise<any>;71-  }72-  return resolved;73-});74-75-const sessionStore = new Map<string, unknown>();76-77-const chromeMock = {78-  runtime: {79-    id: "peach-test-extension-id",80-    sendMessage,81-    getURL: (path: string) => `chrome-extension://peach-test/${path}`,82-    onMessage: {83-      addListener: (fn: any) => messageListeners.push(fn),84-      removeListener: (fn: any) => {85-        const i = messageListeners.indexOf(fn);86-        if (i >= 0) messageListeners.splice(i, 1);87-      },88-    },89-    lastError: undefined as undefined | { message: string },90-  },91-  storage: {92-    session: {93-      get: (key: string) =>94-        Promise.resolve(sessionStore.has(key) ? { [key]: sessionStore.get(key) } : {}),95-      set: (obj: Record<string, unknown>) => {96-        for (const [k, v] of Object.entries(obj)) sessionStore.set(k, v);97-        return Promise.resolve();98-      },99-    },100-    local: {101-      get: () => Promise.resolve({}),102-      set: () => Promise.resolve(),103-    },104-  },105-};106-107-// Install on globalThis so `chrome` is a resolvable free identifier in the108-// modules under test, exactly as it is inside a real content script.109-(globalThis as any).chrome = chromeMock;110-111-// jsdom ships no ResizeObserver; inject.ts's observeAnchorPosition and the112-// selector's height-animation both construct one at call time. A no-op stub is113-// enough — the tests assert on injected DOM, not on layout reflow.114-if (typeof (globalThis as any).ResizeObserver === "undefined") {115-  (globalThis as any).ResizeObserver = class {116-    observe(): void {}117-    unobserve(): void {}118-    disconnect(): void {}119-  };120-}121-122-// navigator.clipboard.writeText is used by the TOTP/auto-copy paths. jsdom does123-// not provide a writable clipboard, so define a spy-able one.124-export const clipboardWrite = vi.fn(() => Promise.resolve());125-if (!("clipboard" in navigator)) {126-  Object.defineProperty(navigator, "clipboard", {127-    configurable: true,128-    value: { writeText: clipboardWrite },129-  });130-} else {131-  Object.defineProperty(navigator.clipboard, "writeText", {132-    configurable: true,133-    value: clipboardWrite,134-  });135-}136-137-/** Reset all captured state between tests. Does NOT clear registered listeners138- *  (those are installed once at module import and must survive across tests). */139-export function resetChromeMock(): void {140-  sentMessages.length = 0;141-  sessionStore.clear();142-  sendMessage.mockClear();143-  clipboardWrite.mockClear();144-  messageResponder = (msg) => {145-    switch (msg?.type) {146-      case "GET_SETTINGS":147-        return { ok: true, data: { accentColor: "#ff9776", theme: "dark" } };148-      case "GET_VAULT_STATUS":149-        return { ok: true, data: { unlocked: false } };150-      default:151-        return { ok: true, data: null };152-    }153-  };154-}155-156-// ── DOM helpers ──────────────────────────────────────────────────────────────157-158-const VISIBLE_RECT = {159-  width: 160,160-  height: 32,161-  top: 10,162-  left: 10,163-  right: 170,164-  bottom: 42,165-  x: 10,166-  y: 10,167-  toJSON: () => ({}),168-} as const;169-170-/** Patch an element so detect.ts's isVisible() treats it as on-screen.171- *  jsdom returns a 0x0 rect for everything; without this every field reads172- *  as invisible and detection returns nothing. */173-export function makeFieldVisible(el: HTMLElement): void {174-  Object.defineProperty(el, "getBoundingClientRect", {175-    configurable: true,176-    value: () => ({ ...VISIBLE_RECT }),177-  });178-}179-180-/** Create a visible <input> with the given attributes appended to the body. */181-export function makeInput(182-  attrs: Record<string, string> = {},183-  parent: HTMLElement = document.body184-): HTMLInputElement {185-  const input = document.createElement("input");186-  for (const [k, v] of Object.entries(attrs)) input.setAttribute(k, v);187-  parent.appendChild(input);188-  makeFieldVisible(input);189-  return input;190-}191-192-/** Standard username + current-password login form. */193-export function createLoginForm(): {194-  form: HTMLFormElement;195-  username: HTMLInputElement;196-  password: HTMLInputElement;197-} {198-  const form = document.createElement("form");199-  document.body.appendChild(form);200-  const username = makeInput(201-    { type: "text", name: "username", autocomplete: "username" },202-    form203-  );204-  const password = makeInput(205-    { type: "password", name: "password", autocomplete: "current-password" },206-    form207-  );208-  const button = document.createElement("button");209-  button.type = "submit";210-  button.textContent = "Log in";211-  form.appendChild(button);212-  return { form, username, password };213-}214-215-/** Email-first (identifier) form: single email field, no password. */216-export function createEmailFirstForm(): {217-  form: HTMLFormElement;218-  email: HTMLInputElement;219-} {220-  const form = document.createElement("form");221-  document.body.appendChild(form);222-  const email = makeInput(223-    { type: "email", name: "email", autocomplete: "email" },224-    form225-  );226-  const button = document.createElement("button");227-  button.type = "submit";228-  button.textContent = "Next";229-  form.appendChild(button);230-  return { form, email };231-}232-233-/** Signup form: username + new-password + confirm. */234-export function createSignupForm(): {235-  form: HTMLFormElement;236-  username: HTMLInputElement;237-  password: HTMLInputElement;238-  confirm: HTMLInputElement;239-} {240-  const form = document.createElement("form");241-  document.body.appendChild(form);242-  const username = makeInput({ type: "text", name: "new-username" }, form);243-  const password = makeInput(244-    { type: "password", name: "new-password", autocomplete: "new-password" },245-    form246-  );247-  const confirm = makeInput(248-    { type: "password", name: "confirm-password", autocomplete: "new-password" },249-    form250-  );251-  const button = document.createElement("button");252-  button.type = "submit";253-  button.textContent = "Create account";254-  form.appendChild(button);255-  return { form, username, password, confirm };256-}257-258-/** Split-OTP form: `count` adjacent single-char numeric inputs. */259-export function createSplitOtpForm(count = 6): {260-  form: HTMLFormElement;261-  boxes: HTMLInputElement[];262-} {263-  const form = document.createElement("form");264-  document.body.appendChild(form);265-  const boxes: HTMLInputElement[] = [];266-  for (let i = 0; i < count; i++) {267-    boxes.push(268-      makeInput({ type: "text", maxlength: "1", inputmode: "numeric" }, form)269-    );270-  }271-  return { form, boxes };272-}

@@ -1,25 +0,0 @@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 { beforeAll, 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("../../content/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("../../content/inject");22-    expect(typeof mod.showAutofillSelector).toBe("function");23-    expect(typeof mod.injectFieldIcon).toBe("function");24-  });25-});

@@ -1,390 +0,0 @@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 "../../content/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 "../../content/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-});

@@ -1,268 +0,0 @@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("../../content/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/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 "../../content/index";44-import { showAutofillSelector } from "../../content/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-});