// lib/tune-cart-sync.js
 // Bridges affiliate attribution from the headless storefront into the
 // Shopify checkout. Affiliate links land with ?transaction_id=... in the URL.
 // We capture it, persist it, and stamp it onto the Shopify cart as the
 // `_tune_txn_id` attribute so the checkout pixel can read it and fire the
 // conversion.

 const STORE_DOMAIN = 'YOUR_STORE.myshopify.com';
 const STOREFRONT_API_TOKEN = 'YOUR_PUBLIC_STOREFRONT_API_TOKEN';
 const STOREFRONT_API_VERSION = '2025-01'; // match your existing cart calls

 const URL_PARAM = 'transaction_id';        // stays as-is in the affiliate URL
 const STORAGE_KEY = 'tune_transaction_id'; // internal localStorage key
 const CART_ATTRIBUTE_KEY = '_tune_txn_id'; // MUST match the checkout pixel

 const CART_ATTRIBUTES_UPDATE = `
   mutation cartAttributesUpdate($cartId: ID!, $attributes: [AttributeInput!]!) {
     cartAttributesUpdate(cartId: $cartId, attributes: $attributes) {
       cart { id }
       userErrors { field message }
     }
   }
 `;

 // Capture ?transaction_id=... from the landing URL and persist it.
 export function captureTuneTransactionId() {
   if (typeof window === 'undefined') return;
   const fromUrl = new URLSearchParams(window.location.search).get(URL_PARAM);
   if (fromUrl) localStorage.setItem(STORAGE_KEY, fromUrl);
 }

 // Read the persisted id (falls back to the current URL).
 export function getTuneTransactionId() {
   if (typeof window === 'undefined') return null;
   return (
     localStorage.getItem(STORAGE_KEY) ||
     new URLSearchParams(window.location.search).get(URL_PARAM)
   );
 }

 // Stamp the transaction id onto the given Shopify cart. Best-effort:
 // never throws, so it can't break the add-to-cart flow.
 export async function syncTuneTransactionIdToCart(cartId) {
   try {
     if (!cartId) return;
     const transactionId = getTuneTransactionId();
     if (!transactionId) return;

     const res = await fetch(
       `https://${STORE_DOMAIN}/api/${STOREFRONT_API_VERSION}/graphql.json`,
       {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
           'X-Shopify-Storefront-Access-Token': STOREFRONT_API_TOKEN,
         },
         body: JSON.stringify({
           query: CART_ATTRIBUTES_UPDATE,
           variables: {
             cartId,
             attributes: [{ key: CART_ATTRIBUTE_KEY, value: transactionId }],
           },
         }),
       }
     );

     const data = await res.json();
     const errors = data?.data?.cartAttributesUpdate?.userErrors;
     if (errors?.length) console.warn('[Tune] Cart attribute errors:', errors);
   } catch (err) {
     console.error('[Tune] Failed to sync transaction id to cart:', err);
   }
 }
Wire it in with two calls - capture on every page load, and stamp the cart after it's created:
// 1. Capture on every page load - in pages/_app.js
 import { useEffect } from 'react';
 import { captureTuneTransactionId } from '../lib/tune-cart-sync';

 export default function MyApp({ Component, pageProps }) {
   useEffect(() => { captureTuneTransactionId(); }, []);
   return <Component {...pageProps} />;
 }

 // 2. Stamp the cart - right after cartCreate / cartLinesAdd resolves
 import { syncTuneTransactionIdToCart } from '../lib/tune-cart-sync';
 await syncTuneTransactionIdToCart(cart.id);

// read the attribute the storefront stamped onto the cart
 const attrs = event.data.checkout.attributes
            ?? event.data.checkout.customAttributes ?? [];
 const transactionId = attrs.find(a => a.key === '_tune_txn_id')?.value;

 if (!transactionId) return; // organic order, not affiliate-driven - skip

 tdl.convert({
   amount: cartSubtotalUSD,                   // your existing USD value
   adv_unique1: event.data.checkout.order.id, // existing
   transaction_id: transactionId,             // <- the line that fixes attribution
 });