     end
 
     @spec memoize(Genomu.key, t) :: t
-    def memoize(key, __MODULE__[snapshot: snapshot, interval: i] = state) do
-      :ets.insert(snapshot, {key, i})
-      state
+    def memoize(key, __MODULE__[snapshot: snapshot, clock: clock, log: log] = state) do
+      :ets.insert(snapshot, {key, clock})
+      state.log([{key, clock}|log])
     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)
+        [{^key, clock}] -> ITC.encode_binary(clock)
       end
     end
 
   end
 
-  def init({root, parent, interval}) do
-    {:ok, State.blank(root: root, parent: parent, interval: interval)}
+  def init({root, parent, clock}) do
+    {:ok, State.blank(root: root, parent: parent, clock: clock)}
   end
 
-  @spec interval(pid | atom) :: ITC.t
-  defcall interval, state: State[interval: i] = state do
-    {:reply, i, state}
+  @spec clock(pid | atom) :: ITC.t
+  defcall clock, state: State[clock: clock] = state do
+    {:reply, clock, state}
   end
 
   @spec root?(pid | atom) :: boolean

  @spec fork(pid | atom, root :: atom | boolean) :: ITC.t
  def fork(server), do: fork(server, false)

  defcall fork(root), state: State[interval: i, children: c] = state do
    {new_interval, channel_interval} = ITC.fork(i)
    {:ok, channel} = :supervisor.start_child(Genomu.Sup.Channels, [root, self, channel_interval])
    Process.monitor(channel)
    :ets.insert(c, [{channel, channel_interval},
                    {channel_interval, channel}])
    state = state.interval(new_interval)
    {:reply, {:ok, channel}, state}
  end

  defcast update(channel, new_interval), state: State[children: c] = state do
    case :ets.lookup(c, channel) do
      [{^channel, interval}] ->
        :ets.insert(c, [{channel, new_interval}, {new_interval, channel}])
        :ets.delete(c, interval)
      [] -> 
        :ok # TODO: log a warning?
    end

  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])
