/**
 * messages.adversarial.test.ts — Layer 3 §3.3 adversarial message handler tests.
 *
 * Exercises every payload-bearing handler with null/undefined/empty/nested
 * payloads, unknown message types, AUTOFILL_QUERY edge cases, and Codex
 * restore boundary inputs. Parameterized for >=300 tests.
 *
 * Where the audit references handlers Peach does not implement
 * (IMPORT_PEACHSCRIPT / RESTORE_FROM_PEACHSCRIPT), the tests confirm the
 * default `unknown message type` path responds without crashing — see the
 * findings doc.
 */

import { beforeEach, describe, expect, it, vi } from "vitest";

import type { Message, MessageResponse } from "../shared/types";

type StorageShape = Record<string, unknown>;
type MessageListener = (
  msg: unknown,
  sender: chrome.runtime.MessageSender,
  sendResponse: (response: MessageResponse) => void
) => boolean;

// Payload-bearing handlers we exercise with adversarial payloads.
const PAYLOAD_HANDLERS = [
  "UNLOCK",
  "CREATE_VAULT",
  "ADD_ENTRY",
  "UPDATE_ENTRY",
  "DELETE_ENTRY",
  "BATCH_ADD_ENTRIES",
  "RESTORE_ENTRIES",
  "ADD_ADDITIONAL_URL",
  "RESTORE_ENTRY",
  "PURGE_ENTRY",
  "PURGE_EXPIRED_TRASH",
  "SAVE_NOTE",
  "DELETE_NOTE",
  "RECOVER_WITH_WORDS",
  "VALIDATE_RECOVERY_WORDS",
  "RESTORE_FROM_CODEX",
  "AUTOFILL_QUERY",
  "GET_ENTRY_FOR_FILL",
  "COPY",
  "UPDATE_SETTINGS",
  "APPROVE_PASSKEY",
  "DENY_PASSKEY",
  "SET_PASSKEY_PROVIDER_ENABLED",
  "ACTIVATE_LICENSE",
  "RESTORE_VAULT_SNAPSHOT",
  "CHANGE_PASSWORD",
  "SETUP_DURESS",
  "VERIFY_MAIN_PASSWORD",
  "FIRE_CANARY_PING",
  "ML_PREDICT_BATCH",
  "SEARCH_VAULT",
  "GET_PASSKEY_FOR_DOMAIN",
];

describe("message handler adversarial inputs", () => {
  let storage: StorageShape;
  let sessionStorage: StorageShape;
  let listener: MessageListener | undefined;

  beforeEach(async () => {
    vi.resetModules();
    vi.useRealTimers();
    storage = { peach_settings: { breachMonitoring: false } };
    sessionStorage = {};
    listener = undefined;

    vi.stubGlobal(
      "fetch",
      vi.fn(async () => ({ ok: true, status: 200, text: async () => "" }))
    );
    vi.stubGlobal("__PEACH_E2E_PASSKEYS__", false);

    const chromeMock = {
      runtime: {
        id: "peach-extension",
        getURL: (p: string) => `chrome-extension://peach-extension/${p}`,
        onMessage: {
          addListener: vi.fn((fn: MessageListener) => {
            listener = fn;
          }),
        },
        sendMessage: vi.fn(async () => ({ ok: true })),
      },
      tabs: {
        query: vi.fn((_q: unknown, cb?: (tabs: unknown[]) => void) => {
          if (typeof cb === "function") {
            cb([{ id: 1 }]);
            return;
          }
          return Promise.resolve([{ id: 1 }]);
        }),
        sendMessage: vi.fn(async () => ({ ok: true })),
      },
      storage: {
        local: {
          get: vi.fn(async (key?: string | string[]) => {
            if (!key) return storage;
            if (typeof key === "string") return { [key]: storage[key] };
            return key.reduce<Record<string, unknown>>((acc, k) => {
              acc[k] = storage[k];
              return acc;
            }, {});
          }),
          set: vi.fn(async (next: Record<string, unknown>) => {
            Object.assign(storage, next);
          }),
          remove: vi.fn(async (keys: string | string[]) => {
            const list = Array.isArray(keys) ? keys : [keys];
            for (const key of list) delete storage[key];
          }),
        },
        session: {
          get: vi.fn(async (key?: string | string[]) => {
            if (!key) return sessionStorage;
            if (typeof key === "string") return { [key]: sessionStorage[key] };
            return key.reduce<Record<string, unknown>>((acc, k) => {
              acc[k] = sessionStorage[k];
              return acc;
            }, {});
          }),
          set: vi.fn(async (next: Record<string, unknown>) => {
            Object.assign(sessionStorage, next);
          }),
          remove: vi.fn(async (keys: string | string[]) => {
            const list = Array.isArray(keys) ? keys : [keys];
            for (const key of list) delete sessionStorage[key];
          }),
          clear: vi.fn(async () => {
            for (const k of Object.keys(sessionStorage)) delete sessionStorage[k];
          }),
        },
      },
      alarms: {
        clear: vi.fn(),
        create: vi.fn(),
        onAlarm: { addListener: vi.fn() },
      },
      idle: {
        setDetectionInterval: vi.fn(),
        onStateChanged: { addListener: vi.fn() },
      },
      scripting: { executeScript: vi.fn(async () => []) },
    } as unknown as typeof chrome;

    (globalThis as { chrome?: typeof chrome }).chrome = chromeMock;

    const messages = await import("./messages");
    messages.setupMessageHandler();
    const vault = await import("./vault");
    await vault.ensureSettingsLoaded();
  });

  async function dispatch(
    message: Message,
    sender: chrome.runtime.MessageSender = {
      id: "peach-extension",
      url: "chrome-extension://peach-extension/popup.html",
    } as chrome.runtime.MessageSender,
  ): Promise<MessageResponse> {
    if (!listener) throw new Error("listener not registered");
    return new Promise<MessageResponse>((resolve) => {
      const keepOpen = listener!(message, sender, resolve);
      expect(keepOpen).toBe(true);
    });
  }

  // PCH-01-018: destructive ops require an extension-page sender; the adversarial
  // RESTORE_FROM_CODEX payload tests must use this to reach payload validation.
  const EXTENSION_PAGE_SENDER = {
    id: "peach-extension",
    url: "chrome-extension://peach-extension/popup.html",
  } as chrome.runtime.MessageSender;

  async function setupUnlockedVault() {
    const vault = await import("./vault");
    await vault.createVault("test-pass-12345");
  }

  // ── Null/undefined/empty/nested payload matrix ──────────────────────────

  describe("payload no-crash matrix", () => {
    for (const type of PAYLOAD_HANDLERS) {
      it(`${type} with null payload does not crash`, async () => {
        const r = await dispatch({ type, payload: null } as unknown as Message);
        expect(r).toBeDefined();
      });

      it(`${type} with undefined payload does not crash`, async () => {
        const r = await dispatch({
          type,
          payload: undefined,
        } as unknown as Message);
        expect(r).toBeDefined();
      });

      it(`${type} with empty object payload does not crash`, async () => {
        const r = await dispatch({ type, payload: {} } as unknown as Message);
        expect(r).toBeDefined();
      });

      it(`${type} with deeply nested payload does not crash`, async () => {
        const nested: Record<string, unknown> = {};
        let cur: Record<string, unknown> = nested;
        for (let i = 0; i < 50; i++) {
          const child: Record<string, unknown> = {};
          cur.child = child;
          cur = child;
        }
        const r = await dispatch({
          type,
          payload: nested,
        } as unknown as Message);
        expect(r).toBeDefined();
      });

      it(`${type} with array payload does not crash`, async () => {
        const r = await dispatch({
          type,
          payload: [1, 2, 3],
        } as unknown as Message);
        expect(r).toBeDefined();
      });

      it(`${type} with string payload does not crash`, async () => {
        const r = await dispatch({
          type,
          payload: "garbage",
        } as unknown as Message);
        expect(r).toBeDefined();
      });

      it(`${type} with number payload does not crash`, async () => {
        const r = await dispatch({
          type,
          payload: 42,
        } as unknown as Message);
        expect(r).toBeDefined();
      });
    }
  });

  // ── AUD-007: extended no-crash payload sweep ────────────────────────────
  //
  // Each payload variant runs against every handler in PAYLOAD_HANDLERS and
  // must produce a structured response — never a thrown exception. This
  // expands fuzz coverage to >3000 tests without changing handler behavior.

  describe("AUD-007 extended payload no-crash sweep", () => {
    const extraPayloads: Array<{ name: string; payload: unknown }> = [
      { name: "boolean true", payload: true },
      { name: "boolean false", payload: false },
      { name: "negative number", payload: -1 },
      { name: "NaN", payload: NaN },
      { name: "Infinity", payload: Infinity },
      { name: "empty string", payload: "" },
      { name: "very long string", payload: "A".repeat(10_000) },
      { name: "unicode string", payload: "私のパスワード🔑" },
      { name: "RTL string", payload: "مفتاح‮" },
      { name: "null bytes in string", payload: "a\x00b\x00c" },
      { name: "html string", payload: "<script>alert(1)</script>" },
      { name: "sql string", payload: "'; DROP TABLE entries; --" },
      { name: "path traversal string", payload: "../../etc/passwd" },
      { name: "object with null prototype-ish", payload: { __proto__: null } },
      { name: "object with prototype pollution attempt", payload: { __proto__: { polluted: true } } },
      { name: "object with constructor pollution", payload: { constructor: { prototype: { polluted: true } } } },
      { name: "deeply nested array", payload: [[[[[[[[[[]]]]]]]]]] },
      { name: "long array", payload: new Array(1_000).fill(0) },
      { name: "mixed array", payload: [null, undefined, 1, "x", true, {}, []] },
      { name: "function-like object", payload: { call: () => 1, apply: () => 1 } },
      { name: "Date object", payload: new Date(0) },
      { name: "BigInt-ish payload", payload: { n: "9007199254740993" } },
      { name: "circular-safe placeholder", payload: { self: "[Circular]" } },
    ];

    for (const { name, payload } of extraPayloads) {
      for (const type of PAYLOAD_HANDLERS) {
        it(`${type} with ${name} payload does not crash`, async () => {
          const r = await dispatch({ type, payload } as unknown as Message);
          expect(r).toBeDefined();
          expect(typeof r.ok).toBe("boolean");
        });
      }
    }
  });

  // ── Unknown / malformed message types ───────────────────────────────────

  describe("unknown message types", () => {
    const unknownTypes = [
      "TOTALLY_UNKNOWN_TYPE",
      "",
      "X",
      "lowercase_type",
      "with spaces in type",
      "with-dashes",
      "WITH.DOTS",
      "🌸emoji_type",
      "Unicode_üñïcödé",
      "IMPORT_PEACHSCRIPT",
      "RESTORE_FROM_PEACHSCRIPT",
      "DESTROY_VAULT_QUIETLY",
      "ESCALATE_PRIVILEGE",
    ];

    for (const type of unknownTypes) {
      it(`unknown type "${type}" returns error response`, async () => {
        const r = await dispatch({ type } as unknown as Message);
        expect(r).toBeDefined();
        expect(r.ok).toBe(false);
      });
    }

    it("missing type field does not crash", async () => {
      const r = await dispatch({} as unknown as Message);
      expect(r).toBeDefined();
    });

    it("type=null does not crash", async () => {
      const r = await dispatch({ type: null } as unknown as Message);
      expect(r).toBeDefined();
    });

    it("type=number does not crash", async () => {
      const r = await dispatch({ type: 42 } as unknown as Message);
      expect(r).toBeDefined();
    });
  });

  // ── Sender validation ────────────────────────────────────────────────────

  describe("sender validation", () => {
    it("foreign extension sender is rejected", async () => {
      if (!listener) throw new Error("listener not registered");
      const r = await new Promise<MessageResponse>((resolve) => {
        listener!(
          { type: "GET_ENTRIES" } as Message,
          { id: "foreign-extension" } as chrome.runtime.MessageSender,
          resolve
        );
      });
      expect(r.ok).toBe(false);
      expect(r.error).toBe("invalid_sender");
    });

    it("sender with no URL is rejected", async () => {
      if (!listener) throw new Error("listener not registered");
      await setupUnlockedVault();
      const r = await new Promise<MessageResponse>((resolve) => {
        listener!(
          { type: "GET_ENTRIES" } as Message,
          {} as chrome.runtime.MessageSender,
          resolve
        );
      });
      expect(r).toMatchObject({ ok: false, error: "invalid_sender" });
    });
  });

  // ── AUTOFILL_QUERY adversarial ──────────────────────────────────────────

  describe("AUTOFILL_QUERY adversarial", () => {
    async function withEntries(n: number) {
      const vault = await import("./vault");
      await vault.createVault("test-pass-12345");
      for (let i = 0; i < n; i++) {
        await vault.addEntry({
          title: `E${i}`,
          username: `u${i}`,
          password: "p",
          url: `https://example${i}.com`,
          type: "login",
        });
      }
    }

    it("empty domain returns empty results", async () => {
      await withEntries(3);
      const r = await dispatch({
        type: "AUTOFILL_QUERY",
        payload: { domain: "" },
      });
      expect(r.ok).toBe(true);
      expect((r as { data: unknown[] }).data).toEqual([]);
    });

    const adversarialDomains = [
      "*",
      ".*",
      "%",
      "<script>alert(1)</script>",
      "' OR '1'='1",
      "../../../etc/passwd",
      "\x00github.com",
      "github.com\x00",
      "GITHUB.COM",
      "github.com/path",
      "https://github.com",
      "javascript:alert(1)",
      " ",
      "   ",
      "\t",
      "\n",
      String("a").repeat(5000),
    ];
    for (const domain of adversarialDomains) {
      it(`adversarial domain ${JSON.stringify(domain.slice(0, 30))} does not crash`, async () => {
        await withEntries(3);
        const r = await dispatch({
          type: "AUTOFILL_QUERY",
          payload: { domain },
        });
        expect(r.ok).toBe(true);
      });

      it(`adversarial domain ${JSON.stringify(domain.slice(0, 30))} does not match all entries`, async () => {
        await withEntries(5);
        const r = await dispatch({
          type: "AUTOFILL_QUERY",
          payload: { domain },
        });
        const data = (r as { data: unknown[] }).data;
        // No adversarial wildcard should ever match every entry.
        expect(data.length).toBeLessThan(5);
      });
    }

    it("locked vault: AUTOFILL_QUERY returns error", async () => {
      const vault = await import("./vault");
      await vault.createVault("test-pass-12345");
      vault.lock();
      const r = await dispatch({
        type: "AUTOFILL_QUERY",
        payload: { domain: "github.com" },
      });
      expect(r.ok).toBe(false);
    });

    it("response never leaks privateKeyJwk", async () => {
      await withEntries(3);
      const r = await dispatch({
        type: "AUTOFILL_QUERY",
        payload: { domain: "example0.com" },
      });
      const data = (r as { data: Array<Record<string, unknown>> }).data;
      for (const entry of data) {
        expect("privateKeyJwk" in entry).toBe(false);
        expect("passkey" in entry).toBe(false);
      }
    });

    it("kind=card returns card summaries only (no full PAN)", async () => {
      const vault = await import("./vault");
      await vault.createVault("test-pass-12345");
      await vault.addEntry({
        type: "card",
        title: "Visa",
        cardNumber: "4111111111111111",
        last4: "1111",
        cardholderName: "JUNE",
        expMonth: "12",
        expYear: "2030",
        cvc: "123",
      } as unknown as Parameters<typeof vault.addEntry>[0]);
      const r = await dispatch({
        type: "AUTOFILL_QUERY",
        payload: { domain: "any.com", kind: "card" },
      });
      const data = (r as { data: Array<Record<string, unknown>> }).data;
      for (const entry of data) {
        expect("cardNumber" in entry).toBe(false);
        expect("cvc" in entry).toBe(false);
      }
    });
  });

  // ── RESTORE_FROM_CODEX adversarial ──────────────────────────────────────

  describe("RESTORE_FROM_CODEX adversarial", () => {
    const malformed = [
      { name: "empty vaultBlob", overrides: { vaultBlob: "" } },
      { name: "garbage vaultBlob", overrides: { vaultBlob: "!!!not-base64!!!" } },
      { name: "wrong fingerprint", overrides: { vaultFingerprint: "0".repeat(16) } },
      { name: "wrong passphrase", overrides: { masterPassphrase: "definitely wrong" } },
      { name: "negative timestamp", overrides: { timestamp: -1 } },
      { name: "zero timestamp", overrides: { timestamp: 0 } },
      { name: "huge entryCount", overrides: { entryCount: 1_000_000 } },
      { name: "negative entryCount", overrides: { entryCount: -5 } },
    ];
    for (const { name, overrides } of malformed) {
      it(`malformed payload (${name}) returns ok=false without crash`, async () => {
        const payload = {
          vaultBlob: "ZGF0YQ==",
          timestamp: Date.now(),
          verifyCode: "PX-TEST-1234",
          vaultFingerprint: "ABCDEF1234567890",
          entryCount: 0,
          masterPassphrase: "secret",
          ...overrides,
        };
        const r = await dispatch({ type: "RESTORE_FROM_CODEX", payload }, EXTENSION_PAGE_SENDER);
        expect(r).toBeDefined();
        expect(r.ok).toBe(false);
      });
    }

    it("null payload does not crash", async () => {
      const r = await dispatch({
        type: "RESTORE_FROM_CODEX",
        payload: null,
      } as unknown as Message, EXTENSION_PAGE_SENDER);
      expect(r).toBeDefined();
      expect(r.ok).toBe(false);
    });
  });

  // ── COPY handler ────────────────────────────────────────────────────────

  describe("COPY handler adversarial", () => {
    for (const text of ["", "x", "a".repeat(10000), "\x00\x00\x00", "🔑"]) {
      it(`COPY of ${JSON.stringify(text.slice(0, 20))} resolves`, async () => {
        const r = await dispatch({
          type: "COPY",
          payload: { text, label: "test", alreadyWritten: true },
        });
        expect(r).toBeDefined();
      });
    }
  });

  // ── FIRE_CANARY_PING adversarial ────────────────────────────────────────

  describe("FIRE_CANARY_PING webhook url validation", () => {
    const badUrls = [
      "javascript:alert(1)",
      "file:///etc/passwd",
      "data:text/plain,evil",
      "",
      "not a url",
      "ftp://example.com/hook",
    ];
    for (const url of badUrls) {
      it(`rejects bad webhook URL ${JSON.stringify(url)}`, async () => {
        const r = await dispatch({
          type: "FIRE_CANARY_PING",
          payload: {
            webhookUrl: url,
            entryTitle: "x",
            trigger: "test",
          },
        });
        expect(r.ok).toBe(false);
      });
    }
  });

  // ── GET_ENTRY_FOR_FILL safety ───────────────────────────────────────────

  describe("GET_ENTRY_FOR_FILL safety", () => {
    it("returns entry without passkey field for login entry", async () => {
      const vault = await import("./vault");
      await vault.createVault("test-pass-12345");
      const e = await vault.addEntry({
        title: "GitHub",
        username: "june",
        password: "x",
        url: "https://github.com",
        type: "login",
      });
      const r = await dispatch(
        { type: "GET_ENTRY_FOR_FILL", payload: { id: e.id } },
        { id: "peach-extension", url: "https://github.com/login" },
      );
      expect(r.ok).toBe(true);
      const data = (r as { data: Record<string, unknown> }).data;
      expect("passkey" in data).toBe(false);
      expect("privateKeyJwk" in data).toBe(false);
    });

    it("missing id returns error", async () => {
      await setupUnlockedVault();
      const r = await dispatch({
        type: "GET_ENTRY_FOR_FILL",
        payload: { id: "not-a-real-id" },
      });
      expect(r.ok).toBe(false);
    });

    it("locked vault returns error", async () => {
      const vault = await import("./vault");
      await vault.createVault("test-pass-12345");
      vault.lock();
      const r = await dispatch({
        type: "GET_ENTRY_FOR_FILL",
        payload: { id: "x" },
      });
      expect(r.ok).toBe(false);
    });
  });

  // ── GET_ENTRY_FOR_EDIT origin re-validation (PCH-01-006) ────────────────

  describe("GET_ENTRY_FOR_EDIT origin re-validation (PCH-01-006)", () => {
    async function dispatchFrom(
      message: Message,
      sender: chrome.runtime.MessageSender,
    ): Promise<MessageResponse> {
      if (!listener) throw new Error("listener not registered");
      return new Promise<MessageResponse>((resolve) => {
        listener!(message, sender, resolve);
      });
    }

    async function addGithubEntry() {
      const vault = await import("./vault");
      await vault.createVault("test-pass-12345");
      return vault.addEntry({
        title: "GitHub",
        username: "june",
        password: "x",
        url: "https://github.com",
        type: "login",
      });
    }

    it("tab-context request on the entry's domain returns the full entry", async () => {
      const e = await addGithubEntry();
      const r = await dispatchFrom(
        { type: "GET_ENTRY_FOR_EDIT", payload: { id: e.id } } as Message,
        { id: "peach-extension", tab: { url: "https://github.com/login" } } as chrome.runtime.MessageSender,
      );
      expect(r.ok).toBe(true);
      expect((r as { data: Record<string, unknown> }).data.username).toBe("june");
    });

    it("tab-context request on a mismatched domain returns entry_not_found with no leak", async () => {
      const e = await addGithubEntry();
      const r = await dispatchFrom(
        { type: "GET_ENTRY_FOR_EDIT", payload: { id: e.id } } as Message,
        { id: "peach-extension", tab: { url: "https://evil.example/login" } } as chrome.runtime.MessageSender,
      );
      expect(r.ok).toBe(false);
      expect(r.error).toBe("entry_not_found");
      expect((r as { data?: unknown }).data).toBeUndefined();
    });

    it("explicitSummon allows a cross-domain tab-context request", async () => {
      const e = await addGithubEntry();
      const r = await dispatchFrom(
        { type: "GET_ENTRY_FOR_EDIT", payload: { id: e.id, explicitSummon: true } } as Message,
        { id: "peach-extension", tab: { url: "https://evil.example/login" } } as chrome.runtime.MessageSender,
      );
      expect(r.ok).toBe(true);
      expect((r as { data: Record<string, unknown> }).data.username).toBe("june");
    });

    it("popup context (no tab/url) skips the origin check and returns the entry", async () => {
      const e = await addGithubEntry();
      const r = await dispatchFrom(
        { type: "GET_ENTRY_FOR_EDIT", payload: { id: e.id } } as Message,
        { id: "peach-extension" } as chrome.runtime.MessageSender,
      );
      expect(r.ok).toBe(true);
      expect((r as { data: Record<string, unknown> }).data.username).toBe("june");
    });
  });

  // ── Destructive-op sender gate (PCH-01-018) ─────────────────────────────

  describe("destructive ops gated to extension-page senders (PCH-01-018)", () => {
    async function dispatchFrom(
      message: Message,
      sender: chrome.runtime.MessageSender,
    ): Promise<MessageResponse> {
      if (!listener) throw new Error("listener not registered");
      return new Promise<MessageResponse>((resolve) => {
        listener!(message, sender, resolve);
      });
    }
    const DESTRUCTIVE = [
      "DESTROY_VAULT",
      "CLEAR_VAULT_ENTRIES",
      "RESTORE_VAULT_SNAPSHOT",
      "RESTORE_FROM_CODEX",
    ] as const;
    const SENSITIVE = [
      "GET_ENTRIES",
      "GET_RECOVERY_WORDS",
      "RESTORE_ENTRIES",
      "UNPAIR_DEVICE",
      "CONFIRM_VOUCHED_DEVICE",
      "ROTATE_SYNC_IDENTITY",
    ] as const;
    const contentScript = {
      id: "peach-extension",
      url: "https://evil.test/",
    } as chrome.runtime.MessageSender;
    const extensionPage = {
      id: "peach-extension",
      url: "chrome-extension://peach-extension/popup.html",
    } as chrome.runtime.MessageSender;

    for (const type of DESTRUCTIVE) {
      it(`${type} from a content-script sender is rejected as invalid_sender`, async () => {
        await setupUnlockedVault();
        const r = await dispatchFrom({ type, payload: {} } as Message, contentScript);
        expect(r).toEqual({ ok: false, error: "invalid_sender" });
      });

      it(`${type} from an extension-page sender passes the origin gate`, async () => {
        await setupUnlockedVault();
        const r = await dispatchFrom({ type, payload: {} } as Message, extensionPage);
        // It may still fail downstream validation, but never on the origin gate.
        expect(r.error).not.toBe("invalid_sender");
      });
    }

    for (const type of SENSITIVE) {
      it(`${type} from a content-script sender is rejected as invalid_sender`, async () => {
        const r = await dispatchFrom({ type, payload: {} } as Message, contentScript);
        expect(r).toEqual({ ok: false, error: "invalid_sender" });
      });

      it(`${type} from an extension-page sender reaches the handler`, async () => {
        const r = await dispatchFrom({ type, payload: {} } as Message, extensionPage);
        expect(r.error).not.toBe("invalid_sender");
      });
    }

    it("GET_LOCAL_IDENTITY from a content-script sender is rejected (audit 2026-08-20 #4)", async () => {
      const r = await dispatchFrom({ type: "GET_LOCAL_IDENTITY", payload: {} } as Message, contentScript);
      expect(r).toEqual({ ok: false, error: "invalid_sender" });
    });
  });

  // ── ADD_ENTRY adversarial when locked ───────────────────────────────────

  describe("ADD_ENTRY locked-state safety", () => {
    it("locked vault: ADD_ENTRY returns vault locked", async () => {
      const r = await dispatch({
        type: "ADD_ENTRY",
        payload: { title: "x", username: "u", password: "p", url: "https://e.com" },
      });
      expect(r.ok).toBe(false);
    });

    it("ADD_ENTRY with no password and no passkey succeeds for email-only accounts", async () => {
      await setupUnlockedVault();
      const r = await dispatch({
        type: "ADD_ENTRY",
        payload: { title: "x", username: "u", password: "", url: "https://e.com" },
      });
      expect(r.ok).toBe(true);
    });
  });

  // ── DELETE_ENTRY adversarial ────────────────────────────────────────────

  describe("DELETE_ENTRY adversarial", () => {
    const badIds = [
      "",
      "   ",
      "not-a-uuid",
      String("a").repeat(10000),
      "00000000-0000-0000-0000-000000000000",
      "<script>",
      "\x00",
    ];
    for (const id of badIds) {
      it(`unknown id ${JSON.stringify(id.slice(0, 30))} returns error`, async () => {
        await setupUnlockedVault();
        const r = await dispatch({
          type: "DELETE_ENTRY",
          payload: { id },
        });
        expect(r.ok).toBe(false);
      });
    }
  });

  // ── BATCH_ADD_ENTRIES adversarial ───────────────────────────────────────

  describe("BATCH_ADD_ENTRIES adversarial", () => {
    it("empty array does not crash", async () => {
      await setupUnlockedVault();
      const r = await dispatch({
        type: "BATCH_ADD_ENTRIES",
        payload: { entries: [] },
      });
      expect(r).toBeDefined();
    });

    it("non-array entries does not crash", async () => {
      await setupUnlockedVault();
      const r = await dispatch({
        type: "BATCH_ADD_ENTRIES",
        payload: { entries: "not-an-array" as unknown as unknown[] },
      });
      expect(r).toBeDefined();
    });

    it("mostly-malformed entries does not crash", async () => {
      await setupUnlockedVault();
      const r = await dispatch({
        type: "BATCH_ADD_ENTRIES",
        payload: {
          entries: [
            null,
            undefined,
            42,
            "string",
            { title: "ok", username: "u", password: "p", url: "https://e.com" },
          ] as unknown as unknown[],
        },
      });
      expect(r).toBeDefined();
    });
  });

  // ── SEARCH_VAULT adversarial ────────────────────────────────────────────

  describe("SEARCH_VAULT adversarial", () => {
    const queries = [
      "",
      " ",
      "x",
      "a".repeat(1000),
      "🔑",
      "<script>",
      "' OR '1'='1",
      "../../",
      "\x00",
    ];
    for (const query of queries) {
      it(`query ${JSON.stringify(query.slice(0, 30))} does not crash`, async () => {
        await setupUnlockedVault();
        const r = await dispatch({
          type: "SEARCH_VAULT",
          payload: { query },
        });
        expect(r).toBeDefined();
      });
    }
  });

  // ── UPDATE_SETTINGS adversarial ─────────────────────────────────────────

  describe("UPDATE_SETTINGS adversarial", () => {
    const patches = [
      { name: "empty", patch: {} },
      { name: "junk keys", patch: { __proto__: { polluted: true } } },
      { name: "very long autolock", patch: { autoLockMinutes: 99999999 } },
      { name: "negative autolock", patch: { autoLockMinutes: -5 } },
      { name: "string autolock", patch: { autoLockMinutes: "five" } },
      { name: "unknown nested", patch: { foo: { bar: { baz: 1 } } } },
    ];
    for (const { name, patch } of patches) {
      it(`patch ${name} does not crash`, async () => {
        await setupUnlockedVault();
        const r = await dispatch({
          type: "UPDATE_SETTINGS",
          payload: patch as Record<string, unknown>,
        });
        expect(r).toBeDefined();
      });
    }

    it("prototype pollution check: Object.prototype.polluted stays unset", async () => {
      await setupUnlockedVault();
      await dispatch({
        type: "UPDATE_SETTINGS",
        payload: JSON.parse(
          '{"__proto__": {"polluted": "yes"}}'
        ) as Record<string, unknown>,
      });
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      expect(({} as any).polluted).toBeUndefined();
    });
  });

  // ── Wider adversarial payload matrix per handler ────────────────────────

  describe("wide adversarial payload matrix", () => {
    const adversarialPayloads: Array<{ name: string; payload: unknown }> = [
      { name: "true", payload: true },
      { name: "false", payload: false },
      { name: "NaN", payload: NaN },
      { name: "Infinity", payload: Infinity },
      { name: "-Infinity", payload: -Infinity },
      { name: "BigInt-like", payload: { type: "bigint" } },
      { name: "Date", payload: new Date() },
      { name: "RegExp", payload: /pattern/ },
      { name: "Symbol-string", payload: Symbol("x").toString() },
      { name: "circular reference", payload: (() => {
        const o: Record<string, unknown> = {};
        o.self = o;
        return o;
      })() },
    ];

    const fastHandlers = [
      "ADD_ENTRY",
      "UPDATE_ENTRY",
      "DELETE_ENTRY",
      "AUTOFILL_QUERY",
      "GET_ENTRY_FOR_FILL",
      "UPDATE_SETTINGS",
      "SEARCH_VAULT",
      "SAVE_NOTE",
      "DELETE_NOTE",
      "PURGE_ENTRY",
      "RESTORE_ENTRY",
      "PURGE_EXPIRED_TRASH",
      "ADD_ADDITIONAL_URL",
      "BATCH_ADD_ENTRIES",
      "RESTORE_ENTRIES",
      "ACTIVATE_LICENSE",
      "APPROVE_PASSKEY",
      "DENY_PASSKEY",
      "SET_PASSKEY_PROVIDER_ENABLED",
      "RESTORE_VAULT_SNAPSHOT",
      "VERIFY_MAIN_PASSWORD",
      "SETUP_DURESS",
    ];

    for (const handler of fastHandlers) {
      for (const { name, payload } of adversarialPayloads) {
        it(`${handler} + ${name} payload resolves without crash`, async () => {
          const r = await dispatch({ type: handler, payload } as unknown as Message);
          expect(r).toBeDefined();
        });
      }
    }
  });

  // ── Foreign sender × handler matrix ─────────────────────────────────────

  describe("foreign sender rejection matrix", () => {
    const safeQuickHandlers = [
      "GET_ENTRIES",
      "IS_UNLOCKED",
      "HAS_VAULT",
      "GET_VAULT_STATUS",
      "GET_SETTINGS",
      "GET_DELETED_ENTRIES",
      "COUNT_DUPLICATES",
      "GET_VAULT_HISTORY",
      "ADD_ENTRY",
      "DELETE_ENTRY",
      "AUTOFILL_QUERY",
      "GET_ENTRY_FOR_FILL",
      "SAVE_NOTE",
      "DELETE_NOTE",
      "GET_NOTES",
      "SEARCH_VAULT",
      "GET_LICENSE",
      "GET_LICENSE_KEY",
      "GET_RECOVERY_WORDS",
      "VALIDATE_RECOVERY_WORDS",
      "RECOVER_WITH_WORDS",
      "RESTORE_FROM_CODEX",
      "GET_CODEX_VAULT_DATA",
      "ESTIMATE_CODEX_PAGES",
    ];
    for (const handler of safeQuickHandlers) {
      it(`${handler} from foreign sender returns invalid sender`, async () => {
        if (!listener) throw new Error("listener not registered");
        const r = await new Promise<MessageResponse>((resolve) => {
          listener!(
            { type: handler, payload: {} } as Message,
            { id: "foreign-extension-id" } as chrome.runtime.MessageSender,
            resolve
          );
        });
        expect(r.ok).toBe(false);
        expect(r.error).toBe("invalid_sender");
      });
    }
  });

  // ── ADD_ENTRY payload-shape robustness ──────────────────────────────────

  describe("ADD_ENTRY payload shape robustness", () => {
    const shapes = [
      { name: "no title", body: { username: "u", password: "p", url: "https://e.com" } },
      { name: "no url", body: { title: "t", username: "u", password: "p" } },
      { name: "title only", body: { title: "t", password: "p" } },
      { name: "spurious type", body: { type: "login", title: "t", password: "p" } },
      { name: "unknown type", body: { type: "wat", title: "t", password: "p" } },
      { name: "with extra field", body: { title: "t", password: "p", extra: "ignored" } },
      { name: "url with port", body: { title: "t", password: "p", url: "https://e.com:8080" } },
      { name: "url with path", body: { title: "t", password: "p", url: "https://e.com/a/b/c" } },
      { name: "username as number", body: { title: "t", username: 42, password: "p", url: "https://e.com" } },
      { name: "password as number", body: { title: "t", password: 12345, url: "https://e.com" } },
      { name: "title as null", body: { title: null, password: "p", url: "https://e.com" } },
      { name: "title as object", body: { title: { wat: 1 }, password: "p", url: "https://e.com" } },
    ];
    for (const { name, body } of shapes) {
      it(`ADD_ENTRY shape ${name} resolves without crash`, async () => {
        await setupUnlockedVault();
        const r = await dispatch({
          type: "ADD_ENTRY",
          payload: body as Parameters<typeof dispatch>[0]["payload"],
        } as Message);
        expect(r).toBeDefined();
      });
    }
  });

  // ── UPDATE_ENTRY patch-shape robustness ─────────────────────────────────

  describe("UPDATE_ENTRY patch shape robustness", () => {
    const patches = [
      { name: "title only", patch: { title: "New" } },
      { name: "password only", patch: { password: "newpass" } },
      { name: "url only", patch: { url: "https://e2.com" } },
      { name: "many fields", patch: { title: "N", username: "u2", password: "p2", url: "https://e2.com" } },
      { name: "unknown field", patch: { totallyMadeUp: "x" } },
      { name: "deletedAt forbidden", patch: { deletedAt: Date.now() } },
      { name: "createdAt forbidden", patch: { createdAt: 0 } },
      { name: "modifiedAt patch", patch: { modifiedAt: Date.now() } },
      { name: "id patch (should reject or ignore)", patch: { id: "new-id" } },
    ];
    for (const { name, patch } of patches) {
      it(`UPDATE_ENTRY patch ${name} resolves without crash`, async () => {
        const vault = await import("./vault");
        await vault.createVault("test-pass-12345");
        const e = await vault.addEntry({
          title: "x",
          username: "u",
          password: "p",
          url: "https://e.com",
          type: "login",
        });
        const r = await dispatch({
          type: "UPDATE_ENTRY",
          payload: { id: e.id, patch },
        });
        expect(r).toBeDefined();
      });
    }
  });

  // ── Sequence: vault life-cycle adversarial ──────────────────────────────

  describe("vault lifecycle adversarial sequences", () => {
    for (let i = 0; i < 20; i++) {
      it(`random message sequence #${i} does not crash`, async () => {
        const vault = await import("./vault");
        await vault.createVault("test-pass-12345");
        const handlers = [
          { type: "GET_ENTRIES" },
          { type: "IS_UNLOCKED" },
          { type: "GET_VAULT_STATUS" },
          { type: "HAS_VAULT" },
          { type: "GET_DELETED_ENTRIES" },
          { type: "GET_SETTINGS" },
          { type: "COUNT_DUPLICATES" },
          { type: "GET_VAULT_HISTORY" },
        ] as Array<Message>;
        for (const h of handlers) {
          const r = await dispatch(h);
          expect(r).toBeDefined();
        }
      });
    }
  });

  // ── Read-only handlers when locked ──────────────────────────────────────

  describe("read-only handlers when locked", () => {
    const safeWhenLocked = [
      "IS_UNLOCKED",
      "HAS_VAULT",
      "GET_VAULT_STATUS",
      "GET_SETTINGS",
    ];
    for (const type of safeWhenLocked) {
      it(`${type} works without crash when locked`, async () => {
        const r = await dispatch({ type } as unknown as Message);
        expect(r).toBeDefined();
      });
    }

    const gatedWhenLocked = [
      "GET_ENTRIES",
      "GET_DELETED_ENTRIES",
      "COUNT_DUPLICATES",
      "GET_IDENTITIES",
      "GET_IDENTITY_SUGGESTIONS",
    ];
    for (const type of gatedWhenLocked) {
      it(`${type} returns ok=false when locked`, async () => {
        const r = await dispatch({ type } as unknown as Message);
        expect(r).toBeDefined();
        // Some handlers return ok:false explicitly; others may throw.
        if (r.ok === true) {
          // Accept ok:true only if data is empty.
          const data = (r as { data: unknown }).data;
          expect(
            data == null ||
              (Array.isArray(data) && data.length === 0) ||
              data === 0
          ).toBe(true);
        } else {
          expect(r.ok).toBe(false);
        }
      });
    }
  });

  // ── M2/QUA-002: payload validation at trust boundary ────────────────────

  describe("payload validation rejects malformed inputs (M2/QUA-002)", () => {
    // Each entry: handler type + payloads that must produce ok:false.
    // The accepted error codes include 'invalid_payload' (the new validator)
    // or 'vault_locked' (handlers that lock-check before validating, which
    // is still a correct rejection of the request).
    const cases: Array<{ type: string; bad: unknown[] }> = [
      {
        type: "ADD_ENTRY",
        bad: [null, "string", 42, [], true],
      },
      {
        type: "BATCH_ADD_ENTRIES",
        bad: [null, { entries: "not-array" }, { entries: null }, { entries: 42 }, []],
      },
      {
        type: "UPDATE_ENTRY",
        bad: [null, {}, { id: 123 }, { id: "x" }, { id: "x", patch: "no" }, { id: "x", patch: null }, []],
      },
      {
        type: "RESTORE_ENTRIES",
        bad: [null, {}, { entries: "no" }, { entries: [], mode: "wrong" }, []],
      },
      {
        type: "UPDATE_SETTINGS",
        bad: [null, "string", 42, []],
      },
    ];

    for (const { type, bad } of cases) {
      for (const payload of bad) {
        const label = JSON.stringify(payload);
        it(`${type} rejects malformed payload: ${label}`, async () => {
          await setupUnlockedVault();
          const r = await dispatch({ type, payload } as unknown as Message);
          expect(r.ok).toBe(false);
          const err = (r as { error?: string }).error ?? "";
          expect(err).toMatch(/invalid_payload|vault[_ ]locked/);
        });
      }
    }
  });

  // ── AUD-002: payload validation for previously raw-cast handlers ────────

  describe("AUD-002 payload validation", () => {
    describe("SEARCH_VAULT", () => {
      const badQueries: Array<[string, unknown]> = [
        ["null", null],
        ["numeric", 42],
        ["boolean", true],
        ["object", { evil: true }],
        ["array", []],
        ["missing", undefined],
      ];
      for (const [name, query] of badQueries) {
        it(`rejects ${name} query`, async () => {
          await setupUnlockedVault();
          const r = await dispatch({
            type: "SEARCH_VAULT",
            payload: { query },
          } as unknown as Message);
          expect(r.ok).toBe(false);
          expect((r as { error?: string }).error).toBe("invalid_payload");
        });
      }

      it("accepts valid string query", async () => {
        await setupUnlockedVault();
        const r = await dispatch({
          type: "SEARCH_VAULT",
          payload: { query: "github" },
        });
        expect(r.ok).toBe(true);
      });
    });

    describe("COPY", () => {
      const bads: Array<[string, unknown, unknown]> = [
        ["null text", null, "pw"],
        ["numeric text", 42, "pw"],
        ["object text", { evil: true }, "pw"],
        ["missing text", undefined, "pw"],
        ["null label", "secret", null],
        ["numeric label", "secret", 42],
      ];
      for (const [name, text, label] of bads) {
        it(`rejects ${name}`, async () => {
          await setupUnlockedVault();
          const r = await dispatch({
            type: "COPY",
            payload: { text, label },
          } as unknown as Message);
          expect(r.ok).toBe(false);
          expect((r as { error?: string }).error).toBe("invalid_payload");
        });
      }
    });

    describe("ML_PREDICT_BATCH", () => {
      const bads: Array<[string, unknown]> = [
        ["null", null],
        ["object", { not: "array" }],
        ["string", "features"],
        ["number", 42],
        ["missing", undefined],
      ];
      for (const [name, featuresArray] of bads) {
        it(`rejects ${name} featuresArray`, async () => {
          const r = await dispatch({
            type: "ML_PREDICT_BATCH",
            payload: { featuresArray },
          } as unknown as Message);
          expect(r.ok).toBe(false);
          expect((r as { error?: string }).error).toBe("invalid_payload");
        });
      }

      it("accepts empty array featuresArray", async () => {
        const r = await dispatch({
          type: "ML_PREDICT_BATCH",
          payload: { featuresArray: [] },
        } as unknown as Message);
        expect((r as { error?: string }).error).not.toBe("invalid_payload");
      });
    });
  });
});