 
   defrecord State, root: false, parent: nil,
                    clock: nil, crash_clock: nil,
-                   outstanding: nil,
+                   outstanding: [],
                    snapshot: nil, log: [],
                    children: nil do
 
     record_type root: atom | boolean, parent: nil | Genomu.gen_server_ref,
                 clock: nil | ITC.t, crash_clock: nil | ITC.t,
-                outstanding: nil | ITC.t,
+                outstanding: [ITC.t],
                 snapshot: nil | :ets.tid, log: [Genomu.Transaction.entry],
                 children: nil | :ets.tid
 

      [{^channel, clock}] ->
        :ets.insert(c, [{channel, new_clock}, {new_clock, channel}])
        :ets.delete(c, clock)
      [] -> 
        :ok # TODO: log a warning?
    end
    {:noreply, state.join_outstanding(new_clock)}
  end

  def handle_info({:DOWN, _ref, :process, pid, _},
                  __MODULE__.State[clock: clock, children: c] = state) do
    [{^pid, child_clock}] = :ets.lookup(c, pid)
    :ets.delete(c, pid)
    :ets.delete(c, child_clock)
    new_clock = ITC.join(clock, child_clock)
    crash_clock = ITC.join(clock, state.outstanding)
    state = state.clock(new_clock).crash_clock(crash_clock)
    {:noreply, state}
  end  

  @spec execute(pid, Genomu.key | Genomu.cell, Genomu.command, Keyword.t) :: term
  defcall execute(key, cmd, options), state: State[] = state do

defmodule Genomu.Channel do
  use GenServer.Behaviour
  import GenX.GenServer

  require Lager

  @spec start :: {:ok, pid} | {:error, reason :: term}
  def start do
