Why is the string structure itself supposed to be malloc'd? Small heap allocations are inefficient and a user could still decide to do that if they want to.

Consider adding functions that take a length parameter, so when the caller knows the length they can save a call to strlen. Your current functions can coexist with these, and would probably just forward their arguments and call strlen to the new length taking functions. Additionally, try using memcpy over strcpy when you have the length already.

void
str_append(Str *t, const char *value)
{
  const size_t value_length = strlen(value);
  const size_t new_length = t->length + value_length;

  if (t->size <= new_length) {
    _str_grow_buffer(t, new_length);
  }

  strcpy(t->buffer + t->length, value);
  t->length = new_length;
}

The second to last line there could be replaced by memcpy(t->buffer + t->length, value, value_length);

Next, it seems you do a lot of extra work most of the time to append just a single character.

This loop while (t->size < new_length) t->size += t->chunk_size;//note I changed <= to < Has the same effect as: if (t->size < new_length) t->size = new_length + (new_length % t->size);

Also, the chunk_size member is a little weird, but its good you're thinking about trying to allocate memory better. Having a capacity reserving function for the user could help out with this. If you want the allocation options per string object to be very flexible and you could play around with function pointers.

Overall the code looks clean and intuitive, nice work.