diff --git a/03-DESIGN/01-to-be/47-milestones/G-20-lead-answers.md b/03-DESIGN/01-to-be/47-milestones/G-20-lead-answers.md index 9c3018fd..16dd3db1 100644 --- a/03-DESIGN/01-to-be/47-milestones/G-20-lead-answers.md +++ b/03-DESIGN/01-to-be/47-milestones/G-20-lead-answers.md @@ -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..` 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.`. +- **A-81** (§588, §369; principle 7) As built in mesh-delivery f12883b2: the publish-again queue key is + `..`; 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 (`.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..` (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..` (the branch escaped as a name) beside `trunk.`, 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: ` 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.` 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 `.` 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.` (a key takes no colon); `want.` 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..` (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 `:`, 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.