@decocms/apps-vtex 8.1.0-next.0 → 8.1.0-next.2

package/src/README.md

@@ -1,6 +0,0 @@
-VTEX is a cloud-based e-commerce platform and digital commerce company that provides a comprehensive set of tools and services for businesses looking to establish and manage their online retail operations.
-
-This app wrapps VTEX API into a comprehensive set of loaders/actions/workflows
-empowering non technical users to interact and act upon their headless commerce.
-
-If you want to use a custom search engine (Algolia, Typesense etc), you will need to fill the App Key & App Token properties. For these, follow this guide

package/src/__conformance__/upstream.test.ts

@@ -1,158 +0,0 @@
-// @vitest-environment node
-/**
- * Conformance: upstream-clients.mdx (Calling APIs) against the next-major
- * client packages. Only the v8 client modules are checked; the v7 app
- * surfaces that still ship beside them are out of scope until v7 is removed.
- */
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { createAlgoliaClient } from "@decocms/apps-algolia";
-import { createVtexClient } from "@decocms/apps-vtex";
-import { describe, expect, it, vi } from "vitest";
-
-const PACKAGES = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..");
-
-/** The next-major client module of each platform package. */
-const V8_CLIENTS: Record<string, string[]> = {
-  "apps-vtex": ["src/vtexClient.ts"],
-  "apps-shopify": ["src/v8/client.ts", "src/v8/graphqlOperationName.ts"],
-  "apps-wake": ["src/wakeClient.ts"],
-  "apps-magento": ["src/magentoClient.ts"],
-  "apps-algolia": ["src/index.ts"],
-  "apps-resend": ["src/emails.ts"],
-  "apps-sfmc-personalization": ["src/index.ts"],
-};
-
-/** The source without comments, so doc examples (`process.env.X!` in a JSDoc) don't count. */
-function code(pkg: string, file: string): string {
-  return fs
-    .readFileSync(path.join(PACKAGES, pkg, file), "utf8")
-    .replace(/\/\*[\s\S]*?\*\//g, "")
-    .replace(/(^|[^:"'`])\/\/.*$/gm, "$1");
-}
-
-describe("what a client is (upstream-clients.mdx)", () => {
-  it("up-01: VTEX, Shopify, Wake, Magento, Algolia, Resend (and others) ship a client built on createInstrumentedFetch", () => {
-    for (const [pkg, files] of Object.entries(V8_CLIENTS)) {
-      expect(fs.existsSync(path.join(PACKAGES, pkg, "package.json"))).toBe(true);
-      expect([pkg, code(pkg, files[0]!)]).toEqual([
-        pkg,
-        expect.stringMatching(/import \{[^}]*createInstrumentedFetch[^}]*\} from "@decocms\/blocks\/fetch"/),
-      ]);
-    }
-  });
-
-  it("up-02: clients take settings as arguments: no environment reads inside a client", () => {
-    for (const [pkg, files] of Object.entries(V8_CLIENTS)) {
-      for (const file of files) {
-        expect([pkg, file, /process\.env|import\.meta\.env|Deno\.env/.test(code(pkg, file))]).toEqual(
-          [pkg, file, false],
-        );
-      }
-    }
-  });
-
-  it("up-03: no React hooks, client components or shared-commerce converters in a client", () => {
-    for (const [pkg, files] of Object.entries(V8_CLIENTS)) {
-      for (const file of files) {
-        const text = code(pkg, file);
-        const found = [
-          /["']use client["']/,
-          /from ["']react["']/,
-          /\buse(Cart|User|Wishlist)\b/,
-          /@decocms\/apps-commerce/,
-          /from ["']\.\/(loaders|actions|hooks)\//,
-        ].filter((pattern) => pattern.test(text));
-        expect([pkg, file, found]).toEqual([pkg, file, []]);
-      }
-    }
-  });
-
-  it("up-05: the Salesforce client is @decocms/apps-sfmc-personalization; @decocms/apps-salesforce is gone", () => {
-    const pkg = JSON.parse(
-      fs.readFileSync(path.join(PACKAGES, "apps-sfmc-personalization/package.json"), "utf8"),
-    );
-    expect(pkg.name).toBe("@decocms/apps-sfmc-personalization");
-    const names = fs
-      .readdirSync(PACKAGES)
-      .filter((dir) => fs.existsSync(path.join(PACKAGES, dir, "package.json")))
-      .map((dir) => JSON.parse(fs.readFileSync(path.join(PACKAGES, dir, "package.json"), "utf8")).name);
-    expect(names).not.toContain("@decocms/apps-salesforce");
-  });
-
-  it("up-07: clients don't cache upstream responses", () => {
-    for (const [pkg, files] of Object.entries(V8_CLIENTS)) {
-      for (const file of files) {
-        expect([
-          pkg,
-          file,
-          /createFetchCache|fetchWithCache|fetchCache|caches\.default|caches\.open|cachedLoader/.test(
-            code(pkg, file),
-          ),
-        ]).toEqual([pkg, file, false]);
-      }
-    }
-  });
-});
-
-describe("call a client (upstream-clients.mdx)", () => {
-  it("up-06: createVtexClient({ account, appKey, appToken }) and vtex.search.products({ query, count })", async () => {
-    const fetch = vi.fn(
-      async (_input: string | URL | Request, _init?: RequestInit) =>
-        new Response(JSON.stringify({ products: [] }), { status: 200 }),
-    );
-    const vtex = createVtexClient({
-      account: "mystore",
-      appKey: "key",
-      appToken: "token",
-      fetch: fetch as unknown as typeof globalThis.fetch,
-    });
-    const products = await vtex.search.products({ query: "linen shirt", count: 12 });
-    expect(products).toEqual({ products: [] });
-    const url = new URL(String(fetch.mock.calls[0]![0]));
-    expect(url.host).toBe("mystore.vtexcommercestable.com.br");
-    expect(url.pathname).toContain("product_search");
-    expect(url.searchParams.get("query")).toBe("linen shirt");
-    expect(url.searchParams.get("count")).toBe("12");
-  });
-});
-
-describe("retries and failures (upstream-clients.mdx)", () => {
-  it("up-08: the VTEX client retries by default", async () => {
-    const statuses = [503, 200];
-    const fetch = vi.fn(
-      async () => new Response("{}", { status: statuses.shift() ?? 200 }),
-    );
-    const vtex = createVtexClient({
-      account: "mystore",
-      fetch: fetch as unknown as typeof globalThis.fetch,
-    });
-    await vtex.search.products({ query: "shirt" });
-    expect(fetch).toHaveBeenCalledTimes(2);
-  });
-
-  it("up-08: the VTEX client's circuit breaker fails fast after repeated failures", async () => {
-    const fetch = vi.fn(async () => new Response("{}", { status: 503 }));
-    const vtex = createVtexClient({
-      account: "mystore",
-      fetch: fetch as unknown as typeof globalThis.fetch,
-    });
-    for (let i = 0; i < 5; i++) await expect(vtex.search.products({ query: "shirt" })).rejects.toThrow();
-    const before = fetch.mock.calls.length;
-    await expect(vtex.search.products({ query: "shirt" })).rejects.toThrow();
-    expect(fetch.mock.calls.length).toBe(before);
-  }, 20_000);
-
-  it("up-08: other clients leave retries off (one attempt on a 503)", async () => {
-    const fetch = vi.fn(async () => new Response("{}", { status: 503 }));
-    const algolia = createAlgoliaClient(
-      { applicationId: "APP123", apiKey: "k" },
-      { fetch: fetch as unknown as typeof globalThis.fetch },
-    );
-    await expect(algolia.search([{ indexName: "products", query: "shirt" }] as never)).rejects.toThrow(
-      "algolia search failed with HTTP 503",
-    );
-    expect(fetch).toHaveBeenCalledTimes(1);
-  });
-});

package/src/__tests__/client-segment-cookie.test.ts

@@ -1,255 +0,0 @@
-/**
- * Regression tests for the auto-forwarding of `vtex_segment` on outgoing
- * VTEX API calls. Without this, Legacy Catalog endpoints don't see the
- * region cookie and return OutOfStock for products only available
- * through regional sellers — see vtex/client.ts:vtexFetchResponse.
- */
-
-import { RequestContext } from "@decocms/blocks/sdk/requestContext";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-	configureVtex,
-	intelligentSearch,
-	setVtexFetch,
-	vtexCachedFetch,
-	vtexFetchResponse,
-} from "../client";
-import { clearFetchCache } from "../utils/fetchCache";
-
-function mockResponse(body: unknown = {}, status = 200): Response {
-	return {
-		ok: status >= 200 && status < 300,
-		status,
-		statusText: status === 200 ? "OK" : "Error",
-		json: () => Promise.resolve(body),
-	} as Response;
-}
-
-/**
- * Run `fn` inside a fake request context with the given cookie header.
- *
- * Two problems prevented a naive `RequestContext.run(new Request(...))`
- * approach from working:
- *
- *  1. Under the Fetch spec a Request's headers are in the "request"
- *     guard mode, which silently drops forbidden request headers —
- *     including `cookie` — at construction time. Node 22 / undici
- *     enforces this strictly, so the cookie never reaches
- *     `request.headers.get("cookie")`.
- *  2. `@decocms/start`'s `RequestContext` is backed by a
- *     `RequestStore` that defaults to a NOOP implementation. The
- *     ALS-backed store is installed by site code at worker boot, not
- *     in unit tests. So `RequestContext.run(req, fn)` calls
- *     `fn()` without any propagation, and `RequestContext.current`
- *     inside `fn` still returns `null` — production code under test
- *     never sees the test's cookie.
- *
- * Fix: build a fresh `Headers` object (which uses the "none" guard,
- * so `set("cookie", ...)` works), wrap it in a minimal `Ctx`-shaped
- * object, and override the `RequestContext.current` getter via
- * `vi.spyOn`. The spy is restored after `fn` resolves to keep tests
- * isolated. Nothing here depends on undici or ALS internals.
- */
-/**
- * Read a header from an init in a shape-agnostic way. After the
- * `mergeHeaders` refactor, `init.headers` is always a `Headers`
- * instance — but the helper handles legacy shapes too so the tests
- * stay robust if someone changes the merge implementation again.
- */
-function headerValue(init: RequestInit | undefined, name: string): string | undefined {
-	const headers = init?.headers;
-	if (!headers) return undefined;
-	if (headers instanceof Headers) return headers.get(name) ?? undefined;
-	if (Array.isArray(headers)) {
-		const found = headers.find(([k]) => k.toLowerCase() === name.toLowerCase());
-		return found?.[1];
-	}
-	const rec = headers as Record<string, string>;
-	const key = Object.keys(rec).find((k) => k.toLowerCase() === name.toLowerCase());
-	return key ? rec[key] : undefined;
-}
-
-function withRequest<T>(cookieHeader: string | null, fn: () => Promise<T>): Promise<T> {
-	const headers = new Headers();
-	if (cookieHeader) headers.set("cookie", cookieHeader);
-	const fakeCtx = {
-		request: { headers } as unknown as Request,
-		signal: new AbortController().signal,
-		responseHeaders: new Headers(),
-		bag: new Map(),
-		startedAt: Date.now(),
-	};
-	const spy = vi
-		.spyOn(RequestContext, "current", "get")
-		.mockReturnValue(fakeCtx as unknown as ReturnType<typeof Reflect.get>);
-	return fn().finally(() => spy.mockRestore());
-}
-
-describe("vtexFetchResponse — vtex_segment cookie forwarding", () => {
-	let lastInit: RequestInit | undefined;
-
-	beforeEach(() => {
-		configureVtex({ account: "testaccount" });
-		lastInit = undefined;
-		setVtexFetch(((_url: string, init?: RequestInit) => {
-			lastInit = init;
-			return Promise.resolve(mockResponse());
-		}) as typeof fetch);
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("forwards vtex_segment cookie when present and caller didn't set one", async () => {
-		await withRequest("vtex_segment=abc123; other=foo", async () => {
-			await vtexFetchResponse("/api/catalog_system/pub/products/x");
-		});
-		expect(headerValue(lastInit, "cookie")).toBe("vtex_segment=abc123");
-	});
-
-	it("does not overwrite a caller-supplied cookie header", async () => {
-		await withRequest("vtex_segment=abc123", async () => {
-			await vtexFetchResponse("/api/x", {
-				headers: { cookie: "custom=zzz" },
-			});
-		});
-		expect(headerValue(lastInit, "cookie")).toBe("custom=zzz");
-	});
-
-	it("does not overwrite a caller-supplied Cookie header (case-insensitive)", async () => {
-		await withRequest("vtex_segment=abc123", async () => {
-			await vtexFetchResponse("/api/x", {
-				headers: { Cookie: "custom=zzz" },
-			});
-		});
-		expect(headerValue(lastInit, "cookie")).toBe("custom=zzz");
-	});
-
-	it("is a no-op when there is no incoming cookie header", async () => {
-		await withRequest(null, async () => {
-			await vtexFetchResponse("/api/x");
-		});
-		expect(headerValue(lastInit, "cookie")).toBeUndefined();
-	});
-
-	it("is a no-op when there is a cookie header but no vtex_segment", async () => {
-		await withRequest("other=foo; another=bar", async () => {
-			await vtexFetchResponse("/api/x");
-		});
-		expect(headerValue(lastInit, "cookie")).toBeUndefined();
-	});
-
-	it("does not crash when called outside a RequestContext", async () => {
-		await vtexFetchResponse("/api/x");
-		expect(headerValue(lastInit, "cookie")).toBeUndefined();
-	});
-
-	it("preserves auth headers alongside the forwarded cookie", async () => {
-		configureVtex({ account: "testaccount", appKey: "k", appToken: "t" });
-		await withRequest("vtex_segment=abc123", async () => {
-			await vtexFetchResponse("/api/x");
-		});
-		expect(headerValue(lastInit, "X-VTEX-API-AppKey")).toBe("k");
-		expect(headerValue(lastInit, "X-VTEX-API-AppToken")).toBe("t");
-		expect(headerValue(lastInit, "cookie")).toBe("vtex_segment=abc123");
-	});
-
-	// Regression: when init.headers is a Headers object (as
-	// `createVtexCheckoutProxy` passes through `getVtexFetch()`), the
-	// existing cookie must survive verbatim. The naive
-	// `{ ...authHeaders, ...init?.headers }` spread collapses a Headers
-	// instance to `{}` (Headers has no own enumerable entries), which
-	// silently wipes the browser's full Cookie header — including the
-	// orderForm cookie any checkout flow depends on.
-	it("preserves an existing Cookie header when init.headers is a Headers instance", async () => {
-		await withRequest("vtex_segment=abc123", async () => {
-			const proxyInit: RequestInit = {
-				headers: new Headers({
-					cookie: "checkout.vtex.com=__ofid=xyz; vtex_segment=originalseg; foo=bar",
-				}),
-			};
-			await vtexFetchResponse("/api/checkout/pub/orderForm", proxyInit);
-		});
-		expect(headerValue(lastInit, "cookie")).toContain("checkout.vtex.com=__ofid=xyz");
-	});
-});
-
-// Module-level counter for cache-busting test URLs. `Date.now()` collides
-// when two tests run within the same millisecond and the SWR cache in
-// fetchWithCache short-circuits the second one — `_fetch` never runs and
-// `lastInit` stays `undefined`. Per-test ids are deterministic and
-// collision-free.
-let testUrlCounter = 0;
-const uniqPath = (prefix: string) => `${prefix}/${++testUrlCounter}`;
-
-describe("vtexCachedFetch — vtex_segment cookie forwarding", () => {
-	let lastInit: RequestInit | undefined;
-
-	beforeEach(() => {
-		clearFetchCache();
-		configureVtex({ account: "testaccount" });
-		lastInit = undefined;
-		setVtexFetch(((_url: string, init?: RequestInit) => {
-			lastInit = init;
-			return Promise.resolve(mockResponse({ ok: true }));
-		}) as typeof fetch);
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("forwards vtex_segment on cached GETs", async () => {
-		await withRequest("vtex_segment=abc123", async () => {
-			await vtexCachedFetch(uniqPath("/api/catalog_system/pub/products"));
-		});
-		expect(headerValue(lastInit, "cookie")).toBe("vtex_segment=abc123");
-	});
-
-	it("does not overwrite a caller-supplied cookie header", async () => {
-		await withRequest("vtex_segment=abc123", async () => {
-			await vtexCachedFetch(uniqPath("/api/x"), {
-				headers: { cookie: "custom=zzz" },
-			});
-		});
-		expect(headerValue(lastInit, "cookie")).toBe("custom=zzz");
-	});
-});
-
-describe("intelligentSearch — vtex_segment cookie forwarding", () => {
-	let lastInit: RequestInit | undefined;
-
-	beforeEach(() => {
-		// Reset the SWR cache: otherwise the second test in this block
-		// can serve the first test's cached body without invoking the
-		// stub _fetch, leaving lastInit undefined.
-		clearFetchCache();
-		configureVtex({ account: "testaccount" });
-		lastInit = undefined;
-		setVtexFetch(((_url: string, init?: RequestInit) => {
-			lastInit = init;
-			return Promise.resolve(mockResponse({ products: [] }));
-		}) as typeof fetch);
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("forwards vtex_segment when caller didn't pass cookieHeader", async () => {
-		await withRequest("vtex_segment=abc123; other=foo", async () => {
-			await intelligentSearch(uniqPath("/product_search"));
-		});
-		expect(headerValue(lastInit, "cookie")).toBe("vtex_segment=abc123");
-	});
-
-	it("respects an explicit cookieHeader override", async () => {
-		await withRequest("vtex_segment=abc123", async () => {
-			await intelligentSearch(uniqPath("/product_search"), undefined, {
-				cookieHeader: "custom=zzz",
-			});
-		});
-		expect(headerValue(lastInit, "cookie")).toBe("custom=zzz");
-	});
-});

package/src/__tests__/client-set-cookie-forward.test.ts

@@ -1,257 +0,0 @@
-/**
- * Regression tests for the Set-Cookie propagation chain through
- * `vtexFetchWithCookies`. Without this chain, VTEX's `checkout.vtex.com`
- * and `CheckoutOrderFormOwnership` cookies never reach the browser via
- * `createServerFn` actions, the storefront's local `__orderFormId`
- * drifts away from VTEX's server-side orderForm, and the user lands
- * on `/checkout` with an empty cart.
- *
- * Two failure modes covered here:
- *
- *  (1) Inbound capture — VTEX `Set-Cookie` headers must be appended
- *      to `RequestContext.responseHeaders`, skipping the two IS
- *      cookies that the middleware owns (`vtex_is_session`,
- *      `vtex_is_anonymous`), and the `domain=` attribute must be
- *      stripped so the browser scopes the cookie to the storefront.
- *
- *  (2) Outbound merge — when the caller passes `init.headers` as a
- *      `Headers` instance (the `createVtexCheckoutProxy` factory does
- *      this through `getVtexFetch()`), spreading it as a plain object
- *      collapses to `{}` and silently wipes every other header the
- *      caller set. The Headers-aware merge in `vtexFetchWithCookies`
- *      keeps the bug from sneaking back in.
- */
-
-import { RequestContext } from "@decocms/blocks/sdk/requestContext";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { configureVtex, setVtexFetch, vtexFetchWithCookies } from "../client";
-
-function mockResponse(opts?: { body?: unknown; status?: number; setCookies?: string[] }): Response {
-	const status = opts?.status ?? 200;
-	const headers = new Headers();
-	for (const c of opts?.setCookies ?? []) headers.append("set-cookie", c);
-	return {
-		ok: status >= 200 && status < 300,
-		status,
-		statusText: status === 200 ? "OK" : "Error",
-		headers,
-		json: () => Promise.resolve(opts?.body ?? {}),
-	} as Response;
-}
-
-function headerValue(init: RequestInit | undefined, name: string): string | undefined {
-	const headers = init?.headers;
-	if (!headers) return undefined;
-	if (headers instanceof Headers) return headers.get(name) ?? undefined;
-	if (Array.isArray(headers)) {
-		const found = headers.find(([k]) => k.toLowerCase() === name.toLowerCase());
-		return found?.[1];
-	}
-	const rec = headers as Record<string, string>;
-	const key = Object.keys(rec).find((k) => k.toLowerCase() === name.toLowerCase());
-	return key ? rec[key] : undefined;
-}
-
-function withRequest<T>(
-	cookieHeader: string | null,
-	fn: (ctx: { responseHeaders: Headers }) => Promise<T>,
-	requestUrl = "https://store.example.com/api/checkout/pub/orderForm",
-): Promise<T> {
-	const reqHeaders = new Headers();
-	if (cookieHeader) reqHeaders.set("cookie", cookieHeader);
-	const responseHeaders = new Headers();
-	const fakeCtx = {
-		request: { headers: reqHeaders, url: requestUrl } as unknown as Request,
-		signal: new AbortController().signal,
-		responseHeaders,
-		bag: new Map(),
-		startedAt: Date.now(),
-	};
-	const spy = vi
-		.spyOn(RequestContext, "current", "get")
-		.mockReturnValue(fakeCtx as unknown as ReturnType<typeof Reflect.get>);
-	return fn({ responseHeaders }).finally(() => spy.mockRestore());
-}
-
-describe("vtexFetchWithCookies — inbound Set-Cookie capture", () => {
-	let lastInit: RequestInit | undefined;
-
-	beforeEach(() => {
-		configureVtex({ account: "testaccount" });
-		lastInit = undefined;
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("captures upstream Set-Cookie into RequestContext.responseHeaders", async () => {
-		setVtexFetch(((_url: string, init?: RequestInit) => {
-			lastInit = init;
-			return Promise.resolve(
-				mockResponse({
-					setCookies: [
-						"checkout.vtex.com=__ofid=abc123; Path=/; HttpOnly; Secure",
-						"CheckoutOrderFormOwnership=def456; Path=/; HttpOnly",
-					],
-				}),
-			);
-		}) as typeof fetch);
-
-		const captured = await withRequest("vtex_segment=seg1", async ({ responseHeaders }) => {
-			await vtexFetchWithCookies("/api/checkout/pub/orderForm");
-			return responseHeaders.getSetCookie();
-		});
-
-		expect(captured).toHaveLength(2);
-		expect(captured.some((c) => c.startsWith("checkout.vtex.com="))).toBe(true);
-		expect(captured.some((c) => c.startsWith("CheckoutOrderFormOwnership="))).toBe(true);
-	});
-
-	// The cart server-fn cookie MUST land at the same scope as the checkout
-	// proxy (domain-scoped to the storefront host) and native VTEX
-	// (`domain=<host>`). Stripping the Domain (host-only) creates a second,
-	// distinct cookie that drifts from the proxy's and causes the
-	// nondeterministic empty-cart bug. So we rewrite Domain, not strip it.
-	it("rewrites the Domain= attribute to the storefront host (matches the proxy)", async () => {
-		setVtexFetch((() =>
-			Promise.resolve(
-				mockResponse({
-					setCookies: [
-						"checkout.vtex.com=__ofid=abc; Domain=.vtexcommercestable.com.br; Path=/; HttpOnly",
-					],
-				}),
-			)) as typeof fetch);
-
-		const captured = await withRequest(
-			"foo=bar",
-			async ({ responseHeaders }) => {
-				await vtexFetchWithCookies("/api/checkout/pub/orderForm");
-				return responseHeaders.getSetCookie();
-			},
-			"https://www.acme.com.br/api/checkout/pub/orderForm",
-		);
-
-		// domain-scoped to the storefront host, NOT the original VTEX domain
-		expect(captured[0]).toMatch(/Domain=www\.acme\.com\.br/);
-		expect(captured[0]).not.toMatch(/vtexcommercestable/i);
-		expect(captured[0]).toContain("checkout.vtex.com=__ofid=abc");
-	});
-
-	it("rewrites only the Domain attribute, not a domain= substring in the cookie value", async () => {
-		setVtexFetch((() =>
-			Promise.resolve(
-				mockResponse({
-					// Pathological value embedding `domain=` before the first `;`.
-					setCookies: [
-						"checkout.vtex.com=__ofid=domain=keep; Domain=.vtexcommercestable.com.br; Path=/",
-					],
-				}),
-			)) as typeof fetch);
-
-		const captured = await withRequest(
-			"foo=bar",
-			async ({ responseHeaders }) => {
-				await vtexFetchWithCookies("/api/checkout/pub/orderForm");
-				return responseHeaders.getSetCookie();
-			},
-			"https://www.acme.com.br/api/checkout/pub/orderForm",
-		);
-
-		// the value's `domain=keep` is untouched; the attribute is rewritten
-		expect(captured[0]).toContain("__ofid=domain=keep");
-		expect(captured[0]).toMatch(/;\s*Domain=www\.acme\.com\.br/);
-		expect(captured[0]).not.toMatch(/vtexcommercestable/i);
-	});
-
-	it("falls back to stripping Domain when there is no request scope (module init)", async () => {
-		setVtexFetch((() =>
-			Promise.resolve(
-				mockResponse({
-					setCookies: ["checkout.vtex.com=__ofid=abc; Domain=.vtexcommercestable.com.br; Path=/"],
-				}),
-			)) as typeof fetch);
-		// No withRequest wrapper → RequestContext.current is null.
-		await expect(vtexFetchWithCookies("/api/checkout/pub/orderForm")).resolves.toBeDefined();
-	});
-
-	it("skips Intelligent Search cookies (managed by middleware, not actions)", async () => {
-		setVtexFetch((() =>
-			Promise.resolve(
-				mockResponse({
-					setCookies: [
-						"checkout.vtex.com=__ofid=abc; Path=/",
-						"vtex_is_session=ignore-me; Path=/",
-						"vtex_is_anonymous=ignore-me-too; Path=/",
-						"CheckoutOrderFormOwnership=def; Path=/",
-					],
-				}),
-			)) as typeof fetch);
-
-		const captured = await withRequest("foo=bar", async ({ responseHeaders }) => {
-			await vtexFetchWithCookies("/api/checkout/pub/orderForm");
-			return responseHeaders.getSetCookie();
-		});
-
-		expect(captured.some((c) => c.startsWith("checkout.vtex.com="))).toBe(true);
-		expect(captured.some((c) => c.startsWith("CheckoutOrderFormOwnership="))).toBe(true);
-		expect(captured.some((c) => c.startsWith("vtex_is_session="))).toBe(false);
-		expect(captured.some((c) => c.startsWith("vtex_is_anonymous="))).toBe(false);
-	});
-
-	it("does not crash when called outside a RequestContext", async () => {
-		setVtexFetch((() =>
-			Promise.resolve(
-				mockResponse({
-					setCookies: ["checkout.vtex.com=__ofid=abc; Path=/"],
-				}),
-			)) as typeof fetch);
-		await expect(vtexFetchWithCookies("/api/checkout/pub/orderForm")).resolves.toBeDefined();
-	});
-
-	// Regression for Hole B: when init.headers is a Headers instance,
-	// the previous Record-cast + spread collapsed it to `{}`, wiping
-	// every other header (auth, content-type) the caller set. After
-	// the fix, the Headers-aware merge preserves all of them.
-	it("preserves other caller headers when init.headers is a Headers instance", async () => {
-		setVtexFetch(((_url: string, init?: RequestInit) => {
-			lastInit = init;
-			return Promise.resolve(mockResponse());
-		}) as typeof fetch);
-
-		await withRequest("vtex_segment=abc; foo=bar", async () => {
-			await vtexFetchWithCookies("/api/checkout/pub/orderForm", {
-				headers: new Headers({
-					"X-Custom-Trace": "trace-id",
-					"X-VTEX-Operation": "test-op",
-				}),
-			});
-		});
-
-		expect(headerValue(lastInit, "x-custom-trace")).toBe("trace-id");
-		expect(headerValue(lastInit, "x-vtex-operation")).toBe("test-op");
-		// Caller didn't pass a Cookie — auto-injection picks up the
-		// request's cookie and forwards it without dropping the
-		// other headers.
-		expect(headerValue(lastInit, "cookie")).toBeDefined();
-	});
-
-	it("preserves an existing Cookie header passed via Headers and sanitises it in place", async () => {
-		setVtexFetch(((_url: string, init?: RequestInit) => {
-			lastInit = init;
-			return Promise.resolve(mockResponse());
-		}) as typeof fetch);
-
-		await withRequest("vtex_segment=abc", async () => {
-			await vtexFetchWithCookies("/api/checkout/pub/orderForm", {
-				headers: new Headers({
-					"X-Custom": "keep-me",
-					cookie: "checkout.vtex.com=__ofid=xyz; vtex_segment=mine",
-				}),
-			});
-		});
-
-		expect(headerValue(lastInit, "x-custom")).toBe("keep-me");
-		expect(headerValue(lastInit, "cookie")).toContain("checkout.vtex.com=__ofid=xyz");
-	});
-});