0.9.0 — one idea has one spelling, and every declaration can cross a boundary

[Sunrisepeak]

Compile-time portability was the floor and was being mistaken for the goal. Every
interface, operation and structure is now shaped so that it can also be crossed
at run time, and clause 3's table states for each which boundaries it crosses.

Thirteen of the fifteen interfaces could not be crossed, and five causes stood
in the way rather than fifteen:

cause	count	answer
an exported data object	10	every report becomes an operation; one that varies between the resources of an interface takes the resource
an operation returns a pointer into the implementation	5	the value is copied into the caller's buffer and the length reported is the value's own
a result wider than one machine word	7	a transfer returns one signed word: the count, or the negated condition when none moved
an entry worded as a call	2	an entry is an address at which a context begins; no return address exists
clause 6.5	1	availability decided at production cannot serve an artifact produced once for many environments, so openkal.exec reports it as well

⭐ The transfer result was going to gain an out-parameter. It did not. The only
consumer of the two-word form collapsed the pair by hand at every site and by one
rule — report what moved, or the condition when nothing did. The pair was never
the shape a caller wanted. kal_io_result is deleted.

Also

• ⚠️ standard and hosted are withdrawn. A class named after a kind of
  environment is falsified by an environment nobody had in mind, and this one was
  falsified inside its own ecosystem: a C library is hosted above an
  implementation providing none of the three interfaces the class promised.
• kal_memory_granularity — a C library above openkal had no way to learn the
  quantum and fixed it at 4 KiB when it was built. One real system has two
  quanta (4 KiB pages, 64 KiB allocations), which is why this is one number
  defined as the coarsest that is always safe rather than a page size.
• kal_node_info carries its own size, reports which fields it filled, and
  carries an opaque identity. Those three questions were conflated, and the
  consequence was two different files reported as the same file with no error.
• Links enter openkal.fs, and resolution is stated in fs.h beside every
  operation it governs. It was stated only in clause 11, and two call sites of
  one implementation consequently chose opposite directions.
• kal_fs_open_file deleted; typed handles at kal_fs_stream and
  kal_spawn_streams; kal_endpoint.addr_len no longer freezes a per-word-size
  difference; clause 7.2 requires a forged handle to be refused; a name-length
  bound is reportable; kal_version and kal_interfaces are exported by every
  implementation and belong to no interface.

One binary, two implementations

tools/run-abi-test.sh is new and is the reason this could land at all. The
property a distributed binary rests upon was not merely untested — there was no
artifact of the shape that could test it, because every target had exactly one
implementation and it was linked in.

It builds openkal-linux as a shared object, builds a second implementation from
the same objects with six names renamed and answered by an interposer, builds one
probe against neither by name, and runs that one binary against each. Every answer
in the second run is a branch nothing here had ever taken: an implementation older
than the consumer's declarations, a coarser quantum, an optional interface
declined at run time, executable memory withheld, and an implementation that
cannot distinguish one node from another.

Two false greens in the suite's own machinery, both found while running it

• run-conformance.sh chose its binary with find | head -1. target
  accumulates a directory per fingerprint, so a run reported 143 held from a
  binary built two days earlier containing none of the observations just added.
• full was defined as ["standard", …]. Withdrawing standard left it naming
  four kinds of examination and no interface: 168 held became 119 held, with an
  exit status of zero both times.

168 observations hold against openkal-linux 0.7.0, up from 143.