I'm currently working on fixing the odd logic in Heap::compute_pstr_size, Heap::allocate_pstr and build_functor!, but I still don't quite understand what the intended pstr layout should be.

I think this may be the reason for #2593.

Note that strings containing \x0\ are not correctly handled in master either in general (#2554).

what the intended pstr layout should be.

The string should be written directly into the heap in its UTF-8 representation (with the exception of 0-bytes, for which a brief excursion into a list with '\x0\' as its first element is needed, whose tail is again a partial string), described in #24 and most completely in #95 (comment).

The key challenge here is to structure the Rust code in such a way so that as few parts as possible need to be aware of this representation. We have seen many issues so far, mostly because currently (in master, and to a lesser extent also still in rebis-dev) too many parts need to take the representation explicitly into account, and it is easy to forget to handle the case.

In particular, in your example, the term stored on the heap should be for example:

----------
| '.'/2  |
----------    
| '\x0\' |     
----------    
|  PSTR  |---+
----------   |
|a0000000| <-+
----------
|  []/0  |
----------

Is it the case? Who knows: The mistake could be in writing the term, which is currently also written in Rust but should be written in Prolog to minimize the Rust parts that need to be aware of this representation.

The mistake is in the current Rust implementation of Heap::allocate_pstr; I'm not sure how these rather direct accesses to the heap should be implemented in prolog instead, but I do agree that we desperately need proper encapsulation to limit the amount of code that manually handles this representation (both here and in other places).

how these rather direct accesses to the heap should be implemented in prolog instead

Prolog predicates will never "see" this representation, they will only "see" that a list must be printed and print it accordingly. Only the underlying Rust-based primitives (notably unification) must be aware of this representation, and ideally as localized as possible.

Oop, I got a funnier one:

A = "abcdefgh\x0\\x0\\x0\".

This one straight up triggers UB :)