# acceding <!-- zero:scaffolded-readme --> <!-- Replace the line below with what this module provides and who consumes it, then delete both comment lines. --> TODO: describe this module.

# RITE — the rules of The Acceding The nine gates, the touch/cool/flinch economy, and the loop that turns a litany into a verdict. RITE is the only writer of `A.state`; everything else reads that table and listens on the bus. ## The nine gates | # | Gate | Demand | A refusal costs | |---|---|---|---| | 1 | THE PORCH | three different glyphs | 0.07 | | 2 | THE FONT | all three of WATER | 0.08 | | 3 | THE HINGE | a glyph and its undoing | 0.09 | | 4 | THE VOW | three withholding, and not the tenderest word | 0.10 | | 5 | THE UNBARRED | no IRON, and one word twice with a different third | 0.11 | | 6 | THE CENSER | all three of ASH | 0.12 | | 7 | THE AMNESTY | nothing from the last litany, and three suits | 0.13 | | 8 | THE OPEN HAND | three giving, opening and closing on one word | 0.15 | | 9 | THE CROWN | one word, three times | 0.17 | Two glyphs to a suit and three slots to a litany, so gates 2 and 6 cannot be answered without saying a word twice, and gates 5, 8 and 9 ask for the repeat outright. The re-saying is forced by the content. Gate 9 is the whole plan in one move: three sayings of a word from cold land it **exactly on** the flinch threshold and never over it, so the crown is free to whoever kept one word rested and costs a flinch to whoever did not. ## The numbers, and why Applied over `A.TUNING` at load. Every one of them was measured against a simulated run of five player models, not guessed. | | | | |---|---|---| | `TOUCH_PER_SAY` | 0.22 | three sayings from cold = 0.66, the threshold exactly | | `FLINCH_AT` | 0.66 | at or over, the next saying flinches | | `COOL_PER_TIER` | 0.18 | what an unspoken glyph sheds when a gate opens | | `FLINCH_EXTRA_TOUCH` | 0.15 | a flinched word is left tenderer still | | `IRRITATION_PER_FLINCH` | 0.22 | doubled at full touch, by `FLINCH_SCALE` | | `RELIEF_PER_ACCEDE` | 0.10 | an opened gate settles the machine | | `REFUSAL_TOUCH_REFUND` | 0.50 | see below | | `TENDER_AT` | 0.45 | LITANY marks a slab tender from here up | **A refused litany is half-remembered.** The Engine takes the full touch of every word as it is uttered and gives half of it back when it does not accede — it keeps what it granted, not what it heard. This is what makes nine unfamiliar demand kinds learnable: a wrong guess costs patience and a beat, not a whole word. The economy of an *accepted* litany, which the curve is tuned against, is untouched by it. A refusal emits `cool` with `cause = "refusal"`, so the meters visibly drop back. **The utterance is paid for before it is judged.** If the flinches in a litany fill the patience, the Engine seals on the spot and the litany never gets a verdict — right words or not. Measured outcomes, over the real module: | player | result | |---|---| | plans a rotation | wins at gate 9, no flinches | | wrong once at **every** gate, then corrects | wins at gate 9, patience 0.75 | | leans on one word every litany | sealed around gate 4–5 | | ignores the demand | sealed by gate 5 | | says one word three times, always | sealed at gate 1 | ## What the other slices need from it ### LITANY `M.demand()` returns `{ n, title, liturgy, plain, barred, miss }` for the gate the player stands at. `barred` is the list of glyphs that cannot appear in **any** answer to this gate — brute-forced, so it stays true for the composite gates and for gate 4, which reads the touch table. Dim them. `M.tenderness(glyphId)` returns `{ touch, tender, wouldFlinch, projected, placed, barred }` — everything a glyph slab needs to warn before it costs something. `projected` accounts for the copies of that glyph already in the litany, so a slab can show what it will be worth **when this litany is spoken**, not what it is worth now. **`M.ladder()` and `M.upcoming(k)` are not optional decoration.** The Engine does not hide what it will ask for. A player who cannot see that gate 6 wants ASH has no way to avoid spending ash at gate 5, and the game becomes a memory test instead of a plan. Render the gate above at minimum; the whole ladder on the how-to-play card is better. The difficulty was tuned against a player who can see one gate ahead. `M.bestLitany({ lookahead = true })` returns a satisfying litany, cheapest first, if the Verger should ever offer help. Callback: RITE answers `rite:skip`. LITANY's own `lit:skip` already calls `M.skip()` directly, which is fine. ### CHOIR RITE speaks these ids, and shows the written form of any line that has no clip rather than dropping it: `verger.open.1`, `verger.open.2`, `verger.touch` (the brief, in that order), `engine.greet`, `engine.accede`, `engine.refuse`, `engine.flinch`, `engine.seal`, `engine.crown`, and `glyph.<id>` for all eight glyphs — spoken once as the word is set down, and again as part of the chant when the litany is committed. That chant is the resaying, heard. **Three demand kinds are new and are registered into `A.DEMAND_KINDS` at runtime:** `twice_said`, `bookend`, `not_tenderest`. Anything generating a clip per demand kind needs those three as well as the seeded nine. Sfx ids RITE fires: `place`, `unplace`, `accede`, `refuse`, `seal`. ### STAGECRAFT and COLUMN `M.begin()` enters `brief` and RITE holds the timer itself, so the opening always ends whether or not anything else is listening; `M.skip()` cuts it short. Bus events, in the order one gate produces them: `gate` → `place` ×3 → `speak` → (`flinch`) → `verdict` → `accede` → `cool` → `gate`, or `verdict` → `irritation` on a refusal, or `phase` + `lose` on a seal. `win` fires when the ninth gate accedes. ## Known seam While the chant and the verdict line are playing, LITANY's line card sits over the glyph slabs and pointer input to them is lost. RITE keeps that window as short as it can — the chant is 0.34 s a word — but the card's own dismissal is LITANY's. ## Re-running it `M.audit()` brute-forces all 512 ordered litanies against every gate and reports how many answer each. A zero anywhere is an unwinnable game. It is cheap; run it after any change to the curriculum.

# art.ui.sigils — the marks on every screen Every piece of art in **The Acceding**'s interface, as inline SVG strings. This module touches nothing in the world: it is a table the screens paint. - `glyph[id]` — one 64 × 64 mark per word. A suit's giving and withholding words are drawn as the same figure turned against itself, so the vocabulary is learned by silhouette before it is learned by name: a lintel with its stem pointing down (KNEEL) against one pointing up (RISE), a vessel closed over (DROWN) against one tipped out (POUR), a shackle meeting its post (SEAL) against one swung clear (OPEN), a cartouche holding a name (NAME) against one coming apart into salt (FORGET). - `seal[suit]` — the four alchemical marks, because the fiction is a machine in a church and these are the marks a diocese would have stamped on it: fire over a bar for ASH, the water triangle, the mars glyph for IRON, the salt circle. - `rosette` — the title mark: nine teeth for nine gates, a verdigris ring, and the fire inside it. - `crown` / `sealed` — the two endings. - `rule`, `socket`, `speak`, `pause`, `slip` — the furniture. Almost every mark paints with `currentColor`, so the widget's CSS `color` tints it and one sigil serves the porcelain, the ember and the blood states without a second copy. `forGlyph(id)` and `forSuit(id)` answer with the socket mark rather than nil for anything unknown. The few marks that carry their own gradients state them `gradientUnits="userSpaceOnUse"`. An `objectBoundingBox` gradient on a zero-area path — a straight rule, a hairline — resolves to no paint at all, and the shape silently draws nothing.

# choir — the sound of The Acceding The mix, the score, the vault's breath, the Engine's own bronze resonance, the one-shot library the other slices fire, and every word anybody says. ## What another slice calls ```lua local Choir = require("choir") Choir.line(id) -- the WRITTEN form: { id, text, speaker, voice, clip } Choir.speak(id) -- say it aloud on the narrative voice Choir.speakNow(id) -- say it aloud on the Litanist's own voice, immediately Choir.sfx(name) -- a one-shot from the library Choir.ui(name) -- the interface's own one-shots, on a quieter channel Choir.music(phase) -- crossfade the score Choir.demandLine(k, a) -- the line id for a gate's demand Choir.glyphLine(id) -- the line id for a spoken glyph Choir.report() -- what sounds, and what does not ``` `line` always answers, whether or not the audio arrived: the written form is the source of truth and the screen shows it either way. `speak` returns false when a line has no clip, and records the gap in `Choir.missing` rather than losing the line. ## What it owns Nine emitters under the `Choir` anchor — the bed, the Engine's resonance, the standing water, two music decks, the narrative voice, the Litanist's own voice, and the two one-shot sources. Assets are `snd_*` under `/source/audio`. Sixty-five clips: forty-five spoken lines, eight CPU-synthesised sounds, eight generated one-shots and four pieces of score. ## Hearing it `choir:say:<lineId>`, `choir:play:<clipName>`, `choir:install`, `choir:generate` and `choir:report` are callback ids the driver forwards here, which is how a sound is auditioned from outside the game: a module required from a loose `execute` is a second copy with no emitters on it, and a call made there plays nothing. Each writes its answer to `/source/audio/audition.txt`.