create-ailk 0.19.0 → 0.20.0

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

@@ -33,15 +33,24 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { prisma } from "../../lib/prisma.js";
+import { personContactPatchSchema } from "@working-theory/validation";
+
 import {
+  contactConfirmedFromRow,
+  ensureMemberPerson,
   findOrCreatePerson,
   isStorablePersonEmail,
+  normalizeCapturedContact,
   normalizePersonEmail,
+  normalizeTelephone,
+  personContactFromRow,
   recordCheckoutPerson,
   resolveCallerBillingCustomerId,
   resolveMemberPersonId,
+  setOwnPersonContact,
   setPersonPlanOffering,
   stampPersonUser,
+  updatePersonContact,
 } from "../person";
 
 type Row = Record<string, unknown>;
@@ -77,6 +86,20 @@ function seedPerson(row: Row): Row {
     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,
@@ -531,6 +554,375 @@ describe("resolveCallerBillingCustomerId (#7961, spec 7894 D13, AC-8)", () => {
   });
 });
 
+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" });

package/templates/apps/api/src/services/__tests__/request-confirm.test.ts

@@ -23,6 +23,7 @@ jest.mock("../../lib/prisma.js");
 
 import { prisma } from "../../lib/prisma.js";
 import { routeLead } from "../lead-routing.js";
+import * as personService from "../person.js";
 import {
   CONFIRM_TOKEN_TTL_MS,
   claimConfirmation,
@@ -218,6 +219,92 @@ describe("recordPaymentLink()", () => {
       data: { stripePaymentLinkId: "plink_abc" },
     });
   });
+
+  // ── #8435 D5 (AC-3) — the Person step, after the Payment Link exists ────
+  describe("links the confirmed callback to its Person", () => {
+    const WORKSPACE = "wksp_00000000-0000-7000-8000-0000000084e5";
+    const PERSON = "person_00000000-0000-7000-8000-0000000084e5";
+    const LINKED = {
+      ok: true as const,
+      value: { personId: PERSON as never, created: true, billing: "unchanged" as const },
+    };
+    const row = (overrides: Record<string, unknown> = {}) => ({
+      workspaceId: WORKSPACE,
+      buyerEmail: "Buyer@Example.com",
+      name: "Bea",
+      phone: "+1 415 555 0123",
+      personId: null,
+      ...overrides,
+    });
+    let find: jest.SpyInstance;
+
+    beforeEach(() => {
+      find = jest.spyOn(personService, "findOrCreatePerson").mockResolvedValue(LINKED);
+    });
+    afterEach(() => find.mockRestore());
+
+    it("writes the link id first, then finds the buyer email's Person in the row's own workspace and stamps it once, guarded on personId: null", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockResolvedValue(row());
+      await recordPaymentLink(CALLBACK_ID, "plink_abc");
+
+      expect(find).toHaveBeenCalledTimes(1);
+      expect(find).toHaveBeenCalledWith(WORKSPACE, {
+        email: "Buyer@Example.com",
+        name: "Bea",
+        contact: { telephone: "+14155550123" },
+      });
+      expect(prisma.callback.updateMany).toHaveBeenCalledTimes(1);
+      expect(prisma.callback.updateMany).toHaveBeenCalledWith({
+        where: { id: CALLBACK_ID, workspaceId: WORKSPACE, personId: null },
+        data: { personId: PERSON },
+      });
+      const order = (fn: jest.Mock) => fn.mock.invocationCallOrder[0]!;
+      expect(order(prisma.callback.update as jest.Mock)).toBeLessThan(order(prisma.callback.findFirst as jest.Mock));
+    });
+
+    it("makes no Person call for a callback a capture already linked", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockResolvedValue(row({ personId: PERSON }));
+      await recordPaymentLink(CALLBACK_ID, "plink_abc");
+      expect(find).not.toHaveBeenCalled();
+      expect(prisma.callback.updateMany).not.toHaveBeenCalled();
+    });
+
+    it("makes no Person call for a row with no buyer email", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockResolvedValue(row({ buyerEmail: null }));
+      await recordPaymentLink(CALLBACK_ID, "plink_abc");
+      expect(find).not.toHaveBeenCalled();
+    });
+
+    it("a Person step that throws still leaves the link id written and recordPaymentLink resolving", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockResolvedValue(row());
+      find.mockRejectedValue(new Error("down"));
+      await expect(recordPaymentLink(CALLBACK_ID, "plink_abc")).resolves.toBeUndefined();
+      expect(prisma.callback.update).toHaveBeenCalledWith({
+        where: { id: CALLBACK_ID },
+        data: { stripePaymentLinkId: "plink_abc" },
+      });
+      expect(prisma.callback.updateMany).not.toHaveBeenCalled();
+    });
+
+    it("a read that throws is swallowed the same way", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockRejectedValue(new Error("down"));
+      await expect(recordPaymentLink(CALLBACK_ID, "plink_abc")).resolves.toBeUndefined();
+    });
+
+    it("claimConfirmation makes no person delegate call at all — the token is spent before any Person work", async () => {
+      (prisma.callback.findFirst as jest.Mock).mockResolvedValue(row());
+      await claimConfirmation({
+        id: CALLBACK_ID,
+        token: "a-token",
+        confirmedTime: "Friday 3pm",
+        buyerEmail: "buyer@example.com",
+      });
+      expect(find).not.toHaveBeenCalled();
+      expect(jest.mocked(prisma.person.findFirst)).not.toHaveBeenCalled();
+      expect(jest.mocked(prisma.person.createMany)).not.toHaveBeenCalled();
+      expect(jest.mocked(prisma.person.updateMany)).not.toHaveBeenCalled();
+    });
+  });
 });
 
 // ── Configuration ──────────────────────────────────────────────────────────

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

@@ -12,6 +12,12 @@
  * The server binds 127.0.0.1, which `ssrfBlocked` rejects; D7's
  * `allowPrivate: true` is what makes this substrate runnable at all.
  *
+ * The backoff schedule is asserted through the injected `sleep` seam, never
+ * against wall-clock: the delays a case observes are the ones the service asked
+ * for, so a loaded runner cannot stretch or shrink them (#7904, #8418). And the
+ * server answers every request `connection: close`, so no attempt can land on
+ * a pooled socket the server has already dropped (#8418).
+ *
  * `CONTENT_REVALIDATE_*` are read through `config`, which snapshots
  * `process.env` at import time — so every case sets env first and then
  * `require`s the service through `jest.resetModules()`.
@@ -73,7 +79,6 @@ interface Recorded {
   eventHeader: string;
   timestampHeader: string;
   contentType: string;
-  receivedAt: number;
 }
 
 let server: Server;
@@ -81,6 +86,10 @@ let serverUrl: string;
 let recorded: Recorded[] = [];
 /** Status codes the server replies with, one per request, in order. */
 let responseStatuses: number[] = [];
+/** Every backoff the service asked to sleep for, in order. */
+let sleeps: number[] = [];
+/** The injected sleep seam: records the backoff and resolves at once. */
+const sleep = async (ms: number): Promise<void> => void sleeps.push(ms);
 
 beforeAll(async () => {
   server = createServer((req, res) => {
@@ -123,10 +132,16 @@ beforeAll(async () => {
         eventHeader,
         timestampHeader,
         contentType: String(req.headers["content-type"] ?? ""),
-        receivedAt: Date.now(),
       });
 
-      res.writeHead(responseStatuses[recorded.length - 1] ?? 200);
+      // `connection: close` — one TCP connection per request. With keep-alive,
+      // fetch reuses a pooled socket, and when the server's idle timeout drops
+      // that socket as the next request goes out, the attempt fails on the
+      // client (UND_ERR_SOCKET) and never reaches this handler: the lost
+      // attempt behind #8418's flake on the #8417 release PR.
+      res.writeHead(responseStatuses[recorded.length - 1] ?? 200, {
+        connection: "close",
+      });
       res.end();
     });
   });
@@ -151,7 +166,14 @@ beforeEach(() => {
   process.env.CONTENT_REVALIDATE_SECRET = TEST_SECRET;
   recorded = [];
   responseStatuses = [];
+  sleeps = [];
   mockLogLines.length = 0;
+  // Drop any connection a previous case left idle — the server-side
+  // keep-alive close that ate attempt 1 on the CI shard, made to happen at the
+  // start of every case. Under `connection: close` there is never one to drop;
+  // without the header, the next case's first attempt lands on the dropped
+  // socket and a counting case below fails on every run, not 1-in-N on CI.
+  server.closeIdleConnections();
 });
 
 afterEach(() => {
@@ -193,35 +215,35 @@ describe("notifyRevalidate", () => {
   it("retries a 5xx with D3 backoff and succeeds on the third attempt", async () => {
     responseStatuses = [500, 500, 200];
 
-    await loadService().notifyRevalidate(TARGET, { event: "unpublish" });
+    await loadService().notifyRevalidate(TARGET, {
+      event: "unpublish",
+      sleep,
+    });
 
     expect(recorded).toHaveLength(3);
-    // D3 — 500 ms before attempt 2, 2000 ms before attempt 3. Bounded on BOTH
-    // sides: a lower bound alone would pass an arbitrarily long backoff, and
-    // the whole point of D3's schedule is that it fits the 60 s publish budget.
-    // The upper slack absorbs loopback scheduling jitter, nothing more.
-    const gapA = recorded[1].receivedAt - recorded[0].receivedAt;
-    const gapB = recorded[2].receivedAt - recorded[1].receivedAt;
-    expect(gapA).toBeGreaterThanOrEqual(500);
-    expect(gapA).toBeLessThan(2000);
-    expect(gapB).toBeGreaterThanOrEqual(2000);
-    expect(gapB).toBeLessThan(4000);
+    // D3 — exactly 500 ms before attempt 2 and 2000 ms before attempt 3, the
+    // schedule that fits the 60 s publish budget. Asserted as the delays the
+    // service scheduled, not as measured gaps a loaded runner can stretch
+    // (#7904: a 2122 ms gapA failed the old `< 2000` bound).
+    expect(sleeps).toEqual([500, 2000]);
     expect(recorded.every((r) => r.signatureValid)).toBe(true);
 
     expect(
       mockLogLines.filter((l) => l.msg === "revalidate.sent"),
     ).toHaveLength(1);
     expect(mockLogLines.some((l) => l.level === "error")).toBe(false);
-  }, 20_000);
+  });
 
   it("stops at three attempts, logs the failure at error, and still resolves", async () => {
     responseStatuses = [500, 500, 500];
 
     await expect(
-      loadService().notifyRevalidate(TARGET, { event: "publish" }),
+      loadService().notifyRevalidate(TARGET, { event: "publish", sleep }),
     ).resolves.toBeUndefined();
 
     expect(recorded).toHaveLength(3);
+    // Two backoffs and no third: running out of the schedule IS the bound.
+    expect(sleeps).toEqual([500, 2000]);
 
     const perAttempt = mockLogLines.filter(
       (l) => l.level === "warn" && l.msg === "revalidate.failed",
@@ -238,7 +260,25 @@ describe("notifyRevalidate", () => {
       attempts: 3,
       lastStatus: 500,
     });
-  }, 20_000);
+  });
+
+  it("waits out the backoff on the real timer when no sleep is injected", async () => {
+    responseStatuses = [500, 200];
+    const setTimeoutSpy = jest.spyOn(global, "setTimeout");
+    let delays: unknown[];
+
+    try {
+      await loadService().notifyRevalidate(TARGET, { event: "publish" });
+      delays = setTimeoutSpy.mock.calls.map(([, ms]) => ms);
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    // The production default: the one backoff is a real 500 ms timer. Asserted
+    // as the delay scheduled, never as a measured gap.
+    expect(recorded).toHaveLength(2);
+    expect(delays).toContain(500);
+  });
 
   it("signs v0:{timestamp}:{event}:{body} and sends the timestamp header (#5902)", async () => {
     responseStatuses = [200];