create-ailk 0.23.0 → 0.25.1

package/templates/apps/api/src/services/__tests__/person.test.ts

@@ -1,1176 +0,0 @@
-/**
- * @file person.test.ts
- * @description `findOrCreatePerson`, `stampPersonUser` and
- * `recordCheckoutPerson` (#852, spec
- * docs/specs/852-person-the-per-workspace-client-spec.md D3, D5, D6;
- * AC-2, AC-4's API half, AC-5), and the member area's two additions,
- * `resolveMemberPersonId` and `setPersonPlanOffering` (#7877 D8; AC-3, AC-5),
- * and the hub's buyer read, `resolveCallerBillingCustomerId`, with the
- * stamped-Person guard on the customer-id write (#7961, spec
- * docs/specs/7894-the-hub-signs-in-its-spec.md D13, SEC-7894-6; AC-8),
- * and the held checkout plan's release on a verified first link
- * (#8793, spec docs/specs/8793-the-hub-s-checkout-plan-spec.md D2–D5;
- * AC-1, AC-2, AC-6).
- *
- * Runs over `createInMemoryPrisma()`, whose `person` delegate enforces the
- * declared `(workspaceId, email)` and `(workspaceId, userId)` keys the way
- * Postgres does: `createMany({ skipDuplicates })` skips a conflict, and an
- * `updateMany` that would put one user on two Persons of a workspace throws
- * `P2002`. The database half of each claim — the CHECKs, the real ON
- * CONFLICT race, the backfill SQL — is `database/__tests__/person.db.test.ts`.
- *
- * External dependency boundary mocked:
- *   - apps/api/src/lib/prisma — the in-memory, where-clause-honouring double.
- */
-
-// eslint-disable-next-line no-restricted-syntax -- lib/prisma.ts wraps the external DB boundary (PrismaClient requires a live connection); the in-memory double is the repo-standard where-honouring test double for it.
-jest.mock("../../lib/prisma.js", () =>
-  jest
-    .requireActual<typeof import("../../__tests__/factories/in-memory-prisma")>(
-      "../../__tests__/factories/in-memory-prisma",
-    )
-    .createInMemoryPrisma(),
-);
-
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { prisma } from "../../lib/prisma.js";
-import { personContactPatchSchema } from "@working-theory/validation";
-
-import {
-  checkoutPlanKey,
-  contactConfirmedFromRow,
-  ensureMemberPerson,
-  findOrCreatePerson,
-  isStorablePersonEmail,
-  normalizeCapturedContact,
-  normalizePersonEmail,
-  normalizeTelephone,
-  personContactFromRow,
-  recordCheckoutPerson,
-  releaseHeldCheckoutPlan,
-  resolveCallerBillingCustomerId,
-  resolveMemberPersonId,
-  setOwnPersonContact,
-  setPersonPlanOffering,
-  stampPersonUser,
-  updatePersonContact,
-} from "../person";
-
-type Row = Record<string, unknown>;
-// The in-memory double's own surface (`__db`, `__calls`) is not on the
-// PrismaClient type the import carries, so it is named here once.
-// eslint-disable-next-line no-restricted-syntax -- justified above
-const store = prisma as unknown as {
-  __db: Record<string, Row[]>;
-  __calls: Array<{ model: string; op: string }>;
-  person: Record<string, jest.Mock>;
-  lead: Record<string, jest.Mock>;
-};
-
-const WS_A1 = "wksp_00000000-0000-7000-8000-0000000000a1";
-const WS_A2 = "wksp_00000000-0000-7000-8000-0000000000a2";
-
-/** A 255-character address — one past the 254 bound. */
-const LONG_255 = `${"a".repeat(244)}@example.io`;
-
-const people = () => (store.__db["person"] ??= []);
-const personCalls = () => store.__calls.filter((c) => c.model === "person");
-
-function reset(): void {
-  for (const key of Object.keys(store.__db)) delete store.__db[key];
-  store.__calls.length = 0;
-}
-
-function seedPerson(row: Row): Row {
-  const full: Row = {
-    id: `person_00000000-0000-7000-8000-${String(people().length + 900).padStart(12, "0")}`,
-    workspaceId: WS_A1,
-    name: null,
-    userId: null,
-    billingProvider: null,
-    billingCustomerId: null,
-    planOffering: null,
-    // #8435 — the contact columns, blank the way Postgres reads them back.
-    givenName: null,
-    familyName: null,
-    telephone: null,
-    addressLine1: null,
-    addressLine2: null,
-    addressCity: null,
-    addressRegion: null,
-    addressPostalCode: null,
-    addressCountry: null,
-    companyName: null,
-    jobTitle: null,
-    contactConfirmedAt: null,
-    contactConfirmedBy: null,
-    createdAt: new Date(Date.UTC(2026, 0, 1 + people().length)),
-    updatedAt: new Date(),
-    ...row,
-  };
-  people().push(full);
-  return full;
-}
-
-beforeEach(() => {
-  reset();
-  jest.restoreAllMocks();
-});
-
-describe("findOrCreatePerson (#852 D3, AC-2)", () => {
-  it("normalizes the email: a padded, mixed-case address and its plain form are one Person per workspace", async () => {
-    const first = await findOrCreatePerson(WS_A1, { email: " Ada@Example.COM\t" });
-    const second = await findOrCreatePerson(WS_A1, { email: "ada@example.com" });
-    expect(first).toEqual({ ok: true, value: expect.objectContaining({ created: true }) });
-    expect(second.ok && second.value).toEqual(
-      expect.objectContaining({ created: false, personId: first.ok && first.value.personId }),
-    );
-    expect(people()).toHaveLength(1);
-    expect(people()[0]!["email"]).toBe("ada@example.com");
-
-    const other = await findOrCreatePerson(WS_A2, { email: "ada@example.com" });
-    expect(other.ok && other.value.created).toBe(true);
-    expect(people()).toHaveLength(2);
-  });
-
-  it("a customer-id match returns that Person, creates nothing and never rewrites its email", async () => {
-    const p = seedPerson({ email: "a@x.io", billingProvider: "stripe", billingCustomerId: "cus_1" });
-    const result = await findOrCreatePerson(WS_A1, { email: "b@x.io", billingCustomerId: "cus_1" });
-    expect(result).toEqual({
-      ok: true,
-      value: { personId: p["id"], created: false, billing: "unchanged" },
-    });
-    expect(people()).toHaveLength(1);
-    expect(people()[0]!["email"]).toBe("a@x.io");
-    expect(personCalls().map((c) => c.op)).toEqual(["findFirst"]);
-  });
-
-  it("an email match writes the customer id only when the Person has none; the first writer is kept", async () => {
-    seedPerson({ email: "c@x.io" });
-    const written = await findOrCreatePerson(WS_A1, { email: "c@x.io", billingCustomerId: "cus_2" });
-    expect(written.ok && written.value.billing).toBe("written");
-    const kept = await findOrCreatePerson(WS_A1, { email: "c@x.io", billingCustomerId: "cus_3" });
-    expect(kept.ok && kept.value.billing).toBe("kept");
-    expect(people()[0]).toEqual(
-      expect.objectContaining({ billingProvider: "stripe", billingCustomerId: "cus_2" }),
-    );
-  });
-
-  it("an email match never writes a customer id onto a Person already linked to a user (SEC-7894-6)", async () => {
-    seedPerson({ email: "d@x.io", userId: "user_00000000-0000-7000-8000-000000000021" });
-    const result = await findOrCreatePerson(WS_A1, { email: "D@x.io", billingCustomerId: "cus_payer" });
-    expect(result.ok && result.value).toEqual(expect.objectContaining({ created: false, billing: "kept" }));
-    expect(people()[0]).toEqual(
-      expect.objectContaining({ billingProvider: null, billingCustomerId: null }),
-    );
-    expect(personCalls().filter((c) => c.op === "updateMany")).toHaveLength(0);
-  });
-
-  it("a Person linked between the match and the write keeps no customer id (the write is guarded on userId)", async () => {
-    seedPerson({ email: "e@x.io", userId: "user_00000000-0000-7000-8000-000000000022" });
-    // Step 2's customer-id read finds nothing; the email match read saw the
-    // Person before the stamp landed.
-    store.person["findFirst"]!.mockResolvedValueOnce(null).mockResolvedValueOnce({
-      id: people()[0]!["id"],
-      name: null,
-      userId: null,
-      billingCustomerId: null,
-    });
-    const result = await findOrCreatePerson(WS_A1, { email: "e@x.io", billingCustomerId: "cus_payer" });
-    expect(result.ok && result.value.billing).toBe("kept");
-    expect(people()[0]!["billingCustomerId"]).toBeNull();
-  });
-
-  it("a new Person given a customer id is created with it", async () => {
-    const result = await findOrCreatePerson(WS_A1, { email: "new@x.io", billingCustomerId: "cus_9" });
-    expect(result.ok && result.value).toEqual(expect.objectContaining({ created: true, billing: "written" }));
-    expect(people()[0]).toEqual(
-      expect.objectContaining({ billingProvider: "stripe", billingCustomerId: "cus_9" }),
-    );
-  });
-
-  it("an email match gains a name only when it has none", async () => {
-    seedPerson({ email: "named@x.io", name: "First" });
-    seedPerson({ email: "nameless@x.io" });
-    await findOrCreatePerson(WS_A1, { email: "named@x.io", name: "Second" });
-    await findOrCreatePerson(WS_A1, { email: "nameless@x.io", name: "Given" });
-    expect(people().map((p) => p["name"])).toEqual(["First", "Given"]);
-  });
-
-  it.each([
-    ["not-an-email"],
-    [""],
-    ["a@b@c.io"],
-    ["zoë@x.io"],
-    ["zero\u200Bwidth@x.io"],
-    [LONG_255],
-  ])("refuses %p as invalid_email with zero person delegate calls", async (email) => {
-    const result = await findOrCreatePerson(WS_A1, { email });
-    expect(result).toEqual({ ok: false, error: { kind: "invalid_email" } });
-    expect(personCalls()).toEqual([]);
-  });
-
-  it("the long case is exactly 255 characters", () => {
-    expect(LONG_255).toHaveLength(255);
-  });
-
-  it("strips control and bidi characters from a name, trims it and cuts it to 200 code points", async () => {
-    await findOrCreatePerson(WS_A1, {
-      email: "n@x.io",
-      name: `  Ad\u202Ea\u0007 ${"😀".repeat(250)}`,
-    });
-    const name = people()[0]!["name"] as string;
-    expect(name.startsWith("Ada ")).toBe(true);
-    const codePoints = Array.from(name, (c) => c.codePointAt(0)!);
-    expect(codePoints.filter((cp) => cp < 0x20 || cp === 0x202e)).toEqual([]);
-    expect(Array.from(name)).toHaveLength(200);
-  });
-
-  it("an empty-after-cleaning name is stored as null", async () => {
-    await findOrCreatePerson(WS_A1, { email: "blank@x.io", name: " \u200E\u0001 " });
-    expect(people()[0]!["name"]).toBeNull();
-  });
-
-  it("a createMany that loses a concurrent race (count 0) answers the re-read's Person with created: false", async () => {
-    store.person["createMany"]!.mockImplementationOnce(async () => {
-      seedPerson({ email: "race@x.io" });
-      return { count: 0 };
-    });
-    const result = await findOrCreatePerson(WS_A1, { email: "race@x.io" });
-    expect(result).toEqual({
-      ok: true,
-      value: { personId: people()[0]!["id"], created: false, billing: "unchanged" },
-    });
-    expect(people()).toHaveLength(1);
-  });
-
-  it("uses createMany with skipDuplicates (ON CONFLICT DO NOTHING), never a caught P2002", async () => {
-    await findOrCreatePerson(WS_A1, { email: "skip@x.io" });
-    expect(store.person["createMany"]).toHaveBeenCalledWith(
-      expect.objectContaining({ skipDuplicates: true }),
-    );
-  });
-
-  it("a delegate that throws answers internal_error with no message", async () => {
-    store.person["findFirst"]!.mockRejectedValueOnce(new Error("relation people does not exist: secret detail"));
-    const result = await findOrCreatePerson(WS_A1, { email: "boom@x.io" });
-    expect(result).toEqual({ ok: false, error: { kind: "internal_error" } });
-    expect(JSON.stringify(result)).not.toContain("secret");
-  });
-
-  it("runs on the client it is handed (the appointment path's transaction)", async () => {
-    const tx = { person: { ...store.person } };
-    const spy = jest.fn(store.person["findFirst"]!);
-    tx.person["findFirst"] = spy;
-    await findOrCreatePerson(WS_A1, { email: "tx@x.io" }, tx as never);
-    expect(spy).toHaveBeenCalled();
-  });
-
-  it("never reads a User: a Person is created with no verified email at all", async () => {
-    await findOrCreatePerson(WS_A1, { email: "nouser@x.io" });
-    expect(store.__calls.filter((c) => c.model === "user")).toEqual([]);
-    expect(people()[0]!["userId"] ?? null).toBeNull();
-  });
-
-  it("imports none of the paid closure or tenant-db", () => {
-    const source = readFileSync(join(__dirname, "..", "person.ts"), "utf8");
-    expect(source).not.toMatch(
-      /from ['"](\.\/lead-promotion|\.\/owner-workspaces|\.\/lead-accept-user|\.\.\/lib\/tenant-db)/,
-    );
-  });
-});
-
-describe("the backfill fixture, API half (#852 AC-4)", () => {
-  type Fixture = {
-    workspaces: Record<string, string>;
-    input: {
-      leads: Array<{ key: string; workspace: string; email: string }>;
-      flowCheckouts: Array<{ workspace: string; lead: string }>;
-      appointments: Array<{ workspace: string; attendeeEmail: string }>;
-    };
-    emails: Array<{ raw: string; normalized: string; storable: boolean }>;
-    expected: {
-      people: Array<{ workspace: string; email: string; name: string | null; billingCustomerId: string | null }>;
-    };
-  };
-  const fixture = JSON.parse(
-    readFileSync(
-      join(__dirname, "..", "..", "..", "..", "..", "database", "__tests__", "fixtures", "person-backfill.json"),
-      "utf8",
-    ),
-  ) as Fixture;
-
-  it("normalizePersonEmail and isStorablePersonEmail agree with every pair the fixture lists (the SQL half is person.db.test.ts)", () => {
-    expect(fixture.emails.map((e) => e.raw)).toEqual(
-      expect.arrayContaining(["vic@x.dev", "\u000Bdana@x.io\u000B", " Eve@X.IO\t"]),
-    );
-    for (const e of fixture.emails) {
-      const n = normalizePersonEmail(e.raw);
-      expect({ raw: e.raw, n, storable: isStorablePersonEmail(n) }).toEqual({
-        raw: e.raw,
-        n: e.normalized,
-        storable: e.storable,
-      });
-    }
-  });
-
-  it("findOrCreatePerson on every raw input email over the backfilled Persons creates zero rows", async () => {
-    for (const p of fixture.expected.people) {
-      seedPerson({
-        workspaceId: fixture.workspaces[p.workspace],
-        email: p.email,
-        name: p.name,
-        billingProvider: p.billingCustomerId === null ? null : "stripe",
-        billingCustomerId: p.billingCustomerId,
-      });
-    }
-    const before = people().length;
-    const leadsByKey = new Map(fixture.input.leads.map((l) => [l.key, l]));
-    const calls: Array<[string, string]> = [
-      ...fixture.input.leads.map((l): [string, string] => [l.workspace, l.email]),
-      ...fixture.input.flowCheckouts.map((c): [string, string] => [c.workspace, leadsByKey.get(c.lead)!.email]),
-      ...fixture.input.appointments.map((a): [string, string] => [a.workspace, a.attendeeEmail]),
-    ];
-    const created: string[] = [];
-    for (const [workspace, email] of calls) {
-      const result = await findOrCreatePerson(fixture.workspaces[workspace]!, { email });
-      if (result.ok && result.value.created) created.push(email);
-    }
-    expect(created).toEqual([]);
-    expect(people()).toHaveLength(before);
-  });
-});
-
-describe("stampPersonUser (#852 D5, AC-5)", () => {
-  const users = () => (store.__db["user"] ??= []);
-  const seedUser = (id: string, email: string, emailVerified: boolean) =>
-    users().push({ id, email, emailVerified });
-  const U = "user_00000000-0000-7000-8000-000000000001";
-  const V = "user_00000000-0000-7000-8000-000000000002";
-
-  it("a verified user whose email normalizes to the Person's is stamped; a second call is already_linked", async () => {
-    const p = seedPerson({ email: "ada@example.com" });
-    seedUser(U, " ADA@example.com", true);
-    expect(await stampPersonUser(WS_A1, p["id"] as string, U)).toBe("stamped");
-    expect(people()[0]!["userId"]).toBe(U);
-    expect(await stampPersonUser(WS_A1, p["id"] as string, U)).toBe("already_linked");
-  });
-
-  it("an unverified user, and a verified user with another email, write nothing", async () => {
-    const p = seedPerson({ email: "ada@example.com" });
-    seedUser(U, "ada@example.com", false);
-    seedUser(V, "someone@example.com", true);
-    expect(await stampPersonUser(WS_A1, p["id"] as string, U)).toBe("user_unverified");
-    expect(await stampPersonUser(WS_A1, p["id"] as string, V)).toBe("email_mismatch");
-    expect(people()[0]!["userId"]).toBeNull();
-  });
-
-  it("a Person already linked to U, stamped with V, stays U", async () => {
-    const p = seedPerson({ email: "ada@example.com", userId: U });
-    seedUser(V, "ada@example.com", true);
-    expect(await stampPersonUser(WS_A1, p["id"] as string, V)).toBe("linked_to_other_user");
-    expect(people()[0]!["userId"]).toBe(U);
-  });
-
-  it("U already on P1 cannot be stamped onto P2 of the same workspace (P2002) — P2 unchanged", async () => {
-    seedPerson({ email: "first@example.com", userId: U });
-    const p2 = seedPerson({ email: "ada@example.com" });
-    seedUser(U, "ada@example.com", true);
-    expect(await stampPersonUser(WS_A1, p2["id"] as string, U)).toBe("user_on_other_person");
-    expect(people()[1]!["userId"]).toBeNull();
-  });
-
-  it("a Person of another workspace is not_found", async () => {
-    const p = seedPerson({ workspaceId: WS_A2, email: "ada@example.com" });
-    seedUser(U, "ada@example.com", true);
-    expect(await stampPersonUser(WS_A1, p["id"] as string, U)).toBe("not_found");
-    expect(people()[0]!["userId"]).toBeNull();
-  });
-
-  it("a store error is internal_error", async () => {
-    store.person["findFirst"]!.mockRejectedValueOnce(new Error("down"));
-    expect(await stampPersonUser(WS_A1, "person_x", U)).toBe("internal_error");
-  });
-});
-
-describe("recordCheckoutPerson (#852 D6)", () => {
-  const SESSION = "cs_live_852";
-  const CHECKOUT = "flchk_00000000-0000-7000-8000-000000000001";
-  const LEAD = "lead_00000000-0000-7000-8000-000000000001";
-
-  function seedCheckout(overrides: Row = {}): void {
-    (store.__db["flowCheckout"] ??= []).push({
-      id: CHECKOUT,
-      leadId: LEAD,
-      workspaceId: WS_A1,
-      stripeSessionId: SESSION,
-      status: "completed",
-      ...overrides,
-    });
-    (store.__db["lead"] ??= []).push({ id: LEAD, workspaceId: WS_A1, email: " Buyer@X.io" });
-  }
-
-  it("live mode: the Person of the checkout's lead, with session.customer", async () => {
-    seedCheckout();
-    expect(
-      await recordCheckoutPerson({ flowCheckoutId: CHECKOUT, stripeSessionId: SESSION, customer: "cus_9", livemode: true }),
-    ).toBe("person_written");
-    expect(people()[0]).toEqual(
-      expect.objectContaining({ workspaceId: WS_A1, email: "buyer@x.io", billingCustomerId: "cus_9" }),
-    );
-  });
-
-  it("live mode onto a Person already linked to a user: the checkout completes and the Person keeps no customer id", async () => {
-    seedCheckout();
-    seedPerson({ email: "buyer@x.io", userId: "user_00000000-0000-7000-8000-000000000023" });
-    expect(
-      await recordCheckoutPerson({ flowCheckoutId: CHECKOUT, stripeSessionId: SESSION, customer: "cus_9", livemode: true }),
-    ).toBe("person_kept");
-    expect(people()).toHaveLength(1);
-    expect(people()[0]!["billingCustomerId"]).toBeNull();
-  });
-
-  it("test mode: the Person, with no customer id", async () => {
-    seedCheckout();
-    expect(
-      await recordCheckoutPerson({ flowCheckoutId: CHECKOUT, stripeSessionId: SESSION, customer: "cus_9", livemode: false }),
-    ).toBe("person_unchanged");
-    expect(people()[0]!["billingCustomerId"] ?? null).toBeNull();
-  });
-
-  it("a session naming a checkout another session completed matches nothing", async () => {
-    seedCheckout({ stripeSessionId: "cs_other" });
-    expect(
-      await recordCheckoutPerson({ flowCheckoutId: CHECKOUT, stripeSessionId: SESSION, customer: "cus_9", livemode: true }),
-    ).toBe("person_skipped");
-    expect(people()).toEqual([]);
-  });
-
-  it("a checkout not yet completed matches nothing", async () => {
-    seedCheckout({ status: "created" });
-    expect(
-      await recordCheckoutPerson({ flowCheckoutId: CHECKOUT, stripeSessionId: SESSION, customer: "cus_9", livemode: true }),
-    ).toBe("person_skipped");
-  });
-
-  it("a missing session id is skipped before any read; a store error is person_failed", async () => {
-    expect(
-      await recordCheckoutPerson({ flowCheckoutId: CHECKOUT, stripeSessionId: undefined, customer: null, livemode: true }),
-    ).toBe("person_skipped");
-    expect(store.__calls).toEqual([]);
-    seedCheckout();
-    store.person["findFirst"]!.mockRejectedValueOnce(new Error("down"));
-    expect(
-      await recordCheckoutPerson({ flowCheckoutId: CHECKOUT, stripeSessionId: SESSION, customer: "cus_9", livemode: true }),
-    ).toBe("person_failed");
-  });
-});
-
-describe("resolveMemberPersonId (#7877 D8, AC-3)", () => {
-  const users = () => (store.__db["user"] ??= []);
-  const U = "user_00000000-0000-7000-8000-000000000011";
-  const V = "user_00000000-0000-7000-8000-000000000012";
-  const log = { warn: jest.fn() };
-
-  beforeEach(() => log.warn.mockClear());
-
-  it("answers the Person already linked to the caller, with no stamp", async () => {
-    const p = seedPerson({ email: "cleo@x.io", userId: U });
-    expect(await resolveMemberPersonId(WS_A1, U, "cleo@x.io", log)).toBe(p["id"]);
-    expect(personCalls().filter((c) => c.op === "updateMany")).toHaveLength(0);
-  });
-
-  it("stamps an unlinked Person whose email is the caller's verified email (case and padding differ)", async () => {
-    const p = seedPerson({ email: "cleo@x.io" });
-    users().push({ id: U, email: "  CLEO@x.io ", emailVerified: true });
-    expect(await resolveMemberPersonId(WS_A1, U, "  CLEO@x.io ", log)).toBe(p["id"]);
-    expect(people()[0]!["userId"]).toBe(U);
-  });
-
-  it("a Person linked to another user is not stamped and not served; the refusal is logged by kind", async () => {
-    seedPerson({ email: "cleo@x.io", userId: V });
-    users().push({ id: U, email: "cleo@x.io", emailVerified: true });
-    expect(await resolveMemberPersonId(WS_A1, U, "cleo@x.io", log)).toBeNull();
-    expect(people()[0]!["userId"]).toBe(V);
-    expect(log.warn).toHaveBeenCalledWith(
-      { event: "member-person-stamp", outcome: "linked_to_other_user" },
-      expect.any(String),
-    );
-    expect(JSON.stringify(log.warn.mock.calls)).not.toContain("cleo@x.io");
-  });
-
-  it("no Person in this workspace is null — another workspace's Person is never answered", async () => {
-    seedPerson({ workspaceId: WS_A2, email: "cleo@x.io", userId: U });
-    expect(await resolveMemberPersonId(WS_A1, U, "cleo@x.io", log)).toBeNull();
-  });
-});
-
-describe("resolveCallerBillingCustomerId (#7961, spec 7894 D13, AC-8)", () => {
-  const users = () => (store.__db["user"] ??= []);
-  const U = "user_00000000-0000-7000-8000-000000000031";
-  const V = "user_00000000-0000-7000-8000-000000000032";
-  const log = { warn: jest.fn() };
-
-  beforeEach(() => log.warn.mockClear());
-
-  it("answers the customer id of the Person linked to the caller", async () => {
-    seedPerson({ email: "fay@x.io", userId: U, billingProvider: "stripe", billingCustomerId: "cus_fay" });
-    expect(await resolveCallerBillingCustomerId(WS_A1, U, "fay@x.io", log)).toBe("cus_fay");
-  });
-
-  it("links an unlinked Person whose email is the caller's verified email, then answers its id", async () => {
-    seedPerson({ email: "fay@x.io", billingProvider: "stripe", billingCustomerId: "cus_fay" });
-    users().push({ id: U, email: "Fay@x.io", emailVerified: true });
-    expect(await resolveCallerBillingCustomerId(WS_A1, U, "Fay@x.io", log)).toBe("cus_fay");
-    expect(people()[0]!["userId"]).toBe(U);
-  });
-
-  it("a Person matched by email alone is never answered: an unverified caller, and a Person linked to another user, are null", async () => {
-    seedPerson({ email: "fay@x.io", billingProvider: "stripe", billingCustomerId: "cus_fay" });
-    users().push({ id: U, email: "fay@x.io", emailVerified: false });
-    expect(await resolveCallerBillingCustomerId(WS_A1, U, "fay@x.io", log)).toBeNull();
-    expect(people()[0]!["userId"]).toBeNull();
-
-    reset();
-    seedPerson({ email: "fay@x.io", userId: V, billingProvider: "stripe", billingCustomerId: "cus_fay" });
-    users().push({ id: U, email: "fay@x.io", emailVerified: true });
-    expect(await resolveCallerBillingCustomerId(WS_A1, U, "fay@x.io", log)).toBeNull();
-  });
-
-  it("a linked Person with no customer id, no Person, and another workspace's Person are all null", async () => {
-    seedPerson({ email: "fay@x.io", userId: U });
-    expect(await resolveCallerBillingCustomerId(WS_A1, U, "fay@x.io", log)).toBeNull();
-
-    reset();
-    expect(await resolveCallerBillingCustomerId(WS_A1, U, "fay@x.io", log)).toBeNull();
-
-    seedPerson({ workspaceId: WS_A2, email: "fay@x.io", userId: U, billingCustomerId: "cus_fay" });
-    expect(await resolveCallerBillingCustomerId(WS_A1, U, "fay@x.io", log)).toBeNull();
-  });
-
-  it("a store error is null, never a throw, and logs no id or email", async () => {
-    seedPerson({ email: "fay@x.io", userId: U, billingCustomerId: "cus_fay" });
-    store.person["findFirst"]!
-      .mockResolvedValueOnce({ id: people()[0]!["id"] })
-      .mockRejectedValueOnce(new Error("down"));
-    expect(await resolveCallerBillingCustomerId(WS_A1, U, "fay@x.io", log)).toBeNull();
-    expect(JSON.stringify(log.warn.mock.calls)).not.toMatch(/cus_fay|fay@x\.io|user_/);
-  });
-});
-
-const ADDRESS = {
-  addressLine1: "1 Main St",
-  addressLine2: null,
-  city: "Austin",
-  region: "TX",
-  postalCode: "78701",
-  country: "US",
-};
-const ADDRESS_COLUMNS = {
-  addressLine1: "1 Main St",
-  addressLine2: null,
-  addressCity: "Austin",
-  addressRegion: "TX",
-  addressPostalCode: "78701",
-  addressCountry: "US",
-};
-
-describe("findOrCreatePerson fills blank contact fields (#8435 D4, AC-2)", () => {
-  const contactCalls = () =>
-    store.__calls.filter((c) => c.model === "person" && c.op === "updateMany");
-
-  it("a new email with a contact creates one Person carrying it, named from given + family", async () => {
-    const result = await findOrCreatePerson(WS_A1, {
-      email: "new@x.io",
-      contact: { givenName: "Ada", familyName: "Lovelace", telephone: "+442071234567" },
-    });
-    expect(result.ok && result.value.created).toBe(true);
-    expect(people()).toHaveLength(1);
-    expect(people()[0]).toEqual(
-      expect.objectContaining({
-        givenName: "Ada",
-        familyName: "Lovelace",
-        telephone: "+442071234567",
-        name: "Ada Lovelace",
-      }),
-    );
-  });
-
-  it("given name alone names the Person; a supplied name wins over given + family", async () => {
-    await findOrCreatePerson(WS_A1, { email: "a@x.io", contact: { givenName: "Ada" } });
-    await findOrCreatePerson(WS_A1, {
-      email: "b@x.io",
-      name: "Countess",
-      contact: { givenName: "Ada", familyName: "Lovelace" },
-    });
-    expect(people().map((p) => p["name"])).toEqual(["Ada", "Countess"]);
-  });
-
-  it("a matched Person's stored value is never overwritten; its blank fields are filled", async () => {
-    seedPerson({ email: "m@x.io", telephone: "+15550000001" });
-    await findOrCreatePerson(WS_A1, {
-      email: "m@x.io",
-      contact: { telephone: "+15550000002", companyName: "Acme" },
-    });
-    expect(people()[0]).toEqual(
-      expect.objectContaining({ telephone: "+15550000001", companyName: "Acme" }),
-    );
-  });
-
-  it("a stored address is left whole; a Person with none gains all six parts", async () => {
-    seedPerson({
-      email: "has@x.io",
-      addressLine1: "9 Old Rd",
-      addressCity: "Leeds",
-      addressRegion: "WYK",
-      addressPostalCode: "LS1",
-      addressCountry: "GB",
-    });
-    seedPerson({ email: "none@x.io" });
-    await findOrCreatePerson(WS_A1, { email: "has@x.io", contact: { address: ADDRESS } });
-    await findOrCreatePerson(WS_A1, { email: "none@x.io", contact: { address: ADDRESS } });
-    expect(people()[0]).toEqual(
-      expect.objectContaining({ addressLine1: "9 Old Rd", addressCity: "Leeds", addressCountry: "GB" }),
-    );
-    expect(people()[1]).toEqual(expect.objectContaining(ADDRESS_COLUMNS));
-  });
-
-  it("a name already on the Person is not replaced by given + family", async () => {
-    seedPerson({ email: "n@x.io", name: "A. L." });
-    await findOrCreatePerson(WS_A1, {
-      email: "n@x.io",
-      contact: { givenName: "Ada", familyName: "Lovelace" },
-    });
-    expect(people()[0]).toEqual(
-      expect.objectContaining({ name: "A. L.", givenName: "Ada", familyName: "Lovelace" }),
-    );
-  });
-
-  it("a nameless uncurated Person gains the joined name", async () => {
-    seedPerson({ email: "n@x.io" });
-    await findOrCreatePerson(WS_A1, {
-      email: "n@x.io",
-      contact: { givenName: "Ada", familyName: "Lovelace" },
-    });
-    expect(people()[0]!["name"]).toBe("Ada Lovelace");
-  });
-
-  it("a customer-id hit (step 2) writes nothing — contact included", async () => {
-    seedPerson({ email: "c@x.io", billingProvider: "stripe", billingCustomerId: "cus_1" });
-    await findOrCreatePerson(WS_A1, {
-      email: "other@x.io",
-      billingCustomerId: "cus_1",
-      contact: { telephone: "+15550000003" },
-    });
-    expect(contactCalls()).toHaveLength(0);
-    expect(people()[0]!["telephone"]).toBeNull();
-  });
-
-  it("a double whose matched row carries no contact keys triggers no contact write", async () => {
-    seedPerson({ email: "d@x.io" });
-    store.person["findFirst"]!.mockResolvedValueOnce({
-      id: people()[0]!["id"],
-      name: null,
-      userId: null,
-      billingCustomerId: null,
-    });
-    await findOrCreatePerson(WS_A1, { email: "d@x.io", contact: { telephone: "+15550000004" } });
-    expect(contactCalls()).toHaveLength(0);
-  });
-
-  describe("only an uncurated Person is filled (SEC-8435-A)", () => {
-    it("a Person linked to a user is not filled", async () => {
-      seedPerson({ email: "u@x.io", userId: "user_00000000-0000-7000-8000-0000000000e1" });
-      await findOrCreatePerson(WS_A1, { email: "u@x.io", contact: { telephone: "+15550000005" } });
-      expect(people()[0]!["telephone"]).toBeNull();
-      expect(contactCalls()).toHaveLength(0);
-    });
-
-    it("a Person a human saved is not filled — a field they cleared is not refilled", async () => {
-      seedPerson({ email: "h@x.io", contactConfirmedAt: new Date(), contactConfirmedBy: "client" });
-      await findOrCreatePerson(WS_A1, { email: "h@x.io", contact: { telephone: "+15550000006" } });
-      expect(people()[0]!["telephone"]).toBeNull();
-      expect(contactCalls()).toHaveLength(0);
-    });
-
-    it("an uncurated Person is filled", async () => {
-      seedPerson({ email: "free@x.io" });
-      await findOrCreatePerson(WS_A1, { email: "free@x.io", contact: { telephone: "+15550000007" } });
-      expect(people()[0]!["telephone"]).toBe("+15550000007");
-    });
-
-    it("a link that lands between the match read and the fill wins: the guarded write matches nothing", async () => {
-      seedPerson({ email: "race@x.io" });
-      const read = store.person["findFirst"]!.getMockImplementation()!;
-      store.person["findFirst"]!.mockImplementationOnce(async (args: unknown) => {
-        const row = await read(args);
-        people()[0]!["userId"] = "user_00000000-0000-7000-8000-0000000000e2";
-        return row;
-      });
-      await findOrCreatePerson(WS_A1, { email: "race@x.io", contact: { telephone: "+15550000008" } });
-      expect(people()[0]!["telephone"]).toBeNull();
-    });
-  });
-
-  it("a failing fill never changes the capture's outcome", async () => {
-    seedPerson({ email: "fail@x.io" });
-    store.person["updateMany"]!.mockRejectedValueOnce(new Error("down"));
-    const result = await findOrCreatePerson(WS_A1, {
-      email: "fail@x.io",
-      contact: { telephone: "+15550000009" },
-    });
-    expect(result.ok && result.value.created).toBe(false);
-  });
-});
-
-describe("the contact normalizers (#8435 D3, AC-2)", () => {
-  it.each([
-    ["+1 (415) 555-0123", "+14155550123"],
-    ["+44 20 7123 4567", "+442071234567"],
-    ["+1.415.555.0123", "+14155550123"],
-    ["415-555-0123", null],
-    ["+0 123", null],
-    ["+1234567890123456", null],
-    ["", null],
-    [4155550123, null],
-    [null, null],
-  ])("normalizeTelephone(%p) → %p", (raw, expected) => {
-    expect(normalizeTelephone(raw)).toBe(expected);
-  });
-
-  it("strips bidi, zero-width, separator and control characters from a given name", () => {
-    expect(normalizeCapturedContact({ givenName: "A‮d​a
\u0007" }).givenName).toBe("Ada");
-  });
-
-  it("cuts a 300-character company to 200 code points", () => {
-    const company = normalizeCapturedContact({ company: "c".repeat(300) }).companyName;
-    expect(Array.from(company ?? "")).toHaveLength(200);
-  });
-
-  it("stores a short region upper-cased, a full region as typed, and drops an address missing a part whole", () => {
-    const base = { addressLine1: "1 Main", city: "Albany", postalCode: "12207", country: "US" };
-    expect(normalizeCapturedContact({ address: { ...base, region: "ny" } }).address?.region).toBe("NY");
-    expect(normalizeCapturedContact({ address: { ...base, region: "New York" } }).address?.region).toBe(
-      "New York",
-    );
-    expect(normalizeCapturedContact({ address: { ...base, region: "NY", postalCode: undefined } }).address).toBeUndefined();
-    expect(normalizeCapturedContact({ address: { ...base, region: "NY", country: "us" } }).address).toBeUndefined();
-  });
-
-  it("drops a non-string value and an empty-after-cleaning one", () => {
-    expect(
-      normalizeCapturedContact({ givenName: 12, familyName: "​  ", company: {}, jobTitle: null, phone: "555" }),
-    ).toEqual({});
-  });
-
-  describe("the capture normalizer and the wire's edit schema agree on one table", () => {
-    // (field, raw) — within its width, so a capture would keep every character.
-    const TABLE: Array<[string, string]> = [
-      ["givenName", "Ada"],
-      ["givenName", "  Ada  "],
-      ["givenName", "A‮d​a
\u0007"],
-      ["givenName", "\u{1D56B}".repeat(100)],
-      ["givenName", "​  "],
-      ["familyName", "Lovelace"],
-      ["companyName", "c".repeat(200)],
-      ["jobTitle", "Founder"],
-      ["telephone", "+1 (415) 555-0123"],
-      ["telephone", "415-555-0123"],
-      ["telephone", "+1 415 555 0123"],
-    ];
-    const CAPTURE_KEY: Record<string, string> = {
-      givenName: "givenName",
-      familyName: "familyName",
-      companyName: "company",
-      jobTitle: "jobTitle",
-      telephone: "phone",
-    };
-
-    it.each(TABLE)("%s %j", (field, raw) => {
-      const captured = normalizeCapturedContact({ [CAPTURE_KEY[field]!]: raw }) as Record<string, unknown>;
-      const parsed = personContactPatchSchema.safeParse({ [field]: raw });
-      if (parsed.success) {
-        expect(captured[field]).toBe((parsed.data as Record<string, unknown>)[field]);
-      } else {
-        expect(captured[field]).toBeUndefined();
-      }
-    });
-
-    it("an address and its short region agree", () => {
-      const address = { addressLine1: "1 Main", city: "Albany", region: "ny", postalCode: "12207", country: "US" };
-      const captured = normalizeCapturedContact({ address }).address;
-      const parsed = personContactPatchSchema.parse({ address }).address;
-      expect(captured).toEqual(parsed);
-    });
-  });
-});
-
-describe("the two human edits of the contact (#8435 D9, D11)", () => {
-  const U = "user_00000000-0000-7000-8000-0000000000f1";
-  const users = () => (store.__db["user"] ??= []);
-
-  it("updatePersonContact writes only the keys present, stamps the operator and serves the saved contact", async () => {
-    const p = seedPerson({ email: "o@x.io", companyName: "Keep" });
-    const outcome = await updatePersonContact(WS_A1, p["id"] as string, {
-      telephone: "+14155550123",
-      address: ADDRESS,
-    });
-    expect(outcome.kind).toBe("saved");
-    expect(people()[0]).toEqual(
-      expect.objectContaining({
-        telephone: "+14155550123",
-        companyName: "Keep",
-        contactConfirmedBy: "operator",
-        ...ADDRESS_COLUMNS,
-      }),
-    );
-    expect(people()[0]!["contactConfirmedAt"]).toBeInstanceOf(Date);
-    if (outcome.kind !== "saved") return;
-    expect(outcome.value.confirmed?.by).toBe("operator");
-    expect(outcome.value.contact.address).toEqual(ADDRESS);
-    expect(outcome.value.contact.companyName).toBe("Keep");
-  });
-
-  it("an address of null clears all six parts", async () => {
-    const p = seedPerson({ email: "o@x.io", ...ADDRESS_COLUMNS });
-    await updatePersonContact(WS_A1, p["id"] as string, { address: null });
-    expect(people()[0]).toEqual(
-      expect.objectContaining({ addressLine1: null, addressCity: null, addressCountry: null }),
-    );
-  });
-
-  it("another workspace's Person, and an absent one, are not_found and unchanged", async () => {
-    const p = seedPerson({ workspaceId: WS_A2, email: "o@x.io" });
-    expect((await updatePersonContact(WS_A1, p["id"] as string, { jobTitle: "x" })).kind).toBe("not_found");
-    expect((await updatePersonContact(WS_A1, "person_nope", { jobTitle: "x" })).kind).toBe("not_found");
-    expect(people()[0]!["jobTitle"]).toBeNull();
-  });
-
-  it("a store error is internal_error, never a throw", async () => {
-    store.person["updateMany"]!.mockRejectedValueOnce(new Error("down"));
-    expect((await updatePersonContact(WS_A1, "person_x", { jobTitle: "x" })).kind).toBe("internal_error");
-  });
-
-  it("setOwnPersonContact replaces all six keys on the caller's own Person only", async () => {
-    const mine = seedPerson({ email: "me@x.io", userId: U, companyName: "Capture-filled", jobTitle: "Boss" });
-    const other = seedPerson({ email: "other@x.io", userId: "user_00000000-0000-7000-8000-0000000000f2" });
-    const outcome = await setOwnPersonContact(WS_A1, mine["id"] as string, U, {
-      givenName: "Me",
-      familyName: null,
-      telephone: "+14155550123",
-      address: null,
-      companyName: null,
-      jobTitle: null,
-    });
-    expect(outcome.kind).toBe("saved");
-    expect(people()[0]).toEqual(
-      expect.objectContaining({
-        givenName: "Me",
-        companyName: null,
-        jobTitle: null,
-        contactConfirmedBy: "client",
-      }),
-    );
-    expect(people()[1]).toBe(other);
-    expect(people()[1]!["givenName"]).toBeNull();
-  });
-
-  it("setOwnPersonContact is not_found for a Person linked to someone else, or of another workspace", async () => {
-    const linkedElsewhere = seedPerson({ email: "a@x.io", userId: "user_00000000-0000-7000-8000-0000000000f3" });
-    const otherWorkspace = seedPerson({ workspaceId: WS_A2, email: "me@x.io", userId: U });
-    const body = { givenName: "X", familyName: null, telephone: null, address: null, companyName: null, jobTitle: null };
-    expect((await setOwnPersonContact(WS_A1, linkedElsewhere["id"] as string, U, body)).kind).toBe("not_found");
-    expect((await setOwnPersonContact(WS_A1, otherWorkspace["id"] as string, U, body)).kind).toBe("not_found");
-    expect(people().map((p) => p["givenName"])).toEqual([null, null]);
-  });
-
-  it("ensureMemberPerson creates the verified email's Person and links it", async () => {
-    users().push({ id: U, email: "  Me@X.io ", emailVerified: true });
-    const result = await ensureMemberPerson(WS_A1, U);
-    expect(result.ok).toBe(true);
-    expect(people()).toHaveLength(1);
-    expect(people()[0]).toEqual(expect.objectContaining({ email: "me@x.io", userId: U }));
-  });
-
-  it("ensureMemberPerson finds the existing Person of that email and links it", async () => {
-    const p = seedPerson({ email: "me@x.io" });
-    users().push({ id: U, email: "me@x.io", emailVerified: true });
-    const result = await ensureMemberPerson(WS_A1, U);
-    expect(result).toEqual({ ok: true, personId: p["id"] });
-    expect(people()).toHaveLength(1);
-    expect(people()[0]!["userId"]).toBe(U);
-  });
-
-  it("ensureMemberPerson is unavailable for an unverified caller and for a Person linked to another user", async () => {
-    users().push({ id: U, email: "me@x.io", emailVerified: false });
-    expect(await ensureMemberPerson(WS_A1, U)).toEqual({ ok: false });
-    users()[0]!["emailVerified"] = true;
-    seedPerson({ email: "me@x.io", userId: "user_00000000-0000-7000-8000-0000000000f4" });
-    expect(await ensureMemberPerson(WS_A1, U)).toEqual({ ok: false });
-    expect(people()[0]!["userId"]).toBe("user_00000000-0000-7000-8000-0000000000f4");
-  });
-
-  it("personContactFromRow serves a whole address or none, and every key even from a sparse row", () => {
-    expect(personContactFromRow({ ...(seedPerson({ email: "r@x.io", ...ADDRESS_COLUMNS }) as never) }).address).toEqual(ADDRESS);
-    expect(personContactFromRow({} as never)).toEqual({
-      givenName: null,
-      familyName: null,
-      telephone: null,
-      address: null,
-      companyName: null,
-      jobTitle: null,
-    });
-    expect(contactConfirmedFromRow({ contactConfirmedAt: null, contactConfirmedBy: null })).toBeNull();
-    expect(
-      contactConfirmedFromRow({ contactConfirmedAt: new Date("2026-10-12T00:00:00.000Z"), contactConfirmedBy: "client" }),
-    ).toEqual({ by: "client", at: "2026-10-12T00:00:00.000Z" });
-  });
-});
-
-describe("setPersonPlanOffering (#7877 D8, AC-4, AC-5)", () => {
-  it("sets and clears the plan, scoped to the workspace", async () => {
-    const p = seedPerson({ email: "cleo@x.io" });
-    expect(await setPersonPlanOffering(WS_A1, p["id"] as string, "retainer")).toBe("set");
-    expect(people()[0]!["planOffering"]).toBe("retainer");
-    expect(await setPersonPlanOffering(WS_A1, p["id"] as string, null)).toBe("set");
-    expect(people()[0]!["planOffering"]).toBeNull();
-  });
-
-  it("another workspace's Person is not_found and unchanged", async () => {
-    const p = seedPerson({ workspaceId: WS_A2, email: "cleo@x.io" });
-    expect(await setPersonPlanOffering(WS_A1, p["id"] as string, "retainer")).toBe("not_found");
-    expect(people()[0]!["planOffering"]).toBeNull();
-  });
-
-  it("a store error is internal_error, never a throw", async () => {
-    store.person["updateMany"]!.mockRejectedValueOnce(new Error("down"));
-    expect(await setPersonPlanOffering(WS_A1, "person_x", "retainer")).toBe("internal_error");
-  });
-});
-
-// ─── The held checkout plan (#8793) ──────────────────────────────────────────
-
-const leads = () => (store.__db["lead"] ??= []);
-const leadCalls = () => store.__calls.filter((c) => c.model === "lead");
-
-/** A spoke checkout lead on a Person, newest last unless `createdAt` says otherwise. */
-function seedMarkedLead(personId: string, row: Row = {}): Row {
-  const full: Row = {
-    id: `lead_00000000-0000-7000-8000-${String(leads().length + 700).padStart(12, "0")}`,
-    workspaceId: WS_A1,
-    personId,
-    email: "Ada@Example.com",
-    source: "web",
-    spokeCheckout: true,
-    payload: { site: "wendi", page: "checkout", offering: "wendi_retainer" },
-    createdAt: new Date(Date.UTC(2026, 1, 1 + leads().length)),
-    ...row,
-  };
-  leads().push(full);
-  return full;
-}
-
-describe("checkoutPlanKey (#8793 D4)", () => {
-  it("strips a leading <site>_ and answers a plan key, else null", () => {
-    expect(checkoutPlanKey("wendi_retainer", "wendi")).toBe("retainer");
-    expect(checkoutPlanKey("retainer", "wendi")).toBe("retainer");
-    expect(checkoutPlanKey("wendi_Not A Key!", "wendi")).toBeNull();
-    expect(checkoutPlanKey(42, "wendi")).toBeNull();
-  });
-});
-
-describe("setPersonPlanOffering's link guard (#8793 D5, AC-1, AC-6)", () => {
-  const U = "user_00000000-0000-7000-8000-000000000031";
-  const V = "user_00000000-0000-7000-8000-000000000032";
-
-  it("a guarded write never overwrites a set plan", async () => {
-    const p = seedPerson({ email: "ada@example.com", userId: U, planOffering: "premium" });
-    expect(
-      await setPersonPlanOffering(WS_A1, p["id"] as string, "x", { linkedUserId: U }),
-    ).toBe("not_found");
-    expect(people()[0]!["planOffering"]).toBe("premium");
-  });
-
-  it("a guarded write never reaches a Person linked to another user", async () => {
-    const p = seedPerson({ email: "ada@example.com", userId: U });
-    expect(
-      await setPersonPlanOffering(WS_A1, p["id"] as string, "x", { linkedUserId: V }),
-    ).toBe("not_found");
-    expect(people()[0]!["planOffering"]).toBeNull();
-  });
-
-  it("the operator's three-argument write still overwrites a set plan", async () => {
-    const p = seedPerson({ email: "ada@example.com", userId: U, planOffering: "premium" });
-    expect(await setPersonPlanOffering(WS_A1, p["id"] as string, "basic")).toBe("set");
-    expect(people()[0]!["planOffering"]).toBe("basic");
-  });
-});
-
-describe("releaseHeldCheckoutPlan (#8793 D3, AC-1)", () => {
-  const U = "user_00000000-0000-7000-8000-000000000041";
-  const EMAIL = "ada@example.com";
-  let personId: string;
-
-  const release = () => releaseHeldCheckoutPlan(WS_A1, personId, U, EMAIL);
-  const plan = () => people()[0]!["planOffering"];
-
-  beforeEach(() => {
-    personId = seedPerson({ email: EMAIL, userId: U })["id"] as string;
-  });
-
-  it("one marked lead sets its key", async () => {
-    seedMarkedLead(personId);
-    expect(await release()).toBe("set");
-    expect(plan()).toBe("retainer");
-  });
-
-  it("two marked leads naming one key, with and without the site prefix, set it", async () => {
-    seedMarkedLead(personId);
-    seedMarkedLead(personId, {
-      payload: { site: "wendi", page: "checkout", offering: "retainer" },
-    });
-    expect(await release()).toBe("set");
-    expect(plan()).toBe("retainer");
-  });
-
-  it.each([
-    ["the basic purchase is newer", 1, 2],
-    ["the retainer purchase is newer", 2, 1],
-  ])("two marked leads naming different keys are ambiguous whatever their order (%s)", async (_label, retainerDay, basicDay) => {
-    seedMarkedLead(personId, { createdAt: new Date(Date.UTC(2026, 2, retainerDay)) });
-    seedMarkedLead(personId, {
-      createdAt: new Date(Date.UTC(2026, 2, basicDay)),
-      payload: { site: "wendi", page: "checkout", offering: "wendi_basic" },
-    });
-    expect(await release()).toBe("ambiguous");
-    expect(plan()).toBeNull();
-  });
-
-  it("a marked lead under another email is ignored", async () => {
-    seedMarkedLead(personId);
-    seedMarkedLead(personId, {
-      email: "other@example.com",
-      payload: { site: "wendi", page: "checkout", offering: "wendi_basic" },
-    });
-    expect(await release()).toBe("set");
-    expect(plan()).toBe("retainer");
-  });
-
-  it("only unmarked leads are none", async () => {
-    seedMarkedLead(personId, { spokeCheckout: false });
-    expect(await release()).toBe("none");
-    expect(plan()).toBeNull();
-  });
-
-  it("only an offering that is no plan key is none", async () => {
-    seedMarkedLead(personId, {
-      payload: { site: "wendi", page: "checkout", offering: "wendi_Not A Key!" },
-    });
-    expect(await release()).toBe("none");
-    expect(plan()).toBeNull();
-  });
-
-  it("51 marked leads are ambiguous, even when they all agree", async () => {
-    for (let i = 0; i < 51; i += 1) seedMarkedLead(personId);
-    expect(await release()).toBe("ambiguous");
-    expect(plan()).toBeNull();
-  });
-
-  it("a plan already set is kept", async () => {
-    people()[0]!["planOffering"] = "premium";
-    seedMarkedLead(personId);
-    expect(await release()).toBe("kept");
-    expect(plan()).toBe("premium");
-  });
-
-  it("a failed lead read is internal_error, with no write", async () => {
-    seedMarkedLead(personId);
-    store.lead["findMany"]!.mockRejectedValueOnce(new Error("down"));
-    expect(await release()).toBe("internal_error");
-    expect(personCalls().filter((c) => c.op === "updateMany")).toHaveLength(0);
-    expect(plan()).toBeNull();
-  });
-});
-
-describe("resolveMemberPersonId releases a held plan on a fresh link only (#8793 D2, AC-2)", () => {
-  const users = () => (store.__db["user"] ??= []);
-  const U = "user_00000000-0000-7000-8000-000000000051";
-  const EMAIL = "ada@example.com";
-  const log = { warn: jest.fn() };
-  let personId: string;
-
-  const plan = () => people()[0]!["planOffering"];
-  const releaseLines = () =>
-    log.warn.mock.calls
-      .map(([fields]) => fields as Record<string, unknown>)
-      .filter((fields) => fields["event"] === "checkout-plan-release");
-
-  beforeEach(() => {
-    log.warn.mockClear();
-    personId = seedPerson({ email: EMAIL })["id"] as string;
-    seedMarkedLead(personId);
-  });
-
-  it("a verified caller's first link releases the held plan, logging nothing", async () => {
-    users().push({ id: U, email: EMAIL, emailVerified: true });
-    expect(await resolveMemberPersonId(WS_A1, U, EMAIL, log)).toBe(personId);
-    expect(people()[0]!["userId"]).toBe(U);
-    expect(plan()).toBe("retainer");
-    expect(releaseLines()).toEqual([]);
-  });
-
-  it("an unverified caller links nothing and releases nothing", async () => {
-    users().push({ id: U, email: EMAIL, emailVerified: false });
-    expect(await resolveMemberPersonId(WS_A1, U, EMAIL, log)).toBeNull();
-    expect(plan()).toBeNull();
-  });
-
-  it("a Person linked before the call is answered with no release and no lead read", async () => {
-    people()[0]!["userId"] = U;
-    expect(await resolveMemberPersonId(WS_A1, U, EMAIL, log)).toBe(personId);
-    expect(plan()).toBeNull();
-    expect(leadCalls()).toHaveLength(0);
-  });
-
-  it("a direct stamp (the inbox accept's and the consents route's path) releases nothing", async () => {
-    users().push({ id: U, email: EMAIL, emailVerified: true });
-    expect(await stampPersonUser(WS_A1, personId, U)).toBe("stamped");
-    expect(plan()).toBeNull();
-    expect(leadCalls()).toHaveLength(0);
-  });
-
-  it("a failed release still answers the Person and logs its kind only", async () => {
-    users().push({ id: U, email: EMAIL, emailVerified: true });
-    store.lead["findMany"]!.mockRejectedValueOnce(new Error("down"));
-    expect(await resolveMemberPersonId(WS_A1, U, EMAIL, log)).toBe(personId);
-    expect(plan()).toBeNull();
-    expect(releaseLines()).toEqual([
-      { event: "checkout-plan-release", outcome: "internal_error" },
-    ]);
-    const logged = JSON.stringify(log.warn.mock.calls);
-    expect(logged).not.toContain(EMAIL);
-    expect(logged).not.toContain("retainer");
-  });
-
-  it("disagreeing purchases release nothing and log ambiguous", async () => {
-    users().push({ id: U, email: EMAIL, emailVerified: true });
-    seedMarkedLead(personId, {
-      payload: { site: "wendi", page: "checkout", offering: "wendi_basic" },
-    });
-    expect(await resolveMemberPersonId(WS_A1, U, EMAIL, log)).toBe(personId);
-    expect(plan()).toBeNull();
-    expect(releaseLines()).toEqual([
-      { event: "checkout-plan-release", outcome: "ambiguous" },
-    ]);
-  });
-
-  it("a release that finds nothing to set logs nothing", async () => {
-    leads().length = 0;
-    users().push({ id: U, email: EMAIL, emailVerified: true });
-    expect(await resolveMemberPersonId(WS_A1, U, EMAIL, log)).toBe(personId);
-    expect(plan()).toBeNull();
-    expect(log.warn).not.toHaveBeenCalled();
-  });
-});