cache feature request for Vaadin

I remember GWT caches control data that it receives dynamically.
The request is that the client terminal that parses UIDL, should inject control data into the cache, for as long we maintain the corresponding component server side.
Here it goes:

I think
Vaadin should have an object hash or something for the server side component that maintains client status, but, only when that changes, should the client UI counterpart change, otherwise it should keep it cached as long as Vaadin keeps a non-null hash
(null meaning a non-existent component, either client or server side). This way client server component validation would be minimal, cache deterministic (if it’s ever), or at least know when to try and set it.

for example:

that file is cached,
couldn’t it be modified by the client javascript terminal, adding a javascript array with data, that will be cached also? Then if a table would be loaded, it would communicate with the server, get a hash, realise it’s identical, and fetch the data from the ‘data cache’.

You can basically getItemById(‘datastore1’).innerHTML add/get Data or something, if you can… i don’t know. There’s a lot of sneaky stuff you can do with javascript, putting and fetching data in and from an unparsable area by the browser shouldn’t be impossible, is it?

Furthermore i heard that HTML5 comes with client side storage area or something like that, perhaps that will be a good time to add something like these cache features.

EDIT: my actual caching problems is about caching the data on the client somehow, by any means,
sneaky javascript
(actually the ‘GET cache’ isn’t an option but for smallest data sets, because is limited to 4K or something like that), or something else, like the upcoming
HTML 5 and client side storage
i heard about, and then make the components pick that cache up. It comes to me that while picking the data from the cache, the control actually only needs to send a request to the server, notifying that something changed, but the
server needs not respond if the data didn’t actually change, thus leaving he client with its cached state, which is perfect.