Merge pull request 'Design 47 G: the lead's answers A-16 to A-25, each tested against the principles' (#554) from design/47-G-lead-answers-2 into main

2026-11-11 20:58:51 +00:00
parent 269d226a8d a1efa45250
commit 597d097982
1 changed files with 44 additions and 2 deletions
@@ -52,12 +52,54 @@ names the principle that settles it, and is cited as "design 47 G A-n".
 - **A-11** (GR10; principle 7) A wait's `version` is the holder's own running fingerprint, as the indexer names it.
 - **A-12** (GR10, §276; principle 4) `grants_release` ends the granting wait: the held entries go on, the wait is said
  ended with `how` `released`, and no `acting-part-late` is raised for it.
- **A-13** (§461, §439, §383; principle 7) mesh-sdk's writer forms its four subjects itself, in §383's form
+- **A-13** (§461, §439, §383; principle 7) mesh-sdk's writer forms its three own subjects (`finding-written`, `finding-cleared`, `findings-stated`) itself, in §383's form
  `mesh.stream.<module>.event.<event>.<node>`, from its module and node, through one function
-  `views.FindingSubjects(module, node)`; a module passes no subjects.
+  `views.FindingSubjects(module, node)`; a module passes no subjects. It hears `findings-asked` on the seat's subject `mesh.seat.mesh-conditions.event.findings-asked` (§387, §390, A-17), never on the part's own stream.
 - **A-14** (§580; principles 7 and 8) A finding that told several findings of one kind on one id apart by a `ref` puts that
  part into its id (`<id>.<ref>`, each escaped as §73 escapes a name); a kind stays a fixed word of its bundle's list. The
  key's scope and id and the subject's scope and id are set equal, as before.
 - **A-15** (§614; principle 3) In the branch follower an `entry` the holder refuses is `not-found`; a transport error leaves
  it `asked` and is asked again; each part writes `entry-not-found` from the follower's changes. As built in mesh-delivery
  ab616fa6.
 - **A-16** (§461, §485, §503; principle 7, the rule that shared code lives in mesh-sdk) A stdio module's writer is made by
  one mesh-sdk constructor, `views.NewStdioWriter`, generic as the writer is,, which fills `Publish` from the module's own event
  publish and `Listen` from its subscription; no module writes that adapter. The tool runner's own finding writer
  (mesh-tools' first views) hands in `Publish` and `Listen` from its bus connection, in its one place.
 - **A-17** (§461, A-16; ADR 0613 §5, principle 7; corrected) `findings-asked` is always the seat `mesh-conditions`' event,
  but a seat's name and contract are mesh-contracts' (ADR 0613 §5), so mesh-sdk names no seat: the writer takes the
  subject it hears in one config field `Asked`, which each module fills from the generated `mesh-conditions` contract's
  own constant (`SubjectFindingsAsked`), in Go and TypeScript alike.
 - **A-18** (§587, §305; principle 7) What G retires leaves no trace: the gate's record type drops the `remove` operation
  and `OpRemove` (§587: a removal is no operation), and its `table`, `recheck` and `close` go with their handlers and
  tools (§305). `checks` goes too, as §431 retires it with the merge states; the check is the runner's now (G-2).
 - **A-19** (§641, §556; principles 1, 7 and 2) `HearSeatEvents` learns that a stream is kept last per subject from the
  stream's own info on the bus, with no new parameter; its ordered read at the start filters on the same subjects as its
  durable; the read's messages go to the same handler as the durable's, so one path handles both; it names the read
  `waiting` and then `read` through one callback option it calls, which the module wires to its first views, so
  `process` imports nothing of `views`.
 - **A-20** (§613, replaces A-8's way of opening the old section; principles 7 and 2, and no data is lost) The gate keeps
  its kept data with the fewest parts that lose none: where the template `state` entry can take the old section's
  existing bucket as its own, it does, and nothing is copied; where it cannot, the old section stays declared in
  `state` under the local name `<name>-old` bound to its existing bucket, read through `stdio.State` like any section,
  copied once by A-8's rule (a key only where the template lacks it), and retired with §613's other old sections.
  The developer says which of the two the runtime allows, with the line of code that shows it.
 - **A-21** (§518, §345, §457, §643; principles 7 and 3) Each put-chunk and each get call carries `objects`, the store's
  local name, as today's put does. The chunk is a constant of `buscalls`, 512 KiB, which fits under the bus's default
  maximum payload of 1 MiB whatever the bus is set to; a value larger than one chunk goes by session, a smaller one in
  one call as today, so there is one threshold.
 - **A-22** (§686, §689, A-14; principle 7) As built in mesh-catalog 9677f200 and b78e90c0: a pending finding's bound is the
  module's own check interval; a field the contract's `Finding` lacks (`resolved`, and its words in every module, the watchman's included) is dropped, the keeper saying a clear in its own words; an id is escaped as a
  name, and a `ref` goes into the id only where two findings of one kind share an id; old keys are cleared by the
  writer's first statement. mesh-sdk keeps no old `views.Finding` or `FindingWriter` beside the generic writer.
 - **A-23** (§81, §132; principle 7) The gate's `recovery` marks the delivery record through its ordinary update, with one
  field `recovery` holding `by` (the proved caller), `why` and `commit`; no new operation. Then it says `recovery-merged`.
 - **A-24** (§431, §172, §592, §158; principles 7 and 4) Once the merge states go, `deliveries`, `show` and `groups` answer
  the delivery records as the gate keeps them (G-3 *The delivery record*), filtered by their arguments, with no line
  form of their own; `stalled` answers the records whose open wait is past its bound, with that wait. The pull-request
  handlers and their effects stay only where G-3 §158 names what the gate owes the forge, rebuilt on the records; the
  rest goes with the state table.
 - **A-25** (§518, A-21; principle 3) A session put loses nothing a one-call put keeps: its first chunk carries the put's
  `description`.
 - **A-26** (§687, §689, A-22; principle 7) A part raises no follower's finding itself: every follower is adopted through
  its reader (`Adopt`), and the reader raises and clears the follower's four findings through the module's writer, so
  the pipeline runner, the indexer and the assigner build none of their own.