     {:stop, :normal, state}
   end
 
-  @spec next_interval(ITC.t, Genomu.command) :: ITC.t
-  defp next_interval(i, {:get, _}), do: i
-  defp next_interval(i, _), do: ITC.event(i)
+  @spec next_clock(ITC.t, Genomu.command) :: ITC.t
+  defp next_clock(clock, {:get, _}), do: clock
+  defp next_clock(clock, _), do: ITC.event(clock)
 
   @spec memoize(Genomu.key, Genomu.command, ITC.t, State.t) :: State.t
-  defp memoize(_key, {:get, _}, _interval, state) do
+  defp memoize(_key, {:get, _}, _clock, state) do
     state
   end
-  defp memoize(key, _cmd, interval, State[] = state) do
-    state.interval(interval).memoize(key)
+  defp memoize(key, _cmd, clock, State[] = state) do
+    state.clock(clock).memoize(key)
   end
 
 end
    end

    @spec memoize(Genomu.key, t) :: t
    def memoize(key, __MODULE__[snapshot: snapshot, interval: i] = state) do
      :ets.insert(snapshot, {key, i})
      state
    end

    @spec lookup(Genomu.key, t) :: nil | ITC.t
    def lookup(key, __MODULE__[snapshot: snapshot]) do
      case :ets.lookup(snapshot, key) do
        [] -> nil
        [{^key, i}] -> ITC.encode_binary(i)
      end
    end

  end

  def init({root, parent, interval}) do
    {:ok, State.blank(root: root, parent: parent, interval: interval)}
  end

  @spec interval(pid | atom) :: ITC.t
  defcall interval, state: State[interval: i] = state do
    {:reply, i, state}
  end

  @spec root?(pid | atom) :: boolean

  end

  @spec start_link(root :: atom | boolean, parent :: nil | pid | atom, interval :: ITC.t) :: {:ok, pid} | {:error, reason :: term}
  def start_link(false, parent, clock) do
    :gen_server.start_link(__MODULE__, {false, parent, clock}, [])
  end
  def start_link(true, parent, clock) do
    :gen_server.start_link(__MODULE__, {true, parent, clock}, [])
  end
  def start_link(name, parent, clock) do
    :gen_server.start_link({:local, name}, __MODULE__, {true, parent, clock}, [])
  end

  defrecord State, root: false, parent: nil,
                   clock: nil,
                   snapshot: nil, log: [],
                   children: nil do

    record_type root: boolean, parent: nil | pid | atom,
                clock: nil | ITC.t,
                snapshot: nil | :ets.tid, log: [Genomu.Transaction.entry],
                children: nil | :ets.tid

    def blank(opts) do
      snapshot = :ets.new(__MODULE__.Snapshot, [:ordered_set])
