Merge pull request 'Design 47 G: the lead's answers A-71 to A-92' (#560) from design/47-G-lead-answers-6 into main

2026-11-11 22:39:59 +00:00
parent 95d2c22471 e8fce4ca46
commit e1609f5dbb
1 changed files with 121 additions and 0 deletions
@@ -275,3 +275,124 @@ names the principle that settles it, and is cited as "design 47 G A-n".
 - **A-70** (§572, A-45; the rule that a process answers no call) The builder's tools bundle serves `reserved` and
  `builder_versions`, following the catalog half's view itself as other bundles follow views; the builder's process
  serves no call.
 - **A-73** (§588, §369; principle 7) To publish again, the builder takes each artifact's kind and package name from the
  catalog entry of the reserved commit, and sends the registry seat's `publish` with the digest and no parts: the
  holder takes the bytes from the artifact store, addressed by digest (A-50). "Not stored" is the holder's refusal;
  the entry then ends failed, said with its reason.
 - **A-74** (§700; principle 1, no module names another) The indexer reads the router's `asks` through the seat
  `operator-channel`: its manifest `uses` that seat, and the bucket is formed from the seat's holder on the seat list
  and the contract's `StateAsks`, never a module's name in code; the teller's and the node-engine's `messenger_asks`
  constant goes the same way in their own change.
 - **A-75** (§654, §610; principle 7, and who may do what is no question) mesh-issues shows the pipeline rows where it
  already shows a delivery: its `DeliveryLine` gains `pipelines`, one row per module with its steps, `no run` where the
  runner's list answers none. A runner verb's old callers list does not refuse a module: from G no verb names its
  callers (§610), so the class's default holds.
 - **A-76** (§588, §568, A-73; principle 7) A reservation keeps the fingerprint of the catalog entry it was made from
  (`versions.Source` gains it), so publish again reads that entry; the registry seat for an artifact is found from its
  package ecosystem as the builder's seat hearing already maps it. A transport fault's class (`no responders`, `name
  lookup`, `connection`, `deadline`) is the one the existing retake reads from the call's error (ADR 0664, ADR 0668).
 - **A-77** (§373; principles 1 and 7) A wait's bound is a bound key with its own time to live in the waiting part's own
  state, as the condition keeper times its two hours (COND7): its expiry is heard as the bus's event and ends the wait
  then, failing the step naming the member; no timer in the process and no looking only at the next event.
 - **A-78** (§374, §375, §377, §354; principles 1 and 7) For `outdated` and its inputs, the indexer keeps what it hears:
  (a) `acted.<acting part>.<dependent>` in its own state, the newest `wait-ended` (ran or released) with the build it
  acted for, compared with the dependent's current build (its newest entry's fingerprint); (b) what a delivered
  version serves is read from that version's catalog entry (its manifest's `serves` and words); (c) a derived edge is
  marked by a field `filled: true` the contract's `VersionEdge` gains, the machines that place a module come from the
  assigner's `placement` (A-62), and each node's last `running` from the node-engine's stream read whole at start
  (§556); (d) an `inputs` entry is also keyed by its run ask's id, so the build seat's `step-ended` of that ask finds
  and deletes it.
 - **A-79** (§558, §614, §684, §196, §444; principle 7) As built in mesh-delivery 6d483af2: the gate's `source` is named
  in the short `invokes` form (the manifest's `invokes` is a list of names); the catalog half's rows go into the part's
  existing `grants_first_views`; while the catalog half is unread the part keeps what the bus loaded and only adds,
  which is §684's way past the cycle, so no registered branch holds nothing. The part's remaining reads of the
  indexer's `manifests`, `modules` and `verdicts` go too (§196): the catalog half answers them.
 - **A-80** (A-66, A-68, A-69, §375, §73; principles 7 and 8) What the indexer keeps as heard (`steps-since`, `toolchain`,
  `delivered`, `pending`, `acted`) lives in one state of its own, `heard`, not in `own-build`, which keeps its one key;
  every key part is escaped as a name (§73), so a dotted module name parses; a kind-3 edge compares its artifact's
  language with `toolchain.<language>`.
 - **A-81** (§588, §369; principle 7) As built in mesh-delivery f12883b2: the publish-again queue key is
  `<holder>.<module>.<version>`; the holders and their nodes are what the builder hears on `running` (read whole at its
  start, §556, so a restart rebuilds them); `running` means not stopped, with a fingerprint; a not-stored artifact is
  remembered on the reservation (`Unstored`); the tool's request rides a reasks mode `republish`; a message the state
  cannot take is not acknowledged, as the other parts do.
 - **A-82** (§7, §428, §704's seed; principle 1, no module names another) The builder finds a build module the way the
  indexer's seed does (mesh-delivery d73aeb02): the build seat whose acting rule `build` has an `on` matching the
  artifact's language or `kind:image`, and that seat's holder on the seat list. `Task.Module` and every lane key are
  that holder's name as the seat list gives it; a plan's artifact, the toolchain sources, `UnpublishedModules` and
  `builder_stuck` all derive from it, and `builder_stuck` reads each build seat's steps through the seat (`<seat>.steps`)
  rather than a named module's state. The floor's sources are the holders of the seats `git` (tags) and `mesh-catalog`
  (requirements) on the seat list.
 - **A-83** (§374, A-78, A-80; principles 1 and 7) `BuildEdges.fp` is the fingerprint of the branch's catalog entry at
  the revision `source` names, which the indexer holds itself; no field is added to `package-published`. For a build
  of another watched branch, kind 1 compares with that branch's newest build, kept as heard in `heard` as
  `branch-build.<module>.<branch>` (the digest `package-published` carries), not with a released digest.
 - **A-84** (§194 and its candidate's-view line, §348, §473; principle 1) The builder follows no candidate: only a run's
  steps read a candidate's view, so the builder learns a candidate's build from the run's build step ask, which names
  each entry by fingerprint; it reads each entry through `mesh-catalog.entry` (repository and commit are the member's
  head) and needs no pull request number, a build being per fingerprint. Its read of the indexer's `candidates` view
  goes.
 - **A-85** (§291, ADR 0666 §6, §9, §614, A-83; principle 7) The indexer keeps a catalog revision per watched branch, as
  it keeps the trunk's: objects `branch.<branch>.<n>` (the branch escaped as a name) beside `trunk.<n>`, the trunk being
  the first watched branch's; the branch follower's per-branch `revision` reads them, and `BuildEdges.fp` is the entry's
  fingerprint in the revision whose `source` the build names.
 - **A-86** (§354, §375; principle 7) `KeepInput` is called by the indexer's own `input` verb, when a run on request's asker
  hands an input; the indexer asks no `run` itself. A kind-3 edge's language is its catalog edge's target artifact's
  language, else the one language the entry's artifacts share, as built in mesh-delivery 652285f0.
 - **A-87** (§568, §589, A-70, A-76; principle 7) As built in mesh-delivery bd228d51: a fault with no node says `no node`;
  `FaultClass` maps `buildstep.PassingCause`'s words onto A-76's four classes. `builder_build`'s `newest: <branch>` is
  read by the tools bundle following the catalog half itself, as A-70 has it for `reserved`.
 - **A-88** (§610, the main file's item 85; principle 7) mesh-networking's A-N1 (callers named in its seven seat
  definitions) is not brought in: from G no verb names its callers (§610), which supersedes item 85's reading.
 - **A-89** (§37, §700, A-74; principle 7, one way for every asker) The runner reads its approval ask's warrant from the
  router's record of its ask, through the seat `operator-channel` as A-74 has it, never from the decided event's body;
  the decided event only wakes it.
 - **A-90** (§13, §14, §291, ADR 0666 §6, A-85; principle 7) A non-first branch's revision is made by the same take-in as
  the trunk's, taken per watched branch: `sourceFollow` takes `source.<branch>` for every watched branch, and the
  source path (`ApplySource`, the catch-up, the heads' take-in) runs with the branch as its argument, writing that
  branch's revision (corrected by A-93).
 - **A-91** (§26, §37, §700, Q-RN8; principle 7) The router's record value carries its `warrant` as §700 says: the
  operator-channel contract's `AsksByAskerIDValue` gains the field. A step the module's policy does not name is no step
  of its pipeline, so `Status` has no open question for it. The runner places a pipeline's steps when it starts it and
  asks each build seat for its step, as its asking half; that half is built in G.
 - **A-92** (§560, A-77, §627; principle 7, and who may do what is no question) The node-engine's bound keys live in a new
  state `bounds` of the seat `node-engine`'s definition, declared in its old section as a foundation part's states are
  (§627), key `<what>.<id>` with its own time to live; the node-engine's account holds it as it holds its other states.
 - **A-93** (§13, §14, §291, ADR 0666 §6, A-85, A-90; principle 7; corrects A-90's trunk) A non-first branch's take-in
  is a pure computation from that branch's merged messages straight into its revision (`KeepBranchEntries`): each
  module's fingerprint, inputs and graph node at the branch's heads, computed as the trunk's are, with no modules view
  or bucket of its own; the trunk's `modules`, `manifests` and graph stay the trunk's alone. The trunk stays the
  mesh-wide branch `main` (ADR 0666's default watched branch), named once in the indexer; a registration's own first
  branch decides only which of its branches it delivers from.
 - **A-94** (§379, §525, §526; principle 1, a part asks for another's data or hears its events) The assigner hears the
  builder's `build.ended` event (§379 names it) and reads no builder state such as `build-log`. A want for a trunk
  revision's entry takes `version` and its parts' digests from the `version-released` whose `source` is that revision;
  a build `build.ended` marks kept (its keeping node) is a kept build, its parts and `kept-on` from that event; a build
  of another watched branch is the one whose `build.ended` names that branch, its parts from that event.
 - **A-95** (§421, §683, §698, A-47; principle 7) As built in the node-engine's commits 7703162c and 97d3df3e: the entry key is
  `entry.<digits>` (a key takes no colon); `want.<module>` holds the want with its own `since`; an entry another node
  runs is learned from `running`; the refusal "no entry of fingerprint" is `not-found`; `first-view-again` refuses in
  words, the node-engine following no view. Still owed in G: a restart composes the bus module and the indexer from the
  kept entries and wants while both are down, without waiting for every input (§683's purpose), and the
  `entry-not-found` finding (§614).
 - **A-96** (§379, G-4's event table, §529, A-67; principles 1 and 7) The builder says `build.ended` itself, as a module
  event on its own stream: a foundation part's old `streams` entry `mesh-delivery-builder-builds`, 7 days, kept last per
  subject `build.ended.<module>.<fingerprint>` (each escaped), its body the build log entry's `module`, `fingerprint`,
  `made` (artifact → digest), `kept-on` and `branch`; the assigner `consumes` `mesh-delivery-builder.build.ended`. A
  want's source revision is the one its pass's kept assignment graph revision was computed from (A-67), matched to
  `version-released.source`; `parts` stay keyed `<module>:<artifact>`, the contract's comment corrected to say so.
 - **A-97** (§230, §194, §473, A-84, A-91; principle 7) A candidate's build is asked by the runner as a pipeline step of
  its own: the runner's asking half asks the seat `mesh-builds` a `build` step naming each entry by fingerprint, and the
  builder takes that ask (its one entry point for a candidate) and answers the step's end; `StepRun`'s steps stay lint,
  unit and integration on the build seats. With the candidate coming that way, the builder's watch of the gate's
  `source` for candidate base merges goes. A kind-3 dependency's `part` is the entry's kind-3 edge, as built in
  2dc51626.
 - **A-98** (§297; principles 3 and 7) The node agent gains one act, `Env.Stop`: it stops a module's units and containers
  and removes nothing, so a revert's data survives; the revert stops the newer build with it, asks `restore-kept`, and
  then `Apply` starts the reverted build. `Remove` keeps its meaning.
 - **A-99** (§230, A-91, A-97; principle 7) `build` is a step every pipeline has, placed first and required whatever its
  policy names, so the runner's step enum gains `build`; each module's pipeline asks the build of its own module's
  entry only, and a group's members are built by their own pipelines.
 - **A-100** (§379, A-96; principle 7) As built in mesh-delivery a5e1a5e5 and 5a352482: `build.ended` is said for a done
  build only; its `branch` is empty for the trunk; its old-section stream keeps 7 days with no keep-last setting (an
  old `streams` entry has none), which A-96's "kept last per subject" gives up.