   end
 
   def init({root, parent, clock}) do
-    {:ok, State.blank(root: root, parent: parent, clock: clock)}
+    {:ok, State.new(root: root, parent: parent, clock: clock)}
   end
 
   @spec clock(pid | atom) :: 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])
      children = :ets.new(__MODULE__.Children, [:ordered_set])
      new(Keyword.merge([snapshot: snapshot, children: children], opts))
    end

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

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

  defcall fork(root), state: State[clock: clock] = state do
    state = ensure_children(state)

    {new_clock, channel_clock} = ITC.fork(clock)
    {:ok, channel} = :supervisor.start_child(Genomu.Sup.Channels, [root, self, channel_clock])
    Process.monitor(channel)
    :ets.insert(state.children,
                [{channel, channel_clock},
                 {channel_clock, channel}])
    state = state.clock(new_clock)
    {:reply, {:ok, channel}, state}
  end
