@bongos/core 1.21.113 → 1.21.114

package/modules/hall-ui/public/street-deck.js

@@ -0,0 +1,1145 @@
+// modules/hall-ui/public/street-deck.js — THE DECISION DECK: decide in a row
+// (task 1004685, the living-city prototype; V3 of four builders).
+//
+// WHAT THIS IS. The owner's first worry is volume: thirty-nine things can wait on
+// a person at once, and a street of pins does not get through them. The deck is
+// one card at a time at /street#deck (every building) and /street#deck=<building>.
+// Since task 1004702 (the Tweak Mode glass language, the owner's approved mocks
+// in docs/design/mocks/decision-cards/) the street stays in view: the card is a
+// glass panel beside the building that asks, a hairline to its pin, a halo on
+// the pin and a light hush over the rest of the scene; the cards still to come
+// are two slivers under it, and a slim dock at the foot holds the run (how many
+// in hand of the to-do count, today's pips, the keys, the way back). On a phone
+// it is a sheet from the foot. Keys 1 / 2 / 3 pick, S skips, D passes it on to a
+// seat, Escape leaves. Answering slides the card away and the next one rises (a
+// class the stylesheet animates; the motion dies under reduced motion).
+//
+// THE WORDS speak as "I", the agent that asked (the owner's pick, 2026-10-13):
+// the question, the said line (saidOf), the answers with "my pick", and the
+// last line as a sentence (footOf). drawAsk() is the one drawing, for the deck,
+// a building's card on the street, the card inside a building and the city
+// card's first ask (city.js answers it through sendAnswer, the deck's path).
+//
+// REAL CARDS (task 1004703): a matter whose agent stored its ask (the server
+// refuses slop: modules/government/asks.js) carries it from the docket, and the
+// deck draws that card. A matter with no stored ask shows in its own words, with
+// its floor's desk beside it (task 1004717: the prototype overlay's rewrites,
+// marks and sample asks are gone; every card is a real matter).
+//
+// ONE CARD SHAPE (the ask format, GovLiving.askFormat): a question of at most
+// twelve words, two or three tap answers each with a one-line result, a pick and
+// why, who it waits on and what happens if nobody answers. Every ask the living
+// model holds (gov-living.js: every docket matter and the open blockers) is
+// drawn in it; the interiors draw the SAME card in place (street-office.js: a
+// build-out vote with its picture, the reserve loan).
+//
+// REAL ASKS ARE REAL. A card over a real docket matter sends what its desk row
+// sends: GovDesk.cardFor() gives the row (the same acts, chips, routes and
+// permission checks as the floor desk and the street card), and an answer's
+// `act` (the stored ask names it) is mapped to that row's act by actFor(). Nothing
+// here invents a route. An answer that records nothing (not me, keep it off,
+// hold) leaves the deck for this visit and says it still waits. The recorded
+// sign-off opens its line in place (GovMatterCard.recordStrip / recordRun, the
+// goal page's own two routes). The preview harness refuses writes with
+// preview_readonly: the deck says the request reached its route and that the
+// preview stores nothing, and clears the card, so the walk can be done there.
+//
+// BATCHING. After an answer, asks like it (same source, same building, the same
+// answer offered) are offered three at a time as a card of their own, in the
+// ask format: "same answer for these 3?" — the 21 Review sign-offs go in seven
+// taps, not twenty-one.
+//
+// TWO HALVES. The model half is pure (no DOM, no fetch, no clock: `now` is
+// passed in) and node-require-safe, so tests/hall_street_deck.mjs runs it
+// without a browser. The page half (`page`) mounts into street.js through an env
+// of street.js's own senders, draws #streetDeck, and is skipped where there is
+// no document. It READS NOTHING: it draws the street's own living model
+// (street.js data.living, over gov-feeds.js), and its numbers are gov-living.js
+// countsOf over its session, the same numbers the street's header, the city and
+// the shell's tally print (tests/hall_gov_counts.mjs).
+
+(function (root) {
+  'use strict';
+  const req = typeof require === 'function' ? require : null;
+  const L = root.GovLiving || (req ? req('./gov-living.js') : null);
+  const C = root.GovMatterCard || (req ? req('./street-card.js') : null);
+  const D = root.GovDesk || (req ? req('./street-desk.js') : null);
+
+  const NAMES = L ? L.BUILDING_NAMES : {};
+  const KEYS = L ? L.BUILDING_KEYS : [];
+  const BATCH = 3;
+  const SEATS = 5;
+  const str = (v) => (v == null ? '' : String(v));
+  const fit = (s, n, w) => (D && D.fit ? D.fit(s, n, w) : str(s).slice(0, n));
+
+  // ---------- an answer's act → the matter card's act ----------
+  // A stored ask's answers name the act they take (ask.options[].act).
+  // A blocker's three options are its decide chips; "force:<key>" is the force
+  // sign-off with that chip; an override is released (approve) or held (reject:
+  // the decline route is the Board Room's, so holding records nothing here).
+  const ALIAS = Object.freeze({ approve: 'release', reject: 'hold' });
+  const DECIDE = Object.freeze({ 'go ahead': 1, 'not now': 1, 'need more': 1 });
+  const QUIET = Object.freeze({ hold: 1, abstain: 1 });
+  function actFor(act) {
+    if (act == null || act === '') return null;
+    const a = str(act);
+    if (DECIDE[a]) return { key: 'decide', input: { option: a, label: a } };
+    const m = /^([a-z_]+):([a-z_]+)$/.exec(a);
+    if (m) return { key: m[1], input: { option: m[2] } };
+    return { key: ALIAS[a] || a, input: {} };
+  }
+
+  // What tapping an answer does, for this viewer:
+  //   send    the desk row's own request (plan.card is the row's card)
+  //   record  the recorded sign-off opens its line in place
+  //   note    records nothing: the ask leaves the deck this visit, still waiting
+  //   off     the viewer may not take this act from here (plan.why)
+  function optionPlan(ask, opt, cv) {
+    if (!ask || !opt) return { mode: 'off', why: 'nothing to answer' };
+    const a = actFor(opt.act);
+    if (!a || QUIET[a.key]) return { mode: 'note' };
+    const row = cv && cv.row;
+    if (!row || !Array.isArray(row.actions)) return { mode: 'off', why: cv && cv.loading ? 'reading the sitting…' : 'not yours to decide here' };
+    if (!row.actions.some((x) => x.key === a.key)) return { mode: 'off', why: 'not yours to do here' };
+    const choice = (row.choices || {})[a.key];
+    if (a.key === 'record') return choice && choice.file ? { mode: 'record', key: 'record', card: row.card, id: row.card && row.card.subject ? str(row.card.subject.id) : '' } : { mode: 'off', why: 'not yours to sign off' };
+    let input = a.input;
+    if (choice && !choice.file && !choice.field && choice.options.length) {
+      const hit = choice.options.find((o) => o.key === str(a.input.option));
+      if (!hit) return { mode: 'off', why: 'not an answer this matter takes' };
+      input = hit.input;
+    }
+    return { mode: 'send', key: a.key, input: input, card: row.card };
+  }
+
+  // ---------- one card ----------
+  // A seat the server routed (task 1004705, `waits_on.real`) is named; an ask
+  // the docket did not route waits on you, or on others, unnamed.
+  function seatWords(ask) {
+    const w = ask.waits_on || {};
+    if (!w.real) return ask.needs_you ? 'waits on you' : 'waits on others';
+    const label = str(w.label) || 'someone';
+    if (ask.needs_you) return label === 'you' || label === 'the owner' || /^the .* Lead$/.test(label) ? 'waits on you' : 'waits on you · ' + label;
+    return 'waits on ' + label;
+  }
+  // ---------- the words, in the asker's own voice (task 1004702) ----------
+  // The owner's pick (2026-10-13): a card speaks as "I", the agent that asked.
+  // The said line is the stored ask's why; a why not already said as "I" is
+  // led by the pick in that voice: "I'd keep it off." for a tap answer said as
+  // an imperative, "I'd pick the cheap host." for one said as a thing.
+  const lowerFirst = (s) => { const t = str(s); return t ? t.charAt(0).toLowerCase() + t.slice(1) : ''; };
+  const upperFirst = (s) => { const t = str(s); return t ? t.charAt(0).toUpperCase() + t.slice(1) : ''; };
+  const stop = (s) => { const t = str(s).trim(); return t ? t + (/[.!?]$/.test(t) ? '' : '.') : ''; };
+  function saidOf(why, rec) {
+    const w = stop(why);
+    if (/^I(?:'|’|\s)/.test(w)) return w;
+    const label = rec && rec.label ? str(rec.label).trim().replace(/[.!?]+$/, '') : '';
+    const thing = /^(the|a|an|my|your|our|this|that|these|those|one|all|both|none|neither|no|yes|not|nobody|someone)\b/i.test(label) || /^[0-9$]/.test(label);
+    const pick = !label ? '' : thing ? "I'd pick " + lowerFirst(label) + '.' : "I'd " + lowerFirst(label) + '.';
+    return [pick, upperFirst(w)].filter(Boolean).join(' ');
+  }
+  // The card's last line, as a sentence: who it waits on (the "you" half is the
+  // only salmon on it), then what happens if nobody answers.
+  function footOf(ask, silent) {
+    const w = (ask && ask.waits_on) || {};
+    const seat = str(w.seat);
+    let you = '';
+    let rest = '';
+    if (ask && ask.needs_you) {
+      const lead = /^lead:(\w+)$/.exec(seat);
+      if (lead && NAMES[lead[1]]) you = "It's the " + NAMES[lead[1]] + " Lead's call, and that's you.";
+      else if (/^(board|committee):/.test(seat) && w.real && str(w.label)) you = upperFirst(w.label) + ' answers ' + (ask.batch ? 'these' : 'this') + ', and you sit in it.';
+      else you = 'Only you can answer ' + (ask.batch ? 'these' : 'this') + '.';
+    } else if (ask) {
+      rest = 'It waits on ' + (str(w.label) || 'others') + '.';
+    }
+    const left = str(silent).trim() ? 'Left alone, ' + lowerFirst(stop(silent)) : '';
+    return { you: you, rest: [rest, left].filter(Boolean).join(' ') };
+  }
+  // Who holds a building, said to the viewer: their seat, its Lead, or the owner
+  // until a Lead is seated (GET /government/leads; unread names nobody).
+  function holdWords(living, key) {
+    if (!living || !living.seats_real) return '';
+    const b = (living.buildings || []).find((x) => x && x.key === key);
+    const v = living.viewer || {};
+    if (!b) return '';
+    if (b.lead) return str(b.lead.id) === str(v.id) ? 'Your seat.' : 'Led by ' + str(b.lead.name || 'its Lead') + '.';
+    const owner = (v.seats || []).some((s) => s && s.role === 'owner');
+    return owner ? 'You hold it until a Lead is seated.' : 'The owner holds it until a Lead is seated.';
+  }
+  // what waits there: the salmon half of a building's line while it is yours
+  function waitWords(onYou, others) {
+    if (onYou) return onYou === 1 ? 'One thing waits on you.' : onYou + ' wait on you.';
+    if (others) return others === 1 ? 'One thing waits on others.' : others + ' wait on others.';
+    return 'Nothing waits here.';
+  }
+
+  // How many sit on the board a 'board:<building>' seat names (the docket's real holders).
+  function boardSeats(docket, seat) {
+    const m = /^board:(\w+)$/.exec(str(seat));
+    const b = m && docket && Array.isArray(docket.buildings) ? docket.buildings.find((x) => x && x.key === m[1]) : null;
+    return b && Array.isArray(b.holders) ? Math.min(12, b.holders.length) : 0;
+  }
+  // ctx { docket, room, constitution, goals (open), now, viewerId }
+  function cardView(ask, ctx) {
+    const c = ctx || {};
+    const shown = ask && ask.shown;
+    if (!ask) return null;
+    const cv = D && D.cardFor && c.docket ? D.cardFor(ask.id, c.docket, { room: c.room, constitution: c.constitution, now: c.now || 0, goals: c.goals || [], viewerId: c.viewerId }) : null;
+    const age = D && D.ageWord ? D.ageWord(ask.opened_at, c.now || 0) : '';
+    const view = {
+      id: str(ask.id), building: ask.building, buildingName: NAMES[ask.building] || str(ask.building),
+      kicker: (NAMES[ask.building] || str(ask.building)) + (age ? ' · ' + age : ''),
+      askReal: !!ask.ask_real, needsYou: !!ask.needs_you, urgent: !!ask.urgent,
+      waits: seatWords(ask), seat: ask.waits_on ? str(ask.waits_on.seat) : '',
+      silent: '', question: '', options: [], rec: null, refused: !shown, errors: ask.format ? ask.format.errors : [],
+      routing: shown && shown.routing_note ? str(shown.routing_note) : '', tally: ask.tally || null, kind: ask.kind || null,
+      // a board's vote shows its seats, one pip each, lit as the sitting's tally says
+      seats: boardSeats(c.docket, ask.waits_on ? str(ask.waits_on.seat) : ''),
+      card: cv,
+    };
+    if (!shown) {
+      // no stored ask: the matter in its own words, and its floor's desk, where its acts are
+      view.question = fit(ask.raw ? ask.raw.title : '', 90);
+      view.desk = '/builders/street#building=' + str(ask.building);
+      view.foot = footOf(ask, '');
+      return view;
+    }
+    view.question = str(shown.question);
+    view.silent = str(shown.if_nobody_answers);
+    // the agent's own stored card (task 1004703), and its floor's desk beside it
+    view.desk = '/builders/street#building=' + str(ask.building);
+    view.options = (shown.options || []).map((o, i) => {
+      const plan = optionPlan(ask, o, cv);
+      return { n: i + 1, key: str(o.key), label: str(o.label), result: str(o.result), act: o.act == null ? null : str(o.act), rec: !!shown.recommend && str(shown.recommend.key) === str(o.key), plan: plan, off: plan.mode === 'off', why: plan.why || '' };
+    });
+    const r = shown.recommend ? view.options.find((o) => o.key === str(shown.recommend.key)) : null;
+    view.rec = r ? { label: r.label, why: str(shown.recommend.why) } : null;
+    // the words in the asker's voice, and the last line as a sentence (task 1004702)
+    view.said = ask.batch ? str(shown.said) : saidOf(shown.recommend ? shown.recommend.why : '', view.rec);
+    view.foot = footOf(ask, view.silent);
+    return view;
+  }
+
+  // ---------- the queue ----------
+  // Every ask that needs a person, in the model's order (needs-you first, then the oldest); answered and
+  // passed-on asks leave; skipped ones go to the back in the order skipped.
+  // session { done{}, delegated{}, skipped[], extra[] }
+  function queueOf(living, session, scope) {
+    const s = session || {};
+    const all = (living && living.city && Array.isArray(living.city.asks) ? living.city.asks : []).concat(Array.isArray(s.extra) ? s.extra : []);
+    const seen = {};
+    const open = all.filter((a) => {
+      if (!a || seen[a.id] || a.state !== 'needs') return false;
+      seen[a.id] = true;
+      if ((s.done || {})[a.id] || (s.delegated || {})[a.id]) return false;
+      return !scope || a.building === scope;
+    });
+    open.sort(L.compareAsks);
+    const skipped = (s.skipped || []).map(str);
+    const front = open.filter((a) => skipped.indexOf(a.id) < 0);
+    const back = skipped.map((id) => open.find((a) => a.id === id)).filter(Boolean);
+    return front.concat(back);
+  }
+  // The deck's session as gov-living.js countsOf reads one: what left it this visit
+  // (answered or passed on) and what a building added to it.
+  function sessionCounts(session) {
+    const s = session || {};
+    return { answered: Object.keys(s.done || {}).concat(Object.keys(s.delegated || {})), extra: Array.isArray(s.extra) ? s.extra : [] };
+  }
+  function scopesOf(living, session) {
+    const q = queueOf(living, session, null);
+    const by = {};
+    q.forEach((a) => { by[a.building] = (by[a.building] || 0) + 1; });
+    return KEYS.filter((k) => by[k]).map((k) => ({ key: k, label: NAMES[k], n: by[k], you: q.some((a) => a.building === k && a.needs_you) }));
+  }
+
+  // ---------- batching ----------
+  // Asks like this one: the same source at the same building, offering the same
+  // answer (key and act), which this viewer may give from here without a file.
+  function likesOf(queue, from, ctx) {
+    if (!from) return [];
+    return queue.filter((a) => {
+      if (a.id === from.id || a.source !== from.source || a.building !== from.building || !a.shown) return false;
+      const o = (a.shown.options || []).find((x) => str(x.key) === from.key && str(x.act) === str(from.act));
+      if (!o) return false;
+      const cv = D && D.cardFor && ctx && ctx.docket ? D.cardFor(a.id, ctx.docket, { room: ctx.room, constitution: ctx.constitution, now: ctx.now || 0, goals: ctx.goals || [], viewerId: ctx.viewerId }) : null;
+      const mode = optionPlan(a, o, cv).mode;
+      return mode === 'send' || mode === 'note';
+    });
+  }
+  // The batch is a card of its own, in the ask format (askFormat accepts it).
+  function batchAsk(from, likes, more) {
+    const n = likes.length;
+    const label = str(from.label);
+    return {
+      id: 'batch:' + from.id, source: 'batch', building: from.building, state: 'needs', needs_you: true, batch: true,
+      // who the likes wait on is who the batch waits on
+      waits_on: likes[0] && likes[0].waits_on ? likes[0].waits_on : { seat: 'you', label: 'you' }, opened_at: null,
+      likes: likes.map((a) => ({ id: a.id, question: a.shown ? str(a.shown.question) : '' })), more: more, from: from,
+      shown: {
+        question: 'Same answer for ' + (n === 1 ? 'this one' : 'these ' + n) + '?',
+        options: [
+          { key: 'all', act: null, label: n === 1 ? label : fit(label + ', all ' + n, 40, 5), result: n === 1 ? 'It gets the same answer and leaves your deck.' : 'Each gets the same answer and leaves your deck.' },
+          { key: 'one', act: null, label: 'One at a time', result: 'They come up one by one, as before.' },
+        ],
+        recommend: { key: 'all', why: 'They ask the same thing of the same seat.' },
+        waits_on: 'you', if_nobody_answers: n === 1 ? 'It waits in your deck.' : 'They wait in your deck.',
+        said: n === 1 ? "It asks what the last one asked. I'd answer it the same." : "They ask the same thing of the same seat. I'd answer them together.",
+      },
+    };
+  }
+
+  // ---------- passing it on ----------
+  // The seats an ask can be passed to: the owner and each building's Lead, never
+  // the seat it already waits on nor the viewer. Up to five, each a one-tap chip.
+  // The server passes it on (task 1004705, POST /government/asks/:matter/pass):
+  // only a stored ask that waits on you, on a routed docket, and only to real
+  // seats. Anything else cannot be passed on from here.
+  function seatsFor(living, ask, viewerId) {
+    const out = [];
+    if (!(ask && living && living.routed && ask.ask_real && ask.needs_you)) return out;
+    const add = (seat, label, sub) => { if (out.length < SEATS && seat !== (ask && ask.waits_on && ask.waits_on.seat) && !out.some((x) => x.seat === seat)) out.push({ seat: seat, label: fit(label, 16), sub: sub }); };
+    const o = living && living.owner;
+    if (o && str(o.id) !== str(viewerId)) add('owner', o.name || 'the owner', 'the owner');
+    (living ? living.buildings : []).forEach((b) => {
+      if (b.lead && str(b.lead.id) !== str(viewerId)) add('lead:' + b.key, b.lead.name, b.name + ' Lead');
+    });
+    return out;
+  }
+
+  // ---------- the whole deck ----------
+  // input { living, docket, room, constitution, goals, now, viewerId, scope,
+  //         session { done, delegated, skipped, extra, batch, noBatch, decided } }
+  function deckModel(input) {
+    const o = input || {};
+    const session = o.session || {};
+    const living = o.living || null;
+    const scope = o.scope && KEYS.indexOf(o.scope) >= 0 ? o.scope : null;
+    const ctx = { docket: o.docket, room: o.room, constitution: o.constitution, goals: o.goals, now: o.now, viewerId: o.viewerId };
+    const queue = queueOf(living, session, scope);
+    // the deck's numbers are the ones every surface prints (gov-living.js countsOf),
+    // over the same session: answered and passed-on asks leave, this visit's join
+    const counts = L.countsOf(living, sessionCounts(session));
+    let current = null;
+    let batch = null;
+    const b = session.batch;
+    if (b && !(session.noBatch || {})[b.source + ':' + b.building]) {
+      const likes = likesOf(queue, b, ctx);
+      if (likes.length) {
+        const take = likes.slice(0, BATCH);
+        batch = batchAsk(b, take, likes.length - take.length);
+        current = cardView(batch, ctx);
+        current.batch = true; current.likes = batch.likes; current.more = batch.more; current.from = b;
+        current.kicker = take.length + ' more like this';
+        if (batch.more) current.foot.rest = [current.foot.rest, batch.more + ' more like ' + (batch.more === 1 ? 'this' : 'these') + ' after.'].filter(Boolean).join(' ');
+      }
+    }
+    if (!current && queue.length) current = cardView(queue[0], ctx);
+    const you = queue.filter((a) => a.needs_you).length;
+    const others = queue.length - you;
+    // the headline: what is on you while anything is, then what waits on others
+    const lead = you ? { n: you, words: L.countWords('on_you', you), you: true } : others ? { n: others, words: L.countWords('on_others', others), you: false } : { n: 0, words: 'to decide', you: false };
+    return {
+      scope: scope, scopeName: scope ? NAMES[scope] : '', remaining: queue.length, you: you, others: others, lead: lead, counts: counts,
+      title: queue.length ? lead.n + ' ' + lead.words : 'nothing to decide',
+      sub: !queue.length ? '' : you ? (others ? others + ' ' + L.countWords('on_others', others) + ' after these' : 'nothing waits on others') : 'nothing to do',
+      scopes: scopesOf(living, session), current: current, behind: Math.max(0, Math.min(2, queue.length - 1)),
+      queue: queue.map((a) => a.id),
+      // passing it on is the server's, over a routed docket, to seats GET /government/leads names (task 1004705)
+      pass: !!(living && living.routed && living.seats_real),
+      // how many cards are in hand: one, or the batch's likes ("3 of 38 to do")
+      hand: current ? (current.batch ? current.likes.length : 1) : 0,
+    };
+  }
+
+  const model = {
+    actFor: actFor, optionPlan: optionPlan, cardView: cardView, queueOf: queueOf, scopesOf: scopesOf, likesOf: likesOf, sessionCounts: sessionCounts,
+    batchAsk: batchAsk, seatsFor: seatsFor, deckModel: deckModel, saidOf: saidOf, footOf: footOf, holdWords: holdWords, waitWords: waitWords,
+    BATCH: BATCH, ALIAS: ALIAS,
+  };
+
+  // =====================================================================
+  // THE PAGE HALF. Mounted by street.js with an env of its own senders:
+  //   env { data() feeds, getJson(url), send(req), say(text, desk), draw(),
+  //         load(), mode(), today() decisions today, decided() takes a pip,
+  //         done(id) the desk drops the row too }
+  // =====================================================================
+  // ---------- the glass card, drawn (task 1004702) ----------
+  // One drawing for every surface: the deck's panel beside its building, a
+  // building's card on the street, the card inside a building, and the city
+  // card's first ask (city.js). The words come first: the question, one line in
+  // the asker's voice, the answers (each with its result, the pick marked "my
+  // pick" in ink), then who it waits on and what happens if nobody answers, as
+  // a sentence. No uppercase kickers, no ruled sections; salmon only on the dot
+  // and the "you" words of what needs you.
+  //   on  { pick(option), skip(), pass(), seats[], passTo(seat), close(),
+  //         record: { state, pick(file), send(), painted(strip) } } (any may be absent)
+  //   o   { where: the deck's top line, inner: in place inside a building's card,
+  //         acts: skip / pass it on as text buttons, busy, recOpen, delegateOpen,
+  //         rise, picture, qid, cls, pos ("1 of 38", a phone's where line) }
+  function drawAsk(doc, cv, on, o) {
+    o = o || {};
+    on = on || {};
+    const h = (tag, cls, text) => {
+      const el = doc.createElement(tag);
+      if (cls) el.className = cls;
+      if (text != null) el.textContent = String(text);
+      return el;
+    };
+    const btn = (cls, text, fn) => {
+      const b = h('button', cls, text);
+      b.setAttribute('type', 'button');
+      if (o.busy) b.setAttribute('disabled', '');
+      b.addEventListener('click', fn);
+      return b;
+    };
+    const card = h('article', 'ask' + (cv.needsYou ? ' ask--needs' : '') + (cv.batch ? ' ask--batch' : '') + (o.rise ? ' ask--rise' : '') + (o.inner ? ' ask--here' : '') + (o.cls ? ' ' + o.cls : ''));
+    card.setAttribute('data-ask', cv.id);
+    if (o.where) {
+      const where = h('div', 'ask__where');
+      const dot = h('span', 'ask__dot' + (cv.needsYou ? ' ask__dot--you' : ''));
+      dot.setAttribute('aria-hidden', 'true');
+      where.appendChild(dot);
+      where.appendChild(h('b', 'ask__bld', cv.buildingName));
+      where.appendChild(h('span', 'ask__sep', '·'));
+      where.appendChild(h('span', 'ask__waits ask__waits--wide', cv.waits));
+      if (o.pos) where.appendChild(h('span', 'ask__waits ask__waits--narrow', o.pos));
+      where.appendChild(h('span', 'ask__gap'));
+      if (on.close) {
+        const x = btn('ask__esc', null, on.close);
+        x.setAttribute('aria-label', 'Close');
+        x.setAttribute('aria-keyshortcuts', 'Escape');
+        x.appendChild(h('kbd', '', 'esc'));
+        where.appendChild(x);
+      }
+      card.appendChild(where);
+    }
+    const q = h(o.inner ? 'h3' : 'h2', 'ask__q', cv.question);
+    q.setAttribute('tabindex', '-1');
+    if (o.qid) q.setAttribute('id', o.qid);
+    card.appendChild(q);
+    if (cv.batch && cv.likes) {
+      const list = h('ul', 'ask__likes');
+      cv.likes.forEach((l) => list.appendChild(h('li', '', l.question)));
+      card.appendChild(list);
+    }
+    if (o.picture) card.appendChild(o.picture);
+    if (cv.said) card.appendChild(h('p', 'ask__said', cv.said));
+    if (!cv.options.length && cv.desk) {
+      // no stored ask: its acts are on its floor's desk
+      const said = h('p', 'ask__said');
+      const go = h('a', 'ask__desk', 'Answer it on its desk');
+      go.setAttribute('href', cv.desk);
+      said.appendChild(go);
+      said.appendChild(h('span', '', ', where its acts are.'));
+      card.appendChild(said);
+    }
+    if (cv.options.length) {
+      const opts = h('div', 'ask__opts');
+      opts.setAttribute('role', 'group');
+      opts.setAttribute('aria-label', 'answers');
+      cv.options.forEach((op) => {
+        const b = h('button', 'ask__opt' + (op.rec ? ' ask__opt--rec' : '') + (op.off ? ' ask__opt--off' : ''));
+        b.setAttribute('type', 'button');
+        b.setAttribute('data-key', op.key);
+        b.setAttribute('data-n', String(op.n));
+        b.setAttribute('aria-keyshortcuts', String(op.n));
+        if (op.off) { b.setAttribute('aria-disabled', 'true'); b.setAttribute('title', op.why); }
+        if (o.busy) b.setAttribute('disabled', '');
+        const n = h('kbd', 'ask__n', op.n);
+        n.setAttribute('aria-hidden', 'true');
+        b.appendChild(n);
+        b.appendChild(h('span', 'ask__label', op.label));
+        b.appendChild(h('span', 'ask__result', op.off ? op.why : op.result));
+        if (op.rec) b.appendChild(h('span', 'ask__pick', 'my pick'));
+        b.addEventListener('click', () => { if (on.pick) on.pick(op); });
+        opts.appendChild(b);
+      });
+      card.appendChild(opts);
+    }
+    if (on.record && o.recOpen && C && C.recordStrip) {
+      const strip = C.recordStrip(doc, on.record.state(), { pick: on.record.pick, send: on.record.send }, 'card', o.busy);
+      on.record.painted(strip);
+      const line = h('div', 'ask__record');
+      line.appendChild(h('span', 'ask__record-ask', 'the recording'));
+      line.appendChild(strip.node);
+      card.appendChild(line);
+    }
+    const f = cv.foot || { you: '', rest: '' };
+    if (f.you || f.rest || cv.seats) {
+      const foot = h('p', 'ask__foot');
+      if (f.you) foot.appendChild(h('span', 'ask__you', f.you));
+      if (f.you && f.rest) foot.appendChild(doc.createTextNode ? doc.createTextNode(' ') : h('span', '', ' '));
+      if (f.rest) foot.appendChild(h('span', '', f.rest));
+      if (cv.seats) {
+        // a board's vote: one pip per seat, lit as the sitting's tally counts them
+        const tally = h('span', 'ask__tally');
+        const t = cv.tally || {};
+        const voted = Math.min(cv.seats, (Number(t.for) || 0) + (Number(t.against) || 0));
+        const dots = h('span', 'desk-pips');
+        dots.setAttribute('aria-hidden', 'true');
+        for (let i = 0; i < cv.seats; i++) dots.appendChild(h('span', 'desk-pip' + (i < voted ? ' desk-pip--on' : '')));
+        tally.appendChild(dots);
+        tally.appendChild(h('span', '', voted + ' of ' + cv.seats + ' voted'));
+        foot.appendChild(tally);
+      }
+      card.appendChild(foot);
+    }
+    if (o.acts && (on.skip || on.pass)) {
+      const more = h('div', 'ask__more');
+      if (on.skip) { const sk = btn('ask__text', 'skip', on.skip); sk.setAttribute('aria-keyshortcuts', 'S'); sk.setAttribute('data-act', 'skip'); more.appendChild(sk); }
+      if (on.pass && !cv.batch && !(Array.isArray(on.seats) && !on.seats.length)) { const p = btn('ask__text', o.delegateOpen ? 'keep it' : 'pass it on', on.pass); p.setAttribute('aria-keyshortcuts', 'D'); p.setAttribute('aria-expanded', o.delegateOpen ? 'true' : 'false'); p.setAttribute('data-act', 'pass'); more.appendChild(p); }
+      card.appendChild(more);
+    }
+    if (o.delegateOpen && on.seats && on.seats.length) {
+      const chips = h('div', 'ask__seats');
+      chips.setAttribute('role', 'group');
+      chips.setAttribute('aria-label', 'pass it on to');
+      chips.appendChild(h('span', 'ask__seats-ask', 'pass it to'));
+      on.seats.forEach((st, i) => {
+        const c = btn('desk-chip desk-chip--choice ask__seat', st.label, () => on.passTo(st));
+        c.setAttribute('title', st.sub);
+        c.setAttribute('aria-keyshortcuts', String(i + 1));
+        chips.appendChild(c);
+      });
+      card.appendChild(chips);
+    }
+    return card;
+  }
+
+  // One answer through the same path a desk row takes: { ok, toast, sent }.
+  // `send(req)` is the page's own sender; the preview harness refuses writes
+  // with preview_readonly, and the card says the request reached its route.
+  function sendAnswer(opt, send) {
+    const plan = opt && opt.plan;
+    const sentence = (s) => upperFirst(stop(s));
+    if (!plan || plan.mode === 'off') return Promise.resolve({ ok: false, toast: sentence((plan && plan.why) || 'not from here') });
+    if (plan.mode === 'note') return Promise.resolve({ ok: true, toast: 'Noted. ' + opt.result });
+    const refused = C.check(plan.card, plan.key, plan.input);
+    if (refused) return Promise.resolve({ ok: false, toast: refused });
+    const r = C.request(plan.card, plan.key, plan.input);
+    if (!r) return Promise.resolve({ ok: true, toast: 'Noted. Nothing goes on the record, and it still waits.' });
+    return send(r).then((out) => {
+      if (out.ok) return { ok: true, toast: C.answer(plan.card, plan.key, out.body).toast || 'Done.', sent: r, stored: true };
+      if (out && out.status === 501 && out.body && out.body.error && out.body.error.code === 'preview_readonly') return { ok: true, toast: 'Sent to ' + r.method + ' ' + r.url.replace(/^\/api\/bongos/, '') + '. This preview stores nothing.', sent: r };
+      return { ok: false, toast: C.refusal(out.status, out.body) };
+    });
+  }
+
+  // ---------- the scene around a panel (task 1004702) ----------
+  // A light hush over the scene with a clear circle around the building that
+  // asks, a halo on its pin (a 24 s breath, still under reduced motion) and a
+  // hairline from the pin to the panel. `layer` is a box over `stage`; the
+  // panel is placed beside the pin when `place` (a wide stage), else left where
+  // the stylesheet puts it (a phone's sheet). Returns where it all went, or null
+  // when there is no layout to measure (a test's DOM).
+  const SVG_NS = 'http://www.w3.org/2000/svg';
+  const rect = (el) => (el && typeof el.getBoundingClientRect === 'function' ? el.getBoundingClientRect() : null);
+  function spot(doc, layer, stage, anchor, panel, o) {
+    o = o || {};
+    while (layer && layer.firstChild) layer.removeChild(layer.firstChild);
+    const s = rect(stage), a = rect(anchor);
+    if (!layer || !s || !a || !(a.width || a.height)) return null;
+    const px = Math.round(a.left + a.width / 2 - s.left);
+    const py = Math.round(a.top + a.height / 2 - s.top);
+    const at = o.place || panel;
+    if (o.place && panel) {
+      const w = panel.offsetWidth || 476, hgt = panel.offsetHeight || 420;
+      const gap = o.gap || 60;
+      let left = px + gap;
+      if (left + w > s.width - 16) left = px - gap - w;
+      left = Math.max(16, Math.min(left, s.width - w - 16));
+      const floor = (o.bottom != null ? o.bottom : s.height - 16) - hgt;
+      const top = Math.max(o.top != null ? o.top : 16, Math.min(py - 150, floor));
+      o.place.style.left = Math.round(left) + 'px';
+      o.place.style.top = Math.round(top) + 'px';
+    }
+    const hush = doc.createElement('div');
+    hush.className = 'gov-hush';
+    hush.setAttribute('aria-hidden', 'true');
+    hush.style.setProperty('--fx', px + 'px');
+    hush.style.setProperty('--fy', (py + (o.fy || 40)) + 'px');
+    hush.style.setProperty('--fr', (o.fr || 90) + 'px');
+    layer.appendChild(hush);
+    const halo = doc.createElement('span');
+    // salmon only while what it asks needs you
+    halo.className = 'gov-halo' + (o.you ? ' gov-halo--you' : '');
+    halo.setAttribute('aria-hidden', 'true');
+    halo.style.left = px + 'px';
+    halo.style.top = py + 'px';
+    layer.appendChild(halo);
+    const p = rect(at);
+    if (!p) return { x: px, y: py };
+    const pl = p.left - s.left, pr = p.right - s.left, pt = p.top - s.top, pb = p.bottom - s.top;
+    let x1 = px, y1 = py, x2, y2;
+    if (pt > py + 24) { y1 = py + 22; x2 = Math.max(pl + 24, Math.min(px, pr - 24)); y2 = pt; }
+    else if (pr < px) { x1 = px - 22; x2 = pr; y2 = Math.max(pt + 28, Math.min(py, pb - 28)); }
+    else { x1 = px + 22; x2 = pl; y2 = Math.max(pt + 28, Math.min(py, pb - 28)); }
+    const svg = doc.createElementNS(SVG_NS, 'svg');
+    svg.setAttribute('class', 'gov-leader');
+    svg.setAttribute('width', '1');
+    svg.setAttribute('height', '1');
+    svg.setAttribute('aria-hidden', 'true');
+    const line = doc.createElementNS(SVG_NS, 'line');
+    [['x1', x1], ['y1', y1], ['x2', x2], ['y2', y2], ['stroke', 'currentColor'], ['stroke-width', 1]].forEach((kv) => line.setAttribute(kv[0], String(kv[1])));
+    const dot = doc.createElementNS(SVG_NS, 'circle');
+    [['cx', x2], ['cy', y2], ['r', 2.5], ['fill', 'currentColor']].forEach((kv) => dot.setAttribute(kv[0], String(kv[1])));
+    svg.appendChild(line);
+    svg.appendChild(dot);
+    layer.appendChild(svg);
+    return { x: px, y: py };
+  }
+
+  const page = (function () {
+    let env = null;
+    const session = { done: {}, delegated: {}, skipped: [], extra: [], batch: null, noBatch: {}, delegateOpen: false, rec: {}, recOpen: null, busy: false, listeners: [] };
+    let lastDrawn = null;
+    let doc = null;
+
+    function data() { return env ? env.data() : {}; }
+    function now() { return Date.now(); }
+    // NO READS OF ITS OWN: the deck draws the street's living model (street.js
+    // data.living, built over gov-feeds.js), so the street, its header and the deck
+    // stand on one read of each feed, and an act's re-read reaches all three
+    function living() { const d = data(); return (d && d.living) || null; }
+    // the living model's feeds as the street read them (the office reads the viewer here)
+    function feeds() { const d = data(); return (d && d.livingFeeds) || {}; }
+
+    function here() {
+      const hsh = root.location ? str(root.location.hash) : '';
+      const m = /^#deck(?:=([a-z]+))?$/.exec(hsh);
+      if (!m) return null;
+      return { scope: m[1] && KEYS.indexOf(m[1]) >= 0 ? m[1] : null };
+    }
+    function viewerId() { const d = data(); return d.docket && d.docket.viewer ? str(d.docket.viewer.id) : null; }
+    function ctxOf() {
+      const d = data();
+      const lv = living();
+      return { living: lv, docket: d.docket, room: d.room, constitution: d.constitution, goals: (d.goals || []).filter((g) => g && g.status === 'open'), now: now(), viewerId: viewerId() };
+    }
+    function deck(scope) { return deckModel(Object.assign(ctxOf(), { scope: scope, session: session })); }
+
+    // ---------- small DOM ----------
+    function h(tag, cls, text) {
+      const el = doc.createElement(tag);
+      if (cls) el.className = cls;
+      if (text != null) el.textContent = String(text);
+      return el;
+    }
+    function clear(el) { while (el && el.firstChild) el.removeChild(el.firstChild); }
+    function btn(cls, text, on) {
+      const b = h('button', cls, text);
+      b.setAttribute('type', 'button');
+      if (session.busy) b.setAttribute('disabled', '');
+      b.addEventListener('click', on);
+      return b;
+    }
+    function pips(n, cls) {
+      const t = D && D.todayPips ? D.todayPips(n) : { pips: [], text: n + ' decided' };
+      const box = h('span', cls || 'deck-pips');
+      box.setAttribute('aria-hidden', 'true');
+      t.pips.forEach((p) => box.appendChild(h('span', 'street-today__pip' + (p.on ? ' street-today__pip--on' : '') + (p.fresh && lastDrawn !== n ? ' desk-pop' : ''))));
+      return box;
+    }
+
+    // ---------- the card, drawn (shared with the interiors) ----------
+    // handlers { pick(option), skip(), pass(), seats[], passTo(seat), record:
+    // { state, pick(file), send() } } — any may be absent
+    function cardEl(cv, on, opts) {
+      const o = Object.assign({ busy: session.busy, recOpen: session.recOpen === cv.id, delegateOpen: session.delegateOpen }, opts || {});
+      return drawAsk(doc, cv, on, o);
+    }
+
+    // ---------- the deck, drawn ----------
+    // The street stays in view (task 1004702): the card is a glass panel beside
+    // the building that asks, a hairline to its pin, the cards still to come two
+    // glass slivers under it, and a slim glass bar at the foot holds the run.
+    function open() { return !!here(); }
+    function draw() {
+      if (!env || !doc) return;
+      const box = doc.getElementById('streetDeck');
+      const win = doc.getElementById('streetWindow');
+      const at = here();
+      if (!box) return;
+      if (!at) {
+        if (!box.hidden) { box.hidden = true; clear(box); }
+        if (win && win.getAttribute('data-view') === 'deck') win.removeAttribute('data-view');
+        session.delegateOpen = false;
+        return;
+      }
+      const arriving = box.hidden;
+      box.hidden = false;
+      if (win) win.setAttribute('data-view', 'deck');
+      const dm = deck(at.scope);
+      paint(box, dm, arriving);
+    }
+    let rising = false;
+    function backTo(dm) {
+      const back = h('a', 'deck-dock__back', dm.scope ? 'back to ' + dm.scopeName : 'back to the street');
+      back.setAttribute('href', dm.scope ? '/builders/street#building=' + dm.scope : '/builders/street');
+      back.setAttribute('id', 'deckBack');
+      if (!dm.scope) back.addEventListener('click', (e) => { if (e && e.preventDefault) e.preventDefault(); leaveDeck(); });
+      return back;
+    }
+    function leaveDeck() {
+      const dm = deck(here() ? here().scope : null);
+      const to = dm.scope ? '/builders/street#building=' + dm.scope : '/builders/street';
+      if (root.history && root.history.pushState) { root.history.pushState(null, '', to); env.draw(); draw(); }
+      else if (root.location) root.location.hash = dm.scope ? '#building=' + dm.scope : '';
+    }
+    function paint(box, dm, arriving) {
+      clear(box);
+      // the scene's hush, the halo and the hairline: spot() fills this layer once the panel stands
+      const scene = h('div', 'deck-scene');
+      scene.setAttribute('aria-hidden', 'true');
+      box.appendChild(scene);
+      const wrap = h('div', 'deck-at');
+      for (let i = dm.behind; i >= 1; i--) { const g = h('div', 'deck-ghost deck-ghost--' + i); g.setAttribute('aria-hidden', 'true'); wrap.appendChild(g); }
+      const pos = dm.hand + ' of ' + dm.lead.n;
+      if (dm.current) {
+        const cv = dm.current;
+        const seats = cv.batch ? [] : seatsFor(living(), find(cv.id), viewerId());
+        const card = cardEl(cv, {
+          pick: (op) => pick(cv, op),
+          skip: () => skip(cv),
+          pass: () => togglePass(),
+          seats: seats,
+          passTo: (s) => passTo(cv, s),
+          close: leaveDeck,
+          record: recordHandlers(cv),
+        }, { rise: rising || arriving, where: true, acts: true, qid: 'deckTitle', cls: 'deck-panel gov-glass', pos: pos });
+        rising = false;
+        wrap.appendChild(card);
+      } else {
+        const q = h('div', 'deck-clear deck-panel gov-glass');
+        const tick = doc.createElementNS ? doc.createElementNS(SVG_NS, 'svg') : h('span');
+        if (tick.setAttribute) { tick.setAttribute('width', '56'); tick.setAttribute('height', '56'); tick.setAttribute('viewBox', '0 0 24 24'); tick.setAttribute('aria-hidden', 'true'); tick.setAttribute('class', 'deck-clear__tick desk-pop'); }
+        const ring = doc.createElementNS ? doc.createElementNS(SVG_NS, 'circle') : h('span');
+        if (ring.setAttribute) { ring.setAttribute('cx', '12'); ring.setAttribute('cy', '12'); ring.setAttribute('r', '9.5'); }
+        const mark = doc.createElementNS ? doc.createElementNS(SVG_NS, 'path') : h('span');
+        if (mark.setAttribute) mark.setAttribute('d', 'M7.5 12.2l3 3 6-6.5');
+        tick.appendChild(ring); tick.appendChild(mark);
+        q.appendChild(tick);
+        const line = h('p', 'deck-clear__line', dm.scope ? 'Nothing waits at ' + dm.scopeName : 'Nothing waits on a person');
+        line.setAttribute('id', 'deckTitle');
+        line.setAttribute('tabindex', '-1');
+        q.appendChild(line);
+        q.appendChild(h('p', 'deck-clear__sub', env.today() + ' decided today'));
+        wrap.appendChild(q);
+      }
+      box.appendChild(wrap);
+
+      // the dock: where you are in the run, today, the keys, the way back
+      const dock = h('div', 'deck-dock gov-glass');
+      dock.setAttribute('role', 'status');
+      const run = h('span', 'deck-dock__run');
+      run.appendChild(h('span', 'deck-dock__n' + (dm.lead.you ? ' deck-dock__n--you' : ''), dm.hand));
+      run.appendChild(h('span', 'deck-dock__of', ' of ' + dm.lead.n + ' ' + (dm.remaining ? dm.lead.words : 'to do')));
+      dock.appendChild(run);
+      dock.appendChild(h('span', 'deck-dock__sep'));
+      const today = h('span', 'deck-dock__today');
+      const n = env.today();
+      today.appendChild(pips(n));
+      today.appendChild(h('span', 'deck-dock__decided', n + ' decided today'));
+      dock.appendChild(today);
+      lastDrawn = n;
+      if (dm.current) {
+        dock.appendChild(h('span', 'deck-dock__sep'));
+        const keys = h('span', 'deck-dock__keys');
+        const g = h('span', 'deck-dock__k');
+        dm.current.options.forEach((op) => g.appendChild(h('kbd', '', op.n)));
+        if (dm.current.options.length) { g.appendChild(h('span', '', 'answer')); keys.appendChild(g); }
+        const key = (k, word, act, fn) => {
+          const b = h('button', 'deck-dock__k deck-dock__btn');
+          b.setAttribute('type', 'button');
+          b.setAttribute('data-act', act);
+          b.setAttribute('aria-keyshortcuts', k);
+          if (session.busy) b.setAttribute('disabled', '');
+          b.appendChild(h('kbd', '', k));
+          b.appendChild(h('span', '', word));
+          b.addEventListener('click', fn);
+          keys.appendChild(b);
+        };
+        key('S', 'skip', 'dock-skip', () => skip(dm.current));
+        // passing it on is the server's: only over a routed docket, a stored ask that waits on you
+        const seats = dm.current.batch ? [] : seatsFor(living(), find(dm.current.id), viewerId());
+        if (dm.pass && seats.length) key('D', session.delegateOpen ? 'keep it' : 'pass it on', 'dock-pass', togglePass);
+        dock.appendChild(keys);
+      }
+      dock.appendChild(backTo(dm));
+      box.appendChild(dock);
+      place(box, scene, wrap, dock, dm);
+    }
+    // Beside the building's pin on a wide stage; on a phone the panel is a sheet
+    // from the foot and the street scrolls so the building stays in view above it.
+    function anchorFor(building) {
+      const pins = doc.getElementById('streetPins');
+      const hit = pins && pins.querySelector ? pins.querySelector('.street-pin[data-building="' + building + '"] .street-pin__head') : null;
+      if (hit) return hit;
+      const doors = doc.getElementById('streetDoors');
+      return doors && doors.querySelector ? doors.querySelector('[data-door="' + building + '"]') : null;
+    }
+    function place(box, scene, wrap, dock, dm) {
+      const cv = dm.current;
+      const stage = doc.getElementById('hall-main');
+      const anchor = cv ? anchorFor(cv.building) : null;
+      if (!anchor || !stage || typeof stage.getBoundingClientRect !== 'function') return;
+      const narrow = root.matchMedia ? root.matchMedia('(max-width: 899px)').matches : false;
+      const win = doc.getElementById('streetWindow');
+      if (narrow && win && typeof win.getBoundingClientRect === 'function') {
+        const a = anchor.getBoundingClientRect(), wr = win.getBoundingClientRect();
+        win.scrollLeft += Math.round(a.left + a.width / 2 - (wr.left + wr.width / 2));
+      }
+      const d = rect(dock), s = rect(stage);
+      spot(doc, scene, stage, anchor, wrap, { place: narrow ? null : wrap, bottom: d && s ? d.top - s.top - 14 : null, top: 60, you: cv.needsYou });
+    }
+    function togglePass() { session.delegateOpen = !session.delegateOpen; draw(); focusCard(session.delegateOpen ? 'seat' : 'pass'); }
+
+    // ---------- acting ----------
+    function find(id) {
+      const lv = living();
+      return (lv ? lv.city.asks : []).concat(session.extra).find((a) => a && a.id === id) || null;
+    }
+    function cardNode() {
+      const box = doc.getElementById('streetDeck');
+      let hit = null;
+      const walk = (el) => { (el && el.children ? Array.prototype.slice.call(el.children) : []).forEach((k) => { if (!hit && /\bask\b/.test(str(k.className)) && k.getAttribute && k.getAttribute('data-ask')) hit = k; else walk(k); }); };
+      walk(box);
+      return hit;
+    }
+    function focusCard(what) {
+      const c = cardNode();
+      if (!c) { const t = doc.getElementById('deckTitle'); if (t && t.focus) t.focus(); return; }
+      let target = null;
+      const walk = (el) => (el && el.children ? Array.prototype.slice.call(el.children) : []).forEach((k) => {
+        if (target) return;
+        const cls = str(k.className);
+        if (what === 'seat' && /\bask__seat\b/.test(cls)) target = k;
+        else if (what === 'pass' && k.getAttribute && k.getAttribute('data-act') === 'pass') target = k;
+        else if (!what && /\bask__q\b/.test(cls)) target = k;
+        walk(k);
+      });
+      walk(c);
+      if (target && target.focus) target.focus();
+    }
+    // The card leaves (a class the stylesheet animates: it slides away, or sinks
+    // to the back for a skip), then the deck redraws with the next one rising.
+    function leave(cls, then) {
+      const c = cardNode();
+      if (c) c.className += ' ' + cls;
+      const go = () => { rising = true; session.delegateOpen = false; then(); draw(); focusCard(); };
+      if (typeof setTimeout !== 'function') return go();
+      setTimeout(go, 320);
+    }
+    function settle(ask, opt, toast) {
+      session.done[ask.id] = true;
+      if (env.done) env.done(ask.id);
+      env.decided();
+      env.say(toast, true);
+      session.batch = opt && (opt.plan.mode === 'send' || opt.plan.mode === 'note') ? { id: ask.id, source: ask.source, building: ask.building, key: opt.key, act: opt.act, label: opt.label } : null;
+      notify();
+    }
+    function preview(out) { return !!(out && out.status === 501 && out.body && out.body.error && out.body.error.code === 'preview_readonly'); }
+    function sentence(s) { const t = str(s); return t ? t.charAt(0).toUpperCase() + t.slice(1) + (/[.!?]$/.test(t) ? '' : '.') : ''; }
+    // One answer, through the same path a desk row takes: { ok, toast } once the
+    // route (or nothing, for a note) has answered. Nothing is
+    // counted here; settle() does that, after the card has left.
+    function perform(ask, opt) {
+      return sendAnswer(opt, env.send).then((res) => { if (res.stored && env.load) env.load(); return res; });
+    }
+    // A tap on an answer: sent first (the card waits, its buttons held), then
+    // the card slides away and the next one rises; a refusal keeps the card.
+    function pick(cv, op) {
+      if (session.busy || !op) return Promise.resolve(false);
+      if (cv.batch) return batch(cv, op);
+      const ask = find(cv.id);
+      if (!ask) return Promise.resolve(false);
+      if (op.plan.mode === 'record') { session.recOpen = ask.id; draw(); focusRecord(); return Promise.resolve(false); }
+      if (op.plan.mode === 'off') { env.say(sentence(op.why || 'not from here'), true); return Promise.resolve(false); }
+      session.busy = op.plan.mode === 'send';
+      if (session.busy) draw();
+      return perform(ask, op).then((res) => {
+        session.busy = false;
+        if (!res.ok) { env.say(res.toast, true); draw(); return false; }
+        return new Promise((done) => leave('ask--gone', () => { settle(ask, op, res.toast); done(true); }));
+      });
+    }
+    // Same answer for the likes, one request at a time; each counts a pip, and
+    // the first refusal stops the run and says why.
+    function batch(cv, op) {
+      const from = cv.from;
+      if (op.key === 'one') {
+        session.noBatch[from.source + ':' + from.building] = true;
+        session.batch = null;
+        return new Promise((done) => leave('ask--skip', () => done(true)));
+      }
+      const ctx = ctxOf();
+      const ids = cv.likes.map((l) => l.id);
+      let i = 0, n = 0;
+      session.busy = true;
+      draw();
+      const next = () => {
+        if (i >= ids.length) return Promise.resolve(null);
+        const ask = find(ids[i++]);
+        if (!ask) return next();
+        const vw = cardView(ask, ctx).options.find((x) => x.key === from.key);
+        if (!vw) return next();
+        return perform(ask, vw).then((res) => {
+          if (!res.ok) return res;
+          session.done[ask.id] = true;
+          if (env.done) env.done(ask.id);
+          runEffect(ask, vw);
+          env.decided();
+          n += 1;
+          return next();
+        });
+      };
+      return next().then((stop) => {
+        session.busy = false;
+        session.batch = from;
+        return new Promise((done) => leave('ask--gone', () => {
+          env.say(stop ? stop.toast : 'Same answer for ' + n + ' more: ' + str(from.label) + '.', true);
+          notify();
+          done(!stop);
+        }));
+      });
+    }
+    function skip(cv) {
+      if (session.busy) return;
+      if (cv.batch) { session.noBatch[cv.from.source + ':' + cv.from.building] = true; session.batch = null; leave('ask--skip', () => {}); return; }
+      session.skipped = session.skipped.filter((x) => x !== cv.id).concat([cv.id]);
+      session.batch = null;
+      leave('ask--skip', () => {});
+    }
+    function passTo(cv, seat, after) {
+      if (session.busy) return;
+      const gone = (toast) => {
+        session.delegated[cv.id] = seat.seat;
+        session.batch = null;
+        leave('ask--gone', () => { env.say(toast, true); notify(); if (after) after(); });
+      };
+      // the server moves it to the seat (task 1004705), or says why not
+      session.busy = true;
+      draw();
+      env.send({ method: 'POST', url: '/api/bongos/government/asks/' + encodeURIComponent(cv.id) + '/pass', body: { seat: seat.seat } }).then((out) => {
+        session.busy = false;
+        session.delegateOpen = false;
+        if (out.ok) { if (env.load) env.load(); gone('Passed to ' + seat.label + '. It leaves your deck.'); return; }
+        if (preview(out)) { gone('Sent to POST /government/asks/' + cv.id + '/pass. This preview stores nothing.'); return; }
+        env.say(C.refusal(out.status, out.body), true);
+        draw();
+      });
+    }
+    // the recorded sign-off on a deck card: its line, its two routes
+    function recState(id) { return session.rec[id] || (session.rec[id] = { file: null, phase: 'empty', pct: 0 }); }
+    let painter = null;
+    function recordHandlers(cv) {
+      const ask = find(cv.id);
+      const op = cv.options.find((o) => o.plan.mode === 'record');
+      if (!ask || !op) return null;
+      return {
+        state: () => recState(cv.id),
+        painted: (s) => { painter = s; },
+        pick: (f) => { C.recordPick(recState(cv.id), f); draw(); focusRecord(); },
+        send: () => {
+          session.busy = true;
+          draw();
+          return C.recordRun(op.plan.id, recState(cv.id), {
+            upload: (url, file, onPct) => C.uploadXhr(root.XMLHttpRequest, url, file, onPct),
+            send: env.send,
+            change: () => { draw(); },
+            progress: (st) => { if (painter) painter.paint(st); },
+          }).then((out) => {
+            session.busy = false;
+            if (!out || !out.ok) { draw(); focusRecord(); return false; }
+            delete session.rec[cv.id];
+            session.recOpen = null;
+            leave('ask--gone', () => settle(ask, op, C.answer(op.plan.card, 'record', out.body).toast));
+            return true;
+          });
+        },
+      };
+    }
+    function focusRecord() {
+      const c = cardNode();
+      let t = null;
+      const walk = (el) => (el && el.children ? Array.prototype.slice.call(el.children) : []).forEach((k) => { if (!t && k.getAttribute && /^record-(send|pick)$/.test(str(k.getAttribute('data-act')))) t = k; walk(k); });
+      walk(c);
+      if (t && str(t.tagName).toLowerCase() === 'label' && t.children && t.children[1]) t = t.children[1];
+      if (t && t.focus) t.focus();
+    }
+
+    // ---------- the keys: 1 / 2 / 3 pick, S skip, D pass it on ----------
+    function onKey(e) {
+      if (!open() || !e || e.ctrlKey || e.metaKey || e.altKey) return false;
+      const t = e.target;
+      const tag = t && t.tagName ? str(t.tagName).toLowerCase() : '';
+      if (tag === 'input' || tag === 'textarea' || tag === 'select' || (t && t.isContentEditable)) return false;
+      const dm = deck(here().scope);
+      const cv = dm.current;
+      const k = str(e.key);
+      if (!cv) { if (k !== 'Escape') return false; leaveDeck(); if (e.preventDefault) e.preventDefault(); return true; }
+      let done = false;
+      if (session.delegateOpen && /^[1-5]$/.test(k)) {
+        const seats = seatsFor(living(), find(cv.id), viewerId());
+        const s = seats[Number(k) - 1];
+        if (s) { passTo(cv, s); done = true; }
+      } else if (/^[1-3]$/.test(k)) {
+        const op = cv.options[Number(k) - 1];
+        if (op) { pick(cv, op); done = true; }
+      } else if (k === 's' || k === 'S') { skip(cv); done = true; }
+      else if ((k === 'd' || k === 'D') && !cv.batch) { session.delegateOpen = !session.delegateOpen; draw(); focusCard(session.delegateOpen ? 'seat' : 'pass'); done = true; }
+      else if (k === 'Escape' && session.delegateOpen) { session.delegateOpen = false; draw(); focusCard('pass'); done = true; }
+      else if (k === 'Escape') { leaveDeck(); done = true; }
+      if (done && e.preventDefault) e.preventDefault();
+      return done;
+    }
+
+    // ---------- a building's card on the street (task 1004702) ----------
+    // A pin opens its building's card over it, in place: who holds it and what
+    // waits, the ask inside (a matter's stored ask, answered through its desk
+    // row's own route), then "go inside", "pass it on" and S to skip to the
+    // pin's next matter. A matter with no stored ask keeps the matter card's own
+    // acts (street.js fillCard); both stand as glass beside the pin.
+    // on { close(), turn(key) the pin's next matter, done() redraw after an answer }
+    let here2 = null;
+    function streetCard(body, key, keys, on) {
+      const ask = doc ? find(key) : null;
+      if (!ask || !ask.shown || !body) { here2 = null; return false; }
+      const lv = living();
+      const cv = cardView(ask, ctxOf());
+      clear(body);
+      const head = h('div', 'bcard__head');
+      head.appendChild(h('span', 'bcard__name', cv.buildingName));
+      const q = queueOf(lv, session, ask.building);
+      const you = q.filter((a) => a.needs_you).length;
+      const hold = holdWords(lv, ask.building);
+      const line = h('p', 'bcard__f', hold);
+      line.appendChild(h('span', 'bcard__n' + (you ? ' bcard__n--you' : ''), (hold ? ' ' : '') + waitWords(you, q.length - you)));
+      head.appendChild(line);
+      body.appendChild(head);
+      const seats = lv && lv.routed && lv.seats_real ? seatsFor(lv, ask, viewerId()) : [];
+      const next = Array.isArray(keys) && keys.length > 1 ? keys[(keys.indexOf(key) + 1) % keys.length] : null;
+      const acts = {
+        pick: (op) => answerHere(ask.id, op).then((ok) => { if (ok) on.done(); return ok; }),
+        seats: seats,
+        passTo: (s) => passTo(cv, s, on.done),
+      };
+      body.appendChild(cardEl(cv, acts, { inner: true }));
+      const row = h('div', 'bcard__acts');
+      const inside = h('a', 'bcard__link', 'go inside');
+      inside.setAttribute('href', '/builders/street#building=' + ask.building);
+      row.appendChild(inside);
+      if (seats.length) {
+        const p = h('button', 'bcard__link', session.delegateOpen ? 'keep it' : 'pass it on');
+        p.setAttribute('type', 'button');
+        p.setAttribute('data-act', 'pass');
+        p.setAttribute('aria-keyshortcuts', 'D');
+        p.setAttribute('aria-expanded', session.delegateOpen ? 'true' : 'false');
+        p.addEventListener('click', () => { session.delegateOpen = !session.delegateOpen; on.redraw(); });
+        row.appendChild(p);
+      }
+      row.appendChild(h('span', 'ask__gap'));
+      if (next) {
+        const s = h('button', 'bcard__skip');
+        s.setAttribute('type', 'button');
+        s.setAttribute('data-act', 'skip');
+        s.setAttribute('aria-keyshortcuts', 'S');
+        s.appendChild(h('kbd', '', 'S'));
+        s.appendChild(h('span', '', 'skip'));
+        s.addEventListener('click', () => on.turn(next));
+        row.appendChild(s);
+      }
+      body.appendChild(row);
+      here2 = { cv: cv, acts: acts, next: next, on: on };
+      const frame = body.parentNode;
+      if (frame && !frame.govKeys && frame.addEventListener) {
+        frame.govKeys = true;
+        frame.addEventListener('keydown', streetKeys);
+      }
+      return true;
+    }
+    // 1 / 2 / 3 answer the card in place, S skips to the pin's next matter
+    function streetKeys(e) {
+      if (!here2 || !e || e.ctrlKey || e.metaKey || e.altKey || session.busy) return;
+      const k = str(e.key);
+      let done = false;
+      if (/^[1-3]$/.test(k)) { const op = here2.cv.options[Number(k) - 1]; if (op) { here2.acts.pick(op); done = true; } }
+      else if ((k === 's' || k === 'S') && here2.next) { here2.on.turn(here2.next); done = true; }
+      if (done && e.preventDefault) e.preventDefault();
+    }
+    // The street card stands beside its pin, over a light hush (a phone keeps its sheet).
+    function placeStreetCard(frame, key) {
+      const stage = doc ? doc.getElementById('hall-main') : null;
+      if (!frame || !stage || frame.hidden || typeof stage.getBoundingClientRect !== 'function') return unspot();
+      const pins = doc.getElementById('streetPins');
+      const list = pins && pins.children ? Array.prototype.slice.call(pins.children) : [];
+      const pin = list.find((p) => str(p.getAttribute('data-matters') || p.getAttribute('data-matter')).split(' ').indexOf(str(key)) >= 0);
+      const anchor = pin && pin.querySelector ? pin.querySelector('.street-pin__head') : null;
+      let layer = doc.getElementById('streetSpot');
+      if (!layer) {
+        layer = doc.createElement('div');
+        layer.setAttribute('id', 'streetSpot');
+        layer.className = 'gov-spot';
+        layer.setAttribute('aria-hidden', 'true');
+        stage.appendChild(layer);
+      }
+      const narrow = root.matchMedia ? root.matchMedia('(max-width: 640px)').matches : false;
+      layer.hidden = false;
+      if (!anchor) { clear(layer); return null; }
+      return spot(doc, layer, stage, anchor, frame, { place: narrow ? null : frame, top: 72, you: /street-pin--(needs|urgent)/.test(str(pin.className)) });
+    }
+    function unspot() {
+      const layer = doc ? doc.getElementById('streetSpot') : null;
+      if (layer) { clear(layer); layer.hidden = true; }
+      here2 = null;
+      session.delegateOpen = false;
+      return null;
+    }
+
+    // ---------- what the interiors share ----------
+    function isDone(id) { return !!session.done[id] || !!session.delegated[id]; }
+    function onChange(fn) { session.listeners.push(fn); }
+    function notify() {
+      session.listeners.forEach((fn) => { try { fn(); } catch (e) { /* a listener never blocks */ } });
+      // every count on the page (the street's header, the shell's tally) follows the deck
+      if (root.GovFeeds && typeof root.GovFeeds.changed === 'function') root.GovFeeds.changed();
+    }
+    // answer an ask from an interior card: the same path, then the interior redraws
+    function answerHere(id, op) {
+      const ask = find(id);
+      if (!ask || session.busy || !op) return Promise.resolve(false);
+      if (op.plan.mode === 'off') { env.say(sentence(op.why || 'not from here'), true); return Promise.resolve(false); }
+      return perform(ask, op).then((res) => {
+        if (!res.ok) { env.say(res.toast, true); return false; }
+        settle(ask, op, res.toast);
+        if (env && env.draw) env.draw();
+        return true;
+      });
+    }
+    function cardFor(ask) { return cardView(ask, ctxOf()); }
+
+    function mount(e) {
+      env = e;
+      doc = root.document || (typeof document !== 'undefined' ? document : null);
+      if (!doc) return Promise.resolve();
+      root.addEventListener('hashchange', () => { session.delegateOpen = false; draw(); const at = here(); if (at) { const t = doc.getElementById('deckTitle'); if (t && t.focus) t.focus(); } });
+      root.addEventListener('popstate', draw);
+      root.addEventListener('keydown', onKey);
+      // the page's counts leave out what the deck answered (gov-feeds.js)
+      if (root.GovFeeds && typeof root.GovFeeds.useSession === 'function') root.GovFeeds.useSession(() => sessionCounts(session));
+      draw();
+      return Promise.resolve();
+    }
+
+    return {
+      mount: mount, draw: draw, onKey: onKey, living: living, feeds: feeds, cardEl: cardEl, cardFor: cardFor, isDone: isDone, onChange: onChange,
+      answerHere: answerHere, session: session, here: here, streetCard: streetCard, placeStreetCard: placeStreetCard, unspot: unspot,
+    };
+  }());
+
+  const api = Object.assign({ page: page, drawAsk: drawAsk, sendAnswer: sendAnswer, spot: spot }, model);
+  root.GovDeck = api;
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+}(typeof window !== 'undefined' ? window : globalThis));