77dd24d: A source check that checks, and a dev server that answers

Published from cloudronin/astara@77dd24d4b0f0c24be9c7a520ae4810a52ee8def9

README.md

@@ -33,9 +33,12 @@ people outside knew about whoever lived there. Knock down a carrier and you get
 
 Neither one names anybody. The gap between them is the whole game.
 
-**Take the letter off the nail and what is left is the patch of cleaner wall it
-kept the weather off for sixty years.** That is where a fragment goes. Stand at
-the door, scroll to one, press take, and it is pinned there.
+**The letter stays on its nail. Under it is a second nail and a lighter patch of
+wall, where their own paper used to hang.** That is where a fragment goes. Stand
+at the door with one in your hand, press take, and it is pinned there.
+
+The door is where you judge: the question nailed in front of you, the answer in
+your hand. Hold `Q` to read your page, let go to read the door again.
 
 ## And then something happens
 
@@ -43,9 +46,9 @@ the door, scroll to one, press take, and it is pinned there.
 up, walks home, opens their own door and stands in it.** They do not speak and
 they do not move again. It is the only act in the level that is not taking.
 
-Put the wrong one there and nothing happens at all. The page sits on the wall
-and the body stays where it fell. You can take it back out and try somewhere
-else — nobody stops you, and nothing tells you which it was.
+Put the wrong one there and they get up anyway — and come for you. The page
+stays on the wrong wall until you take it back down and try somewhere else.
+Guessing is allowed. It costs.
 
 **Inside every house, hanging by the door, there is a key to the gate.** You can
 see it from the first time you light that door and you cannot reach it, because

manifest.json

@@ -967,39 +967,72 @@
         480,
         760
       ],
-      "nailAt": [
+      "letterAt": [
         [
-          288,
+          282,
+          612,
+          56,
+          76
+        ],
+        [
+          272,
+          612,
+          56,
+          76
+        ],
+        [
+          282,
+          612,
+          56,
+          76
+        ],
+        [
+          272,
+          612,
+          56,
+          76
+        ],
+        [
+          272,
+          612,
+          56,
+          76
+        ]
+      ],
+      "slotAt": [
+        [
+          282,
           704,
           56,
           76
         ],
         [
-          288,
+          272,
           704,
           56,
           76
         ],
         [
-          288,
+          282,
           704,
           56,
           76
         ],
         [
-          288,
+          272,
           704,
           56,
           76
         ],
         [
-          288,
+          272,
           704,
           56,
           76
         ]
       ],
-      "_nailAt_note": "ONE SPOT BESIDE EVERY DOOR, in the clip's own pixels, and it does three jobs in turn: the house's letter hangs there; take it and what is left is the lighter patch of wall the paper kept the weather off for sixty years; pin a fragment and it sits in that patch. WHAT IT REPLACES: a letter rect and, under it, a bright square frame — which read as a noticeboard, and no village in any century had one bolted to every house. THE PATCH IS EARNED: a house you have not read has a letter and no slot, so taking the letter is the thing that shows you where a fragment goes. That is the affordance the frame was trying to be. AND IT IS LOW, NOT HIGH ON THE DOOR: with the torch in her standing drawing's hand it hangs at hip height, the top of the light fell from 310 to 506, and everything above the door is dark. This is the rectangle the frame took four tries to find. GENERATED by gen_placeholders.js from the same geometry it draws the doorway from, never hand-written.",
+      "_letterAt_note": "THE LETTER, in the clip's own pixels, one per house. It never comes down: letters stay where they were left, and fragments come off bodies. So the door is where you judge — the question nailed in front of you, the fragment in your hand. STACKED OVER THE SLOT, the question above the answer: the only lit, empty wall is the ~118px column between where he stands and the arch's left jamb, and two pages side by side put one behind his shoulder. Its middle is 250px off the ground, nearer the flame. GENERATED by gen_placeholders.js from the same arch geometry it draws the doorway from, never hand-written.",
+      "_slotAt_note": "THE SLOT, in the clip's own pixels: a second nail under the letter and the lighter patch where their own paper used to hang. Pinning a fragment is putting that paper back. THERE FROM THE FIRST LIGHT, because it is the affordance — a bare nail beside a letter says something goes here, a lighter patch says something was here. A VALUE, NOT AN OUTLINE: no border and no glow. At the height the single nail used to hang, 22px off the jamb so the forge's anvil horn clears it by 6. GENERATED, with letterAt.",
       "keyAt": [
         [
           380,
@@ -1032,7 +1065,7 @@
           62
         ]
       ],
-      "_keyAt_note": "WHERE THE KEY HANGS, in the clip's own pixels, one per house. Just inside the left jamb and low — inside, because a key to your own front door hangs inside your own front door, and low for the same reason the frame and the letter are low: her standing drawing holds the torch at hip height, so the top of the light fell from 310 to 506 and everything above the door is dark. GENERATED, not written down: gen_placeholders.js publishes these out of the same arch geometry it draws the doorway from, so moving a door moves the key with it. letterAt was hand-authored and drifted from the art twice.",
+      "_keyAt_note": "WHERE THE KEY HANGS, in the clip's own pixels, one per house. Just inside the left jamb and low — inside, because a key to your own front door hangs inside your own front door, and low because it was hung when the torch was held at hip height, and the light still finds it there from where he stands to read the letter. GENERATED, not written down: gen_placeholders.js publishes these out of the same arch geometry it draws the doorway from, so moving a door moves the key with it. The first hand-authored letter rect drifted from the art twice.",
       "_doorAt_note": "Where the torch has to fall for the door to count as looked at, in the clip's own pixels. Same point in all five, because the door is at the middle of every facade. Move the door in the art and the reveal follows it.",
       "bleedEdges": [
         "bottom"
@@ -1073,7 +1106,7 @@
         210,
         1180
       ],
-      "nailAt": [
+      "letterAt": [
         [
           185,
           984,
@@ -1081,27 +1114,7 @@
           76
         ]
       ],
-      "_nailAt": "On the trunk wherever the trunk went, at a house nail's height above the ground, so the torch finds it from where a player already stands to read a door. The generator prints it.",
-      "silhouette": "auto"
-    },
-    "origin_tree": {
-      "_what": "WHERE THE NOTE CAME FROM, drawn at the foot of its page the way the order's page carries the palace. A lone tree.",
-      "path": "assets/origin_tree/",
-      "file": "lit_{nn}.svg",
-      "frames": 1,
-      "fps": 1,
-      "native": [
-        960,
-        900
-      ],
-      "pivot": [
-        480,
-        900
-      ],
-      "_pivot": "Same canvas and pivot as houses, so drawLetterHouse scales it with the same k.",
-      "bleedEdges": [
-        "bottom"
-      ],
+      "_letterAt": "The note, on the trunk wherever the trunk went, at a house slot's height above the ground, so the torch finds it from where a player already stands at a door. It never comes down and there is no slot: nothing goes back to a tree. The generator prints it.",
       "silhouette": "auto"
     },
     "kept": {
@@ -1137,7 +1150,7 @@
         48
       ],
       "silhouette": "auto",
-      "_frames": "Five village papers, one palace one and one scrap. The sixth is the order, cleaner and squarer because the palace does not write on scraps. The seventh is the note off the tree, torn and in a hand that is not the village's. Every frame stays inside the same ink box: the box is the union of all of them, and one that reached further would shrink every letter on every nail and every page."
+      "_frames": "Five village papers, one palace one and one scrap. The sixth is the order, cleaner and squarer because the palace does not write on scraps. The seventh is the note on the tree, torn and in a hand that is not the village's. Every frame stays inside the same ink box: the box is the union of all of them, and one that reached further would shrink every letter on every nail and every page."
     },
     "key": {
       "_note": "ONE KEY, AND EVERY HOUSE HAS THE SAME ONE. Every household in a walled village holds a key to the gate; that is how village gates work. It is not evidence: it never enters the sheaf, it cannot be read, and there is nothing at all to work out about it. All the deduction in this level is in the paper. Visible from the moment a door is lit and not takeable until somebody comes home and opens it — you can see it the whole time and not have it.",

src/assets.js

@@ -195,10 +195,11 @@ export async function loadClips(manifest) {
       variantScale: def.variantScale ?? null,
       keptDrop: def.keptDrop ?? null,
       doorAt: def.doorAt ?? null,
-      // One spot beside each door: the letter, then the patch it leaves, then
-      // the page filed into that patch. Generated, never hand-written — the
-      // two rects this replaces included the one that drifted.
-      nailAt: def.nailAt ?? null,
+      // Two spots beside each door, stacked: the letter, which never comes
+      // down, and under it the slot a fragment is pinned into. Generated, never
+      // hand-written — the rects these replace included one that drifted.
+      letterAt: def.letterAt ?? null,
+      slotAt: def.slotAt ?? null,
       keyAt: def.keyAt ?? null,
       mapPivot: def.mapPivot ?? null,
       plots: def.plots ?? null,

src/checks.js

@@ -14,7 +14,7 @@
 // continuous tone allowed in the background the proxy stops working, so the two
 // tests below ask the real question directly, in the two places it matters.
 
-import { TUNING, BOWL, TORCH } from './tuning.js';
+import { TUNING, BOWL, TORCH, REVEAL_T } from './tuning.js';
 import { HOUSE_OF, laneLook, figureMidY } from './drained.js';
 import { BAND, linesNeeded, bandBox } from './band.js';
 import { GROUND_Y, W, H } from './scene.js';
@@ -715,14 +715,21 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
   /**
    * THE SHEAF. A pile of loose paper, and every claim here is about paper.
    *
-   * The map is page one. Everything after it is in the order he picked it up —
-   * no grouping, no sorting, no index and no tabs, because all of those are the
-   * game telling him what he has, and what he has is the thing he is meant to
-   * work out.
+   * His orders are page one. Everything after them is in the order he picked
+   * it up — no grouping, no sorting, no index and no tabs, because all of those
+   * are the game telling him what he has, and what he has is the thing he is
+   * meant to work out.
+   *
+   * AND NOTHING IN IT CAME OFF A WALL. Letters stay on their doors and the
+   * note stays on its tree: he does not pocket a stranger's mail. So the paper
+   * in it is his orders and the fragments he took off bodies, and in village
+   * one that is five pages at the most. Keys go in too, and come out again at
+   * the gate; they are carried, and they are not paper.
    */
   function sheafPages() {
     scene.reset();
     const sheaf = s.sheaf;
+    const isPaper = (p) => p.kind === 'letter' || p.kind === 'fragment';
 
     // 1. IT STARTS WITH HIS ORDERS AND NOTHING ELSE.
     //
@@ -736,83 +743,63 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       order.kind === 'letter' && !s.houses[order.house] &&
       s.textFor(order) === s.letters.byHouse[order.house].letter;
 
-    // 2. THE PLAIN TORCH READS IT WHERE IT LIES, and taking it is a separate
-    //    act. It used to fall into the sheaf the instant the door lit, which
-    //    made raising the sheaf the only way to see a word of the writing.
-    //    Now it is an object in the room: look at it, then take it.
-    s.prince.x = s.prince.prevX = s.houses[1].x - 300;
-    s.prince.facing = 1;
-    drive(2, { torch: true });
-    const readsIt = !!s.band.text && s.band.text === s.letters.byHouse[1].letter;
-    const notYetFiled = sheaf.pages.length === 1;   // the order, and nothing taken yet
-
-    drive(0.4, { torch: true, pickup: true });
-    const letterFiled = sheaf.pages.length === 2 &&
-      sheaf.pages[1].kind === 'letter' && sheaf.pages[1].house === 1 &&
-      sheaf.index === 1 && s.houses[1].letterTaken;
-
-    // And it is gone from the wall: taking it twice cannot happen.
-    drive(0.4, { torch: true, pickup: true });
-    const takenOnce = sheaf.pages.length === 2;
-
-    // 2b. AND THE TORCH DOES NOT HAVE TO STILL BE UP. Seeing latches; taking is
-    //     a separate act, the same as it is for a page on the ground. It used
-    //     to need the light held, which on a phone made the letter impossible:
-    //     TORCH and TAKE are both on the left wheel and one thumb cannot hold
-    //     one while pressing the other.
-    const h2 = s.houses[2];
-    const [d2] = s.doorPoint(h2);
-    s.prince.x = s.prince.prevX = d2 - 300;
-    drive(1.4, { torch: true });
-    drive(0.5);                                   // torch down, still stood there
-    const offeredInTheDark = s.canTakeLetter && s.torch.raise < 0.01;
-    drive(0.4, { pickup: true });
-    const takenInTheDark = h2.letterTaken;
-
-    //     But not from anywhere. Across the village it is not his to take.
-    const h3 = s.houses[3];
-    const [d3] = s.doorPoint(h3);
-    s.prince.x = s.prince.prevX = d3 - 300;
-    drive(1.4, { torch: true });
-    s.prince.x = s.prince.prevX = d3 - 1500;
-    drive(0.4);
-    const notFromAcrossTheVillage = !s.canTakeLetter && s.houses[3].letterSeen;
+    // 2. LETTERS STAY WHERE THEY WERE LEFT. Light every door and the tree,
+    //    stand at each and press E: the band reads it, and the pile does not
+    //    grow by a single page. With his orders on top, E at a bare slot does
+    //    nothing at all.
+    const stops = s.houses.map((h) => ({ x: h.x, text: s.letters.byHouse[h.index].letter }));
+    if (s.tree) stops.push({ x: s.tree.x, text: s.letters.byHouse[s.tree.index].letter });
+    let readEveryOne = true;
+    for (const st of stops) {
+      s.prince.x = s.prince.prevX = st.x - 300;
+      s.prince.facing = 1;
+      s.camera.reset(s.prince.x);
+      drive(1.4, { torch: true });
+      readEveryOne = readEveryOne && s.band.text === st.text;
+      tap();
+    }
+    const nothingCameOffAWall = sheaf.pages.length === 1 && sheaf.pages[0] === order;
 
     // 3. And running off the front of a one-page pile stays on that page.
     drive(0.5, { sheaf: true, left: true });
     const holdsAtTheFront = sheaf.index === 0 && !!s.band.text;
 
-    // 4. A FLIP WITH A BEAT. Holding an arrow walks the pile at reading speed,
-    //    not at frame rate. Three more pages, then hold right for a second and
-    //    count the turns: at 60fps a free browse would be sixty.
-    for (let k = 2; k < 5; k++) {
-      const h = s.houses[k];
-      s.prince.x = s.prince.prevX = h.x - 300;
-      drive(1.2, { torch: true });
-      drive(0.4, { torch: true, pickup: true });
-    }
-    // The order he FOUND them in, which is the order of everything after his
-    // orders — page zero was in his hand before he left the palace.
-    const foundOrder = sheaf.pages.slice(1).map((p) => p.house).join(',');
+    // 4. HIS ORDERS AND FOUR FRAGMENTS, AND THAT IS ALL THE PAPER THERE IS.
+    //    armed() downs every carrier in the village and takes what each one
+    //    was carrying, in the order they stand — so this is the fullest the
+    //    pile's paper can ever be, in the order he found it.
+    const carriers = armed();
+    const paper = sheaf.pages.filter(isPaper);
+    const fullPile = paper.length === 5 && paper.length === carriers.length + 1 &&
+      paper[0].kind === 'letter' && !s.houses[paper[0].house] &&
+      paper.slice(1).every((p) => p.kind === 'fragment');
+    const neverAWallsLetter = sheaf.pages.every((p) => p.kind !== 'letter' ||
+      (!s.houses[p.house] && p.house !== s.tree?.index));
+    const foundOrder = paper.slice(1).map((p) => p.kept).join(',');
+    const takenOrder = carriers.map((c) => c.kept).join(',');
+
+    // 5. A FLIP WITH A BEAT. Holding an arrow walks the pile at reading speed,
+    //    not at frame rate. Hold right for a second from the front and count
+    //    the turns: at 60fps a free browse would be sixty.
     sheaf.index = 0;
     const before = sheaf.turns;
     drive(1, { sheaf: true, right: true });
     const turnsPerSecond = sheaf.turns - before;
 
-    // 5. IT DOES NOT WRAP. Running off the end of a pile of paper does nothing.
+    // 6. IT DOES NOT WRAP. Running off the end of a pile of paper does nothing.
     drive(4, { sheaf: true, right: true });
     const stopsAtTheEnd = sheaf.index === sheaf.pages.length - 1;
     drive(6, { sheaf: true, left: true });
     const stopsAtTheStart = sheaf.index === 0;
 
-    // 6. THE INDEX SURVIVES RELEASE. He reopens where he left off.
+    // 7. THE INDEX SURVIVES RELEASE. He reopens where he left off.
     drive(1.2, { sheaf: true, right: true });
     const wasOn = sheaf.index;
     drive(1);                                   // sheaf down, walking about
     drive(0.6, { sheaf: true });
     const reopensWhereHeLeftIt = sheaf.index === wasOn && wasOn > 0;
 
-    // 7. A `?` RESOLVES THE MOMENT HE PAGES TO IT, and only the one he turned
+    // 8. A `?` RESOLVES THE MOMENT HE PAGES TO IT, and only the one he turned
     //    to. Two blind takes, open the second: it fills, the first stays blank.
     //    The pages BEHIND the one in his hand are what the unknown state is for.
     scene.reset();
@@ -826,7 +813,7 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       s.band.text === s.letters.byHouse[2].fragment;
     const resolvedTheOneHeIsOn = !s.prince.inventory[0].seen;
 
-    // 8. And the one still behind him reads as blank paper — no words in the
+    // 9. And the one still behind him reads as blank paper — no words in the
     //    band for a page he has not turned to.
     sheaf.index = 1;                            // the FIRST fragment, past the order
     s.band.text = null;
@@ -837,21 +824,20 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
 
     return {
       name: 'the sheaf pages',
-      pass: startsWithTheOrder && letterFiled && readsIt && notYetFiled && takenOnce &&
-            offeredInTheDark && takenInTheDark && notFromAcrossTheVillage &&
-            holdsAtTheFront &&
-            foundOrder === '1,2,3,4' && turnsPerSecond >= 3 && turnsPerSecond <= 5 &&
+      pass: startsWithTheOrder && readEveryOne && nothingCameOffAWall &&
+            holdsAtTheFront && fullPile && neverAWallsLetter &&
+            foundOrder === takenOrder &&
+            turnsPerSecond >= 3 && turnsPerSecond <= 5 &&
             stopsAtTheEnd && stopsAtTheStart && reopensWhereHeLeftIt &&
             blankWhileUnknown && resolvedOnPage && resolvedTheOneHeIsOn &&
             opensWhenHeTurnsToIt,
-      startsWithTheOrder, letterFiled,
-      theTorchAloneReadsIt: readsIt,
-      andLookingDoesNotTakeIt: notYetFiled,
-      takenOnceOnly: takenOnce,
-      takeableWithTheTorchDown: offeredInTheDark && takenInTheDark,
-      butNotFromAcrossTheVillage: notFromAcrossTheVillage,
+      startsWithTheOrder,
+      readsEveryDoorAndTheTree: readEveryOne,
+      andTakesNothingOffAWall: nothingCameOffAWall,
       holdsAtTheFrontOfThePile: holdsAtTheFront,
-      foundOrder, turnsPerSecondHeld: turnsPerSecond,
+      paperAtItsFullest: paper.length, ordersAndFourFragments: fullPile,
+      neverAHouseLetterOrTheNote: neverAWallsLetter,
+      foundOrder, takenOrder, turnsPerSecondHeld: turnsPerSecond,
       stopsAtTheEnd, stopsAtTheStart, reopensWhereHeLeftIt,
       blankUntilHeTurnsToIt: blankWhileUnknown, resolvesOnPage: resolvedOnPage,
       leavesThePagesBehindHimBlank: resolvedTheOneHeIsOn,
@@ -1031,7 +1017,11 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
         ticks++;
       }
       drive(1.4, { torch: true });
-      tap(); tap();                       // the letter first, then the key
+      // HIS ORDERS ON TOP, so the press can only be for the key. It used to go
+      // to the letter first; letters stay on the door now, and a fragment on
+      // top at a door that is not its own would pin there and wake somebody.
+      s.sheaf.index = 0;
+      tap();
       keyRows.push({ house: s.houses[k].kind, at: Math.round(kx),
         open: s.houses[k].open, taken: s.prince.keys > before });
     }
@@ -1046,6 +1036,7 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     s.camera.reset(s.prince.x);
     drive(1.6, { torch: true });
     const heldBefore = s.prince.keys;
+    s.sheaf.index = 0;                  // his orders on top: nothing to pin here
     tap(); tap(); tap();
     const residue = { lit: loom.seen, open: loom.open, taken: loom.keyTaken,
       gotNothing: s.prince.keys === heldBefore };
@@ -1206,19 +1197,14 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
   /**
    * Stand at house i with the sheaf up, on the page for fragment k.
    *
-   * THE LETTER COMES OFF FIRST, because until it does there is no slot: the
-   * nail beside the door holds the letter, and the patch it leaves is where a
-   * fragment goes. That is the order a player does it in too.
+   * THE DOOR IS LIT FIRST, the one time it needs to be: the slot takes a pin
+   * from the first light, and the letter stays where it is.
    */
   function atDoor(i, k = null) {
     s.prince.x = s.prince.prevX = s.houses[i].x - 300;
     s.prince.facing = 1;
     s.camera.reset(s.prince.x);
-    if (!s.houses[i].letterTaken) {
-      drive(1.4, { torch: true });
-      drive(0.2, { pickup: true });
-      drive(0.15);
-    }
+    if (!s.houses[i].seen) drive(1.4, { torch: true });
     if (k !== null) {
       s.sheaf.index = s.sheaf.pages.findIndex((p) => p.kind === 'fragment' && p.kept === k);
     }
@@ -1249,14 +1235,8 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     drive(0.6);                                   // Q released
     const stillFragment = held()?.kind === 'fragment' && !s.sheaf.up;
 
-    // A letter is a different shape in the hand, and it can be on top too —
-    // but one has to be in the pile first, and armed() only takes fragments.
-    s.prince.x = s.prince.prevX = s.houses[2].x - 300;
-    s.prince.facing = 1;
-    s.camera.reset(s.prince.x);
-    drive(1.4, { torch: true });
-    drive(0.2, { pickup: true });
-    drive(0.15);
+    // A letter is a different shape in the hand, and it can be on top too.
+    // The only one he carries is his orders — the rest stay on their doors.
     const li = s.sheaf.pages.findIndex((p) => p.kind === 'letter');
     s.sheaf.index = li;
     drive(0.6);
@@ -1329,16 +1309,13 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       const A = 0, B = 2;
       const h = s.houses[H];
 
-      // 1. A letter on the nail, anything on top -> takes the letter.
-      put(0); stand(H, withQ);
-      // the door has to have been looked at at least once for anything to be
-      // offered, which is the latch, not a mode
-      drive(1.4, { torch: true });
+      // The door has to have been looked at once for anything to be offered,
+      // which is the latch, not a mode. THERE IS NO LETTER ROW ANY MORE: it
+      // took the letter, and letters stay on the door.
       stand(H, withQ);
-      press();
-      const tookLetter = h.letterTaken && h.filed == null;
+      drive(1.4, { torch: true });
 
-      // 2. A bare patch, a fragment on top -> pins it.
+      // 2. A bare slot, a fragment on top -> pins it.
       put(A); stand(H, withQ); press();
       const pinned = h.filed === A;
 
@@ -1366,13 +1343,12 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       const forge = s.houses[F];
       put(0); stand(F, withQ);
       drive(1.4, { torch: true });
-      stand(F, withQ); press();                  // letter off
       put(0); stand(F, withQ); press();          // the forge's own, so it settles
       const settled = forge.settled && forge.filed === 0;
       put(B); stand(F, withQ); press();          // try to swap it
       const lockHeld = forge.filed === 0 && settled;
 
-      rows.push({ withQ, tookLetter, pinned, swapped, tookBackSame,
+      rows.push({ withQ, pinned, swapped, tookBackSame,
         tookBackWithLetter, bareAndLetterDoesNothing, lockHeld });
     }
     scene.reset();
@@ -1420,7 +1396,7 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     return withOverlayOff(() => {
       const clip = s.houseClip;
       const patch = (h) => {
-        const [nx, ny, nw, nh] = clip.nailAt[h.variant];
+        const [nx, ny, nw, nh] = clip.slotAt[h.variant];
         return [Math.round(h.x - s.camera.x - clip.pivotX + nx),
           Math.round(GROUND_Y - clip.pivotY + ny), nw, nh];
       };
@@ -1470,10 +1446,6 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
         s.prince.facing = 1;
         s.camera.reset(s.prince.x);
         drive(1.4, { torch: true });
-        if (!h.letterTaken) {
-          drive(0.2, { torch: true, pickup: true });
-          drive(0.15, { torch: true });
-        }
         drive(0.5, { torch: true });      // settled, and staying up
       };
       const put = (k) => {
@@ -1486,25 +1458,25 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       const forge = s.houses[0];
       stand(forge);
 
-      // 1. A LETTER ON TOP IS A BARE PATCH, and two renders of it back to back
+      // 1. HIS ORDERS ON TOP IS A BARE SLOT, and two renders of it back to back
       //    are the grain floor everything else is measured against.
       put(null);
       const bare = brightness(shot(forge));
       const noise = Math.abs(brightness(shot(forge)) - bare);
 
-      // 1b. AND AN EMPTY PATCH BREATHES.
+      // 1b. AND AN EMPTY SLOT DOES NOT GLOW. THIS CLAIM IS INVERTED.
       //
-      //     The ghost below only helps somebody already standing here with the
-      //     right thing in hand. Nothing walked them over: they lit a door, saw
-      //     a slightly cleaner rectangle, and had no reason to think it was
-      //     anything — which is what actually happened to the first person who
-      //     played it. The breath is the same one a dropped scrap has and a key
-      //     has, at the same numbers, and it means what it has always meant.
+      //     It used to breathe, with the same pulse a dropped scrap has: the
+      //     patch only appeared once the letter came off, and nothing walked a
+      //     player over to find it. The slot is under the letter from the first
+      //     light now, and a bare nail under a letter asks its own question. A
+      //     pulse on a wall reads as UI — and the loom house's empty slot has to
+      //     read as a letter nobody answered, all level, not as a button.
       //
       //     Measured over one full cycle of KEPT_PULSE_HZ, on a box wider than
-      //     the patch so the halo around it is counted too.
+      //     the slot so any halo around it would be counted too.
       const wide = (h) => {
-        const [nx, ny, nw, nh] = clip.nailAt[h.variant];
+        const [nx, ny, nw, nh] = clip.slotAt[h.variant];
         return [Math.round(h.x - s.camera.x - clip.pivotX + nx) - 26,
           Math.round(GROUND_Y - clip.pivotY + ny) - 26, nw + 52, nh + 52];
       };
@@ -1518,7 +1490,7 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
         s.clock = 3.0;
         return Math.round(Math.max(...seen) - Math.min(...seen));
       };
-      const emptyBreathes = breath(forge);
+      const emptyIsStill = breath(forge);
 
       // 2. A SCRAP ON TOP AND THE WALL SHOWS IT.
       put(0);
@@ -1536,10 +1508,7 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       const pinned = brightness(shot(forge));
       const ghostIsNotThePin = ghosted - pinned;      // solid, so darker again
 
-      // AND IT STOPS. An empty place asks its own question; a full one has
-      // nothing left to ask. Same reason the gate's sockets never needed
-      // explaining — and why the loom house goes on asking all level, with
-      // nobody left to answer it.
+      // AND A FULL ONE IS STILL TOO. Nothing on this wall pulses, ever.
       const filledIsStill = breath(forge);
 
       // 4. AND IT IS OVER. Lightning, not a filter.
@@ -1564,11 +1533,11 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
         pass: ghostShows > Math.max(8, noise * 3) &&
               ghostIsNotThePin > Math.max(8, noise * 3) &&
               wrongGhost > Math.max(8, noise * 3) &&
-              emptyBreathes > 8 && filledIsStill <= 2 &&
+              emptyIsStill <= 2 && filledIsStill <= 2 &&
               struck && quiet && gone,
         flickerMovesTheMeanBy: noise,
-        anEmptyPatchBreathesBy: emptyBreathes,
-        andAFilledOneIsStill: filledIsStill,
+        anEmptySlotMovesBy: emptyIsStill,
+        andAFilledOneBy: filledIsStill,
         theWallPreviewsTheScrap: ghostShows,
         andItPreviewsAWrongOneToo: wrongGhost,
         theGhostIsNotThePin: ghostIsNotThePin,
@@ -1723,37 +1692,15 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       const visible = rows.every((r) => r.ink > 120 && r.light > 200 && r.litByTheTorch);
       const noneOfferedWhileShut = rows.every((r) => !r.offered);
 
-      // 1b. AND THE DOOR CARRIES THREE THINGS NOW. The nail, the key and the
-      //     room all live in the same arch, and all three have to be inside
-      //     the light from where he stops — which is the constraint that took
-      //     four tries to satisfy for two of them.
-      const three = s.houses.map((h) => {
-        const [nx, ny, nw, nh] = clip.nailAt[h.variant];
-        const [kx, ky, kw, kh] = clip.keyAt[h.variant];
-        s.prince.x = s.prince.prevX = h.x - 300;
-        s.prince.facing = 1;
-        s.camera.reset(s.prince.x);
-        drive(1.6, { torch: true });
-        const np = s.letterPoint(h);
-        const kp = s.keyPoint(h);
-        return {
-          house: h.kind,
-          // Rectangles, in the clip's own pixels. They may not touch.
-          clear: nx + nw <= kx || kx + kw <= nx || ny + nh <= ky || ky + kh <= ny,
-          nailLit: s.torch.covers(np[0], np[1]),
-          keyLit: s.torch.covers(kp[0], kp[1]),
-          // And from as far back as the letter can be taken from, which is
-          // wider than where he stands to read it.
-          nailInReach: Math.abs(s.prince.x - np[0]) <= TUNING.DOOR_REACH,
-          keyInReach: Math.abs(s.prince.x - kp[0]) <= TUNING.DOOR_REACH,
-        };
-      });
-      const doorCarriesThree = three.every((r) =>
-        r.clear && r.nailLit && r.keyLit && r.nailInReach && r.keyInReach);
+      // THE DOOR CARRIES FOUR THINGS NOW — letter, slot, key and room — and
+      // whether they all fit is its own check. See theDoorCarriesFour.
 
       // 2. NOT HIS WHILE THE DOOR IS SHUT.
+      // HIS ORDERS ON TOP. The top page after armed() is a fragment, and E at
+      // a door that is not its own pins it there — and wakes its owner.
       s.prince.x = s.prince.prevX = s.houses[0].x - 300;
       drive(1.6, { torch: true });
+      s.sheaf.index = 0;
       tap(); tap();
       const shut = { keys: s.prince.keys, taken: s.houses[0].keyTaken };
 
@@ -1767,7 +1714,8 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
         s.prince.x = s.prince.prevX = s.houses[k].x - 300;
         s.camera.reset(s.prince.x);
         drive(1.6, { torch: true });
-        tap(); tap();                    // the letter first, then the key
+        s.sheaf.index = 0;               // his orders on top: the press is for the key
+        tap();
       }
       const open = { keys: s.prince.keys, taken: s.houses.map((h) => h.keyTaken) };
 
@@ -1779,21 +1727,20 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       s.camera.reset(s.prince.x);
       drive(1.6, { torch: true });
       const offeredAtTheLoom = s.canTakeKey;
+      s.sheaf.index = 0;
       tap(); tap(); tap();
       const residue = { open: s.houses[3].open, taken: s.houses[3].keyTaken,
         offered: offeredAtTheLoom, keys: s.prince.keys };
 
       return {
         name: 'the key is behind the door',
-        pass: visible && noneOfferedWhileShut && doorCarriesThree &&
+        pass: visible && noneOfferedWhileShut &&
               shut.keys === 0 && !shut.taken &&
               open.keys === 4 && open.taken.filter(Boolean).length === 4 &&
               !residue.open && !residue.taken && !residue.offered && residue.keys === 4 &&
               carriers.length === 4,
         visibleInEveryLitDoorway: visible,
         andNotOfferedWhileShut: noneOfferedWhileShut,
-        theNailTheKeyAndTheRoomAllClearEachOther: doorCarriesThree,
-        three,
         shut, open,
         theLoomHouseNeverOpens: residue,
         rows,
@@ -1962,9 +1909,7 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
    */
   function markingIsAClaim() {
     scene.reset();
-    // Stand at house i's door, letter off the nail, sheaf up. The letter has
-    // to come off first now: the nail holds it, and the patch it leaves is the
-    // slot. See claim 1b.
+    // Stand at house i's door with the sheaf up, the door lit.
     const at = (i) => atDoor(i);
     const mark = () => drive(0.3, { sheaf: true, pickup: true });
     const filed = () => s.houses.map((h) => h.filed);
@@ -1983,29 +1928,24 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     //    nail is still bare.
     const nothingAutoFiles = filed().every((f) => f == null);
 
-    // 1b. AND THERE IS NOWHERE TO FILE UNTIL THE LETTER IS OFF THE NAIL.
+    // 1b. AND A DOOR TAKES A PIN THE FIRST TIME IT IS LIT. THIS CLAIM IS
+    //     INVERTED.
     //
-    //     One spot beside each door, and the letter is on it. Take the letter
-    //     and the patch of cleaner wall it kept the weather off for sixty
-    //     years is the slot. A house he has not read has nowhere to put
-    //     anything, so taking the letter is the thing that shows him where —
-    //     an affordance earned rather than drawn, which is why the frame went.
+    //     It used to assert that there was nowhere to file until the letter
+    //     came off the nail: one spot, the letter on it, and the patch it left
+    //     was the slot. Letters stay on the door now and the slot is under the
+    //     letter from the first light, so a door he has only just lit takes a
+    //     pin like any other. It is the MOVE in claim 2 that takes it off again.
     const unread = s.houses[2];
+    const neverLit = !unread.seen;
     s.prince.x = s.prince.prevX = unread.x - 300;
     s.prince.facing = 1;
     s.camera.reset(s.prince.x);
     s.sheaf.index = fragA;
     drive(1.2, { sheaf: true });
-    const offeredBeforeReading = s.canMark;
-    const litNotRead = unread.seen && !unread.letterTaken;
+    const offeredOnFirstLight = unread.seen && s.canMark && s.canPin;
     mark();
-    // AND THE PRESS IS NOT WASTED. MARK is not offered, so the same button
-    // does the thing that IS available at a door with a letter still on it:
-    // it takes the letter. Which is what makes the slot. One button, and it
-    // walks a player through the order on its own — letter first, claim after.
-    const tookTheLetterInstead = unread.letterTaken && unread.filed == null;
-    const needsTheLetterOff = !offeredBeforeReading && litNotRead &&
-      tookTheLetterInstead;
+    const slotFromTheFirstLight = neverLit && offeredOnFirstLight && unread.filed === 2;
 
     // 2. He files one at a lit door.
     s.sheaf.index = fragA; at(0); mark();
@@ -2083,14 +2023,13 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
 
     return {
       name: 'marking is a claim',
-      pass: nothingAutoFiles && needsTheLetterOff && noSheafNeeded &&
+      pass: nothingAutoFiles && slotFromTheFirstLight && noSheafNeeded &&
             afterFirst[0] === 2 && afterReplace[0] === 3 &&
             afterMove[0] == null && afterMove[1] === 3 && onlyOnce &&
             needsADoor && mapCannotBeFiled && noVerdict &&
             frozenAtTheGate,
       nothingFilesItself: nothingAutoFiles,
-      andThereIsNoSlotUntilTheLetterIsOff: needsTheLetterOff,
-      theSamePressTakesTheLetterInstead: tookTheLetterInstead,
+      aDoorTakesAPinTheFirstTimeItIsLit: slotFromTheFirstLight,
       afterFirst, afterReplace, afterMove,
       oneFragmentOneHouse: onlyOnce,
       needsALitDoor: needsADoor,
@@ -2307,12 +2246,13 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
    * at a door, which is the thing the cue was meant to teach. So the question
    * is asked in the world.
    *
-   * IT WAS A FRAME AND IT IS NOW A NAIL. A bright square box bolted to every
+   * IT WAS A FRAME AND IT IS NOW TWO NAILS. A bright square box bolted to every
    * house read as a noticeboard, and no village in any century had one. A
    * letter nailed up is how you reached somebody who was not home, anywhere,
-   * ever — and when the letter comes off, the lighter patch of wall it kept the
-   * weather off is the slot. The frame was drawn; the patch is EARNED, because
-   * a house he has not read has a letter and no slot at all.
+   * ever — and under it hangs a second nail and the lighter patch of wall where
+   * their own reply hung. That patch is the slot. The frame was drawn; the
+   * patch is a VALUE, and it is there from the first light, beside a letter
+   * that never comes down.
    *
    * THE GATE HAS ALWAYS WORKED THIS WAY. Four empty sockets on the leaf, and
    * nobody has ever needed telling what they are for.
@@ -2320,12 +2260,14 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
    * Measured in pixels, because it is entirely a claim about what is on screen.
    */
   function theRoomAsks() {
-    const nailRect = (house) => {
+    const onScreen = (house, rect) => {
       const clip = s.houseClip;
-      const [fx, fy, fw, fh] = clip.nailAt[house.variant];
+      const [fx, fy, fw, fh] = rect;
       return [Math.round(house.x - s.camera.x - clip.pivotX + fx),
         Math.round(GROUND_Y - clip.pivotY + fy), fw, fh];
     };
+    const nailRect = (house) => onScreen(house, s.houseClip.slotAt[house.variant]);
+    const letterRect = (house) => onScreen(house, s.houseClip.letterAt[house.variant]);
     const look = (house) => {
       const [dx] = s.doorPoint(house);
       s.prince.x = s.prince.prevX = dx - 300;
@@ -2353,18 +2295,20 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       const forge = s.houses[0];
       const home = s.houses[3];
 
-      // 1. THE LETTER IS ON THE NAIL, and it is the only thing there. A house
-      //    he has not read has nowhere to put anything.
-      const withLetter = look(forge);
-      const letterLum = brightness(withLetter);
-      const noise = differs(look(forge), withLetter);
-
-      // 2. TAKE IT, AND WHAT IS LEFT IS THE PATCH.
-      drive(0.2, { pickup: true });
-      drive(0.15);
+      // 1. THE FIRST LIGHT, AND BOTH ARE THERE. Nothing has been read, taken or
+      //    pinned: the letter hangs on its nail and the slot is under it.
       const patch = look(forge);
       const patchLum = brightness(patch);
-      const appeared = differs(patch, withLetter);
+      const noise = differs(look(forge), patch);
+      const letterLum = (() => {
+        const [x, y, w, h] = letterRect(forge);
+        return brightness(ctx.getImageData(x, y, w, h).data);
+      })();
+
+      // 2. AND THE LETTER IS PAPER, NOT PATCH. The two share a column and a
+      //    shape, so the thing that tells them apart is the value: the letter
+      //    is a lit page with writing on it, the slot is a paler mark on wood.
+      const letterIsPaper = letterLum > patchLum + 20;
 
       // THE WALL BELOW IT, which is what the patch has to beat. Finding
       // somewhere that is actually wall took three goes as the spot moved:
@@ -2407,13 +2351,9 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       const [hx] = s.doorPoint(home);
       s.prince.x = s.prince.prevX = hx - 300;
       drive(1.4, { torch: true });
-      drive(0.2, { pickup: true });
-      drive(0.15);
       // Its own grain floor, measured here rather than borrowed from the
-      // forge: two looks at this door with nothing changed between them. The
-      // forge's floor was taken before its letter came off and under a
-      // different stretch of world, and a floor from somewhere else is not a
-      // floor.
+      // forge: two looks at this door with nothing changed between them. A
+      // floor taken under a different stretch of world is not a floor.
       const homeBefore = look(home);
       const homeNoise = differs(look(home), homeBefore);
       const homeSettled = look(home);
@@ -2422,14 +2362,14 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
 
       return {
         name: 'the room asks',
-        pass: appeared > Math.max(300, noise * 4) &&
+        pass: letterIsPaper &&
               readsAsWall && patchLum > wall + 40 &&
               filledDiff > Math.max(300, noise * 4) &&
               homeDiff <= Math.max(homeNoise * 2, 200),
         letterOnTheNailLum: letterLum,
         patchLum, wallLum: wall, doorwayLum: doorway,
         grainNoiseFloor: noise, atTheFifthNail: homeNoise,
-        takingTheLetterRevealsTheSlot: appeared > Math.max(300, noise * 4),
+        letterAndSlotBothThereFromTheFirstLight: letterIsPaper && readsAsWall,
         andTheSlotIsAMarkNotASocket: readsAsWall,
         itReadsAgainstTheWall: patchLum > wall + 40,
         pinningPutsItOnTheWall: filledDiff > Math.max(300, noise * 4),
@@ -2517,20 +2457,18 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     };
     const atInit = isFirst(false) === true;
 
-    // It survives a letter, four fragments and a key going on top of it.
-    for (let k = 0; k < 5; k++) {
-      s.prince.x = s.prince.prevX = s.houses[k].x - 300;
-      s.camera.reset(s.prince.x);
-      drive(1.2, { torch: true });
-      drive(0.4, { torch: true, pickup: true });
-    }
+    // It survives four fragments going on top of it.
+    armed();
     const afterTaking = isFirst(false) === true;
 
-    // It survives pinning and retrieving at a patch.
+    // It survives pinning and retrieving at a slot. Not the forge's own
+    // fragment, or it settles and the retrieve is refused.
     const armedPages = s.sheaf.pages.length;
-    s.sheaf.index = s.sheaf.pages.findIndex((p) => p.kind === 'fragment');
-    const h = s.houses.find((hh) => hh.letterTaken) ?? s.houses[0];
-    s.prince.x = s.prince.prevX = h.x + (s.letterPoint(h)?.[0] ?? h.x) - h.x;
+    const h = s.houses[0];
+    s.sheaf.index = s.sheaf.pages.findIndex((p) => p.kind === 'fragment' && p.kept !== h.index);
+    s.prince.x = s.prince.prevX = h.x - 300;
+    s.camera.reset(s.prince.x);
+    if (!h.seen) drive(1.4, { torch: true });
     drive(0.3, { pickup: true });
     drive(0.3);
     drive(0.3, { pickup: true });
@@ -2611,8 +2549,15 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     const frozen = Math.abs(s.prince.x - from) < 0.001 && !s.prince.attacking;
 
     // The page goes down on the existing ramp and he can walk.
+    //
+    // THE BAND STOPS READING HIS ORDERS, which is not the same as closing. At
+    // ?at=gate he starts 320px from the gatehouse, and reading his orders by
+    // torchlight lights its letter too — so with the orders down and him stood
+    // still, the band reads that door. That is the rule for a lit door, not
+    // the order hanging on.
     drive(0.8);
-    const lowered = !s.sheaf.up && s.torch.raise < 0.01 && s.band.alpha < 0.01;
+    const lowered = !s.sheaf.up && s.torch.raise < 0.01 &&
+      (s.band.alpha < 0.01 || s.band.text !== s.letters.byHouse[oh].letter);
     drive(0.5, { right: true });
     const controlsLive = s.prince.x > from + 100;
 
@@ -2821,10 +2766,11 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
    * read before the first fight — and far enough from every drained that
    * lighting it wakes nobody.
    *
-   * Light it and the band reads it. Take it and it is page two, the rebels'
-   * instruction after the palace's, carrying a tree at its foot. The nail it
-   * leaves is bare and asks for nothing: holding a page there, nothing is
-   * offered. A restart puts the note back.
+   * It reads exactly the way a door does. Light it and the band reads it;
+   * after that, standing by it reads it again with the torch down; walking
+   * past, it does not. It STAYS ON THE TREE, like every letter stays on its
+   * door, so it is never a page. And it is not a door: holding a fragment
+   * there, nothing is offered, and E does nothing.
    */
   function theTreeTeaches() {
     scene.reset();
@@ -2836,46 +2782,564 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     const clearOfAll = Math.min(...road.map((d) => Math.abs(d.x - t.x)));
     const placed = t.x > first + TUNING.TREE_CLEAR && t.x < BOWL.X0 &&
       clearOfAll >= TUNING.TREE_CLEAR;
+    const settle = TUNING.READ_STILL_MS / 1000 + 0.4;
 
-    // Up to it in the dark: nothing read yet.
+    // Up to it in the dark, and stood there: nothing read. The first read
+    // needs light.
     s.prince.x = s.prince.prevX = t.x - 300;
     s.prince.facing = 1;
     s.camera.reset(s.prince.x);
-    drive(0.5);
-    const unreadInTheDark = !t.letterSeen && s.band?.text !== note;
+    drive(settle);
+    const unreadInTheDark = !t.seen && s.band?.text !== note;
 
     // Lit: the band reads it, and nobody wakes.
     drive(1.4, { torch: true });
-    const reads = t.letterSeen && s.band?.text === note && s.canTakeLetter;
+    const reads = t.seen && s.band?.text === note;
     const nobodyWoke = s.drained.every((d) => !d.revealed);
 
-    // Taken: page two, the tree's, after his orders.
-    const before = s.sheaf.pages.length;
-    tap();
-    const p = s.sheaf.pages[1];
-    const pageTwo = before === 1 && s.sheaf.pages.length === 2 && p?.kind === 'letter' &&
-      p.house === t.index && s.textFor(p) === note && s.sheaf.pages[0].house !== t.index;
-    const origin = s.letters.byHouse[p?.house]?.origin;
-    const bare = t.letterTaken && !s.canTakeLetter;
+    // Torch down and still stood by it: it reads again, for nothing.
+    drive(settle);
+    const readsAgain = s.torch.raise < 0.01 && s.band?.text === note;
+
+    // Walking past it, it does not. Every frame of a walk from one side of
+    // its reach to the other.
+    let openWhileWalking = 0;
+    let frames = 0;
+    while (s.prince.x < t.x + TUNING.DOOR_REACH + 100 && frames < 60 * 20) {
+      scene.update(1 / 60, { ...NONE, right: true });
+      if (s.band?.text) openWhileWalking++;
+      frames++;
+    }
+    const closedWhileWalking = openWhileWalking === 0 && frames > 0;
 
-    // Nothing goes back on it: holding a page there, nothing is offered.
+    // It stays on the tree: E there does nothing, holding a fragment or not,
+    // and the pile is what it was.
+    s.prince.x = s.prince.prevX = t.x - 300;
+    s.camera.reset(s.prince.x);
     s.prince.inventory.push({ kept: 0, answers: null, seen: true });
     s.sheaf.pages.push({ kind: 'fragment', kept: 0 });
     s.sheaf.index = s.sheaf.pages.length - 1;
+    const pile = s.sheaf.pages.length;
     drive(0.5, { torch: true });
     drive(0.3);
-    const nothingGoesBack = !s.canPin && !s.canMark && !s.canTakeLetter;
+    const nothingGoesBack = !s.canPin && !s.canMark;
+    tap();
+    s.sheaf.index = 0;
+    tap();
+    const staysOnTheTree = s.sheaf.pages.length === pile &&
+      s.sheaf.pages.every((p) => p.kind !== 'letter' || p.house !== t.index);
+    const stillNobodyWoke = s.drained.every((d) => !d.revealed);
 
     scene.reset();
-    const backOnItsNail = !t.letterTaken && !t.letterSeen;
+    const unlitAfterARestart = !t.seen;
     return {
       name: 'the tree teaches',
-      pass: !!note && placed && unreadInTheDark && reads && nobodyWoke && pageTwo &&
-            origin === 'tree' && bare && nothingGoesBack && backOnItsNail,
+      pass: !!note && placed && unreadInTheDark && reads && nobodyWoke &&
+            readsAgain && closedWhileWalking && nothingGoesBack && staysOnTheTree &&
+            stillNobodyWoke && unlitAfterARestart,
       at: t.x, pastTheFirstDrained: t.x - first, clearOfEveryDrained: clearOfAll,
       clearFloor: TUNING.TREE_CLEAR, beforeTheVillage: t.x < BOWL.X0,
       unreadInTheDark, readsUnderTheTorch: reads, nobodyWoke,
-      pageTwo, originOnThePage: origin, bareNailAfter: bare, nothingGoesBack, backOnItsNail,
+      readsAgainWithTheTorchDown: readsAgain,
+      framesOpenWhileWalkingPast: openWhileWalking, walkedFrames: frames,
+      nothingGoesBack, staysOnTheTree, stillNobodyWoke, unlitAfterARestart,
+    };
+  }
+
+  // --- letters stay on the door ------------------------------------------------
+  //
+  // Letters stay where they were left; fragments come off bodies. He does not
+  // pocket a stranger's mail, and the door becomes where he judges: the
+  // question nailed in front of him, the answer in his hand. See
+  // docs/specs/astara-letters-stay-addendum.md.
+
+  /**
+   * THE LETTERS STAY, on every door and on the tree, whatever he does.
+   *
+   * There is no state for it any more — nothing can take one down — so this
+   * looks at the wall. At the start of a run, after every input there is at
+   * every door, and at the end of a whole run with the gate open: the letter's
+   * rect is paper. And not once in all of that does a letter from a wall turn
+   * up in the sheaf.
+   *
+   * PAPER IS COUNTED, NOT AVERAGED. The share of the rect brighter than 140,
+   * which nothing on a wall at night comes near except a lit page — and two
+   * renders of the same frame are the grain floor it has to clear.
+   */
+  function lettersStay() {
+    return withOverlayOff(() => {
+      const orderAt = orderHouse();
+      let wallLettersHeld = 0;
+      const note = () => {
+        wallLettersHeld += s.sheaf.pages
+          .filter((p) => p.kind === 'letter' && p.house !== orderAt).length;
+      };
+      const targets = [...s.houses, ...(s.tree ? [s.tree] : [])];
+      const clipOf = (t) => (t === s.tree ? s.treeClip : s.houseClip);
+      const rectOf = (t) => clipOf(t).letterAt[t.variant];
+      // WHERE HE STANDS: 130px short of the letter, which is h.x - 300 at a
+      // house — where every check and every player reads a door from — and
+      // the same distance from the note on the tree.
+      const standX = (t) => {
+        const r = rectOf(t);
+        return t.x - clipOf(t).pivotX + r[0] + r[2] / 2 - 130;
+      };
+      const paper = (t) => {
+        const clip = clipOf(t);
+        const [rx, ry, rw, rh] = rectOf(t);
+        const d = ctx.getImageData(Math.round(t.x - s.camera.x - clip.pivotX + rx),
+          Math.round(GROUND_Y - clip.pivotY + ry), rw, rh).data;
+        let n = 0;
+        for (let i = 0; i < d.length; i += 4) if (lum(d, i) > 140) n++;
+        return n / (d.length / 4);
+      };
+      const shot = () => {
+        s.clock = 3.0;
+        renderer.drawLevel(scene, 0, { pass1Ms: 0, pass2Ms: 0, bgDrawn: 0 });
+      };
+      const look = (t) => {
+        s.prince.x = s.prince.prevX = standX(t);
+        s.prince.facing = 1;
+        s.camera.reset(s.prince.x);
+        drive(1.4, { torch: true });
+        shot();
+        const a = paper(t);
+        shot();
+        const floor = Math.abs(paper(t) - a);
+        note();
+        return { at: t.kind, paper: +a.toFixed(3), floor: +floor.toFixed(3),
+          present: a > Math.max(0.35, floor * 4) };
+      };
+
+      // 1. FROM THE FIRST FRAME. Every carrier down and every fragment taken,
+      //    and every letter is still where it was left.
+      const carriers = armed();
+      const atStart = targets.map(look);
+
+      // 2. AND NOTHING HE CAN DO AT A DOOR TAKES ONE DOWN. E with his orders
+      //    on top, Q, SPACE, F — and E with the house's own fragment, which
+      //    pins it and sends its owner home.
+      const afterInputs = targets.map((t) => {
+        look(t);
+        s.sheaf.index = 0; tap();
+        drive(0.6, { sheaf: true }); drive(0.3);
+        drive(0.6, { torch: true }); drive(0.3);
+        drive(0.1, { attack: true }); drive(0.6);
+        const own = t === s.tree ? -1
+          : s.sheaf.pages.findIndex((p) => p.kind === 'fragment' && p.kept === t.index);
+        if (own >= 0) { s.sheaf.index = own; tap(); }
+        note();
+        return look(t);
+      });
+
+      // 3. A WHOLE RUN. Everybody who can go home does, four keys come off
+      //    four hooks, and the gate opens on them.
+      let ticks = 0;
+      while (s.drained.some((d) => d.homing) && ticks < 60 * 250) {
+        scene.update(1 / 60, NONE); ticks++;
+      }
+      for (const h of s.houses) {
+        if (!h.open) continue;
+        s.prince.x = s.prince.prevX = h.x - 300;
+        s.camera.reset(s.prince.x);
+        drive(1.4, { torch: true });
+        s.sheaf.index = 0;
+        tap();
+      }
+      note();
+      s.prince.x = s.prince.prevX = s.gateStopX;
+      s.camera.reset(s.prince.x);
+      drive(0.3);
+      for (let i = 0; i < TUNING.GATE_WANTS; i++) tap();
+      drive(2 + TUNING.GATE_OPEN_MS / 1000);
+      const gateOpen = s.gate.open >= 1;
+      note();
+      const atTheEnd = targets.map(look);
+
+      const all = (rows) => rows.every((r) => r.present);
+      return {
+        name: 'letters stay',
+        pass: carriers.length === TUNING.GATE_WANTS && targets.length === 6 &&
+              all(atStart) && all(afterInputs) && gateOpen && all(atTheEnd) &&
+              wallLettersHeld === 0,
+        onEveryWallAtTheStart: all(atStart),
+        afterEveryInputAtEveryDoor: all(afterInputs),
+        andAtTheEndOfARunWithTheGateOpen: gateOpen && all(atTheEnd),
+        wallLettersEverInTheSheaf: wallLettersHeld,
+        atStart, afterInputs, atTheEnd,
+      };
+    });
+  }
+
+  /**
+   * THE SLOT IS ALWAYS THERE, from the first light, at every door.
+   *
+   * It is the affordance, and it used to be earned: no slot until the letter
+   * came off. Now a bare nail and a lighter patch sit under the letter from the
+   * first moment the torch finds the wall — before anything is pinned, and
+   * before anything is read. Rendered with the door's latch wiped, to prove
+   * the wall draws it off nothing but the light.
+   *
+   * AND IT IS STILL. A value, not a glow: over a whole pulse cycle the patch
+   * and the wall round it do not move. The tree has no slot at all.
+   */
+  function theSlotIsAlwaysThere() {
+    return withOverlayOff(() => {
+      const clip = s.houseClip;
+      const box = (h, pad = 0) => {
+        const [nx, ny, nw, nh] = clip.slotAt[h.variant];
+        return [Math.round(h.x - s.camera.x - clip.pivotX + nx) - pad,
+          Math.round(GROUND_Y - clip.pivotY + ny) - pad, nw + pad * 2, nh + pad * 2];
+      };
+      const brightness = (d) => {
+        let sum = 0;
+        for (let i = 0; i < d.length; i += 4) sum += lum(d, i);
+        return Math.round(sum / (d.length / 4));
+      };
+      const render = (clock = 3.0) => {
+        s.clock = clock;
+        renderer.drawLevel(scene, 0, { pass1Ms: 0, pass2Ms: 0, bgDrawn: 0 });
+      };
+      const rows = s.houses.map((h) => {
+        scene.reset();
+        s.prince.x = s.prince.prevX = h.x - 300;
+        s.prince.facing = 1;
+        s.camera.reset(s.prince.x);
+        drive(1.4, { torch: true });
+        // FORGET HE EVER LOOKED. The render reads state only, so with the
+        // latch wiped nothing in the scene says this door was lit or read.
+        h.seen = false;
+        render();
+        const slot = brightness(ctx.getImageData(...box(h)).data);
+        const [bx, by, bw, bh] = box(h);
+        const wall = brightness(ctx.getImageData(bx, by + bh + 8, bw, bh).data);
+        render();
+        const floor = Math.abs(brightness(ctx.getImageData(...box(h)).data) - slot);
+        const seenPulse = [];
+        for (let i = 0; i < 12; i++) {
+          render(3.0 + (i / 12) / TORCH.KEPT_PULSE_HZ);
+          seenPulse.push(brightness(ctx.getImageData(...box(h, 26)).data));
+        }
+        render();
+        return { house: h.kind, slot, wall, floor,
+          movesOverAPulse: Math.max(...seenPulse) - Math.min(...seenPulse),
+          nothingPinned: h.filed == null };
+      });
+      const everyDoor = rows.every((r) => r.nothingPinned &&
+        r.slot > r.wall + 40 && r.slot - r.wall > r.floor * 3);
+      const still = rows.every((r) => r.movesOverAPulse <= 2);
+      const treeHasNone = !!s.treeClip && !s.treeClip.slotAt;
+      scene.reset();
+      return {
+        name: 'the slot is always there',
+        pass: everyDoor && still && treeHasNone,
+        onEveryDoorFromTheFirstLight: everyDoor,
+        andItDoesNotGlow: still,
+        theTreeHasNone: treeHasNone,
+        rows,
+      };
+    });
+  }
+
+  /**
+   * THE BAND READS THE DOOR, and it is one button to compare.
+   *
+   *   Q held                                   the page in his hand. Wins
+   *   the torch on a letter, in reach          that letter. The first read
+   *   standing still, in reach of a lit door   that door's letter
+   *   otherwise                                closed
+   *
+   * THE FIRST READ NEEDS LIGHT; EVERY ONE AFTER IS FREE. On a phone TORCH and
+   * PAGES share a thumb, so comparing a door with the page in his hand cannot
+   * need both: hold PAGES for the paper, let go for the door.
+   *
+   * And the band never reads one door while E would act on another. Sampled
+   * on every frame this check runs.
+   */
+  function bandReadsTheDoor() {
+    const wait = TUNING.READ_STILL_MS;
+    const letterOf = (h) => s.letters.byHouse[h.index].letter;
+    let frames = 0;
+    let notTheDoorEActsOn = 0;
+    const step = (input = {}) => {
+      scene.update(1 / 60, { ...NONE, ...input });
+      frames++;
+      if (s.band.text) {
+        const h = s.houses.find((hh) => letterOf(hh) === s.band.text);
+        if (h && h !== s.nearDoor) notTheDoorEActsOn++;
+      }
+    };
+    const run = (secs, input = {}, each = null) => {
+      const n = Math.round(secs * 60);
+      for (let i = 0; i < n; i++) { step(input); if (each) each(i); }
+    };
+    const standAt = (x) => {
+      s.prince.x = s.prince.prevX = x;
+      s.prince.facing = 1;
+      s.camera.reset(x);
+    };
+
+    scene.reset();
+    const forge = s.houses[0];
+    const L = letterOf(forge);
+
+    // 1. A DOOR HE HAS NEVER LIT: closed, however long he stands at it.
+    standAt(forge.x - 300);
+    run(wait / 1000 + 0.5);
+    const neverLitIsClosed = !forge.seen && s.band.text == null;
+
+    // 2. THE FIRST READ IS THE TORCH'S. Walk in, stop, raise it: it reads
+    //    before standing still could have opened it.
+    standAt(forge.x - 400);
+    run(0.2, { right: true });
+    let firstRead = -1;
+    run(0.5, { torch: true }, (i) => { if (firstRead < 0 && s.band.text === L) firstRead = i + 1; });
+    const firstReadMs = Math.round(firstRead * 1000 / 60);
+    const theTorchReadsIt = firstRead > 0 && firstReadMs < wait && forge.seen;
+
+    // 3. TORCH DOWN, STILL STOOD THERE: the same letter again, for nothing.
+    run(0.3);
+    run(wait / 1000 + 0.2);
+    const readsAgainInTheDark = s.torch.raise < 0.01 && s.band.text === L;
+
+    // 4. COMPARING IS ONE BUTTON. A fragment in his hand; hold Q and the band
+    //    reads it, let go and it reads the door. Twice, and the torch is never
+    //    pressed. It blanks at every switch: two pieces of paper, not a label.
+    s.prince.inventory.push({ kept: 2, answers: null, seen: true });
+    s.sheaf.pages.push({ kind: 'fragment', kept: 2 });
+    s.sheaf.index = s.sheaf.pages.length - 1;
+    const F = s.letters.byHouse[2].fragment;
+    const switches = [];
+    let last = s.band.text;
+    const watch = () => {
+      if (s.band.text && s.band.text !== last) {
+        switches.push({ to: s.band.text === F ? 'page' : s.band.text === L ? 'door' : 'other',
+          alpha: +s.band.alpha.toFixed(3) });
+      }
+      if (s.band.text) last = s.band.text;
+    };
+    for (let k = 0; k < 2; k++) {
+      run(0.8, { sheaf: true }, watch);
+      run(0.6, {}, watch);
+    }
+    const order = switches.map((w) => w.to).join(',');
+    const oneButton = order === 'page,door,page,door';
+    const blanksEachTime = switches.length > 0 && switches.every((w) => w.alpha < 0.1);
+
+    // 5. EVERY DOOR LIT, THEN THE WHOLE STREET WALKED WITH THE TORCH DOWN:
+    //    closed on every frame he is walking.
+    for (const h of s.houses) { standAt(h.x - 300); run(1.4, { torch: true }); }
+    const allLit = s.houses.every((h) => h.seen);
+    standAt(s.houses[0].x - 700);
+    const end = s.houses[s.houses.length - 1].x + 600;
+    let walked = 0;
+    let openWhileWalking = 0;
+    while (s.prince.x < end && walked < 60 * 60) {
+      step({ right: true });
+      walked++;
+      if (s.band.text) openWhileWalking++;
+    }
+    const closedWhileWalking = allLit && walked > 60 && openWhileWalking === 0;
+
+    // 6. STOPPING AT A LIT DOOR OPENS IT AFTER READ_STILL_MS, AND NOT BEFORE.
+    standAt(forge.x - 700);
+    while (s.prince.x < forge.x - 300) step({ right: true });
+    let opened = -1;
+    for (let i = 0; i < 60; i++) {
+      step();
+      if (opened < 0 && s.band.text === L) opened = i + 1;
+    }
+    const openedMs = Math.round(opened * 1000 / 60);
+    const waitsThenOpens = opened > 0 && openedMs >= wait - 1 && openedMs <= wait + 50;
+
+    // 7. A SWING IS NOT STANDING STILL. Nothing flashes up mid-fight.
+    let swingFrames = 0;
+    let openWhileSwinging = 0;
+    step({ attack: true });
+    while (s.prince.attacking && swingFrames < 120) {
+      swingFrames++;
+      if (s.band.text) openWhileSwinging++;
+      step();
+    }
+    const closedWhileSwinging = swingFrames > 0 && openWhileSwinging === 0;
+
+    // 8. OUT OF REACH: closed.
+    standAt(forge.x - 900);
+    run(wait / 1000 + 0.5);
+    const closedOutOfReach = s.band.text == null;
+
+    scene.reset();
+    return {
+      name: 'the band reads the door',
+      pass: neverLitIsClosed && theTorchReadsIt && readsAgainInTheDark &&
+            oneButton && blanksEachTime && closedWhileWalking && waitsThenOpens &&
+            closedWhileSwinging && closedOutOfReach && notTheDoorEActsOn === 0,
+      neverLitIsClosed,
+      theTorchReadsItFirst: theTorchReadsIt, firstReadAfterMs: firstReadMs,
+      readsAgainWithTheTorchDown: readsAgainInTheDark,
+      comparingIsOneButton: oneButton, switches: order,
+      andItBlanksAtEachSwitch: blanksEachTime,
+      closedWhileWalkingPastLitDoors: closedWhileWalking, framesWalked: walked,
+      opensAfterStandingStillMs: openedMs, readStillMs: wait,
+      waitsThenOpens, closedWhileSwinging, closedOutOfReach,
+      framesReadingADoorEWouldNotActOn: notTheDoorEActsOn, framesSampled: frames,
+    };
+  }
+
+  /**
+   * THE DOOR CARRIES FOUR THINGS: the letter, the slot, the key and the room.
+   *
+   * None may cover another — except the key, which has always hung INSIDE the
+   * room by the jamb, because that is where a key to your own front door goes.
+   * The room is measured off the art rather than written down: the lit
+   * doorway's own pixels, and 16px round them for the things that poke out of
+   * it, the forge's anvil horn furthest.
+   *
+   * AND BOTH PAPERS ARE LIT FROM WHERE HE STANDS, on every frame of three
+   * seconds of flicker rather than on one: a check that passes or fails on
+   * which frame it sampled is not a check. Within DOOR_REACH too, which is
+   * where E and the band both measure from.
+   */
+  function theDoorCarriesFour() {
+    const clip = s.houseClip;
+    const clear = (a, b) =>
+      a[0] + a[2] <= b[0] || b[0] + b[2] <= a[0] || a[1] + a[3] <= b[1] || b[1] + b[3] <= a[1];
+    const roomBox = (v) => {
+      const off = new OffscreenCanvas(clip.width, clip.height);
+      const o = off.getContext('2d', { willReadFrequently: true });
+      o.drawImage(clip.frames[v].lit, 0, 0);
+      const d = o.getImageData(0, 0, clip.width, clip.height).data;
+      let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+      for (let y = 0; y < clip.height; y++) {
+        for (let x = 0; x < clip.width; x++) {
+          const i = (y * clip.width + x) * 4;
+          if (d[i + 3] < 250 || Math.abs(d[i] - 0xd8) > 6 ||
+              Math.abs(d[i + 1] - 0xc3) > 6 || Math.abs(d[i + 2] - 0xa0) > 6) continue;
+          if (x < x0) x0 = x;
+          if (x > x1) x1 = x;
+          if (y < y0) y0 = y;
+          if (y > y1) y1 = y;
+        }
+      }
+      return [x0 - 16, y0 - 16, x1 - x0 + 33, y1 - y0 + 33];
+    };
+    const rows = s.houses.map((h) => {
+      const L = clip.letterAt[h.variant];
+      const S = clip.slotAt[h.variant];
+      const K = clip.keyAt[h.variant];
+      const R = roomBox(h.variant);
+      scene.reset();
+      s.prince.x = s.prince.prevX = h.x - 300;
+      s.prince.facing = 1;
+      s.camera.reset(s.prince.x);
+      drive(0.6, { torch: true });
+      // The margin by which each paper is inside the reveal circle, at the
+      // worst frame. Positive is lit.
+      let letterMargin = Infinity;
+      let slotMargin = Infinity;
+      const inside = (p) => REVEAL_T * s.torch.radius - Math.hypot(p[0] - s.torch.cx, p[1] - s.torch.cy);
+      for (let i = 0; i < 180; i++) {
+        scene.update(1 / 60, { ...NONE, torch: true });
+        letterMargin = Math.min(letterMargin, inside(s.letterPoint(h)));
+        slotMargin = Math.min(slotMargin, inside(s.slotPoint(h)));
+      }
+      const lp = s.letterPoint(h);
+      const sp = s.slotPoint(h);
+      return {
+        house: h.kind, room: R,
+        letterClearOfSlot: clear(L, S), letterClearOfKey: clear(L, K),
+        slotClearOfKey: clear(S, K), letterClearOfRoom: clear(L, R),
+        slotClearOfRoom: clear(S, R), keyInsideTheRoom: !clear(K, R),
+        letterLitEveryFrame: letterMargin > 0, slotLitEveryFrame: slotMargin > 0,
+        worstLetterMargin: Math.round(letterMargin), worstSlotMargin: Math.round(slotMargin),
+        inReach: Math.abs(s.prince.x - lp[0]) <= TUNING.DOOR_REACH &&
+          Math.abs(s.prince.x - sp[0]) <= TUNING.DOOR_REACH,
+      };
+    });
+    scene.reset();
+    const ok = rows.every((r) => r.letterClearOfSlot && r.letterClearOfKey &&
+      r.slotClearOfKey && r.letterClearOfRoom && r.slotClearOfRoom && r.keyInsideTheRoom &&
+      r.letterLitEveryFrame && r.slotLitEveryFrame && r.inReach);
+    return {
+      name: 'the door carries four',
+      pass: ok && rows.length === 5,
+      everyDoor: ok,
+      rows,
+    };
+  }
+
+  /**
+   * THE GATEWAY IS HIS ONCE ITS KEEPER HAS GONE HOME.
+   *
+   * While the gatekeeper holds his post, the shut leaf stops the prince just
+   * inside the left post. Once the keeper has walked home, he can walk the
+   * whole width of the leaf, under all four sockets, to just inside the right
+   * post. Found in play: stood at the left edge, a player could not get close
+   * enough to count what the gate wanted. The view follows him in far enough to
+   * frame the whole gateway.
+   *
+   * AND THE LEAF STILL HAS TO LIFT, AND HE STILL HAS TO WALK. Standing under
+   * it when it opens does not end the level; a step through it does.
+   */
+  function theGateRoomOpens() {
+    // The posts' outer edges, as render.js draws the gate: a 420px half-leaf
+    // and a 100px post each side.
+    const EDGE = 520;
+    const toGate = (secs = 6) => {
+      s.prince.x = s.prince.prevX = s.gateX - 900;
+      s.prince.facing = 1;
+      s.camera.reset(s.prince.x);
+      drive(secs, { right: true });
+    };
+    const keeper = gatekeeper();
+
+    // 1. Down, but at his post: the old stop. A fight does not move him.
+    const carriers = armed();
+    toGate();
+    const heldShut = Math.round(s.prince.x) === s.gateStopX;
+
+    // 2. His scrap on his own door, and he gets up and walks home.
+    atDoor(4, 4);
+    tap({ sheaf: true });
+    drive(3);
+    const goneHome = keeper.state === 'HOMING' || keeper.state === 'HOME';
+
+    // 3. The whole gateway, and no further — with all of it in the frame.
+    toGate();
+    const walkedIn = Math.round(s.prince.x) === s.gateRoomX;
+    const cam = s.camera.x;
+    const framed = s.gateX - EDGE - cam >= 0 && s.gateX + EDGE - cam <= W &&
+      s.prince.x - cam <= W - 200;
+
+    // 4. Walking into the far post with the leaf shut ends nothing.
+    drive(1, { right: true });
+    const shutEndsNothing = !s.gate.through && s.fade === 0;
+
+    // 5. The leaf lifts over him while he stands under it, and he is still
+    //    there. One step takes him through.
+    s.prince.x = s.prince.prevX = s.gateX + 100;
+    s.prince.keys = TUNING.GATE_WANTS;
+    s.sheaf.index = 0;
+    for (let i = 0; i < TUNING.GATE_WANTS; i++) tap();
+    drive(1 + TUNING.GATE_OPEN_MS / 1000);
+    const openOverHim = s.gate.open >= 1 && !s.gate.through;
+    drive(0.3, { right: true });
+    const aStepTakesHimThrough = s.gate.through;
+
+    // 6. A restart puts the keeper back on his post, and the gateway shuts.
+    scene.reset();
+    toGate();
+    const shutAgain = Math.round(s.prince.x) === s.gateStopX;
+
+    return {
+      name: 'the gate room opens',
+      pass: carriers.length === TUNING.GATE_WANTS && heldShut && goneHome && walkedIn &&
+            framed && shutEndsNothing && openOverHim && aStepTakesHimThrough && shutAgain,
+      whileHeHoldsThePost: heldShut, keeperWalkedHome: goneHome,
+      walksTheWholeGateway: walkedIn, stopsAt: Math.round(s.gateRoomX - s.gateX),
+      theWholeGatewayIsInFrame: framed,
+      shutEndsNothing, openOverHimAndStillThere: openOverHim, aStepTakesHimThrough,
+      shutAgainAfterARestart: shutAgain,
     };
   }
 
@@ -3274,7 +3738,9 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
       orderIsPageOne(), openingHolds(),
       nobodyBlocksTheRoad(), gatekeeperIsOnTheRoad(), stepDownTelegraphs(),
       watchesYouPass(), laneReads(), theGlanceStillWorks(),
-      wrongDoorWakes(), gatekeeperWakesAtHisPost(), theTreeTeaches()];
+      wrongDoorWakes(), gatekeeperWakesAtHisPost(), theTreeTeaches(),
+      lettersStay(), theSlotIsAlwaysThere(), bandReadsTheDoor(), theDoorCarriesFour(),
+      theGateRoomOpens()];
     return { pass: out.every((r) => r.pass), results: out };
   }
 
@@ -3309,6 +3775,8 @@ export function createChecks({ renderer, scene, canvas, clips = {}, audio = null
     nobodyBlocksTheRoad, gatekeeperIsOnTheRoad, stepDownTelegraphs,
     watchesYouPass, laneReads, theGlanceStillWorks,
     wrongDoorWakes, gatekeeperWakesAtHisPost, theTreeTeaches,
+    lettersStay, theSlotIsAlwaysThere, bandReadsTheDoor, theDoorCarriesFour,
+    theGateRoomOpens,
     all, frameAt, frameAtX };
 
   return Object.fromEntries(Object.entries(api).map(([k, fn]) => [k, silent(fn)]));

src/input.js

@@ -166,9 +166,10 @@ export function createInput(target, { onReset } = {}) {
    *
    * The top page of the pile is now what he is holding, so TAKE acts on it
    * wherever he stands and the second button is deleted. Whether this press
-   * takes a letter, pins a page, takes one back down, takes a key or picks
-   * something off the ground is decided by where he is standing — which is
-   * what TAKE has meant everywhere else in this game since the first object.
+   * pins a page, takes one back down, takes a key or picks something off the
+   * ground is decided by where he is standing — which is what TAKE has meant
+   * everywhere else in this game since the first object. Letters are not on
+   * that list: they stay on the door.
    */
   const takeBtn = pad?.querySelector('.wheel [data-act="pickup"]');
   let takeLive = false;

src/main.js

@@ -117,7 +117,7 @@ const loop = createLoop({
       // EVERY OFFER THE SCENE MAKES, and the scene is the only thing that
       // decides. This used to re-run the ground scan itself, which was two
       // places that had to agree about what is within reach.
-      input.setTakeAvailable?.(st.canMark || st.canTakeLetter || st.canTakeKey ||
+      input.setTakeAvailable?.(st.canMark || st.canTakeKey ||
         st.canPlaceKey || st.canTake);
     }
   },

src/render.js

@@ -266,9 +266,9 @@ export function createRenderer(ctx) {
    *
    * THE NOTE, BOTH WAYS. In the dark the scrap shows pale — paper catching
    * what light there is, so a lone tree says "something is pinned here" the
-   * way a house's lit doorway does. Under the torch it is the letter on its
-   * nail, drawn by drawNail like every other; once taken, a bare nail and a
-   * paler patch, and — `quiet` — nothing asking to be filled.
+   * way a house's lit doorway does. Under the torch it is the note on its
+   * nail, drawn by drawNail like every letter. It stays there, and there is
+   * no slot under it: nothing is ever pinned back to a tree.
    */
   function drawTree(c, s, camX, mode) {
     const t = s.tree;
@@ -280,10 +280,10 @@ export function createRenderer(ctx) {
     const y = GROUND_Y - clip.pivotY;
     c.drawImage(clip.frames[0][mode === 'lit' ? 'lit' : 'dark'], x, y);
     if (mode === 'lit') {
-      drawNail(c, s, clip, t, x, y, s.clock ?? 0, true);
-    } else if (!t.letterTaken && s.treeNoteDark) {
+      drawNail(c, s, clip, t, x, y, { slot: false });
+    } else if (s.treeNoteDark) {
       const art = s.letterArt;
-      const b = nailBox(clip, t, x, y, art);
+      const b = nailBox(clip.letterAt?.[t.variant], x, y, art);
       if (b) {
         c.drawImage(s.treeNoteDark, b.px - b.ink.x * b.k, b.py - b.ink.y * b.k,
           art.width * b.k, art.height * b.k);
@@ -409,7 +409,7 @@ export function createRenderer(ctx) {
         // only shows where the light actually falls.
         if (mode === 'lit') {
           c.drawImage(clip.frames[h.variant].lit, x, y);
-          drawNail(c, s, clip, h, x, y, s.clock ?? 0);
+          drawNail(c, s, clip, h, x, y);
           drawRoomKey(c, s, clip, h, x, y, s.clock ?? 0);
         } else {
           c.drawImage(s.houseArt[h.variant], x, y);
@@ -614,13 +614,19 @@ export function createRenderer(ctx) {
   }
 
   /**
-   * A warm pulse at a door, OUT IN THE DARK, with the torch down.
+   * A warm pulse at a door, OUT IN THE DARK, with the torch down — for a key
+   * whose door somebody opened, and nothing else.
    *
-   * The patch and the key only ever existed inside the torchlight, because
-   * everything in a doorway is drawn in the lit pass. So the street said
-   * nothing: you had to already be holding the light on a door to learn there
-   * was anything at it, which is the wrong way round — the light is what you
-   * spend, and something has to be worth spending it on.
+   * The key only ever existed inside the torchlight, because everything in a
+   * doorway is drawn in the lit pass. So the street said nothing: you had to
+   * already be holding the light on a door to learn there was anything at it,
+   * which is the wrong way round — the light is what you spend, and something
+   * has to be worth spending it on.
+   *
+   * THE EMPTY SLOT USED TO PULSE HERE TOO, and does not any more. It is a
+   * value, not a glow: a mark on a wall that breathes in the dark is UI, and
+   * the loom house's slot, which nothing ever fills, would have been asking
+   * for the whole level in a voice the game uses for "take this".
    *
    * THE DROPPED SCRAPS HAVE ALWAYS DONE THIS. "A warm pulse out there is a
    * thing you notice from across the screen, and it is the only reason to walk
@@ -675,9 +681,7 @@ export function createRenderer(ctx) {
       }
     };
 
-    // An empty mark, once the letter is off it and there is somewhere to pin.
-    if (house.letterTaken && house.filed == null) at(clip.nailAt?.[house.variant], s.kept);
-    // And a key whose door somebody opened.
+    // A key whose door somebody opened.
     if (house.open && !house.keyTaken) at(clip.keyAt?.[house.variant], s.keyArt);
   }
 
@@ -955,13 +959,11 @@ export function createRenderer(ctx) {
   function drawLetterHouse(c, s, sheet, x0, y0, pg) {
     if (!pg || pg.kind !== 'letter') return;
     const house = s.houses?.[pg.house];
-    // WHERE IT CAME FROM. Five of the letters come from a house in this village
-    // and show it. The order came from the palace and the note from a tree on
-    // the road, and neither has an entry in `houses` — so their own `origin`
-    // says which, and no house and no origin still means the palace.
-    const origin = house ? null : s.letters?.byHouse?.[pg.house]?.origin;
-    const hc = house ? s.houseClip
-      : origin === 'tree' ? (s.treeIconClip ?? s.palaceClip) : s.palaceClip;
+    // WHERE IT CAME FROM. The only letter he carries is his orders, and they
+    // came from the palace. House letters and the note on the tree stay where
+    // they were left, so they are never a page here — but a letter with a
+    // house behind it would still draw that house.
+    const hc = house ? s.houseClip : s.palaceClip;
     if (!hc) return;
     const frame = house ? house.variant : 0;
     const bx = x0 + sheet.width / 2;
@@ -1124,32 +1126,28 @@ export function createRenderer(ctx) {
   }
 
   /**
-   * THE LETTER LYING IN THE ROOM.
+   * THE LETTER ON THE DOOR, and it never comes down.
    *
-   * It is an object, and it behaves like every other object in this game: it is
-   * there, the torch shows it, and take picks it up. It used to fall into the
-   * sheaf the moment the door lit — so the only way to READ it was to raise the
-   * sheaf and page to it, and anyone who had not worked out that the sheaf
-   * pages never saw a word of the writing.
+   * Letters stay where they were left; fragments come off bodies. He does not
+   * pocket a stranger's mail, and that puts the deduction where it belongs:
+   * the question is nailed in front of him, the fragment is in his hand, and
+   * the door is where he judges.
    *
    * NO GLOW. The objects on the ground pulse because a dark street gives no
    * other reason to walk over to one; a door is already that reason, and a glow
    * bleeding through an unlit house would break the one rule the whole look
    * rests on — that a building is a black mass until he lights it.
-   *
-   * Gone from the nail the moment he takes it. What is left is the patch of
-   * cleaner wall it kept the weather off, waiting for the other half.
    */
   // The same value a lit doorway is drawn at, and it has to be: a page held in
   // that light is the same paper as the light falling out of the room.
   const DOORLIGHT = '#d8c3a0';
 
   /**
-   * THE WALL PATCH, and it is what a deleted frame left behind.
+   * THE SLOT, and it is what a deleted frame left behind.
    *
-   * A letter hung on this nail for sixty years and kept the weather off the
-   * wall under it. Take the letter and that rectangle of cleaner wall is what
-   * is left — and it is where a fragment goes.
+   * Their own paper hung on a second nail under the letter left for them, and
+   * kept the weather off the wall behind it. The fragment on a body is that
+   * paper, and the lighter patch is where it goes back.
    *
    * IT IS A VALUE, NOT AN OUTLINE. No border, no socket, no glow, and it must
    * never read as UI. The palette makes that a narrow window: the wall sits at
@@ -1159,9 +1157,8 @@ export function createRenderer(ctx) {
    */
   const PATCH = '#6f6553';        // lum 101 — over the forbidden zone, under the door
 
-  /** Where the nail's one spot lands on screen, for whatever is hanging on it. */
-  function nailBox(clip, house, x, y, art) {
-    const rect = clip.nailAt?.[house.variant];
+  /** Where a rect on the wall lands on screen, for whatever is hanging in it. */
+  function nailBox(rect, x, y, art) {
     if (!rect || !art) return null;
     const [nx, ny, nw, nh] = rect;
     const ink = art.ink ?? { x: 0, y: 0, w: art.width, h: art.height };
@@ -1173,78 +1170,49 @@ export function createRenderer(ctx) {
   }
 
   /**
-   * WHAT IS ON THE NAIL. One spot, three states, in the order a player meets
-   * them: the letter somebody left, the mark it left, and the answer he pins
-   * back into that mark.
+   * WHAT IS ON THE WALL BESIDE A DOOR, top to bottom: the letter somebody
+   * left, and under it the slot — the patch, the bare nail, and whatever he
+   * pins there. The question above the answer, and the eye reads down.
    *
-   * LIT PASS ONLY, so all three live and die with the torch like everything
+   * LIT PASS ONLY, so all of it lives and dies with the torch like everything
    * else in a doorway.
+   *
+   * THE TREE HAS NO SLOT (`slot: false`). It carries the note and nothing
+   * else: nothing is ever pinned back to a tree.
    */
-  function drawNail(c, s, clip, house, x, y, clock, quiet = false) {
-    if (!clip.nailAt) return;
-
-    // 1. THE LETTER, while it is still hanging there.
-    if (!house.letterTaken) {
-      const art = s.letterArt;
-      const frame = art?.frames[house.index];
-      const b = nailBox(clip, house, x, y, art);
-      if (!b || !frame) return;
+  function drawNail(c, s, clip, house, x, y, { slot = true } = {}) {
+    // 1. THE LETTER. Always: nothing takes it down.
+    const paper = s.letterArt;
+    const written = paper?.frames[house.index];
+    const lb = nailBox(clip.letterAt?.[house.variant], x, y, paper);
+    if (lb && written) {
       // PAPER FIRST. The page art is contour and writing on nothing, so on a
       // dark wall it came out dark-on-dark. It is a sheet of paper in
       // torchlight, so it gets the value a lit doorway gets.
       c.fillStyle = DOORLIGHT;
-      c.fillRect(Math.round(b.px - 3), Math.round(b.py - 3),
-        Math.round(b.w + 6), Math.round(b.h + 6));
-      c.drawImage(frame.lit, b.px - b.ink.x * b.k, b.py - b.ink.y * b.k,
-        art.width * b.k, art.height * b.k);
-      return;
+      c.fillRect(Math.round(lb.px - 3), Math.round(lb.py - 3),
+        Math.round(lb.w + 6), Math.round(lb.h + 6));
+      c.drawImage(written.lit, lb.px - lb.ink.x * lb.k, lb.py - lb.ink.y * lb.k,
+        paper.width * lb.k, paper.height * lb.k);
     }
+    if (!slot) return;
 
-    // 2. THE PATCH. Flat, borderless, and slightly bigger than the page that
-    //    made it, because paper curls and the weather got in at the edges.
-    const rect = clip.nailAt[house.variant];
+    // 2. THE SLOT, UNDER IT. Flat, borderless, and slightly bigger than the
+    //    page that made it, because paper curls and the weather got in at the
+    //    edges. There from the first light, whether or not anything is in it.
+    const rect = clip.slotAt?.[house.variant];
+    if (!rect) return;
     const [nx, ny, nw, nh] = rect;
     const px0 = Math.round(x + nx);
     const py0 = Math.round(y + ny);
 
-    // 2a. AND WHILE IT IS EMPTY IT BREATHES.
+    // IT DOES NOT BREATHE. It used to, while it was empty: the patch only
+    // appeared once the letter came off, and nothing walked a player over to a
+    // door to find it. It is under the letter from the first light now, and a
+    // bare nail under a letter asks its own question. A pulse on a wall reads
+    // as UI, and the loom house's empty slot has to read as a letter nobody
+    // answered, not as a button nobody pressed.
     //
-    // The ghost below only helps a player who is ALREADY standing here with
-    // the right thing in his hand. Nothing walked him over in the first place:
-    // he lit a door, saw a slightly cleaner rectangle of wall, and had no
-    // reason to think it was anything. That is what actually happened to the
-    // first person who played it.
-    //
-    // THE GAME ALREADY HAS A WORD FOR THIS and it is not a new one. A scrap
-    // lying in the dark breathes; so does a key once its door is open. Same
-    // numbers, same rhythm, same meaning — something here is yours to do
-    // something with. A new kind of highlight would have been UI; this is the
-    // sentence the level has been speaking since the first object on the
-    // ground.
-    //
-    // IT STOPS THE MOMENT SOMETHING IS IN IT. An empty place asks its own
-    // question, which is the same reason four empty sockets on the gate have
-    // never needed explaining — and it is why the loom house goes on asking
-    // for the whole level, with nobody left to answer it.
-    //
-    // NOT ON THE TREE (`quiet`). Nothing ever goes back on it, so its empty
-    // patch must not ask for anything: a bare nail and a paler mark, no more.
-    if (house.filed == null && !quiet) {
-      const pulse = 1 - TORCH.KEPT_PULSE_DEPTH *
-        (0.5 - 0.5 * Math.cos(clock * Math.PI * 2 * TORCH.KEPT_PULSE_HZ));
-      const cx = px0 + nw / 2;
-      const cy = py0 + nh / 2;
-      const r = Math.max(nw, nh) * TORCH.KEPT_GLOW_R;
-      const g = c.createRadialGradient(cx, cy, 0, cx, cy, r);
-      g.addColorStop(0, `rgba(${TORCH.KEPT_RGB},${(TORCH.KEPT_GLOW * pulse).toFixed(3)})`);
-      g.addColorStop(1, `rgba(${TORCH.KEPT_RGB},0)`);
-      const was = c.globalCompositeOperation;
-      c.globalCompositeOperation = 'lighter';
-      c.fillStyle = g;
-      c.fillRect(cx - r, cy - r, r * 2, r * 2);
-      c.globalCompositeOperation = was;
-    }
-
     // IT IS THE SHAPE OF WHAT GOES IN IT.
     //
     // A rectangle says "a place" without saying what for, and that is exactly
@@ -1291,11 +1259,11 @@ export function createRenderer(ctx) {
     // AND IT IS NOT A VERDICT. It appears for the wrong page just as readily,
     // because it is a preview of an act and not an opinion about it.
     if (house.filed == null) {
-      if (quiet || !s.canPin || s.markHouse !== house.index) return;
+      if (!s.canPin || s.markHouse !== house.index) return;
       const held = s.handPage;
       const ghostArt = held?.kind === 'fragment' ? s.kept : null;
       const gf = ghostArt?.frames[held.kept];
-      const gb = nailBox(clip, house, x, y, ghostArt);
+      const gb = nailBox(rect, x, y, ghostArt);
       if (!gf || !gb) return;
       c.globalAlpha = 0.5;
       c.drawImage(gf.lit, gb.px - gb.ink.x * gb.k, gb.py - gb.ink.y * gb.k,
@@ -1313,7 +1281,7 @@ export function createRenderer(ctx) {
     // up the street, and that takes as long as it takes.
     const art = s.kept;
     const frame = art?.frames[house.filed];
-    const b = nailBox(clip, house, x, y, art);
+    const b = nailBox(rect, x, y, art);
     if (!b || !frame) return;
     c.drawImage(frame.lit, b.px - b.ink.x * b.k, b.py - b.ink.y * b.k,
       art.width * b.k, art.height * b.k);
@@ -1836,10 +1804,9 @@ export function createRenderer(ctx) {
             : '—') +
           (s.canPin ? '   [E] PIN IT HERE'
             : s.canMark ? '   [E] take it back down'
-              : s.canTakeLetter ? '   [E] take the letter'
-                : s.canPlaceKey ? `   [E] put a key in  (${s.prince.keys} in hand)`
-                  : s.canTakeKey ? '   [E] take the key'
-                    : nearKept ? '   [E] take' : '') +
+              : s.canPlaceKey ? `   [E] put a key in  (${s.prince.keys} in hand)`
+                : s.canTakeKey ? '   [E] take the key'
+                  : nearKept ? '   [E] take' : '') +
           // ONLY WHEN IT IS NOT WORKING. Spelled out because a phone has no
           // console and no backtick key — "running / playback" and still silent
           // on an iPhone means the ringer switch, not the game. Once it is

src/scene_level.js

@@ -201,12 +201,23 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
   // thing that says the mode changed.
   const GATE_X = BOWL.X1;
   const GATE_STOP_X = GATE_X - 380;      // inside the gateway, clear of the post
+  // AND THE FAR SIDE OF THE SAME GATEWAY, once the man who holds it has gone
+  // home. 40px inside the right post, as GATE_STOP_X is inside the left, so he
+  // never stands in front of pure black and disappears into it.
+  const GATE_ROOM_X = GATE_X + 380;
   // Where the view stops, and it is not simply the gate. Bounding the camera at
   // GATE_X - W/2 put the wall across the middle of the frame and shoved him
   // into the left half to stand at it. Stopping three quarters of the way over
   // leaves the village behind him visible while he is working out that the gate
   // will not open, which is the exact moment he has to turn around.
   const GATE_CAM_X = GATE_X - W * 0.75;
+  // AND A LITTLE FURTHER ONCE THE GATEWAY IS HIS. With its keeper home he can
+  // walk to the far post, and at GATE_CAM_X that stood him 100px from the edge
+  // of the frame with the post cut in half. This frames the whole gateway —
+  // both posts, the leaf and all four sockets — with 100px of wall past it.
+  // The keeper leaves while the prince is at the gatehouse, a screen away, so
+  // the view is never at either bound when it changes and nothing jumps.
+  const GATE_ROOM_CAM_X = GATE_X + 620 - W;
 
   // THERE IS NO ONE-WAY MOUTH, and the reason is worth keeping.
   //
@@ -291,21 +302,20 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     variant: i,
     x: houseX(i),
     w: houseClip ? houseClip.width : 960,
-    seen: false,       // has the torch been held on its door? Latches, like the
-                       // objects on the ground, and for the same reason
+    // HAS THE TORCH BEEN ON ITS DOOR OR ITS LETTER? Latches, like the objects
+    // on the ground, and for the same reason. It is the whole of what the door
+    // remembers about him: the band reads a lit door again for free, and the
+    // slot takes a pin.
+    //
+    // THE LETTER NEVER COMES DOWN, so there is no second flag for it. Letters
+    // stay where they were left and fragments come off bodies: he does not
+    // pocket a stranger's mail, and the door is where he judges.
+    seen: false,
     // WHAT HE HAS FILED UNDER THIS HOUSE, and nothing else in the build writes
     // it. The `kept` index of one fragment, or null. The map used to fill this
     // in by itself the moment he looked at something, which made it a receipt;
     // a claim only means anything if it can be wrong, so he makes it.
     filed: null,
-    // THE LETTER IS AN OBJECT IN THE ROOM, not a thing the house hands over for
-    // being looked at. Light it to read it, press take to keep it — the same
-    // two acts, in the same order, that every fragment on the ground already
-    // asks for. It used to drop into the sheaf the instant the door lit, which
-    // meant the only way to READ it was to raise the sheaf and page to it, and
-    // a player who had not found paging never saw a word of the writing.
-    letterSeen: false,
-    letterTaken: false,
     // SOMEBODY CAME HOME TO IT. Set when a body finishes its walk at this
     // door, and it is the only thing in the level that is ever a verdict —
     // except that it is not one, because the game does not say it. A person
@@ -339,16 +349,26 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
   const doorPoint = (h) => [h.x + doorOffset[0], GROUND_Y + doorOffset[1]];
 
   /**
-   * The middle of the nail beside that door, as a world point — which is the
-   * letter while it is hanging there, and the patch it leaves, and the page
-   * pinned into the patch. One spot, so one point, and the torch test is the
-   * same for all three.
+   * The middle of the letter beside that door, as a world point. It never
+   * comes down, so this is always where it hangs.
    *
    * Straight out of the clip's own pixels, the same deal `doorAt` gets: move it
    * in the art and the thing the torch has to cover moves with it.
    */
   const letterPoint = (h) => {
-    const r = houseClip?.nailAt?.[h.variant];
+    const r = houseClip?.letterAt?.[h.variant];
+    if (!r) return null;
+    return [h.x - houseClip.pivotX + r[0] + r[2] / 2,
+      GROUND_Y - houseClip.pivotY + r[1] + r[3] / 2];
+  };
+
+  /**
+   * And the middle of the slot under it: the second nail, the lighter patch
+   * where their own paper hung, and the page he pins back into it. Same column
+   * as the letter, so the reach to either is the same reach.
+   */
+  const slotPoint = (h) => {
+    const r = houseClip?.slotAt?.[h.variant];
     if (!r) return null;
     return [h.x - houseClip.pivotX + r[0] + r[2] / 2,
       GROUND_Y - houseClip.pivotY + r[1] + r[3] / 2];
@@ -394,18 +414,18 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
   // --- the tree on the road ------------------------------------------------
   // A rebel nailed the rule to it: they cannot speak, what they carried is all
   // that is left of them, take it home. Never an answer — not which ones, not
-  // which home. It is a letter like the houses' in every way the code cares
-  // about: light it, read it in the band, take it, and it is a page. It just
-  // is not a door, so nothing is ever pinned back to it.
+  // which home. It reads like a house's letter in every way the code cares
+  // about: light it and the band reads it, and after that standing by it
+  // does. It stays on the tree, the same as every letter stays on its door,
+  // and it is not a door — no slot, and nothing is ever pinned back to it.
   const treeClip = clips.road_tree ?? null;
   const TREE_NOTE = letters?.byHouse?.findIndex((h) => h.origin === 'tree') ?? -1;
   const TREE = treeClip && TREE_NOTE >= 0
-    ? { kind: 'tree', x: TREE_X, index: TREE_NOTE, variant: 0,
-      seen: false, letterSeen: false, letterTaken: false, filed: null }
+    ? { kind: 'tree', x: TREE_X, index: TREE_NOTE, variant: 0, seen: false }
     : null;
-  /** The middle of the nail on the tree, as a world point. Off the clip's pixels. */
+  /** The middle of the note on the tree, as a world point. Off the clip's pixels. */
   const treePoint = () => {
-    const r = treeClip?.nailAt?.[0];
+    const r = treeClip?.letterAt?.[0];
     if (!TREE || !r) return null;
     return [TREE.x - treeClip.pivotX + r[0] + r[2] / 2,
       GROUND_Y - treeClip.pivotY + r[1] + r[3] / 2];
@@ -563,6 +583,10 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
       { standing: true, stayDown: true, post: true, kept: HOUSE_OF.indexOf('the gatehouse'),
         keptMaxX: KEPT_MAX_X }));
   }
+  // Whether his post is empty: walking home, or home. Nothing else takes him
+  // off it — a fight leaves him on the ground where he stood.
+  const GATEKEEPER = village[village.length - 1];
+  const keeperGone = () => GATEKEEPER.state === HOMING || GATEKEEPER.state === HOME;
 
   /**
    * THE DEAL, AND IT IS A CONSTRAINED SHUFFLE.
@@ -703,15 +727,21 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
    * THE SHEAF. Loose pages he carries, and the map is one of them.
    *
    * Built here at L2 and paged at L3. What arrives when:
-   *   the map        at the start
-   *   a house letter when he lights that door
+   *   his orders     at the start, and permanently page one
    *   a fragment     when he takes it
+   *   a key          when he takes it off its hook
+   *
+   * NO HOUSE LETTERS AND NO NOTE. Those stay where they were left — on the
+   * door and on the tree — and the band reads them there.
    *
    * FOUND ORDER. Not grouped, not sorted, no index and no tabs — the order he
    * picked them up in is the only order there is.
    */
   // Last frame's take button, so an act fires on the edge. See where it is read.
   let prevPickup = false;
+  // How long he has stood still, in ms. The band reads a door he has lit again
+  // once this passes READ_STILL_MS. See the band.
+  let still = 0;
   // Whether he wanted the light last frame, so the flame fires on the raise
   // and not on every frame of holding it.
   let litLast = false;
@@ -793,9 +823,10 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
   const page = () => sheaf.pages[sheaf.index] ?? null;
 
   /**
-   * Has he looked at this page's contents? A letter is read off a lit door, so
-   * it arrives known. A FRAGMENT CAN BE TAKEN BLIND and arrives unknown, and
-   * the whole gate at the end of the level turns on that difference.
+   * Has he looked at this page's contents? The one letter he carries is his
+   * orders, which he is reading when the game starts. A FRAGMENT CAN BE TAKEN
+   * BLIND and arrives unknown, and the whole gate at the end of the level
+   * turns on that difference.
    */
   const pageSeen = (pg) => {
     // A letter was read off a lit door and a key has nothing written on it, so
@@ -824,10 +855,10 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
    * Put a page on the pile and open on it.
    *
    * FOUND ORDER means it goes on the end. Moving the index to it is what a
-   * person does with a handful of letters — the new one is the one in your
-   * hand — and it is what makes lighting a door one gesture instead of two:
-   * `Q` raises the torch, the door lights, the letter arrives, and it is the
-   * page already open.
+   * person does with a handful of papers — the new one is the one in your
+   * hand — and it is what makes pinning one gesture instead of two: take a
+   * fragment off a body, walk to a door, press E, and it is already the page
+   * he is holding.
    */
   const filePage = (pg) => {
     sheaf.pages.push(pg);
@@ -842,8 +873,8 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
    * explaining that he begins carrying nothing. That was true of a pile of
    * things he had FOUND. This is the one page he did not find: it is what he
    * was handed at the palace and what sent him down this road, and by the end
-   * of the village it sits under nine letters and fragments that between them
-   * contradict every word of it. Nothing has to say so.
+   * of the village it sits under four fragments that, with the letters on the
+   * doors they answer, contradict every word of it. Nothing has to say so.
    *
    * IT IS AN ORDINARY LETTER PAGE. Not its own kind: it is a page of writing
    * with a building behind it, which is what every letter in this game is, and
@@ -863,10 +894,12 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
 
   /**
    * What the band is showing, and it shows the document rather than describing
-   * it. At L2 that is the letter of whatever door the torch is on; at L3 the
-   * sheaf takes it over and the band opens and closes with the pages.
+   * it: the page he is holding up, or the letter on the wall in front of him.
+   *
+   * `key` says WHICH document, so the band can blank between two of them —
+   * a page turn, or looking from the door to his papers and back. See the band.
    */
-  const band = { text: null, alpha: 0, turns: 0 };
+  const band = { text: null, alpha: 0, key: null };
 
   /**
    * WHAT THIS BUILD IS FOR, counted.
@@ -903,7 +936,6 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     sheetClip, mapClip, hurtClip, run, sheaf, band, textFor, letters, page, pageSeen, filedUnder,
     canMark: false,
     markHouse: null,
-    canTakeLetter: false,
     canTakeKey: false,
     canPlaceKey: false,
     // Whether there is anything at his feet to pick up. Computed once here
@@ -911,9 +943,15 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     canTake: false,
     seed: SEED,
     houses: HOUSES, houseTint: PALETTE.WATCHERS,
-    houseClip, palaceClip, houseArt, doorPoint, keyPoint, letterPoint,
-    tree: TREE, treeClip, treeIconClip: clips.origin_tree ?? null, treeNoteDark, treePoint,
-    village, gateX: GATE_X, gateStopX: GATE_STOP_X,
+    houseClip, palaceClip, houseArt, doorPoint, keyPoint, letterPoint, slotPoint,
+    tree: TREE, treeClip, treeNoteDark, treePoint,
+    // What the band is reading off a wall right now, if anything: the house or
+    // the tree. Published for the checks, which ask whether it is the same
+    // door E would act on.
+    readingAt: null,
+    // The house E would act on, if any. Same door the band reads.
+    nearDoor: null,
+    village, gateX: GATE_X, gateStopX: GATE_STOP_X, gateRoomX: GATE_ROOM_X,
     villageGap: VILLAGE_GAP, bowlX0: BOWL.X0,
     flame: { clip: clips.fire, player: createPlayer(clips.fire), frame: 0 },
     torchArm: TORCH_ARM,
@@ -942,10 +980,12 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     state.clock = 0;
     for (const h of HOUSES) {
       h.seen = false; h.filed = null;
-      h.letterSeen = false; h.letterTaken = false;
       h.open = false; h.settled = false; h.keyTaken = false;
     }
-    if (TREE) { TREE.seen = false; TREE.letterSeen = false; TREE.letterTaken = false; }
+    if (TREE) TREE.seen = false;
+    still = 0;
+    state.readingAt = null;
+    state.nearDoor = null;
     prevPickup = false;
     prince.attacking = false;
     prince.attackTime = 0;
@@ -970,7 +1010,7 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     sheaf.turns = 0;
     band.text = null;
     band.alpha = 0;
-    band.turns = 0;
+    band.key = null;
     state.fade = 0;
     // Deaths survive a restart. Everything else about the run does not — that
     // is what "the findings are at stake" means.
@@ -993,6 +1033,10 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
 
   function update(dt, input) {
     prince.prevX = prince.x;
+    // Where he started this frame, for "is he standing still". Not prevX: a
+    // hit and a shove both reset that to stop the draw smearing, so a knock
+    // would look like standing still.
+    const xFrom = prince.x;
     torch.snapshot();
     camera.snapshot();
     state.clock += dt;
@@ -1105,9 +1149,18 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
       if (prince.x < 0) prince.x = 0;
       // He does not hit a boundary, he hits a shut gate. Once it is up, the
       // only thing left in his way is the man standing in it.
-      const stop = gate.open >= 1 ? GATE_X + 260 : GATE_STOP_X;
+      //
+      // AND THE GATEWAY IS HIS ONCE ITS KEEPER HAS GONE HOME. While the keeper
+      // holds the post, the shut leaf stops him just inside the left post.
+      // With the post empty he can walk the whole width of the leaf, under all
+      // four sockets, to just inside the right one. Found in play: he stood
+      // at the left edge and could not get close enough to see how many
+      // sockets the gate wanted.
+      const shut = keeperGone() ? GATE_ROOM_X : GATE_STOP_X;
+      const stop = gate.open >= 1 ? Math.max(GATE_X + 260, shut) : shut;
       if (prince.x > stop) prince.x = stop;
     }
+    camera.setBounds(0, keeperGone() ? GATE_ROOM_CAM_X : GATE_CAM_X);
     camera.follow(prince.x);
 
     // --- The sword --------------------------------------------------------
@@ -1332,46 +1385,45 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     // Lighting one is the only thing that says who lived here. It latches, the
     // same way seeing an object on the ground latches, and for the same reason:
     // he looked, and looking is not something he can un-do.
-    // IT LATCHES AND NOTHING READS IT THIS FRAME ANY MORE. There used to be a
-    // `lit` house here, meaning "the torch is on this door right now", and it
-    // was what marking tested. Marking now tests a LATCH plus a distance, the
-    // same deal the letter and the key already had — so all this loop does is
-    // remember that he looked.
-    let litLetter = null;
+    //
+    // THE DOOR OR ITS LETTER, EITHER ONE. The letter hangs left of the arch,
+    // nearer him than the door, so there is a stretch of wall where the light
+    // is on the letter and not yet on the door. If only the door counted he
+    // could read a letter in the band and then find the door had never been
+    // lit: the next read would not come free, and E would not pin.
     for (const h of HOUSES) {
       const [dx, dy] = doorPoint(h);
-      if (!torch.covers(dx, dy)) continue;
-      h.seen = true;
-      // And the letter on its wall. Same latch as an object on the ground: he
-      // looked, and looking is not something he can un-do.
-      if (!h.letterTaken && letterPoint(h) && torch.covers(...letterPoint(h))) {
-        h.letterSeen = true;
-      }
+      const lp = letterPoint(h);
+      if (torch.covers(dx, dy) || (lp && torch.covers(lp[0], lp[1]))) h.seen = true;
     }
     // THE NOTE ON THE TREE. No door to light first: the paper is all there is.
-    if (TREE && !TREE.letterTaken) {
+    if (TREE) {
       const p = treePoint();
-      if (p && torch.covers(p[0], p[1])) { TREE.seen = true; TREE.letterSeen = true; }
+      if (p && torch.covers(p[0], p[1])) TREE.seen = true;
     }
 
-    // TAKING IT DOES NOT NEED THE TORCH STILL UP. Seeing latches; taking is a
-    // separate act, exactly as it is for a page on the ground, which he can
-    // pick up in the dark once it has fallen.
+    // THE DOOR HE IS AT, AND IT IS LATCHED RATHER THAN LIT.
+    //
+    // There used to be a `lit` house here, meaning "the torch is on this door
+    // right now", and it was what marking tested — which only worked because
+    // holding the sheaf forced the torch up. Seeing latches instead, and acting
+    // on it only needs him to still be standing there.
     //
-    // IT USED TO, AND ON A PHONE THAT MADE IT IMPOSSIBLE. TORCH and TAKE are
-    // both on the left-hand wheel and one thumb cannot hold one while pressing
-    // the other — so letting go of TORCH to reach TAKE un-offered the letter
-    // every time. On a keyboard you could hold both and never notice.
+    // ONE DOOR, AND THE BAND AND E BOTH USE IT. The band never reads him one
+    // door while E acts on another. The doors are about 4200px apart and the
+    // reach is 440, so there is never more than one to choose from anyway.
+    let nearDoor = null;
     for (const h of HOUSES) {
-      if (h.letterTaken || !h.letterSeen) continue;
-      const p = letterPoint(h);
-      if (p && Math.abs(prince.x - p[0]) <= TUNING.DOOR_REACH) { litLetter = h; break; }
+      if (!h.seen) continue;
+      const p = slotPoint(h);
+      if (p && Math.abs(prince.x - p[0]) <= TUNING.DOOR_REACH) { nearDoor = h; break; }
     }
-    // And the tree's, on the same terms. From here the band and E do not know
-    // the difference: it reads as a letter and files as one, with its own page.
-    if (!litLetter && TREE && !TREE.letterTaken && TREE.letterSeen) {
+    // And the tree, on the same terms. It reads like a door and it never joins
+    // nearDoor: there is nothing on it to pin to.
+    let nearTree = null;
+    if (TREE?.seen) {
       const p = treePoint();
-      if (p && Math.abs(prince.x - p[0]) <= TUNING.DOOR_REACH) litLetter = TREE;
+      if (p && Math.abs(prince.x - p[0]) <= TUNING.DOOR_REACH) nearTree = TREE;
     }
 
     // AND THE KEY, WHICH NEEDS THE DOOR OPEN AND NOT THE TORCH UP.
@@ -1392,39 +1444,64 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
 
     // --- the band -----------------------------------------------------------
     //
-    // IT OPENS WITH THE SHEAF AND CLOSES WITH IT. At L2 it hung off whatever
-    // door the torch was on, because there was nothing to page. Now it shows
-    // the page he is holding up and nothing else, which is why `Q` is the whole
-    // reading gesture: it raises the torch, the door in front of him lights,
-    // the room shows, and the letter that just arrived is the page already
-    // open. One button, both halves.
+    // IT SHOWS A DOCUMENT, VERBATIM, and a document is in one of two places: in
+    // his hand, or nailed to the wall in front of him. Nothing else in this
+    // game gets text: not doors, not the gate, not objects and not the prince.
+    //
+    //   Q held                                   the page in his hand. Wins
+    //   the torch on a letter, in reach          that letter. The first read
+    //   standing still, in reach of a lit door   that door's letter
+    //   otherwise                                closed
     //
-    // Raising the plain torch still lights a door and still shows the room. It
-    // just does not read the paper out, because he is not holding any paper up.
+    // COMPARING IS LOOKING AT THE DOOR, THEN AT HIS PAPERS, THEN AT THE DOOR.
+    // Hold Q and the band reads the fragment in his hand; let go and it reads
+    // the door again. That is the whole deduction, stood in one place.
     //
-    // Verbatim, always. Nothing else in this game gets text: not doors, not the
-    // gate, not objects and not the prince.
+    // THE FIRST READ NEEDS LIGHT, AND ONLY THE FIRST. The first draft had every
+    // read need the torch, so comparing was SPACE held with Q tapped in
+    // between. On a phone TORCH and PAGES are both on the left wheel and one
+    // thumb cannot hold one while pressing the other — the trap taking a letter
+    // fell into once already. So a door he has lit reads again for nothing,
+    // and comparing is one button: PAGES down, PAGES up.
+    //
+    // STANDING STILL is what stops it opening at every door he walks past. Not
+    // walking, not swinging and not knocked back, for READ_STILL_MS. Holding Q
+    // counts — he cannot walk with it up — so letting go of Q goes straight
+    // back to the door.
+    const stood = !prince.moving && !prince.attacking && prince.x === xFrom;
+    still = stood ? still + dt * 1000 : 0;
+    const readAt = nearDoor ?? nearTree;
+    const readPoint = readAt === TREE ? treePoint() : readAt ? letterPoint(readAt) : null;
+    const reading = !!readAt &&
+      ((!!readPoint && torch.covers(readPoint[0], readPoint[1])) ||
+        still >= TUNING.READ_STILL_MS);
+    state.readingAt = sheaf.up || !reading ? null : readAt;
     // Gated on the raise so the band and the page arrive together — the sheet
     // itself is not drawn until the arm is up, and a band that beat it there
     // would read as a subtitle rather than as the paper in his hand.
+    //
+    // THE SHEAF WINS FROM THE MOMENT Q GOES DOWN, not from when the page is
+    // up. For the quarter-second of the raise the band is blank: he has looked
+    // away from the wall and not yet down at his hand.
     const pg = sheaf.up && torch.raise > 0.9 ? page() : null;
     // AN UNKNOWN PAGE HAS NOTHING ON IT YET. He took it blind and he has not
     // looked; the band would be reading him words he cannot have.
-    //
-    // AND A LETTER STILL LYING IN ITS ROOM READS UNDER THE PLAIN TORCH. That is
-    // what "look at it" means everywhere else in this game, and making the
-    // writing cost a second gesture hid it from anyone who had not worked out
-    // that the sheaf pages. The sheaf still wins when it is up: he is holding a
-    // page, and the page in his hand is the one he is reading.
-    const want = pg && pageSeen(pg) ? textFor(pg)
-      : litLetter ? textFor({ kind: 'letter', house: litLetter.index })
+    const want = sheaf.up ? (pg && pageSeen(pg) ? textFor(pg) : null)
+      : state.readingAt ? textFor({ kind: 'letter', house: state.readingAt.index })
         : null;
 
-    // CLEARED AND REFILLED ON EVERY TURN, never swapped in place. The blank
-    // between two pages is a fraction of a second and it is the entire reason a
-    // turn reads as a turn — swap the text and two letters in a row look like
-    // one letter changing its mind.
-    if (sheaf.turns !== band.turns) { band.turns = sheaf.turns; band.alpha = 0; }
+    // CLEARED AND REFILLED EVERY TIME IT CHANGES DOCUMENT, never swapped in
+    // place. The blank between two pages is a fraction of a second and it is
+    // the entire reason a turn reads as a turn — swap the text and two letters
+    // in a row look like one letter changing its mind. Looking from the door to
+    // the page in his hand is the same thing: two pieces of paper, not one
+    // label flipping.
+    //
+    // A page is keyed by the turn count rather than by its words, because
+    // paging from one page to another with the SAME words has to still read as
+    // a turn.
+    const key = !want ? null : pg ? `page ${sheaf.turns}` : `wall ${state.readingAt.index}`;
+    if (key !== band.key) { band.key = key; if (key) band.alpha = 0; }
     band.text = want;
     band.alpha = Math.min(1, Math.max(0, band.alpha + (want ? dt * 5 : -dt * 9)));
 
@@ -1434,14 +1511,14 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     // more: what goes under a plot is a claim he makes, and a claim only means
     // something if it can be wrong.
     //
-    // THE ACT IS THE SAME POSTURE AS EVERYTHING ELSE. He stands at a door,
-    // torch up, holding a piece of paper against it, and presses take. No menu,
-    // no drag, no assignment screen — and no new button, because TAKE is
-    // already the contextual one and both acts are "put this where it goes".
+    // THE ACT IS THE SAME POSTURE AS EVERYTHING ELSE. He stands at a door with
+    // a piece of paper in his hand and presses take. No menu, no drag, no
+    // assignment screen — and no new button, because TAKE is already the
+    // contextual one and pinning is "put this where it goes".
     //
-    // The door has to be LIT, which is the same rule reading it uses, and
-    // holding the sheaf raises the torch — so at a door the door is lit by
-    // definition and there is no second condition to discover.
+    // The door has to have been LIT ONCE — the same latch that reads it again
+    // for free — and he has to be standing at it. Not lit now and not with Q
+    // held: asking for both hands is the problem the hand addendum fixed.
     // ONE ACT PER PRESS, DECIDED HERE AND NOT UPSTREAM.
     //
     // input.js already makes `pickup` a one-shot, and that was enough while
@@ -1476,42 +1553,15 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     const handPage = page();
     state.handPage = handPage;
 
-    // THE DOOR HE IS AT, AND IT IS LATCHED RATHER THAN LIT.
-    //
-    // `lit` above is whether the torch is ON a door this frame, and that was
-    // the marking test — which worked only because holding the sheaf forced the
-    // torch up. With the sheaf out of it, the torch is down and `lit` is null,
-    // so the old test could never fire again.
-    //
-    // The letter and the key already solved this: seeing latches, and taking is
-    // a separate act that only needs him to still be standing there. The patch
-    // is the third thing on that wall and it gets the same deal.
-    let nearDoor = null;
-    for (const h of HOUSES) {
-      if (!h.seen) continue;
-      const p = letterPoint(h);
-      if (p && Math.abs(prince.x - p[0]) <= TUNING.DOOR_REACH) { nearDoor = h; break; }
-    }
-    // AND NOT BEFORE THE LETTER IS OFF THE NAIL.
-    //
-    // There is one spot beside each door and the letter is on it. Take the
-    // letter and what is left is the patch of cleaner wall it kept the weather
-    // off for sixty years, and THAT is where a fragment goes. So a house he
-    // has not read has nowhere to put anything, and taking the letter is the
-    // thing that shows him where — the affordance is earned rather than drawn,
-    // which is the whole reason the frame went.
-    //
-    // It also closes a hole the frame never had: filing into a nail that still
-    // had a letter on it put a page somewhere nothing draws, so the claim was
-    // made and invisible.
+    // THE SLOT TAKES A PIN FROM THE FIRST LIGHT. It used to wait for the letter
+    // to come off: the patch was earned, and taking the letter was what showed
+    // him where a fragment goes. The letter never comes off now, and the slot
+    // is beside it from the start — a bare nail under a letter says something
+    // goes here.
     //
     // AND NOT AT A DOOR THAT IS FINISHED WITH. Someone walked home to it; the
-    // patch has the only thing it was ever going to hold.
-    //
-    // AND NOT AT A DOOR THAT IS FINISHED WITH. Someone walked home to it; the
-    // patch has the only thing it was ever going to hold.
-    const patchTakes = !!nearDoor && !gate.through && !nearDoor.settled &&
-      nearDoor.letterTaken;
+    // slot has the only thing it was ever going to hold.
+    const patchTakes = !!nearDoor && !gate.through && !nearDoor.settled;
     const holding = handPage?.kind === 'fragment' ? handPage.kept : null;
 
     // PIN, or TAKE BACK, and which one is decided by what is already there.
@@ -1527,17 +1577,21 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     const canPin = patchTakes && holding !== null && holding !== nearDoor.filed;
     const canMark = canPin || canRetrieve;
 
-    // LETTER FIRST, THEN THE PATCH, THEN THE KEY. An unread door hands over the
-    // reading before it will accept a claim about it, and the thing that opens
-    // a gate comes last. Evidence before conclusions before rewards, which is
-    // the order this whole game is arguing for.
-    state.canTakeLetter = !!litLetter;
-    state.canMark = !litLetter && canMark;
-    state.canPin = !litLetter && canPin;
+    // THE SLOT, THEN THE KEY. A claim about a door comes before the thing that
+    // opens the gate: evidence before conclusions before rewards, which is the
+    // order this whole game is arguing for.
+    //
+    // READING IS NOT ON THIS LIST. What the band shows decides nothing about E.
+    // It used to — a letter in reach switched off pinning until it was taken —
+    // and with letters never taken that would have switched pinning off at
+    // exactly the moment he reads the letter he is trying to answer.
+    state.canMark = canMark;
+    state.canPin = canPin;
+    state.nearDoor = nearDoor;
     // WHICH house it would go under. The sheet draws that house's plot beside
     // the page when this is set, so the paper itself says "this one, here".
     state.markHouse = state.canPin ? nearDoor.index : null;
-    state.canTakeKey = !litLetter && !canMark && !!litKey;
+    state.canTakeKey = !canMark && !!litKey;
     // AND PUTTING ONE IN. He stops 380px short of the leaf and can never get
     // closer, so the reach is the door's, not the ground's.
     state.canPlaceKey = !canMark && prince.keys > 0 && !gate.through &&
@@ -1622,16 +1676,7 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     // second time to decide whether to light the button, which is two places
     // that have to agree about what is in reach.
     state.canTake = !!nearest;
-    // TAKING THE LETTER OUT OF THE ROOM. Third job for the same button, and it
-    // cannot collide with the other two: marking needs the sheaf up on a
-    // fragment, and this needs a letter still lying in a lit room. Ahead of the
-    // object at his feet because he is looking into the room, and because the
-    // clear pocket round every door keeps drops out of this spot anyway.
-    if (wantsPickup && state.canTakeLetter && !prince.attacking) {
-      litLetter.letterTaken = true;
-      filePage({ kind: 'letter', house: litLetter.index });
-      audio?.mark?.();
-    } else if (wantsPickup && state.canPlaceKey && !prince.attacking) {
+    if (wantsPickup && state.canPlaceKey && !prince.attacking) {
       // THE SAME POSTURE AS EVERYTHING ELSE. He stands at the thing and
       // presses take. Four times, one socket each, and the leaf lifts on the
       // fourth — no ceremony, no confirmation, and nothing said about the
@@ -1728,7 +1773,10 @@ export async function createLevelScene(clips, { audio = null, seed = null, lette
     if (gate.filled >= TUNING.GATE_WANTS && gate.open < 1) {
       gate.open = Math.min(1, gate.open + (dt * 1000) / TUNING.GATE_OPEN_MS);
     }
-    if (gate.open >= 1 && prince.x >= GATE_X - 40) {
+    // THROUGH IS A STEP, not a place. He can be standing inside the gateway
+    // when the leaf lifts — it is his to walk once the keeper is home — and
+    // the level must not end on him for standing still under it.
+    if (gate.open >= 1 && prince.x >= GATE_X - 40 && prince.moving && prince.facing > 0) {
       // Through it, and the playthrough is over. No prompt, no score screen,
       // and no mention of the empty slot. The gate wanted four. It got four.
       gate.through = true;

src/tuning.js

@@ -511,11 +511,18 @@ export const TUNING = {
   // 225px out from the body, and he stops about 170px short of it when he
   // fights, so this makes him walk the last stretch on purpose.
   PICKUP_REACH: 120,
-  // How close he has to be to a door to take the letter off its wall, once he
-  // has looked at it. Wider than PICKUP_REACH because the letter is up on the
+  // How close he has to be to a door to read its letter or pin to its slot,
+  // once he has lit it. Wider than PICKUP_REACH because both are up on the
   // wall rather than at his feet, and wide enough to cover anywhere he could
   // have lit it from — he reads it standing about 300px off.
   DOOR_REACH: 440,
+  // How long he has to stand still at a door he has lit before the band reads
+  // it to him again. The first read needs the torch; every read after that is
+  // free, or comparing a door with the page in his hand takes two buttons, and
+  // on a phone both are under one thumb. Standing still is what stops it
+  // opening at every door he walks past — and the wait is what stops it
+  // flashing half open between two swings of the sword.
+  READ_STILL_MS: 300,
 
   // The gate wants four objects he has LOOKED at. Not four objects.
   GATE_WANTS: 4,
@@ -833,6 +840,8 @@ const OVERRIDABLE = new Set([
   'DOWN_MS', 'RISE_MS', 'STAGGER_MS', 'HITS_TO_DOWN',
   'WALK_SPEED', 'DRAINED_SPEED', 'RUSH_SPEED', 'HOME_SPEED', 'REVEAL_MS', 'START_AT',
   'ORDER_HOLD_MS',
+  // Letters stay on the door. How long standing still takes to read one again.
+  'READ_STILL_MS',
   // The two lanes. Every one of these is a start value that gets tuned by eye.
   'BACK_LANE_SCALE', 'BACK_LANE_RISE', 'BACK_LANE_VALUE', 'STEP_MS', 'WATCH_NEAR', 'WATCH_FAR', 'STIR_TREMBLE_PX', 'STIR_TREMBLE_FROM',
   // The V1 judgement. Sweeping it has to be a query string, not an edit.