writeAddressIndex(encoder, info);
            encoder.writeBinary(info.token);
            encoder.writeByte((byte) info.state.ordinal());
            encoder.writeLong(info.lastBusy);
            DefaultDaemonContext.SERIALIZER.write(encoder, (DefaultDaemonContext) info.context);
        }

        private void writeAddressIndex(Encoder encoder, DaemonInfo info) throws IOException {

     */
    void encodeChunked(EncodeAction<Encoder> writeAction) throws Exception;

    /**
     * Writes a signed 64 bit long value. The implementation may encode the value as a variable number of bytes, not necessarily as 8 bytes.
     */
    void writeLong(long value) throws IOException;

    /**

        sinkBuffer.writeByte(b1)
        sinkBuffer.writeShort(dataSize.toInt())
      }
      else -> {
        b1 = b1 or PAYLOAD_LONG
        sinkBuffer.writeByte(b1)
        sinkBuffer.writeLong(dataSize)
      }
    }

    if (isClient) {
      random.nextBytes(maskKey!!)
      sinkBuffer.write(maskKey)

      if (dataSize > 0L) {
        messageBuffer.readAndWriteUnsafe(maskCursor!!)

        Cursor writePos = Cursor.newBottomLeft();
        int startRow = writePos.row
        String text = "A" * TERMINAL_WIDTH

        when:
        ansiExecutor.writeAt(writePos) {
            it.a(text)
        }

        then:
        writeCursor == Cursor.at(startRow, TERMINAL_WIDTH)
        writePos == writeCursor
        0 * newLineListener._
    }

    public Cursor getWritePosition() {
        return writePos;
    }

    public void setVisible(boolean isVisible) {
        this.isVisible = isVisible;
    }

    public boolean isOverlappingWith(Cursor cursor) {
        return cursor.row == writePos.row && writePos.col > cursor.col;
    }

    @Override
    public void redraw(AnsiContext ansi) {
        if (writePos.row < 0) {

        private final Ansi delegate;
        private final ColorMap colorMap;
        private final Cursor writePos;

        AnsiContextImpl(Ansi delegate, ColorMap colorMap, Cursor writePos) {
            this.delegate = delegate;
            this.colorMap = colorMap;
            this.writePos = writePos;
        }

        @Override

        addImport(clazz.getCanonicalName());
    }

    protected void addImport(String clazz) throws IOException {
        writeLn("import " + clazz + ";");
    }

    protected void writeLn() throws IOException {
        writer.write(ln);
    }

    public void writeLn(String source) throws IOException {
        writeIndent();
        writer.write(source + ln);
    }

        when:
        def stream = output.start(0)
        stream.writeInt(123)
        stream.writeByte(12)
        output.done()

        then:
        file.length() == 5
        file.seek(0)
        file.readInt() == 123
        file.readByte() == 12

        when:
        stream = output.start(5)
        stream.writeInt(321)
        output.done()

        then:
        file.length() == 9

    private final Cursor writePos = new Cursor();
    private final AnsiExecutor ansiExecutor;

    public DefaultTextArea(AnsiExecutor ansiExecutor) {
        this.ansiExecutor = ansiExecutor;
    }

    /**
     * Returns the bottom right position of this text area.
     */
    public Cursor getWritePosition() {
        return writePos;
    }

    public void newLineAdjustment() {

    writeLines(lines, System.getProperty("line.separator"));
  }

  /**
   * Writes the given lines of text to this sink with each line (including the last) terminated with
   * the given line separator.
   *
   * @throws IOException if an I/O error occurs while writing to this sink
   */
  public void writeLines(Iterable<? extends CharSequence> lines, String lineSeparator)
      throws IOException {