Spacetime sync'ing

When two points are moving through space and time, there is a warp in the spacetime fabric between them, caused by relativity effects.

When computers leave the factory, their clocks are set and Quality Control ensures they are beating in sync. As they are shipped and handled they invariably end up taking different routes through space and time which could make the clocks differ.

If an observer measures the clock, frequency and the numerical value might appear the same between two points. But this implies a third, observing, absolute point.

But how do only two points do it?

If one computer sends its current time value, there IS a delay when comparing:

function compare(tick){
  return tick == new Date;
}

Seems like a difficult task to make that function return true.

However, let's assume that the clocks don't differ and what this warping is actually the medium through which the computers are communicating. We start with the assumption that the epoch (the origin or zero) is constant between all computers and assume that any difference in synchronicity is directly caused by a warp in the communication medium.

Furthermore, assume that the computers in question are physically the same computer, but in different positions in time. Could we send messages back and forth between them?

Analizing a possible method:

Taking a binary stream (since that is what electronics communicate through), measure the length between changes. That is, instead of measuring how many times a 1 or 0 were encountered, only measure how long it remains unchanged. An unwarped system does not have separate information of data and time because all distances are unitary, therefore we assume that time is constant.

To function like a reliable channel and data storage node, information exchanged must be unchanged and encrypted. Assuming that both nodes have a separate resolution of time, their unique id would be their time signatures, as measured by themselves. This unique id is what serves as a crypto key, and not even the client knows it, the key itself is encrypted into the memory, as a signature of how the memory is allocated.

Using then time as part of the data, the problem becomes a matter of storing the data, unwarped.

Since we assume that two nodes cannot control the warp on the medium, but to comply with being a reliable data store each node can assume that it will get what it expects. The first test of the system is its ability to function like a memory:

function recall(reference){
  // the very first thing: to record the first data point
  var now = Number(new Date);
  // while no change, return nothing
  if (!reference) return;

  var callee = arguments.callee;
  var caller = callee.caller;
  
  setTimeout(function(){
  // callback with data response
    caller.call(null, callee[reference]);
  // in this unwarped medium, the ratio remains constant
  // so a client would expect a spacetime delay directly
  // proportional to the data given. In other words, the
  // function takes a predictable amount of time to execute
  }, start/Number(new Date));
}

var bytestream = '11000010';
// calculating lengths = 2, 4, 1, 1:

function measure(){
  var start = Number(new Date);
  var caller = arguments.callee.caller;
  var input = Number(arguments[0]) || 0;
  // function serves as its own memory
  var memory = arguments.callee;
  var response = memory[input];
  setTimeout(function(){
    caller.call(caller, response);
  }, Number(response || 0)/start);
}

Can this work?