Carry a value in and out of a stream field the way the catalog states

[estebanzimanyi]

A shape names one arity and one operand vocabulary, so a function differing from
a covered one only in the type of its second argument falls out of the streamable
surface entirely. value_marshalled asks the catalog the same question of every
argument and of the result -- can a stream field carry a value of this type, and
can the answer be handed back -- and emits whenever all of them say yes. It is
last in SHAPES, so every named shape keeps its own naming, ordering and
comments and this answers only what none of them claimed.

A span, a set and a spanset travel in hex-WKB because that is the only encoding
that round-trips one: the text form of a Span * states no variety, and the
catalog's own in for it is bigintspan_in, one of many. The
typeEncodings[T].decoders.wkb entry names a decoder for the type itself, so one
decoder answers every variety, and the result comes back through the _as_hexwkb
sibling -- the same exchange form a temporal already travels in, so the output of
one operator is the input of the next. A type carrying a text parser named for
itself keeps it, which leaves the operators already emitted byte-identical.

Every codec is called from its own catalogued signature rather than from the
arity of the one the templates were written against: interval_in takes a typmod
after the string, raster_as_hexwkb takes only a length, and pcpoint_as_hexwkb
neither. A pointer-to-pointer marshals as nothing, since rstrip("*") reads
Cbuffer ** as a Cbuffer, which is an array or an answer written back through
the argument and not one value.

The operand that gets built is the first argument that needs building, and
primary_index records where it goes back in the call, which is what lets an
operand sit in the middle of a longer argument list.

structural_residue() is asked before the shapes. What a function IS -- an
aggregate's state transition, a value's own text form, an answer returned through
its argument list -- decides that no per-event operator exists for it whatever a
shape makes of its signature. The --out descriptor path applies the same gate,
so the ledger and the descriptor name one set.

The ledger reads 1695 GENERATED, 774 GAP, 868 RESIDUE and 172 DEFERRED over the
3509 public functions the catalog carries, and every one of the 1695 emitted
operator cores compiles against a -DMEOS=ON -DALL=ON MEOS with 0 errors and 0
warnings.

An operator whose answer is serialized in a form the operand side cannot parse
composes with nothing, and a circular buffer left in hex-WKB was exactly that: a
Cbuffer operand is read from the text its own _in parses, so the answer has to
leave as that text. result_marshalling asks operand_marshalling which
encoding the type travels in and takes that encoding's encoder, which is what
keeps the two sides from disagreeing. A span stays hex-WKB, because hex-WKB is
the only form stating which variety it is.

The encoder is typeEncodings[T].encoders.text rather than a composed <t>_out,
which is what answers a geometry: its text encoder is geo_as_ewkt. The
arguments after the value are what out_aux names, counted against the encoder's
own parameters, so a geometry is written at the precision the catalog states and
a type whose encoder says something else declines.

A geometry is also an operand a function can be built around, read with geom_in
-- the parser the binding already uses for a geometry argument, and the one that
accepts the SRID-carrying EWKT the result side writes. It is parsed directly
rather than through StaticGeometry so the value is owned by the lambda, which
is what the single free at the end of the call expects.

The ledger reads 1826 GENERATED, 662 GAP, 868 RESIDUE and 153 DEFERRED, and every
one of the 1826 emitted operator cores compiles against a -DMEOS=ON -DALL=ON
MEOS with 0 errors and 0 warnings.

[estebanzimanyi]

Closing: the change is not decidable on the evidence this repository can produce for it.

The branch carries a 59-line delta to codegen_nebula.py, and running the pristine and the
modified generator against tools/codegen/trgeo-descriptor.json -- the only descriptor the
repository commits, byte-identical on both arms -- emits output that is identical file for file,
0 differing lines over 140 emitted paths. The rig discriminates: injecting one line into an
emitted .cpp moves it to 1 differing file and restoring it returns 0. So that descriptor does
not reach the paths this change touches, and a green run over it says nothing about the change.

Deciding it needs a descriptor covering the value marshalling and timestamp-argument shapes the
delta actually alters, built from a freshly derived meos-idl.json.