@decocms/tanstack 7.0.0

package/src/sdk/createInvoke.ts

@@ -0,0 +1,57 @@
+/**
+ * Generic bridge that turns any async function into a TanStack Start server function.
+ *
+ * Used by @decocms/apps to expose commerce actions/loaders as typed
+ * `invoke.*` calls that execute on the server with full credentials.
+ *
+ * @example
+ * ```ts
+ * import { createInvokeFn } from "@decocms/start/sdk/createInvoke";
+ * import { addItemsToCart } from "./actions/checkout";
+ *
+ * export const invoke = {
+ *   vtex: {
+ *     actions: {
+ *       addItemsToCart: createInvokeFn(
+ *         (input: { orderFormId: string; orderItems: CartItem[] }) =>
+ *           addItemsToCart(input.orderFormId, input.orderItems),
+ *         { unwrap: true },
+ *       ),
+ *     },
+ *   },
+ * };
+ *
+ * // Client-side usage:
+ * await invoke.vtex.actions.addItemsToCart({ data: { orderFormId, orderItems } });
+ * ```
+ */
+import { createServerFn } from "@tanstack/react-start";
+
+export interface InvokeFnOpts {
+  /**
+   * When true, extracts `.data` from the result before returning.
+   * Use for VTEX checkout functions that return VtexFetchResult<T>
+   * (i.e. `{ data: T, setCookies: string[] }`).
+   */
+  unwrap?: boolean;
+}
+
+/**
+ * Transforms an async function into a `createServerFn` wrapper.
+ *
+ * - Client calls: `fn({ data: input })`
+ * - Server executes: `action(input)`
+ * - If `unwrap: true`, extracts `.data` from VtexFetchResult-shaped results
+ */
+export function createInvokeFn<TInput, TOutput>(
+  action: (input: TInput) => Promise<TOutput>,
+  opts?: InvokeFnOpts,
+): (ctx: { data: TInput }) => Promise<TOutput> {
+  return createServerFn({ method: "POST" }).handler(async (ctx) => {
+    const result = await action(ctx.data as TInput);
+    if (opts?.unwrap && result && typeof result === "object" && "data" in result) {
+      return (result as any).data;
+    }
+    return result;
+  }) as unknown as (ctx: { data: TInput }) => Promise<TOutput>;
+}

package/src/sdk/kvHydration.test.ts

@@ -0,0 +1,171 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { computeRevision, getRevision, KV_KEYS, type KVNamespace, loadBlocks, setBlocks } from "@decocms/blocks/cms";
+import {
+  __resetKvHydrationStateForTests,
+  ensureBlocksHydrated,
+  isFastDeployEnabled,
+  maybePollRevision,
+} from "./kvHydration";
+
+const BUNDLED = { Site: { name: "bundled" } };
+
+/** KV stub that counts get() calls so we can assert throttling / single-load. */
+function makeKV(initial: Record<string, string> = {}) {
+  const store = new Map<string, string>(Object.entries(initial));
+  let getCalls = 0;
+  const kv: KVNamespace = {
+    get: (k) => {
+      getCalls++;
+      return Promise.resolve(store.get(k) ?? null);
+    },
+    put: (k, v) => {
+      store.set(k, v);
+      return Promise.resolve();
+    },
+    delete: (k) => {
+      store.delete(k);
+      return Promise.resolve();
+    },
+  };
+  return { kv, store, getCalls: () => getCalls };
+}
+
+function snapshotEnv(blocks: Record<string, unknown>, extra: Record<string, unknown> = {}) {
+  const { kv, ...rest } = makeKV({
+    [KV_KEYS.SNAPSHOT]: JSON.stringify(blocks),
+    [KV_KEYS.REVISION]: computeRevision(blocks),
+  });
+  // DECO_FAST_DEPLOY="1" is the explicit opt-in required alongside the binding.
+  return { env: { DECO_KV: kv, DECO_FAST_DEPLOY: "1", ...extra }, kv, ...rest };
+}
+
+/** Collects ctx.waitUntil promises so tests can await background polls. */
+function makeCtx() {
+  const promises: Promise<unknown>[] = [];
+  return {
+    ctx: { waitUntil: (p: Promise<unknown>) => promises.push(p) },
+    settle: () => Promise.allSettled(promises),
+  };
+}
+
+beforeEach(() => {
+  __resetKvHydrationStateForTests();
+  setBlocks({ ...BUNDLED }); // reset in-memory decofile to a known bundled state
+  vi.restoreAllMocks();
+});
+
+describe("isFastDeployEnabled", () => {
+  it("is false without a KV binding even when the flag is set", () => {
+    expect(isFastDeployEnabled({ DECO_FAST_DEPLOY: "1" })).toBe(false);
+  });
+
+  it("is false when a non-KV value is named DECO_KV", () => {
+    expect(isFastDeployEnabled({ DECO_KV: "some-secret-string", DECO_FAST_DEPLOY: "1" })).toBe(false);
+  });
+
+  it("is false when bound but DECO_FAST_DEPLOY is not set (explicit opt-in required)", () => {
+    const { kv } = makeKV();
+    expect(isFastDeployEnabled({ DECO_KV: kv })).toBe(false);
+  });
+
+  it("is true when bound AND DECO_FAST_DEPLOY=1", () => {
+    const { kv } = makeKV();
+    expect(isFastDeployEnabled({ DECO_KV: kv, DECO_FAST_DEPLOY: "1" })).toBe(true);
+  });
+
+  it("accepts DECO_FAST_DEPLOY=true as well", () => {
+    const { kv } = makeKV();
+    expect(isFastDeployEnabled({ DECO_KV: kv, DECO_FAST_DEPLOY: "true" })).toBe(true);
+  });
+
+  it("is false when DECO_FAST_DEPLOY=0 even if bound", () => {
+    const { kv } = makeKV();
+    expect(isFastDeployEnabled({ DECO_KV: kv, DECO_FAST_DEPLOY: "0" })).toBe(false);
+  });
+});
+
+describe("ensureBlocksHydrated", () => {
+  it("is a no-op when fast-deploy is disabled (keeps bundled blocks)", async () => {
+    await ensureBlocksHydrated({});
+    expect(loadBlocks()).toEqual(BUNDLED);
+  });
+
+  it("swaps the in-memory decofile with the KV snapshot", async () => {
+    const kvBlocks = { Site: { name: "from-kv" }, "pages-home": { path: "/" } };
+    const { env } = snapshotEnv(kvBlocks);
+    await ensureBlocksHydrated(env);
+    expect(loadBlocks()).toEqual(kvBlocks);
+    expect(getRevision()).toBe(computeRevision(kvBlocks));
+  });
+
+  it("loads only once even across concurrent first requests", async () => {
+    const kvBlocks = { Site: { name: "from-kv" } };
+    const { env, getCalls } = snapshotEnv(kvBlocks);
+    await Promise.all([
+      ensureBlocksHydrated(env),
+      ensureBlocksHydrated(env),
+      ensureBlocksHydrated(env),
+    ]);
+    // SNAPSHOT + REVISION = 2 gets for a single load (not 6).
+    expect(getCalls()).toBe(2);
+  });
+
+  it("keeps the bundled snapshot when the snapshot key is absent", async () => {
+    const { kv } = makeKV({ [KV_KEYS.REVISION]: "r" }); // no SNAPSHOT
+    await ensureBlocksHydrated({ DECO_KV: kv });
+    expect(loadBlocks()).toEqual(BUNDLED);
+  });
+
+  it("falls back to bundled (and does not throw) when KV errors", async () => {
+    const kv: KVNamespace = {
+      get: () => Promise.reject(new Error("KV down")),
+      put: () => Promise.resolve(),
+      delete: () => Promise.resolve(),
+    };
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    await expect(ensureBlocksHydrated({ DECO_KV: kv })).resolves.toBeUndefined();
+    expect(loadBlocks()).toEqual(BUNDLED);
+  });
+});
+
+describe("maybePollRevision", () => {
+  it("is a no-op before cold-start hydration has run", async () => {
+    const { env, getCalls } = snapshotEnv({ Site: { name: "x" } });
+    const { ctx, settle } = makeCtx();
+    maybePollRevision(env, ctx); // kvHydrated is false
+    await settle();
+    expect(getCalls()).toBe(0);
+  });
+
+  it("reloads the decofile when the KV revision changed", async () => {
+    const initial = { Site: { name: "v1" } };
+    const { env, store } = snapshotEnv(initial);
+    await ensureBlocksHydrated(env);
+    expect(loadBlocks()).toEqual(initial);
+
+    // Simulate a publish from another isolate: KV now holds v2.
+    const updated = { Site: { name: "v2" }, "pages-x": { path: "/x" } };
+    store.set(KV_KEYS.SNAPSHOT, JSON.stringify(updated));
+    store.set(KV_KEYS.REVISION, computeRevision(updated));
+
+    const { ctx, settle } = makeCtx();
+    maybePollRevision(env, ctx);
+    await settle();
+    expect(loadBlocks()).toEqual(updated);
+  });
+
+  it("throttles to one probe per interval", async () => {
+    const { env, getCalls } = snapshotEnv({ Site: { name: "x" } });
+    await ensureBlocksHydrated(env);
+    const callsAfterHydrate = getCalls();
+
+    const { ctx, settle } = makeCtx();
+    maybePollRevision(env, ctx); // fires (revision unchanged → 1 get)
+    maybePollRevision(env, ctx); // throttled → no get
+    maybePollRevision(env, ctx); // throttled → no get
+    await settle();
+
+    // Exactly one extra getRevision() beyond the hydrate calls.
+    expect(getCalls()).toBe(callsAfterHydrate + 1);
+  });
+});

package/src/sdk/kvHydration.ts

@@ -0,0 +1,176 @@
+/**
+ * Fast-deploy KV hydration — the runtime read path.
+ *
+ * Bridges a Cloudflare KV namespace to the in-memory decofile so CMS content
+ * edits propagate WITHOUT a `wrangler deploy`. Two entry points, both called
+ * from `workerEntry.ts`:
+ *
+ * - `ensureBlocksHydrated(env, ctx)` — on the FIRST request per isolate, load
+ *   the whole snapshot from KV and swap it in via `setBlocks()`. Awaited, so it
+ *   adds one ~10-30ms cold-start hit per isolate but guarantees fresh content
+ *   (the bundled `blocks.gen` snapshot is frozen at the last code deploy).
+ *
+ * - `maybePollRevision(env, ctx)` — on EVERY request, opportunistically (gated
+ *   to once per `POLL_INTERVAL_MS`) probe `index:revision` via `ctx.waitUntil`
+ *   so it never blocks the response; reload + swap when it changed.
+ *
+ * Everything is a no-op unless fast-deploy is enabled (`isFastDeployEnabled`),
+ * so non-migrated sites behave exactly as before.
+ *
+ * Why whole-snapshot swap (not per-block async): the resolver reads
+ * `loadBlocks()` synchronously in dozens of places. Loading the entire decofile
+ * once and swapping the map keeps that hot path synchronous — KV is touched
+ * only on cold start and during the throttled poll. Mirrors the
+ * `DecofileProvider` pattern from the deco-cx/deco Fresh runtime.
+ */
+
+import { getRevision, setBlocks } from "@decocms/blocks/cms";
+import { KVBlockSource } from "../cms/kvBlockSource";
+import type { KVNamespace } from "@decocms/blocks/cms";
+import { setSpanAttribute } from "@decocms/blocks/sdk/observability";
+
+/** How often (ms) an isolate re-probes `index:revision`. */
+export const POLL_INTERVAL_MS = 10_000;
+
+/** KV binding name expected on the Worker `env`. */
+export const KV_BINDING = "DECO_KV";
+
+/** Opt-in env var — set to "1" (or "true") to enable fast-deploy. The DECO_KV
+ * binding must also be present. */
+export const FAST_DEPLOY_ENV = "DECO_FAST_DEPLOY";
+
+// globalThis-backed state so all Vite server-function split-module copies share
+// the same hydration flags (same pattern as `loader.ts`).
+const G = globalThis as unknown as {
+  __deco?: {
+    kvHydrated?: boolean;
+    kvHydration?: Promise<void> | null;
+    kvLastPolledAt?: number;
+  };
+};
+if (!G.__deco) G.__deco = {};
+
+/** Minimal Cloudflare ExecutionContext shape (matches workerEntry.ts). */
+interface ExecutionContextLike {
+  waitUntil(promise: Promise<unknown>): void;
+}
+
+type Env = Record<string, unknown>;
+
+function getKV(env: Env): KVNamespace | null {
+  const binding = env[KV_BINDING];
+  // Duck-type the binding: a real KVNamespace has get/put. Guards against a
+  // string/secret accidentally named DECO_KV.
+  if (binding && typeof (binding as KVNamespace).get === "function") {
+    return binding as KVNamespace;
+  }
+  return null;
+}
+
+/**
+ * Fast-deploy is active only when BOTH hold: `DECO_FAST_DEPLOY` is set to "1"
+ * (or "true") — an explicit, per-site opt-in — AND the `DECO_KV` binding is
+ * present. Either missing ⇒ bundled-snapshot behavior, identical to
+ * pre-fast-deploy. Requiring the explicit flag means simply binding a KV
+ * namespace can't silently flip a site onto the KV read/write path.
+ */
+export function isFastDeployEnabled(env: Env): boolean {
+  const flag = env[FAST_DEPLOY_ENV];
+  if (flag !== "1" && flag !== "true") return false;
+  return getKV(env) !== null;
+}
+
+/**
+ * Resolve the KV namespace for the write-through path, or `null` when
+ * fast-deploy is disabled. Shared by `decofile.ts` so the enablement rule
+ * lives in exactly one place.
+ */
+export function getFastDeployKV(env: Env): KVNamespace | null {
+  if (!isFastDeployEnabled(env)) return null;
+  return getKV(env);
+}
+
+/**
+ * Cold-start hydration. Awaits the KV snapshot once per isolate and swaps it
+ * into the in-memory block map. Concurrent first requests share a single
+ * in-flight load. On any error (KV outage, bad JSON) we keep the bundled
+ * snapshot and mark hydration done — recovery happens via `maybePollRevision`
+ * once KV is reachable again (its revision will differ from the bundled one).
+ */
+export function ensureBlocksHydrated(env: Env, _ctx?: ExecutionContextLike): Promise<void> {
+  if (!isFastDeployEnabled(env)) return Promise.resolve();
+  if (G.__deco!.kvHydrated) return Promise.resolve();
+  if (G.__deco!.kvHydration) return G.__deco!.kvHydration;
+
+  const kv = getKV(env);
+  if (!kv) return Promise.resolve();
+
+  const load = (async () => {
+    try {
+      const snapshot = await new KVBlockSource(kv).loadSnapshot();
+      if (snapshot) {
+        setBlocks(snapshot.blocks);
+        setSpanAttribute("deco.block.source", "kv");
+      } else {
+        setSpanAttribute("deco.block.source", "bundled");
+      }
+    } catch (e) {
+      // Non-fatal: serve the bundled snapshot. The poll loop recovers later.
+      console.warn("[CMS/KV] cold-start hydration failed, using bundled snapshot:", e);
+      setSpanAttribute("deco.block.source", "bundled");
+    } finally {
+      G.__deco!.kvHydrated = true;
+      G.__deco!.kvHydration = null;
+    }
+  })();
+
+  G.__deco!.kvHydration = load;
+  return load;
+}
+
+/**
+ * Opportunistic revision poll. Throttled to once per `POLL_INTERVAL_MS` and run
+ * through `ctx.waitUntil` so it never adds latency to the response. Reloads the
+ * snapshot and swaps it in when KV's revision differs from the in-memory one.
+ */
+export function maybePollRevision(env: Env, ctx?: ExecutionContextLike): void {
+  if (!isFastDeployEnabled(env)) return;
+  if (!G.__deco!.kvHydrated) return; // wait until cold-start hydration finished
+
+  const now = Date.now();
+  if (now - (G.__deco!.kvLastPolledAt ?? 0) < POLL_INTERVAL_MS) return;
+  G.__deco!.kvLastPolledAt = now;
+
+  const kv = getKV(env);
+  if (!kv) return;
+
+  const poll = pollRevisionOnce(kv);
+  // Prefer waitUntil so the work outlives the response; fall back to a
+  // fire-and-forget promise (dev / tests) with its rejection swallowed.
+  if (ctx?.waitUntil) ctx.waitUntil(poll);
+  else void poll.catch(() => {});
+}
+
+async function pollRevisionOnce(kv: KVNamespace): Promise<void> {
+  try {
+    const source = new KVBlockSource(kv);
+    const remoteRevision = await source.getRevision();
+    if (!remoteRevision || remoteRevision === getRevision()) return;
+
+    const snapshot = await source.loadSnapshot();
+    if (snapshot) {
+      setBlocks(snapshot.blocks);
+      console.info(`[CMS/KV] decofile refreshed → revision ${snapshot.revision}`);
+    }
+  } catch (e) {
+    // Swallow — a failed poll must never affect the request. Next tick retries.
+    console.warn("[CMS/KV] revision poll failed:", e);
+  }
+}
+
+/** Test-only: reset the isolate-level hydration flags. */
+export function __resetKvHydrationStateForTests(): void {
+  G.__deco!.kvHydrated = false;
+  G.__deco!.kvHydration = null;
+  G.__deco!.kvLastPolledAt = 0;
+}

package/src/sdk/router.ts

@@ -0,0 +1,92 @@
+/**
+ * Deco-flavored TanStack Router factory.
+ *
+ * Uses standard URLSearchParams serialization instead of TanStack's default
+ * JSON-based format. Required because VTEX (and most commerce platforms) uses
+ * filter URLs like `?filter.brand=Nike&filter.brand=Adidas` which must
+ * round-trip correctly through the router's search system.
+ */
+import { createRouter as createTanStackRouter } from "@tanstack/react-router";
+import type {
+	SearchSerializer,
+	SearchParser,
+	AnyRoute,
+	TrailingSlashOption,
+} from "@tanstack/react-router";
+
+export const decoParseSearch: SearchParser = (searchStr) => {
+	const str = searchStr.startsWith("?") ? searchStr.slice(1) : searchStr;
+	if (!str) return {};
+
+	const params = new URLSearchParams(str);
+	const result: Record<string, string | string[]> = {};
+
+	for (const key of new Set(params.keys())) {
+		const values = params.getAll(key);
+		result[key] = values.length === 1 ? values[0] : values;
+	}
+	return result;
+};
+
+export const decoStringifySearch: SearchSerializer = (search) => {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(search)) {
+		if (value === undefined || value === null || value === "") continue;
+		if (Array.isArray(value)) {
+			for (const v of value) params.append(key, String(v));
+		} else {
+			params.append(key, String(value));
+		}
+	}
+	const str = params.toString();
+	return str ? `?${str}` : "";
+};
+
+export interface CreateDecoRouterOptions {
+	routeTree: AnyRoute;
+	scrollRestoration?: boolean;
+	defaultPreload?: "intent" | "viewport" | "render" | false;
+	trailingSlash?: TrailingSlashOption;
+	/**
+	 * Router context — passed to all route loaders/components via routeContext.
+	 * Commonly used for { queryClient } per TanStack Query integration docs.
+	 */
+	context?: Record<string, unknown>;
+	/**
+	 * Non-DOM provider component to wrap the entire router.
+	 * Per TanStack docs, only non-DOM-rendering components (providers) should
+	 * be used — anything else causes hydration errors.
+	 *
+	 * Example: QueryClientProvider wrapping
+	 *   Wrap: ({ children }) => <QueryClientProvider client={qc}>{children}</QueryClientProvider>
+	 */
+	Wrap?: (props: { children: any }) => any;
+}
+
+/**
+ * Create a TanStack Router with Deco defaults:
+ * - URLSearchParams-based search serialization (not JSON)
+ * - Scroll restoration enabled
+ * - Preload on intent
+ */
+export function createDecoRouter(options: CreateDecoRouterOptions) {
+	const {
+		routeTree,
+		scrollRestoration = true,
+		defaultPreload = "intent",
+		trailingSlash,
+		context,
+		Wrap,
+	} = options;
+
+	return createTanStackRouter({
+		routeTree,
+		scrollRestoration,
+		defaultPreload,
+		trailingSlash,
+		context: context as any,
+		Wrap,
+		parseSearch: decoParseSearch,
+		stringifySearch: decoStringifySearch,
+	});
+}

package/src/sdk/useHydrated.ts

@@ -0,0 +1,19 @@
+/**
+ * Re-export of TanStack Router's `useHydrated` hook.
+ *
+ * Returns `false` during SSR and on the first client render (before hydration),
+ * then `true` for all subsequent renders. Use this instead of
+ * `typeof document === "undefined"` checks for conditional rendering.
+ *
+ * @example
+ * ```tsx
+ * import { useHydrated } from "@decocms/start/sdk/useHydrated";
+ *
+ * function CartButton() {
+ *   const hydrated = useHydrated();
+ *   if (!hydrated) return <CartSkeleton />;
+ *   return <InteractiveCart />;
+ * }
+ * ```
+ */
+export { useHydrated } from "@tanstack/react-router";

package/src/sdk/workerEntry.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it } from "vitest";
+import { injectGeoCookies } from "./workerEntry";
+
+function parseCookies(header: string): Record<string, string> {
+  return Object.fromEntries(
+    header.split("; ").map((c) => {
+      const [k, ...v] = c.split("=");
+      return [k, v.join("=")];
+    }),
+  );
+}
+
+function makeRequest(
+  cf: Record<string, string> | undefined,
+  headers: Record<string, string> = {},
+): Request {
+  const req = new Request("https://example.com/", { headers });
+  if (cf) {
+    Object.defineProperty(req, "cf", { value: cf, configurable: true });
+  }
+  return req;
+}
+
+describe("injectGeoCookies", () => {
+  it("strips cf-region from the outgoing Request headers while preserving the value in __cf_geo_region cookie", () => {
+    const req = makeRequest(
+      { region: "São Paulo", country: "BR" },
+      { "cf-region": "São Paulo", "cf-ipcountry": "BR" },
+    );
+
+    const out = injectGeoCookies(req);
+
+    expect(out.headers.get("cf-region")).toBeNull();
+    // ASCII CF headers (cf-ipcountry) are still forwarded
+    expect(out.headers.get("cf-ipcountry")).toBe("BR");
+    // Geo data is preserved as cookies for matchers
+    const cookies = parseCookies(out.headers.get("cookie") ?? "");
+    expect(cookies.__cf_geo_region).toBe(encodeURIComponent("São Paulo"));
+    expect(cookies.__cf_geo_country).toBe("BR");
+  });
+
+  it("strips cf-ipcity from the outgoing Request headers while preserving the value in __cf_geo_city cookie", () => {
+    const req = makeRequest(
+      { city: "Brasília", country: "BR" },
+      { "cf-ipcity": "Brasília" },
+    );
+
+    const out = injectGeoCookies(req);
+
+    expect(out.headers.get("cf-ipcity")).toBeNull();
+    const cookies = parseCookies(out.headers.get("cookie") ?? "");
+    expect(cookies.__cf_geo_city).toBe(encodeURIComponent("Brasília"));
+  });
+
+  it("returns the original request unchanged when there is no cf object", () => {
+    const req = makeRequest(undefined, { "cf-region": "São Paulo" });
+
+    const out = injectGeoCookies(req);
+
+    // Without cf, we don't build cookies, and we return the original request
+    // untouched (so the cf-region header is still present — but that's the
+    // caller's pre-existing state, not something we re-introduced).
+    expect(out).toBe(req);
+  });
+
+  it("returns the original request unchanged when cf has no relevant geo fields", () => {
+    const req = makeRequest({ asn: "12345" }, { "cf-region": "São Paulo" });
+
+    const out = injectGeoCookies(req);
+
+    expect(out).toBe(req);
+  });
+
+  it("preserves a pre-existing cookie header", () => {
+    const req = makeRequest(
+      { region: "São Paulo" },
+      { cookie: "vtex_segment=abc; another=xyz" },
+    );
+
+    const out = injectGeoCookies(req);
+
+    const raw = out.headers.get("cookie") ?? "";
+    expect(raw).toContain("vtex_segment=abc");
+    expect(raw).toContain("another=xyz");
+    expect(raw).toContain("__cf_geo_region=");
+  });
+
+  it("forwards non-geo headers untouched", () => {
+    const req = makeRequest(
+      { region: "Paraná" },
+      {
+        "user-agent": "test-agent",
+        accept: "*/*",
+        "x-custom": "value",
+        "cf-ray": "9ff5b26cf9bc067a",
+      },
+    );
+
+    const out = injectGeoCookies(req);
+
+    expect(out.headers.get("user-agent")).toBe("test-agent");
+    expect(out.headers.get("accept")).toBe("*/*");
+    expect(out.headers.get("x-custom")).toBe("value");
+    expect(out.headers.get("cf-ray")).toBe("9ff5b26cf9bc067a");
+  });
+});