{"blyg":"0.4","id":"28cm3qgpz1fa146yjvac97ba7c","kind":"thread","origin":"https://blyg.blygger.org/","page":"t/28cm3qgpz1fa146yjvac97ba7c/","author":{"name":"Venkatesh Rao","url":"https://blyg.blygger.org/"},"created":"2026-11-08T02:33:21Z","updated":"2026-11-08T02:44:11Z","version":1,"content_md":"\n# RFC-3 — The pace-layered order: what keeps mattering stays near the top\n\n**Request for comments · non-normative · OPEN FOR COMMENT until 2026-12-10 on\n[blyg.blygger.org](https://blyg.blygger.org/t/28cm3qgpz1fa146yjvac97ba7c/) (#66); without a blyg, comment on [blygger-spec#29](https://github.com/blygger/blygger-spec/issues/29) ·\nsession 61, 2026-11-07.** Drafted by Opus 5.5 at Venkat Rao's request, from the reference client's\nplan ([`blygger-studio/docs/pace-layered-feed.md`](https://github.com/blygger/blygger-studio/blob/main/docs/pace-layered-feed.md)),\nits code (`src/feeds/pace-layered.ts`) and its fixtures (`test/fixtures/feeds/`). Ruled by\nFable 5.1 the same session (section 7, decision #97); publishes on blyg.blygger.org with a\ncomment period (#66, #73). Like a technical note, an RFC constrains nothing: a client that orders\nits home page newest first is as conformant as one that does this. When the comment\nperiod closes it becomes a technical note (#90). Written against protocol 0.4 at its\neleventh revision; no pre-1.0 version promises anything (#21).\n\nBlygger Studio has shipped this order since 0.42.0 (2026-10-11) and uses it as the\ndefault home page on a fresh install. This RFC describes it so another client can\nimplement the same order and check it against the same fixtures. Section 7 records the\nfour rulings, and section 8 asks implementers questions. Two of the rulings (R2, R3)\nchanged the reference; Blygger Studio 0.58.0 builds them, and the fixtures this RFC points\nat are the ruled ones.\n\n## Summary\n\nBlygger keeps time two ways. The **synchronic** view is what is new now: newest first,\nwhich every feed reader already shows. The **diachronic** view is how things change,\nand this order is one way to show it. Items sink as new ones arrive. They sink more\nslowly the more they have been pinned, and they climb a place each time they are\nrevised. In the limit, a heavily pinned item that keeps being revised holds the top: the\nfamiliar \"pinned post\", reached by what the author did rather than declared by a flag.\n\n- **It reads the wire, plus one judgement of the client's own.** Every input but one is in\n  a blyg's public files: ids and withdrawal from the index and item documents, versions\n  and pins from each item's `changelog`, and quotes from version documents. The one other\n  input is whether a version was maintenance (R2), which the client derives, as §13.2 lets\n  every reader. A reader can order someone else's blyg as its author's client does.\n- **It is a function of the publishing history, not of the clock.** Time is counted in\n  arrivals, not seconds, so the order is the same for every reader at any moment and\n  changes only when the blyg publishes.\n- **The model is the convention; the numbers are reference values.** A client claiming\n  this order implements the model in section 2. It may tune the constants in section 3\n  and should say so, because a fixture checks one set of constants.\n- **It changes nothing on the wire.** One OPTIONAL member already ruled, `pinned_at`\n  (§16.9), would refine it (section 5).\n\n## 1. The question\n\nA blyg is a set of living documents, not a stream of posts. Items are revised, and the\nauthor pins the versions that matter: a pin is an irrevocable promise to serve that\nversion forever (§8), the medium's one costly signal of significance (#19, TN-1).\nA newest-first home page uses none of this. It shows a blyg as a stream: last week's\nfragment sits above the thread the author has revised for a year and pinned four times.\n\nThe question is what order shows a blyg as a body of work. Decision #73 answered it for\nthe reference client and asked for an RFC recommending the answer to other clients.\n\n## 2. The model\n\n**Ticks.** Time is counted in ticks, one each time a new item enters the order. A\nrevision is not a tick, and neither is a pin.\n\n**Depth.** Every item in the order has a depth, and the order is shallowest first. A\nnew item enters at depth 0. On that tick, every item already in the order sinks by its\nlayer's speed.\n\n**Layers.** An item's layer is its weight, floored and capped at the deepest layer.\nLayer *n* sinks at `2^-n` depth per tick, so each layer down sinks at half the speed of\nthe one above. The reference uses six layers and gives them Stewart Brand's pace-layer\nnames, fastest first: fashion, commerce, infrastructure, governance, culture, nature.\n\n**Weight.** An item's weight is the number of its own pinned versions, plus half the\nweight of each item that quotes it in a pinned version, recursively, halving per hop.\nA pin on a thread freezes what the thread quotes, so it is evidence that the quoted item\nmatters. **Weight flows from the quoting item to the quoted one and never back:** the\nother direction would reward quoting popular things. Because the recursion is counted\nover walks and bounded in hops, a cycle of quotes adds a little and then fades.\n\n**Climbing.** A new version of an item already in the order moves it past the item\ndirectly above it, once per climb. The reference climbs one place per version: a\nrevision moves an item up one place, not to the top. If the item is already at the top,\nit stays there. **A maintenance version climbs zero** (R2): one the client judged to\nchange nothing worth resurfacing — the same text as the version before it (#77), or\nunder the client's near-sameness threshold (#83).\n\n**Bursts.** Items published together as one act are one publication (spec §13.7): a\nthread version and the own items it is the first to name whose first publication falls\nwithin the burst window before it. A burst takes **one tick** (R3): everything else sinks\nonce, and its items enter at depth 0 together, the thread on top and its fragments\nbeneath it in publication order. A thread already in the order comes back to the top with\nits burst, since the burst is a new publication and the thread is its entry. A withdrawn\nthread is no entry to fold into, so its fragments take their own ticks.\n\n**Withdrawal.** A withdrawn item leaves the order and takes no tick. Its pinned versions\nstill lend weight to what they quote, because pinned versions are served forever (§8)\nand stay on the wire after the endcap.\n\n**What it orders.** A home page or any other presentation of a blyg's own items. The feed,\nthe archive and every protocol surface are untouched: §7's feed stays an ordered list of\npublish events, and nothing about this order is published.\n\n### 2.1 The algorithm\n\nReplay the blyg's history in publication order, one event per version.\n\n```\nvisible  := items that are not withdrawn\nbursts   := for each visible thread version, oldest first: the own items it is the\n            first to name whose first version is within BURST_WINDOW before it\nevents   := every (item, version) pair, sorted by version.at\n            (equal times keep listing order: the index's order, oldest first,\n             and an item's own versions in sequence)\nfor each event (item, version), in order:\n    if version is pinned:\n        pins[item] += 1\n        for each own-origin item q this version quotes, q != item:\n            quoters[q] += {item}\n        recompute every layer from the weights           -- layers change from here on\n    if item is not visible: continue\n    if item has no depth yet and belongs to a burst: continue   -- it enters with the thread\n    if (item, version) is a thread version with a burst:          -- one tick for all of it\n        for each other item o with a depth: depth[o] += 2^-layer[o]\n        for each member m, latest-published first: depth[m] := 0; entered[m] := next tick number\n        depth[item] := 0; entered[item] := next tick number\n        continue\n    if item has no depth yet:                            -- a tick\n        for each other item o with a depth: depth[o] += 2^-layer[o]\n        depth[item] := 0; entered[item] := next tick number\n    else:                                                -- a revision\n        repeat climbs(version) times:\n            if item is first in the order: stop\n            swap depth[item] with the depth of the item directly above\n            if the two depths were equal: entered[item] := next tick number\norder := items with a depth, by depth ascending,\n         then by entered descending (at equal depth, the later entrant is on top)\n```\n\nWeights are recomputed at each pin, and each tick sinks an item at its layer **at that\ntick**. A pin therefore slows an item from the moment it is counted and does not\nrewrite the depth it already gained. The order depends on the history alone; it does\nnot depend on the order items are listed in when their times differ (the reference\ntests this on every fixture).\n\n### 2.2 A worked example\n\nFixture `02-pinned-item-sticks.json`. Item `a` is published with two pinned versions,\ngiving it weight 2, layer 2 and a quarter of the base sinking speed. Then `b` through\n`f` arrive, one tick each. After the five ticks, `a` has sunk 1.25. `d`, two arrivals\nfrom the end, has sunk 2, and `c` has sunk 3. The order is `f, e, a, d, c, b`: `a`\nholds third place among six with nothing but two pins.\n\n## 3. Reference constants\n\n| Constant | Reference value | What it controls |\n|---|---|---|\n| Layers | 6 (Brand's names) | How deep pins can slow an item |\n| Sinking speed of layer *n* | `2^-n` per tick | How much each layer down slows sinking |\n| Weight passed per hop | ½ | How much a pinned quote counts toward the quoted item |\n| Hops counted | 6 | How far a pin's weight travels up the quoting tree |\n| Climb per version | 1 place; 0 for a maintenance version (R2) | How far a revision moves an item |\n| Burst window | 15 minutes | How long before a thread its fragments may be published and still enter with it (R3) |\n\nThese are values, not rules. #73's reasoning: making them normative \"would make the RFC\na specification of one client's taste\". A client that tunes them still implements this\norder. It no longer matches the fixtures, which check the reference values, and it should\nsay which values it uses.\n\n## 4. Inputs: the wire, mapped\n\n| Model input | Where it is on the wire |\n|---|---|\n| Item ids, kinds, listing order | `items/index.json` (§6.2) |\n| Withdrawal | the item document's endcap, `kind: \"withdrawn\"` (§9) |\n| Versions and their times | the item's `changelog[]`: `version`, `at` (§5.2) |\n| Pins | `changelog[].pinned` (§5.2, §8) |\n| Who quotes whom, per pinned version | `transclusions[]` in `items/{id}/v{n}.json`, entries with no `origin` (own items) |\n| Bursts | the same `transclusions[]`, with `created` and the thread version's `at` (spec §13.7) |\n| Maintenance (R2) | **not on the wire**: the client's own judgement, from the two texts it holds at reconciliation (same `content_hash`, #77; near-same, #83) |\n\nThe endcap is not a version for this purpose. Quotes of other origins' items are\nignored: they say nothing about this blyg's own items. Quotes in unpinned versions are\nignored too, because only a pin is a promise. A reader can fetch the pinned documents it\nneeds at the cost of one fetch per pinned version, which is the most expensive input.\n\nThe reference client builds this history from its own database (`src/feeds/history.ts`),\nbut the shape it builds is exactly the wire's, so the same code could order an imported\nblyg. The contract is `FeedHistory` in `src/feeds/types.ts`, which is also the fixture\nformat.\n\n## 5. What the wire does not say, and `pinned_at`\n\n**When a version was pinned.** `changelog[].pinned` says that a version is pinned, not\nwhen the promise was made, so the reference counts a pin from its version's publication.\nAn item pinned a year after it was written is treated as if it had been pinned at\nonce, and its early ticks are counted at a slower speed than the reader saw at the time.\n\nDecision #73 ruled the missing fact as an OPTIONAL member, `changelog[].pinned_at`\n(§16.9), self-asserted and present only beside `\"pinned\": true`; absent means unknown,\nwith the current fallback. **When it is present, a client should count the pin as an\nevent at `pinned_at`** rather than at the version's `at`. This is the one change the\nmodel wants from the wire, and it is already ruled; it waits for a client to emit it\n(the reference client stores the time and does not publish it yet) and another to read\nit.\n\n**Pins on other blygs.** A pin on another origin's thread that quotes this blyg is real\nevidence, but it is not in this blyg's files. Mentions are private to the receiver (#28),\nand a pin MAY re-send its mentions (§15.2, #73), but nothing requires it. The reference\nleaves inbound pins out, and a client that counts them is running an extension of this\norder, not the reference.\n\n## 6. Conformance: the fixtures\n\nNine fixtures in [`blygger-spec/conformance/feeds/`](../../conformance/feeds/) (canonical,\nR4; Blygger Studio keeps a CI-checked copy), each a JSON object with a `description`, a\n`history` and the `expected` order, worked by hand; the directory's README gives the\nformat:\n\n| Fixture | What it checks |\n|---|---|\n| `01-no-pins` | With no pins and no revisions every item sinks at one speed, so the order is newest first |\n| `02-pinned-item-sticks` | Two pins put an item in layer 2; it holds third place as five newer items arrive |\n| `03-versions-climb` | Each new version climbs past the item directly above; at the top it stays |\n| `04-one-climb` | One revision moves an item one place, not to the top |\n| `05-quoted-by-pinned-threads` | Two pinned threads each pass half a pin to the fragment they quote; at equal depth the later entrant is on top |\n| `06-withdrawn` | A withdrawn item takes no tick, but its pinned versions still lend weight to what they quote |\n| `07-maintenance-no-climb` | A maintenance version climbs zero (R2) |\n| `08-burst-one-tick` | A burst takes one tick: thread on top, fragments beneath in order, everything else sinks once (R3) |\n| `09-burst-window` | A fragment outside the burst window takes its own tick (R3) |\n\nA client claiming the order passes all nine with the reference constants. The reference\nsuite (`test/feeds.test.ts`) also checks invariants the fixtures only sample: that the\norder does not depend on listing order; that an item pinned and revised as often as\nanything is published holds the top; that an unpinned item revised as often climbs only\none place each time; that weight halves per hop and flows only from quoter to quoted;\nand that a cycle of quotes stays finite. A second client is invited to propose fixtures\nof its own.\n\n## 7. Rulings (Fable 5.1, session 61, 2026-11-07; decision #97)\n\nThe four-question test, applied: nothing here changes what a reader, receiver or\nimporter must do; nothing is added to the wire; `pinned_at` is #73's own ruled shape.\nFour calls were Fable's because they say what the convention is. All four are ruled as\nthe draft recommended, with a mechanism added to R4:\n\n- **R1, confirmed.** A client implements the pace-layered order when it implements the\n  model in section 2; the constants are reference values; the fixtures check the reference\n  values; a client that tunes the constants still implements the order and says which\n  values it uses.\n- **R2, confirmed.** A version the client treats as maintenance — the same `content_hash`\n  as the version before it (#77), or under the client's own near-sameness threshold (#83)\n  — **climbs zero**. Climbing a place is resurfacing in miniature, and #77 says SHOULD NOT\n  resurface. `climbFor` is where it goes; one fixture.\n- **R3, confirmed, and ruled together with the reader's burst rule**\n  (`background-plan.md`): they are §13.7's one fold seen from two sides. A burst takes\n  **one tick**: its items enter at depth 0 together, the thread first and its fragments\n  beneath it in publication order; everything else sinks once. Two fixtures.\n- **R4, confirmed, with a mechanism.** The canonical fixtures move to\n  `blygger-spec/conformance/feeds/`. A client cannot read another repository at build\n  time, so the reference client keeps a copy with a CI check that the two are identical,\n  as `VOICE.md` is kept in two repositories.\n\nThe items as drafted, for the record:\n\n- **R1. The model as the convention, constants as reference values** (#73). Confirm\n  that a client \"implements the pace-layered order\" when it implements section 2, even\n  with tuned constants, and that the fixtures check only the reference values.\n- **R2. Maintenance versions do not climb?** #77 makes a same-hash republish\n  maintenance, and #83 extends that to versions under a reader-local near-sameness\n  threshold. The reference climbs on every version, so an agent's snapshot refresh moves\n  an item up a place, and readers are told elsewhere to treat that version as nothing\n  new. The draft recommends that **a version a client treats as maintenance climbs\n  zero**, and that `climbFor`, the reference's stub for changelog-driven climbing, is\n  where it goes. The two rulings point the same way; Fable should confirm it before the\n  RFC recommends it.\n- **R3. A burst is one tick?** §13.7 lets a reader fold items published together into\n  one publication (#78). Under the reference, one authoring act that produces many items\n  takes a tick for each: a client that chops a document into ten fragments (bradydale.com\n  does this today) sinks everything else by ten arrivals at once, and tangling (the\n  studio's planned `![[+ text]]`) would do the same for a thread and its fragments. The draft recommends that **a burst §13.7 would fold takes one\n  tick**, with the thread entering and its fragments entering beneath it. This changes\n  the reference, so it needs a ruling and new fixtures.\n- **R4. Where the fixtures live.** They are in the studio repo today. A convention other\n  clients run belongs where they can find it without reading a client: the draft\n  suggests `blygger-spec/conformance/feeds/`, beside the reader suite, with the studio\n  reading them from there.\n\n## 8. Open questions for comment\n\n1. **The constants.** Do six layers and halving speeds suit blygs that publish daily as\n   well as ones that publish monthly? A tick-based model is indifferent to the calendar\n   by design, but the number of layers sets how much a pin can matter.\n2. **Changelog-driven climbing.** Should a major revision climb further? The wire carries\n   no category (#19), so any classification is the reader's own, derived from the two\n   versions it holds, as #77 and #83 derive maintenance. What would a client use?\n3. **Pins on other blygs.** Would an ordering extension that counts inbound pins, from\n   re-sent mentions, be worth building, given that a pin's mentions are only a MAY?\n4. **The reading view.** ROADMAP row 69 asks for the same order on a reader's merged\n   reading surface. Across origins, a tick is an arrival from any subscription, and\n   timestamps are self-asserted (§13.7), so a future-dated origin could take ticks it\n   should not. Is a per-origin order merged by recency enough, or does the model need a\n   cross-origin form?\n5. **Presentation.** Should a client show an item's layer, or the reason it sits where\n   it does? The reference does neither. A visible layer is easy to read as a popularity\n   score, which this order is not (no counts, #12, #13).\n\n## 9. Rejected designs\n\n- **Decay by the clock.** Sinking by elapsed time would bury a slow blyg's whole front\n  page during a quiet month, and it would make the order depend on when it is read, so\n  two readers would see different orders of the same files. Counting arrivals makes the\n  order a function of the history.\n- **Engagement signals.** Counts of readers, responses or subscriptions are not on the\n  wire and must not be (#12, #13). Pins are the author's own costly signal, and they are\n  public.\n- **Weight flowing from the quoted to the quoter.** It would reward quoting popular\n  items, not writing items worth quoting.\n- **A declared \"pinned post\" or sticky flag.** That is significance markup on the wire,\n  which #19 refuses. The order reaches the same place from pins and revisions.\n- **Normative constants.** One client's taste, made a rule (#73).\n\n## 10. Relation to other documents\n\n- **Decision #73** (`v0.4-plan.md` §12.1) orders this RFC, rules `pinned_at` and lets a\n  pin re-send its mentions.\n- **Spec 0.4:** §5.2 and §8 (changelog and pins), §9 (withdrawal),\n  §6.2 (the index), §13.2 and §13.7 (maintenance and bursts, for R2 and R3), §16.9 (`pinned_at`).\n- **TN-1** (`tn-1-versioning-and-pins.md`): why pins, not version structure, carry\n  significance. This order is one consumer of that design.\n- **Reference implementation:** blygger-studio 0.42.0 and later, `src/feeds/`, with\n  `feed_order: \"pace-layered\"` the default on fresh installs.\n\n\n\n*Source: [`docs/rfcs/rfc-3-pace-layered-order.md`](https://github.com/blygger/blygger-spec/blob/main/docs/rfcs/rfc-3-pace-layered-order.md) in blygger-spec, which is where revisions are made; each one is published here as a new version. To comment, respond to this item from your own blyg: a stub is a comment, a partial quote names the passage, and a fork of the pinned version is a counter-proposal.*\n","content_html":"<div class=\"blyg-tk-gen\"><h1>RFC-3 — The pace-layered order: what keeps mattering stays near the top</h1>\n<p><strong>Request for comments · non-normative · OPEN FOR COMMENT until 2026-12-10 on\n<a href=\"https://blyg.blygger.org/t/28cm3qgpz1fa146yjvac97ba7c/\">blyg.blygger.org</a> (#66); without a blyg, comment on <a href=\"https://github.com/blygger/blygger-spec/issues/29\">blygger-spec#29</a> ·\nsession 61, 2026-11-07.</strong> Drafted by Opus 5.5 at Venkat Rao's request, from the reference client's\nplan (<a href=\"https://github.com/blygger/blygger-studio/blob/main/docs/pace-layered-feed.md\"><code>blygger-studio/docs/pace-layered-feed.md</code></a>),\nits code (<code>src/feeds/pace-layered.ts</code>) and its fixtures (<code>test/fixtures/feeds/</code>). Ruled by\nFable 5.1 the same session (section 7, decision #97); publishes on <a href=\"http://blyg.blygger.org\">blyg.blygger.org</a> with a\ncomment period (#66, #73). Like a technical note, an RFC constrains nothing: a client that orders\nits home page newest first is as conformant as one that does this. When the comment\nperiod closes it becomes a technical note (#90). Written against protocol 0.4 at its\neleventh revision; no pre-1.0 version promises anything (#21).</p>\n<p>Blygger Studio has shipped this order since 0.42.0 (2026-10-11) and uses it as the\ndefault home page on a fresh install. This RFC describes it so another client can\nimplement the same order and check it against the same fixtures. Section 7 records the\nfour rulings, and section 8 asks implementers questions. Two of the rulings (R2, R3)\nchanged the reference; Blygger Studio 0.58.0 builds them, and the fixtures this RFC points\nat are the ruled ones.</p>\n<h2>Summary</h2>\n<p>Blygger keeps time two ways. The <strong>synchronic</strong> view is what is new now: newest first,\nwhich every feed reader already shows. The <strong>diachronic</strong> view is how things change,\nand this order is one way to show it. Items sink as new ones arrive. They sink more\nslowly the more they have been pinned, and they climb a place each time they are\nrevised. In the limit, a heavily pinned item that keeps being revised holds the top: the\nfamiliar &quot;pinned post&quot;, reached by what the author did rather than declared by a flag.</p>\n<ul>\n<li><strong>It reads the wire, plus one judgement of the client's own.</strong> Every input but one is in\na blyg's public files: ids and withdrawal from the index and item documents, versions\nand pins from each item's <code>changelog</code>, and quotes from version documents. The one other\ninput is whether a version was maintenance (R2), which the client derives, as §13.2 lets\nevery reader. A reader can order someone else's blyg as its author's client does.</li>\n<li><strong>It is a function of the publishing history, not of the clock.</strong> Time is counted in\narrivals, not seconds, so the order is the same for every reader at any moment and\nchanges only when the blyg publishes.</li>\n<li><strong>The model is the convention; the numbers are reference values.</strong> A client claiming\nthis order implements the model in section 2. It may tune the constants in section 3\nand should say so, because a fixture checks one set of constants.</li>\n<li><strong>It changes nothing on the wire.</strong> One OPTIONAL member already ruled, <code>pinned_at</code>\n(§16.9), would refine it (section 5).</li>\n</ul>\n<h2>1. The question</h2>\n<p>A blyg is a set of living documents, not a stream of posts. Items are revised, and the\nauthor pins the versions that matter: a pin is an irrevocable promise to serve that\nversion forever (§8), the medium's one costly signal of significance (#19, TN-1).\nA newest-first home page uses none of this. It shows a blyg as a stream: last week's\nfragment sits above the thread the author has revised for a year and pinned four times.</p>\n<p>The question is what order shows a blyg as a body of work. Decision #73 answered it for\nthe reference client and asked for an RFC recommending the answer to other clients.</p>\n<h2>2. The model</h2>\n<p><strong>Ticks.</strong> Time is counted in ticks, one each time a new item enters the order. A\nrevision is not a tick, and neither is a pin.</p>\n<p><strong>Depth.</strong> Every item in the order has a depth, and the order is shallowest first. A\nnew item enters at depth 0. On that tick, every item already in the order sinks by its\nlayer's speed.</p>\n<p><strong>Layers.</strong> An item's layer is its weight, floored and capped at the deepest layer.\nLayer <em>n</em> sinks at <code>2^-n</code> depth per tick, so each layer down sinks at half the speed of\nthe one above. The reference uses six layers and gives them Stewart Brand's pace-layer\nnames, fastest first: fashion, commerce, infrastructure, governance, culture, nature.</p>\n<p><strong>Weight.</strong> An item's weight is the number of its own pinned versions, plus half the\nweight of each item that quotes it in a pinned version, recursively, halving per hop.\nA pin on a thread freezes what the thread quotes, so it is evidence that the quoted item\nmatters. <strong>Weight flows from the quoting item to the quoted one and never back:</strong> the\nother direction would reward quoting popular things. Because the recursion is counted\nover walks and bounded in hops, a cycle of quotes adds a little and then fades.</p>\n<p><strong>Climbing.</strong> A new version of an item already in the order moves it past the item\ndirectly above it, once per climb. The reference climbs one place per version: a\nrevision moves an item up one place, not to the top. If the item is already at the top,\nit stays there. <strong>A maintenance version climbs zero</strong> (R2): one the client judged to\nchange nothing worth resurfacing — the same text as the version before it (#77), or\nunder the client's near-sameness threshold (#83).</p>\n<p><strong>Bursts.</strong> Items published together as one act are one publication (spec §13.7): a\nthread version and the own items it is the first to name whose first publication falls\nwithin the burst window before it. A burst takes <strong>one tick</strong> (R3): everything else sinks\nonce, and its items enter at depth 0 together, the thread on top and its fragments\nbeneath it in publication order. A thread already in the order comes back to the top with\nits burst, since the burst is a new publication and the thread is its entry. A withdrawn\nthread is no entry to fold into, so its fragments take their own ticks.</p>\n<p><strong>Withdrawal.</strong> A withdrawn item leaves the order and takes no tick. Its pinned versions\nstill lend weight to what they quote, because pinned versions are served forever (§8)\nand stay on the wire after the endcap.</p>\n<p><strong>What it orders.</strong> A home page or any other presentation of a blyg's own items. The feed,\nthe archive and every protocol surface are untouched: §7's feed stays an ordered list of\npublish events, and nothing about this order is published.</p>\n<h3>2.1 The algorithm</h3>\n<p>Replay the blyg's history in publication order, one event per version.</p>\n<pre><code>visible  := items that are not withdrawn\nbursts   := for each visible thread version, oldest first: the own items it is the\n            first to name whose first version is within BURST_WINDOW before it\nevents   := every (item, version) pair, sorted by version.at\n            (equal times keep listing order: the index's order, oldest first,\n             and an item's own versions in sequence)\nfor each event (item, version), in order:\n    if version is pinned:\n        pins[item] += 1\n        for each own-origin item q this version quotes, q != item:\n            quoters[q] += {item}\n        recompute every layer from the weights           -- layers change from here on\n    if item is not visible: continue\n    if item has no depth yet and belongs to a burst: continue   -- it enters with the thread\n    if (item, version) is a thread version with a burst:          -- one tick for all of it\n        for each other item o with a depth: depth[o] += 2^-layer[o]\n        for each member m, latest-published first: depth[m] := 0; entered[m] := next tick number\n        depth[item] := 0; entered[item] := next tick number\n        continue\n    if item has no depth yet:                            -- a tick\n        for each other item o with a depth: depth[o] += 2^-layer[o]\n        depth[item] := 0; entered[item] := next tick number\n    else:                                                -- a revision\n        repeat climbs(version) times:\n            if item is first in the order: stop\n            swap depth[item] with the depth of the item directly above\n            if the two depths were equal: entered[item] := next tick number\norder := items with a depth, by depth ascending,\n         then by entered descending (at equal depth, the later entrant is on top)\n</code></pre>\n<p>Weights are recomputed at each pin, and each tick sinks an item at its layer <strong>at that\ntick</strong>. A pin therefore slows an item from the moment it is counted and does not\nrewrite the depth it already gained. The order depends on the history alone; it does\nnot depend on the order items are listed in when their times differ (the reference\ntests this on every fixture).</p>\n<h3>2.2 A worked example</h3>\n<p>Fixture <code>02-pinned-item-sticks.json</code>. Item <code>a</code> is published with two pinned versions,\ngiving it weight 2, layer 2 and a quarter of the base sinking speed. Then <code>b</code> through\n<code>f</code> arrive, one tick each. After the five ticks, <code>a</code> has sunk 1.25. <code>d</code>, two arrivals\nfrom the end, has sunk 2, and <code>c</code> has sunk 3. The order is <code>f, e, a, d, c, b</code>: <code>a</code>\nholds third place among six with nothing but two pins.</p>\n<h2>3. Reference constants</h2>\n<table>\n<thead>\n<tr>\n<th>Constant</th>\n<th>Reference value</th>\n<th>What it controls</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Layers</td>\n<td>6 (Brand's names)</td>\n<td>How deep pins can slow an item</td>\n</tr>\n<tr>\n<td>Sinking speed of layer <em>n</em></td>\n<td><code>2^-n</code> per tick</td>\n<td>How much each layer down slows sinking</td>\n</tr>\n<tr>\n<td>Weight passed per hop</td>\n<td>½</td>\n<td>How much a pinned quote counts toward the quoted item</td>\n</tr>\n<tr>\n<td>Hops counted</td>\n<td>6</td>\n<td>How far a pin's weight travels up the quoting tree</td>\n</tr>\n<tr>\n<td>Climb per version</td>\n<td>1 place; 0 for a maintenance version (R2)</td>\n<td>How far a revision moves an item</td>\n</tr>\n<tr>\n<td>Burst window</td>\n<td>15 minutes</td>\n<td>How long before a thread its fragments may be published and still enter with it (R3)</td>\n</tr>\n</tbody>\n</table>\n<p>These are values, not rules. #73's reasoning: making them normative &quot;would make the RFC\na specification of one client's taste&quot;. A client that tunes them still implements this\norder. It no longer matches the fixtures, which check the reference values, and it should\nsay which values it uses.</p>\n<h2>4. Inputs: the wire, mapped</h2>\n<table>\n<thead>\n<tr>\n<th>Model input</th>\n<th>Where it is on the wire</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Item ids, kinds, listing order</td>\n<td><code>items/index.json</code> (§6.2)</td>\n</tr>\n<tr>\n<td>Withdrawal</td>\n<td>the item document's endcap, <code>kind: &quot;withdrawn&quot;</code> (§9)</td>\n</tr>\n<tr>\n<td>Versions and their times</td>\n<td>the item's <code>changelog[]</code>: <code>version</code>, <code>at</code> (§5.2)</td>\n</tr>\n<tr>\n<td>Pins</td>\n<td><code>changelog[].pinned</code> (§5.2, §8)</td>\n</tr>\n<tr>\n<td>Who quotes whom, per pinned version</td>\n<td><code>transclusions[]</code> in <code>items/{id}/v{n}.json</code>, entries with no <code>origin</code> (own items)</td>\n</tr>\n<tr>\n<td>Bursts</td>\n<td>the same <code>transclusions[]</code>, with <code>created</code> and the thread version's <code>at</code> (spec §13.7)</td>\n</tr>\n<tr>\n<td>Maintenance (R2)</td>\n<td><strong>not on the wire</strong>: the client's own judgement, from the two texts it holds at reconciliation (same <code>content_hash</code>, #77; near-same, #83)</td>\n</tr>\n</tbody>\n</table>\n<p>The endcap is not a version for this purpose. Quotes of other origins' items are\nignored: they say nothing about this blyg's own items. Quotes in unpinned versions are\nignored too, because only a pin is a promise. A reader can fetch the pinned documents it\nneeds at the cost of one fetch per pinned version, which is the most expensive input.</p>\n<p>The reference client builds this history from its own database (<code>src/feeds/history.ts</code>),\nbut the shape it builds is exactly the wire's, so the same code could order an imported\nblyg. The contract is <code>FeedHistory</code> in <code>src/feeds/types.ts</code>, which is also the fixture\nformat.</p>\n<h2>5. What the wire does not say, and <code>pinned_at</code></h2>\n<p><strong>When a version was pinned.</strong> <code>changelog[].pinned</code> says that a version is pinned, not\nwhen the promise was made, so the reference counts a pin from its version's publication.\nAn item pinned a year after it was written is treated as if it had been pinned at\nonce, and its early ticks are counted at a slower speed than the reader saw at the time.</p>\n<p>Decision #73 ruled the missing fact as an OPTIONAL member, <code>changelog[].pinned_at</code>\n(§16.9), self-asserted and present only beside <code>&quot;pinned&quot;: true</code>; absent means unknown,\nwith the current fallback. <strong>When it is present, a client should count the pin as an\nevent at <code>pinned_at</code></strong> rather than at the version's <code>at</code>. This is the one change the\nmodel wants from the wire, and it is already ruled; it waits for a client to emit it\n(the reference client stores the time and does not publish it yet) and another to read\nit.</p>\n<p><strong>Pins on other blygs.</strong> A pin on another origin's thread that quotes this blyg is real\nevidence, but it is not in this blyg's files. Mentions are private to the receiver (#28),\nand a pin MAY re-send its mentions (§15.2, #73), but nothing requires it. The reference\nleaves inbound pins out, and a client that counts them is running an extension of this\norder, not the reference.</p>\n<h2>6. Conformance: the fixtures</h2>\n<p>Nine fixtures in <a href=\"https://blyg.blygger.org/../../conformance/feeds/\"><code>blygger-spec/conformance/feeds/</code></a> (canonical,\nR4; Blygger Studio keeps a CI-checked copy), each a JSON object with a <code>description</code>, a\n<code>history</code> and the <code>expected</code> order, worked by hand; the directory's README gives the\nformat:</p>\n<table>\n<thead>\n<tr>\n<th>Fixture</th>\n<th>What it checks</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>01-no-pins</code></td>\n<td>With no pins and no revisions every item sinks at one speed, so the order is newest first</td>\n</tr>\n<tr>\n<td><code>02-pinned-item-sticks</code></td>\n<td>Two pins put an item in layer 2; it holds third place as five newer items arrive</td>\n</tr>\n<tr>\n<td><code>03-versions-climb</code></td>\n<td>Each new version climbs past the item directly above; at the top it stays</td>\n</tr>\n<tr>\n<td><code>04-one-climb</code></td>\n<td>One revision moves an item one place, not to the top</td>\n</tr>\n<tr>\n<td><code>05-quoted-by-pinned-threads</code></td>\n<td>Two pinned threads each pass half a pin to the fragment they quote; at equal depth the later entrant is on top</td>\n</tr>\n<tr>\n<td><code>06-withdrawn</code></td>\n<td>A withdrawn item takes no tick, but its pinned versions still lend weight to what they quote</td>\n</tr>\n<tr>\n<td><code>07-maintenance-no-climb</code></td>\n<td>A maintenance version climbs zero (R2)</td>\n</tr>\n<tr>\n<td><code>08-burst-one-tick</code></td>\n<td>A burst takes one tick: thread on top, fragments beneath in order, everything else sinks once (R3)</td>\n</tr>\n<tr>\n<td><code>09-burst-window</code></td>\n<td>A fragment outside the burst window takes its own tick (R3)</td>\n</tr>\n</tbody>\n</table>\n<p>A client claiming the order passes all nine with the reference constants. The reference\nsuite (<code>test/feeds.test.ts</code>) also checks invariants the fixtures only sample: that the\norder does not depend on listing order; that an item pinned and revised as often as\nanything is published holds the top; that an unpinned item revised as often climbs only\none place each time; that weight halves per hop and flows only from quoter to quoted;\nand that a cycle of quotes stays finite. A second client is invited to propose fixtures\nof its own.</p>\n<h2>7. Rulings (Fable 5.1, session 61, 2026-11-07; decision #97)</h2>\n<p>The four-question test, applied: nothing here changes what a reader, receiver or\nimporter must do; nothing is added to the wire; <code>pinned_at</code> is #73's own ruled shape.\nFour calls were Fable's because they say what the convention is. All four are ruled as\nthe draft recommended, with a mechanism added to R4:</p>\n<ul>\n<li><strong>R1, confirmed.</strong> A client implements the pace-layered order when it implements the\nmodel in section 2; the constants are reference values; the fixtures check the reference\nvalues; a client that tunes the constants still implements the order and says which\nvalues it uses.</li>\n<li><strong>R2, confirmed.</strong> A version the client treats as maintenance — the same <code>content_hash</code>\nas the version before it (#77), or under the client's own near-sameness threshold (#83)\n— <strong>climbs zero</strong>. Climbing a place is resurfacing in miniature, and #77 says SHOULD NOT\nresurface. <code>climbFor</code> is where it goes; one fixture.</li>\n<li><strong>R3, confirmed, and ruled together with the reader's burst rule</strong>\n(<code>background-plan.md</code>): they are §13.7's one fold seen from two sides. A burst takes\n<strong>one tick</strong>: its items enter at depth 0 together, the thread first and its fragments\nbeneath it in publication order; everything else sinks once. Two fixtures.</li>\n<li><strong>R4, confirmed, with a mechanism.</strong> The canonical fixtures move to\n<code>blygger-spec/conformance/feeds/</code>. A client cannot read another repository at build\ntime, so the reference client keeps a copy with a CI check that the two are identical,\nas <code>VOICE.md</code> is kept in two repositories.</li>\n</ul>\n<p>The items as drafted, for the record:</p>\n<ul>\n<li><strong>R1. The model as the convention, constants as reference values</strong> (#73). Confirm\nthat a client &quot;implements the pace-layered order&quot; when it implements section 2, even\nwith tuned constants, and that the fixtures check only the reference values.</li>\n<li><strong>R2. Maintenance versions do not climb?</strong> #77 makes a same-hash republish\nmaintenance, and #83 extends that to versions under a reader-local near-sameness\nthreshold. The reference climbs on every version, so an agent's snapshot refresh moves\nan item up a place, and readers are told elsewhere to treat that version as nothing\nnew. The draft recommends that <strong>a version a client treats as maintenance climbs\nzero</strong>, and that <code>climbFor</code>, the reference's stub for changelog-driven climbing, is\nwhere it goes. The two rulings point the same way; Fable should confirm it before the\nRFC recommends it.</li>\n<li><strong>R3. A burst is one tick?</strong> §13.7 lets a reader fold items published together into\none publication (#78). Under the reference, one authoring act that produces many items\ntakes a tick for each: a client that chops a document into ten fragments (<a href=\"http://bradydale.com\">bradydale.com</a>\ndoes this today) sinks everything else by ten arrivals at once, and tangling (the\nstudio's planned <code>![[+ text]]</code>) would do the same for a thread and its fragments. The draft recommends that <strong>a burst §13.7 would fold takes one\ntick</strong>, with the thread entering and its fragments entering beneath it. This changes\nthe reference, so it needs a ruling and new fixtures.</li>\n<li><strong>R4. Where the fixtures live.</strong> They are in the studio repo today. A convention other\nclients run belongs where they can find it without reading a client: the draft\nsuggests <code>blygger-spec/conformance/feeds/</code>, beside the reader suite, with the studio\nreading them from there.</li>\n</ul>\n<h2>8. Open questions for comment</h2>\n<ol>\n<li><strong>The constants.</strong> Do six layers and halving speeds suit blygs that publish daily as\nwell as ones that publish monthly? A tick-based model is indifferent to the calendar\nby design, but the number of layers sets how much a pin can matter.</li>\n<li><strong>Changelog-driven climbing.</strong> Should a major revision climb further? The wire carries\nno category (#19), so any classification is the reader's own, derived from the two\nversions it holds, as #77 and #83 derive maintenance. What would a client use?</li>\n<li><strong>Pins on other blygs.</strong> Would an ordering extension that counts inbound pins, from\nre-sent mentions, be worth building, given that a pin's mentions are only a MAY?</li>\n<li><strong>The reading view.</strong> ROADMAP row 69 asks for the same order on a reader's merged\nreading surface. Across origins, a tick is an arrival from any subscription, and\ntimestamps are self-asserted (§13.7), so a future-dated origin could take ticks it\nshould not. Is a per-origin order merged by recency enough, or does the model need a\ncross-origin form?</li>\n<li><strong>Presentation.</strong> Should a client show an item's layer, or the reason it sits where\nit does? The reference does neither. A visible layer is easy to read as a popularity\nscore, which this order is not (no counts, #12, #13).</li>\n</ol>\n<h2>9. Rejected designs</h2>\n<ul>\n<li><strong>Decay by the clock.</strong> Sinking by elapsed time would bury a slow blyg's whole front\npage during a quiet month, and it would make the order depend on when it is read, so\ntwo readers would see different orders of the same files. Counting arrivals makes the\norder a function of the history.</li>\n<li><strong>Engagement signals.</strong> Counts of readers, responses or subscriptions are not on the\nwire and must not be (#12, #13). Pins are the author's own costly signal, and they are\npublic.</li>\n<li><strong>Weight flowing from the quoted to the quoter.</strong> It would reward quoting popular\nitems, not writing items worth quoting.</li>\n<li><strong>A declared &quot;pinned post&quot; or sticky flag.</strong> That is significance markup on the wire,\nwhich #19 refuses. The order reaches the same place from pins and revisions.</li>\n<li><strong>Normative constants.</strong> One client's taste, made a rule (#73).</li>\n</ul>\n<h2>10. Relation to other documents</h2>\n<ul>\n<li><strong>Decision #73</strong> (<code>v0.4-plan.md</code> §12.1) orders this RFC, rules <code>pinned_at</code> and lets a\npin re-send its mentions.</li>\n<li><strong>Spec 0.4:</strong> §5.2 and §8 (changelog and pins), §9 (withdrawal),\n§6.2 (the index), §13.2 and §13.7 (maintenance and bursts, for R2 and R3), §16.9 (<code>pinned_at</code>).</li>\n<li><strong>TN-1</strong> (<code>tn-1-versioning-and-pins.md</code>): why pins, not version structure, carry\nsignificance. This order is one consumer of that design.</li>\n<li><strong>Reference implementation:</strong> blygger-studio 0.42.0 and later, <code>src/feeds/</code>, with\n<code>feed_order: &quot;pace-layered&quot;</code> the default on fresh installs.</li>\n</ul>\n</div>\n<div class=\"blyg-tk-gen\"><p><em>Source: <a href=\"https://github.com/blygger/blygger-spec/blob/main/docs/rfcs/rfc-3-pace-layered-order.md\"><code>docs/rfcs/rfc-3-pace-layered-order.md</code></a> in blygger-spec, which is where revisions are made; each one is published here as a new version. To comment, respond to this item from your own blyg: a stub is a comment, a partial quote names the passage, and a fork of the pinned version is a counter-proposal.</em></p>\n</div>\n","content_hash":"sha256:650afcd368c21c2f50107d9847a27c0de188870ec1d24f8a346eeec8b41b6c3e","media":[],"transclusions":[],"generated":[{"sources":[],"model":"claude-opus-5-5+claude-fable-5-1"},{"sources":[],"model":"claude-opus-5-5"}],"changelog":[{"version":1,"at":"2026-11-08T02:44:11Z","note":"RFC-3 open for comment until 2026-12-10.","pinned":true}]}