@bongos/core 1.21.112 → 1.21.114

package/modules/hall-ui/public/city-draw.js

@@ -48,6 +48,8 @@
 
 (function (root) {
   'use strict';
+  // the living model's one count rule (gov-living.js), so the city never counts for itself
+  const Living = root.GovLiving || (typeof require === 'function' ? require('./gov-living.js') : null);
 
   // ---------- the iso sub-palette (Street.dc.html theme(mode).iso) ----------
   function isoTheme(mode) {
@@ -230,7 +232,12 @@
   }
 
   // ---------- the city's fixed layout (Street.dc.html homeView) ----------
-  const CIVIC_SLOTS = Object.freeze([['planning', 5, 5], ['rules', 7, 5], ['treasury', 9, 5], ['people', 5, 7], ['charter', 7, 7], ['release', 9, 7], ['disputes', 5, 9], ['automation', 7, 9], ['review', 9, 9]]);
+  // The back corner (5,5), the centre (7,7) and the front corner (9,9) stand in
+  // one screen column, so whatever is at the back sits behind the centre. The
+  // Charter, the tallest, takes the back corner and rises over the quarter;
+  // Planning takes the centre, where nothing in front is tall enough to hide its
+  // lit floor (task 1004718: behind the Charter, Planning's floor never showed).
+  const CIVIC_SLOTS = Object.freeze([['charter', 5, 5], ['rules', 7, 5], ['planning', 9, 5], ['people', 5, 7], ['treasury', 7, 7], ['release', 9, 7], ['disputes', 5, 9], ['automation', 7, 9], ['review', 9, 9]]);
   const ROOF = Object.freeze({ charter: 158, rules: 36, treasury: 66, planning: 51, people: 31, release: 72, disputes: 60, review: 53, automation: 86 });
 
   // The four prototype districts (route = the parcel road it feeds), then the
@@ -364,21 +371,536 @@
   // The home line, when the docket could not be read.
   const FALLBACK_LINE = 'the docket could not be read just now';
 
+  // ======================================================================
+  // THE LIVING CITY (task 1004685, the living-city prototype)
+  // ======================================================================
+  // When cityModel() is handed `living` (GovLiving.livingModel()'s output,
+  // gov-living.js) the city keeps its look and gains three levels, each with
+  // one meaning:
+  //   ground  the goal districts, hazed toward the void by depth band (a
+  //           district with an agent at work stands one band clearer), and
+  //           the spend conduit in the reserve blue, from the Treasury round
+  //           the ring to them: the trunk's width is the real spend rate.
+  //   civic   the nine buildings, each now a core: the Lead's floor, then a
+  //           capsule floor per committee room and built floor plug into a shaft on the
+  //           roof, so structure is height. Ink windows say how busy it is;
+  //           SALMON windows, on the floor whose seat the ask waits on, are
+  //           the only salmon: questions waiting on the viewer. A build-out
+  //           the form of government allows is a live site; a proposal waiting
+  //           on a vote is a parked crane, a dashed-glass ghost annex and the
+  //           council's tally arc; an open sitting is a light shaft.
+  //   sky     one chrome pod per active claim on a lane from the building its
+  //           work answers to to its goal's district, at fixed spacing so the
+  //           count reads; a dry pot's reserve-borrow beacon.
+  // Every mark is drawn from a real read (task 1004717: the prototype overlay
+  // is gone). Motion is the page's CSS: this file only names
+  // the parts that move (`cls`) and where their still frame stands (`style`).
+  const FLOOR_H = 13;
+  const BUILD_FLOORS = 3;
+  // [where the shaft starts, where the first capsule sits] on each recipe's roof
+  const CORE = Object.freeze({ charter: [144, 158], rules: [36, 36], treasury: [66, 66], planning: [38, 51], people: [0, 31], release: [56, 72], disputes: [48, 60], automation: [36, 44], review: [53, 53] });
+  // the main mass whose two seen faces carry the windows: x0, y0, x1, y1 on the slot, z0, z1
+  const BODY = Object.freeze({
+    charter: [0.3, 0.3, 1.7, 1.7, 6, 52], rules: [0.22, 0.62, 1.78, 1.38, 4, 32], treasury: [0.4, 0.4, 1.6, 1.6, 22, 52],
+    planning: [0.3, 0.3, 1.7, 1.7, 14, 38], people: [0.35, 1.1, 1.0, 1.7, 7, 14], release: [1.25, 0.75, 1.7, 1.25, 0, 66],
+    disputes: [0.75, 0.55, 1.25, 1.45, 14, 48], automation: [0.35, 0.4, 1.65, 1.5, 20, 36], review: [0.38, 0.38, 1.62, 1.62, 14, 50],
+  });
+  // where a crane's mast stands on the slot, and the z it stands on
+  const MAST = Object.freeze({ release: [1.5, 1.0, 66], treasury: [1.55, 1.0, 57] });
+  const LANE_PERIOD = 26; // seconds, the same on every lane: speed carries no data
+  const POD_GAP = 0.07; // the fixed spacing between pods on one lane, as a share of it
+  const MAX_LANE_PODS = 8; // a lane's convoy fits its spacing; past it the lane says "+N"
+  const MAX_PODS = 64; // the city's whole sky stays inside the moving-node budget (~100)
+  const AGE_FULL_DAYS = 14; // an age ring is full when the oldest ask on you is two weeks old
+  // The far, middle and near depth bands. Even the near band is hazed a little, so the civic
+  // quarter (never hazed) is the crispest thing in the city: the districts are its skyline.
+  const HAZE = Object.freeze([0.62, 0.48, 0.34]);
+  const ACTIVE_HAZE = 0.4; // a district with an agent at work keeps this share of its band's haze
+  const QUIET_HAZE = 0.3; // a civic building with no agent and no ask sits darker
+  // the haze the far bands mix toward: the void in dark, and on paper a cool sea-tinted
+  // paper, so distance reads as atmosphere (fainter, cooler, lower contrast) in both modes
+  const VOID = Object.freeze({ dark: '#000000', light: '#cbd3e4' }); // light: a cooler, deeper sea so the haze reads on paper (task 1004718)
+
+  const clamp01 = (n) => Math.max(0, Math.min(1, Number(n) || 0));
+  const r1 = (n) => Math.round(n * 10) / 10;
+
+  // ---------- haze: a tone mixed toward the void (drawing data, like isoTheme) ----------
+  function parseColor(c) {
+    let m = /^#([0-9a-f]{6})$/i.exec(String(c));
+    if (m) { const n = parseInt(m[1], 16); return [(n >> 16) & 255, (n >> 8) & 255, n & 255, 1]; }
+    m = /^rgba?\(([^)]+)\)$/i.exec(String(c));
+    if (m) { const p = m[1].split(',').map((x) => Number(x.trim())); return [p[0], p[1], p[2], p.length > 3 ? p[3] : 1]; }
+    return null;
+  }
+  const hex2 = (n) => ('0' + Math.max(0, Math.min(255, Math.round(n))).toString(16)).slice(-2);
+  // A solid face mixes toward the ground; a line or a glaze (alpha) thins out.
+  function mixToward(c, target, t) {
+    const a = parseColor(c), b = parseColor(target);
+    if (!a || !b || !(t > 0)) return c;
+    if (a[3] < 1) return 'rgba(' + a[0] + ',' + a[1] + ',' + a[2] + ',' + Math.round(a[3] * (1 - t) * 1000) / 1000 + ')';
+    return '#' + hex2(a[0] + (b[0] - a[0]) * t) + hex2(a[1] + (b[1] - a[1]) * t) + hex2(a[2] + (b[2] - a[2]) * t);
+  }
+  function hazeTheme(I, t, mode) {
+    if (!(t > 0)) return I;
+    const to = VOID[mode] || VOID.dark;
+    const out = {};
+    Object.keys(I).forEach((key) => {
+      const v = I[key];
+      if (v && typeof v === 'object') {
+        const o = {};
+        Object.keys(v).forEach((f) => { o[f] = f === 'dash' ? v[f] : mixToward(v[f], to, t); });
+        out[key] = o;
+      } else out[key] = typeof v === 'string' ? mixToward(v, to, t) : v;
+    });
+    return out;
+  }
+  // A district's band from its plot's centre: far (back corner), middle, near.
+  function hazeBand(lot) {
+    const d = (lot.x0 + lot.x1 + 1) / 2 + (lot.y0 + lot.y1 + 1) / 2;
+    return d < 8 ? 0 : d < 18 ? 1 : 2;
+  }
+
+  // ---------- who and what stands in a building ----------
+  // A building's floors, bottom up: the Lead's (GET /government/leads, task 1004709),
+  // then one per committee room and one per floor, annex or district that stands
+  // built (its `structure`, task 1004711).
+  function structureFloors(b) {
+    const out = [];
+    if (!b) return out;
+    if (b.lead) out.push({ kind: 'lead', seat: 'lead:' + b.key, name: String(b.lead.name || 'Lead') });
+    ((b.structure && b.structure.committees) || []).forEach((c) => out.push({ kind: 'committee', seat: 'committee:' + b.key + '.' + c.key, name: String(c.name || c.key) }));
+    ((b.structure && b.structure.built) || []).forEach((x) => out.push({ kind: String(x.capsule || 'floor'), seat: null, name: String(x.name || 'Floor') }));
+    return out;
+  }
+  // A building's asks, less the ones the viewer has answered on this page. On you
+  // and on others are gov-living.js's own predicates (countsOf counts with them).
+  const onYouRule = (a) => (Living ? Living.isOnYou(a) : a.state === 'needs' && !!a.needs_you);
+  const onOthersRule = (a) => (Living ? Living.isOnOthers(a) : a.state === 'needs' && !a.needs_you);
+  function asksAt(b, answered) {
+    const gone = answered || {};
+    const all = (b && Array.isArray(b.asks) ? b.asks : []).filter((a) => a && !gone[a.id]);
+    const open = all.filter((a) => a.state !== 'settled');
+    return { all: all, open: open, onYou: all.filter(onYouRule), others: all.filter(onOthersRule) };
+  }
+  function isQuiet(b, v) { return !!b && !(b.agents > 0) && v.open.length === 0; }
+
+  // ---------- windows ----------
+  // Window cells on the two faces of a box the viewer sees (y = y1, then x = x1), rows bottom up.
+  function windowCells(x0, y0, x1, y1, z0, z1) {
+    const cells = [];
+    const rows = Math.max(1, Math.floor((z1 - z0 - 3) / 9));
+    const nx = Math.max(2, Math.round((x1 - x0) / 0.28)), ny = Math.max(2, Math.round((y1 - y0) / 0.28));
+    for (let j = 0; j < rows; j++) {
+      const z = z0 + 3 + j * 9;
+      for (let i = 0; i < nx; i++) cells.push({ face: 'y', u: x0 + (x1 - x0) * (i + 0.5) / nx, v: y1, z: z });
+      for (let i = 0; i < ny; i++) cells.push({ face: 'x', u: y0 + (y1 - y0) * (i + 0.5) / ny, v: x1, z: z });
+    }
+    return cells;
+  }
+  function windowD(k, c) {
+    const P = k.P, hw = 0.045, h = 3.5;
+    return c.face === 'y'
+      ? k.poly([P(c.u - hw, c.v, c.z), P(c.u + hw, c.v, c.z), P(c.u + hw, c.v, c.z + h), P(c.u - hw, c.v, c.z + h)])
+      : k.poly([P(c.v, c.u - hw, c.z), P(c.v, c.u + hw, c.z), P(c.v, c.u + hw, c.z + h), P(c.v, c.u - hw, c.z + h)]);
+  }
+  // A capsule's round window: an octagon laid on the face (y = v, or x = v).
+  function porthole(k, face, u, v, z) {
+    const P = k.P, pts = [];
+    for (let i = 0; i < 8; i++) {
+      const a = Math.PI * 2 * i / 8, du = Math.cos(a) * 0.06, dz = Math.sin(a) * 2.6;
+      pts.push(face === 'y' ? P(u + du, v, z + dz) : P(v, u + du, z + dz));
+    }
+    return k.poly(pts);
+  }
+  function cls(out, d, c) { if (d) out.push({ d: d, f: 'none', s: 'none', dash: 'none', w: 1, cls: c }); }
+
+  // ---------- a crane ----------
+  // The mast, then the jib (with its ties, counterweight, hook and load) as its own list so a
+  // live site can swing it about the mast head. `parked` folds the jib along the other axis.
+  function crane(k, mx, my, z0, zTop, parked) {
+    const P = k.P, I = k.I, mast = [], jib = [];
+    let d = k.seg(P(mx, my, z0), P(mx, my, zTop + 6)) + k.seg(P(mx + 0.05, my + 0.05, z0), P(mx + 0.05, my + 0.05, zTop + 6));
+    for (let z = z0 + 6; z < zTop; z += 10) d += k.seg(P(mx, my, z), P(mx + 0.05, my + 0.05, z + 5));
+    push(mast, d, 'none', I.vacantLine);
+    const end = parked ? (dx) => P(mx, my - dx, zTop) : (dx) => P(mx - dx, my, zTop);
+    const at = parked ? (dx, z) => P(mx, my - dx, z) : (dx, z) => P(mx - dx, my, z);
+    const peak = P(mx, my, zTop + 12);
+    push(jib, k.seg(end(-0.3), end(1.0)) + k.seg(peak, end(1.0)) + k.seg(peak, end(-0.3)), 'none', I.vacantLine);
+    const hookAt = parked ? 0.35 : 0.7, drop = parked ? 6 : 18;
+    push(jib, k.seg(at(hookAt, zTop), at(hookAt, zTop - drop)), 'none', I.vacantLine);
+    const hx = parked ? mx : mx - hookAt, hy = parked ? my - hookAt : my;
+    isoBox(jib, k, hx - 0.06, hy - 0.06, hx + 0.06, hy + 0.06, zTop - drop - 6, 6, I.crate);
+    const cw = parked ? [mx - 0.06, my + 0.18, mx + 0.06, my + 0.3] : [mx + 0.18, my - 0.06, mx + 0.3, my + 0.06];
+    isoBox(jib, k, cw[0], cw[1], cw[2], cw[3], zTop - 5, 5, I.plinth);
+    const pivot = P(mx, my, zTop);
+    return { mast: mast, jib: jib, pivot: [r1(pivot[0]), r1(pivot[1])] };
+  }
+
+  // ---------- one civic building, alive ----------
+  // Draws the core, the capsule floors, the windows and the construction of one building into
+  // `polys` (static) and `parts` (ordered; a part with `cls` moves), and says where its top is.
+  function civicLiving(polys, k, slot, b, v, living) {
+    const key = slot[0], ox = slot[1], oy = slot[2], cx = ox + 1, cy = oy + 1, I = k.I, P = k.P;
+    const parts = [];
+    const floors = structureFloors(b);
+    const held = floors.map((f) => (f.seat ? v.onYou.filter((a) => a.waits_on && a.waits_on.seat === f.seat).length : 0));
+    const bodyYou = v.onYou.length - held.reduce((n, x) => n + x, 0);
+
+    // the windows of the main mass: salmon for the asks it holds, then ink for how busy it is
+    const bx = BODY[key];
+    const cells = windowCells(ox + bx[0], oy + bx[1], ox + bx[2], oy + bx[3], bx[4], bx[5])
+      .map((c, i) => ({ c: c, r: rnd(i * 7 + ox * 31 + oy * 17 + 3) }))
+      .sort((a, z) => a.r - z.r)
+      .map((x) => x.c);
+    const nYou = Math.min(cells.length, bodyYou * 2);
+    const nLit = Math.min(cells.length - nYou, Math.round(clamp01(b && b.lit) * cells.length * 0.6));
+    // what needs you lights the TOP rows first (still scattered within a row), so a
+    // neighbour in front never hides it (task 1004718); ink windows take the rest
+    const you = cells.slice().sort((a, z) => z.z - a.z).slice(0, nYou);
+    const rest = cells.filter((c) => you.indexOf(c) < 0);
+    cls(polys, you.map((c) => windowD(k, c)).join(''), 'city-win city-win--you');
+    cls(polys, rest.slice(0, nLit).map((c) => windowD(k, c)).join(''), 'city-win city-win--lit');
+
+    // the core and its capsule floors (the Lead's first), each plugging in on the world's arrive curve
+    const start = CORE[key][1];
+    let top = ROOF[key];
+    if (floors.length) {
+      const coreTop = start + floors.length * FLOOR_H + 3;
+      isoBox(polys, k, cx - 0.13, cy - 0.13, cx + 0.13, cy + 0.13, CORE[key][0], coreTop - CORE[key][0], I.roof, { fins: true, n: 2 });
+      floors.forEach((f, i) => {
+        const z0 = start + i * FLOOR_H + 1, h = FLOOR_H - 2, zc = z0 + h / 2;
+        const ySide = i % 2 === 0;
+        const box = ySide ? [cx - 0.25, cy + 0.13, cx + 0.25, cy + 0.47] : [cx + 0.13, cy - 0.25, cx + 0.47, cy + 0.25];
+        const shell = [];
+        isoBox(shell, k, box[0], box[1], box[2], box[3], z0, h, I.civic);
+        parts.push({ cls: 'city-plug', style: { '--i': String(i) }, polys: shell, floor: f.kind });
+        const win = ySide
+          ? porthole(k, 'y', cx - 0.12, box[3], zc) + porthole(k, 'y', cx + 0.12, box[3], zc) + porthole(k, 'x', cy + 0.3, box[2], zc)
+          : porthole(k, 'x', cy - 0.12, box[2], zc) + porthole(k, 'x', cy + 0.12, box[2], zc) + porthole(k, 'y', cx + 0.3, box[3], zc);
+        const lit = held[i] > 0 ? 'city-win city-win--you' : (b && b.lit > 0.3 ? 'city-win city-win--lit' : 'city-win');
+        const pane = [{ d: win, f: I.door, s: 'none', dash: 'none', w: 1, cls: lit }];
+        parts.push({ cls: 'city-plug city-plug--detail', style: { '--i': String(i) }, polys: pane, floor: f.kind });
+      });
+      const cap = [];
+      isoBox(cap, k, cx - 0.17, cy - 0.17, cx + 0.17, cy + 0.17, coreTop, 2, I.roof);
+      parts.push({ cls: 'city-plug', style: { '--i': String(floors.length) }, polys: cap });
+      top = coreTop + 2;
+    }
+
+    // construction: an allowed build-out is a live site; a proposal waits as a ghost (real from task 1004711)
+    const list = (b && b.construction) || [];
+    const live = list.find((c) => c.authorised);
+    const pending = live ? null : list.find((c) => !c.authorised);
+    const total = BUILD_FLOORS * FLOOR_H;
+    const fp = [cx - 0.3, cy - 0.3, cx + 0.3, cy + 0.3];
+    const m = MAST[key] || [1.55, 1.0, start];
+    let site = null, shaft = null, tally = null;
+    if (live) {
+      const progress = clamp01(live.progress);
+      const built = Math.min(BUILD_FLOORS, Math.floor(progress * BUILD_FLOORS + 1e-9));
+      const frac = Math.round((progress * BUILD_FLOORS - built) * 1000) / 1000;
+      const solid = [];
+      for (let i = 0; i < built; i++) isoBox(solid, k, fp[0], fp[1], fp[2], fp[3], top + i * FLOOR_H, FLOOR_H - 1, I.civic, { rows: true });
+      if (solid.length) parts.push({ cls: null, polys: solid });
+      if (built < BUILD_FLOORS) {
+        const rising = [];
+        isoBox(rising, k, fp[0], fp[1], fp[2], fp[3], top + built * FLOOR_H, FLOOR_H - 1, I.civic);
+        parts.push({ cls: 'city-rise', style: { '--rise': String(frac) }, polys: rising });
+      }
+      const frame = [];
+      isoBox(frame, k, fp[0] - 0.04, fp[1] - 0.04, fp[2] + 0.04, fp[3] + 0.04, top, total, I.scaffold, { fins: true, n: 3 });
+      parts.push({ cls: 'city-scaffold', polys: frame });
+      const cage = [];
+      isoBox(cage, k, fp[2] - 0.02, fp[3] - 0.16, fp[2] + 0.1, fp[3] - 0.02, top, 6, I.crate);
+      const lift = r1((total - 6) * k.S);
+      parts.push({ cls: 'city-climb', style: { '--climb': -lift + 'px', '--climb-at': -r1(progress * lift) + 'px' }, polys: cage });
+      const c = crane(k, ox + m[0], oy + m[1], m[2], top + total + 10, false);
+      parts.push({ cls: 'city-crane', polys: c.mast });
+      parts.push({ cls: 'city-jib', style: { '--pivot': c.pivot[0] + 'px ' + c.pivot[1] + 'px' }, polys: c.jib });
+      site = { kind: 'live', id: live.id, label: live.label, progress: progress, built: built, floors: BUILD_FLOORS };
+      top = top + total + 22;
+    } else if (pending) {
+      const ghost = [];
+      isoBox(ghost, k, fp[0], fp[1], fp[2], fp[3], top, total, Object.assign({}, I.glass, { dash: '4 3' }), { fins: true, n: 3 });
+      parts.push({ cls: 'city-ghost', polys: ghost });
+      const c = crane(k, ox + m[0], oy + m[1], m[2], top + total + 6, true);
+      parts.push({ cls: 'city-crane city-crane--parked', polys: c.mast.concat(c.jib) });
+      // the council's tally: one dot per seat on an arc over the ghost, filled as they vote
+      // (before its sitting's tally is read, one open dot per holder: nobody has voted)
+      const ask = v.all.find((a) => a.id === pending.id || a.id === pending.ask_id) || null;
+      const t = ask && ask.tally ? ask.tally : null;
+      const holders = (living.byKey.charter && living.byKey.charter.seats || []).filter((s) => s.role === 'holder').length;
+      const seats = t ? Math.max(1, (Number(t.for) || 0) + (Number(t.against) || 0) + (Number(t.open) || 0)) : Math.max(3, holders);
+      const yes = t ? Number(t.for) || 0 : 0, no = t ? Number(t.against) || 0 : 0;
+      const centre = P(cx, cy, top + total + 4);
+      const arc = { yes: '', no: '', open: '' };
+      for (let i = 0; i < seats; i++) {
+        const a = Math.PI * (1.12 + 0.76 * (seats === 1 ? 0.5 : i / (seats - 1)));
+        const d = ellipse(r1(centre[0] + Math.cos(a) * 22), r1(centre[1] + Math.sin(a) * 14), 2.4, 2.4);
+        arc[i < yes ? 'yes' : i < yes + no ? 'no' : 'open'] += d;
+      }
+      const tl = [];
+      cls(tl, arc.yes, 'city-tally city-tally--yes');
+      cls(tl, arc.no, 'city-tally city-tally--no');
+      cls(tl, arc.open, 'city-tally city-tally--open');
+      parts.push({ cls: null, polys: tl });
+      tally = { seats: seats, yes: yes, no: no };
+      site = { kind: 'pending', id: pending.id, label: pending.label, needs: pending.needs || 'a vote', ask_id: ask ? ask.id : null };
+      // an open sitting: a light shaft from the ghost's roof
+      if (!ask || ask.state !== 'settled') {
+        const s0 = P(cx, cy, top + total);
+        shaft = { key: 'shaft:' + key, building: key, x: r1(s0[0]), y: r1(s0[1]), h: 150 };
+      }
+      top = top + total + 26;
+    }
+    return { parts: parts, top: top, floors: floors, held: held, bodyYou: bodyYou, windows: { cells: cells.length, you: nYou, lit: nLit }, site: site, tally: tally, shaft: shaft };
+  }
+
+  // ---------- the sky: one pod per agent ----------
+  function skyLanes(k, traffic, districts, civicTop) {
+    const P = k.P, lanes = [], byKey = {}, lotOf = {};
+    districts.forEach((D) => { lotOf[D.goal_id] = D.lot; });
+    const slot = {};
+    CIVIC_SLOTS.forEach((s) => { slot[s[0]] = s; });
+    ((traffic && traffic.claims) || []).forEach((c) => {
+      if (!c || !slot[c.building]) return;
+      const goal = c.goal_id != null && lotOf[String(c.goal_id)] ? String(c.goal_id) : null;
+      const key = c.building + '>' + (goal || 'here');
+      if (!byKey[key]) { byKey[key] = { key: key, building: c.building, goal_id: goal, claims: [] }; lanes.push(byKey[key]); }
+      byKey[key].claims.push(c);
+    });
+    lanes.forEach((L) => {
+      const s = slot[L.building];
+      const a = P(s[1] + 1, s[2] + 1, civicTop[L.building] + 18);
+      const lot = L.goal_id ? lotOf[L.goal_id] : null;
+      if (lot) {
+        const b = P((lot.x0 + lot.x1 + 1) / 2, (lot.y0 + lot.y1 + 1) / 2, 96);
+        const c = [(a[0] + b[0]) / 2, Math.min(a[1], b[1]) - 70];
+        L.d = 'M' + r1(a[0]) + ' ' + r1(a[1]) + 'Q' + r1(c[0]) + ' ' + r1(c[1]) + ' ' + r1(b[0]) + ' ' + r1(b[1]);
+        L.orbit = false;
+      } else {
+        // work with no district circles over its own building
+        L.d = 'M' + r1(a[0] - 26) + ' ' + r1(a[1]) + 'a26 9 0 1 0 52 0a26 9 0 1 0 -52 0';
+        L.orbit = true;
+      }
+      L.pods = L.claims.slice(0, MAX_LANE_PODS).map((c, i) => ({
+        key: 'pod:' + String(c.claim_id || c.task_id || i), task_id: c.task_id != null ? String(c.task_id) : null,
+        at: r1(28 + i * POD_GAP * 100), delay: -r1(LANE_PERIOD * (0.18 + i * POD_GAP)), dur: LANE_PERIOD,
+      }));
+      L.extra = L.claims.length - L.pods.length;
+    });
+    // past the moving-node budget the lanes keep their first pods and say how many more
+    let budget = MAX_PODS;
+    lanes.forEach((L) => {
+      const keep = Math.max(0, Math.min(L.pods.length, budget));
+      budget -= keep;
+      L.extra += L.pods.length - keep;
+      L.pods = L.pods.slice(0, keep);
+      const end = L.orbit ? null : /([-\d.]+) ([-\d.]+)$/.exec(L.d);
+      L.more = L.extra > 0 ? { n: L.extra, x: end ? Number(end[1]) : null, y: end ? Number(end[2]) : null } : null;
+    });
+    return lanes;
+  }
+
+  // ---------- the ground: the spend conduit ----------
+  // The trunk runs from the Treasury onto the ring, round it; its width is the real spend rate
+  // (this month's spend over the days so far). A spur feeds each district its pot's share
+  // (GET /government/treasury, task 1004712); a dry pot's spur is
+  // starved and its district raises a beacon over its borrow from the reserve.
+  const RING = Object.freeze([4.2, 11.8]);
+  function spendRate(spend, now) {
+    if (!spend) return null;
+    const day = Number(now) > 0 ? new Date(Number(now)).getUTCDate() : null;
+    if (spend.month_usd != null && day) return Math.round(Number(spend.month_usd) / day * 100) / 100;
+    return spend.today_usd != null ? Number(spend.today_usd) : null;
+  }
+  function trunkWidth(rate) { return rate > 0 ? r1(Math.max(1.5, Math.min(8, Math.sqrt(rate) / 5))) : 0; }
+  function conduits(k, living, districts, now) {
+    const P = k.P, flat = [], beacons = [];
+    const spend = living.city && living.city.spend;
+    const rate = spendRate(spend, now);
+    const w = trunkWidth(rate);
+    const route = (pts) => pts.map((p, i) => { const q = P(p[0], p[1]); return (i ? 'L' : 'M') + r1(q[0]) + ' ' + r1(q[1]); }).join('');
+    if (w > 0) {
+      flat.push({ d: route([[RING[0], RING[0]], [RING[1], RING[0]], [RING[1], RING[1]], [RING[0], RING[1]]]) + 'Z', f: 'none', s: 'none', dash: 'none', w: w, cls: 'city-conduit', key: 'trunk' });
+      flat.push({ d: route([[10.85, 6], [RING[1], 6]]), f: 'none', s: 'none', dash: 'none', w: w, cls: 'city-conduit', key: 'treasury' });
+    }
+    const byGoal = {};
+    (living.districts || []).forEach((d) => { byGoal[d.goal_id] = d; });
+    const spent = districts.reduce((n, D) => { const p = byGoal[D.goal_id] && byGoal[D.goal_id].pot; return n + (p && p.spent_usd > 0 ? p.spent_usd : 0); }, 0);
+    const spurs = [];
+    districts.forEach((D) => {
+      const ld = byGoal[D.goal_id];
+      const pot = ld && ld.pot;
+      if (!pot || !(w > 0)) return;
+      const L = D.lot, cx = (L.x0 + L.x1 + 1) / 2, cy = (L.y0 + L.y1 + 1) / 2;
+      const ex = Math.max(RING[0], Math.min(RING[1], cx)), ey = Math.max(RING[0], Math.min(RING[1], cy));
+      const pts = ex !== cx && ey !== cy ? [[ex, ey], [ex, cy], [cx, cy]] : [[ex, ey], [cx, cy]];
+      const share = spent > 0 ? Math.max(0, pot.spent_usd) / spent : 0;
+      const sw = pot.dry ? 1.2 : r1(Math.max(0.75, w * Math.sqrt(share)));
+      flat.push({ d: route(pts), f: 'none', s: 'none', dash: pot.dry ? '2 3' : 'none', w: sw, cls: pot.dry ? 'city-conduit city-conduit--dry' : 'city-conduit', key: 'spur:' + D.goal_id });
+      spurs.push({ goal_id: D.goal_id, width: sw, share: Math.round(share * 1000) / 1000, dry: !!pot.dry });
+      if (pot.dry) {
+        // the reserve-borrow beacon, in the sky over the district
+        const foot = P(cx, cy, 70), head = P(cx, cy, 128);
+        const d = k.seg(foot, head);
+        const dia = 'M' + r1(head[0]) + ' ' + r1(head[1] - 5) + 'L' + r1(head[0] + 4) + ' ' + r1(head[1]) + 'L' + r1(head[0]) + ' ' + r1(head[1] + 5) + 'L' + r1(head[0] - 4) + ' ' + r1(head[1]) + 'Z';
+        beacons.push({ d: d, f: 'none', s: 'none', dash: '1 3', w: 1, cls: 'city-beacon city-beacon--stem' });
+        beacons.push({ d: dia, f: 'none', s: 'none', dash: 'none', w: 1, cls: 'city-beacon' });
+        beacons.push({ d: ellipse(r1(head[0]), r1(head[1]), 9, 4.5), f: 'none', s: 'none', dash: 'none', w: 1, cls: 'city-beacon city-beacon--ring' });
+        D.beacon = { goal_id: D.goal_id, ask_id: pot.borrow_ask_id || null, x: r1(head[0]), y: r1(head[1]) };
+      }
+    });
+    return { flat: flat, beacons: beacons, rate: rate, width: w, spurs: spurs };
+  }
+
+  // ---------- the pins, read from the living asks ----------
+  // Salmon (urgent, needs) only for asks that wait on the viewer's own seat; others deciding is
+  // ink (moving); a building whose only matter is settled is a grey dot. The age ring is the
+  // oldest ask on you, full at two weeks. Every pin is a real matter.
+  function livingPins(k, living, answered, civicTop) {
+    const P = k.P, pins = [];
+    let n = 0;
+    CIVIC_SLOTS.forEach((s) => {
+      const b = living.byKey[s[0]];
+      const v = asksAt(b, answered);
+      if (!v.all.length) return;
+      let tier, list;
+      if (v.onYou.length) { tier = v.onYou.some((a) => a.urgent) ? 'urgent' : 'needs'; list = v.onYou; } else if (v.open.length) { tier = 'moving'; list = v.open; } else { tier = 'settled'; list = v.all; }
+      const m = list[0];
+      const top = P(s[1] + 1, s[2] + 1, civicTop[s[0]] + 8);
+      const g = glyph(m.rule, 7, 7, 13);
+      const ages = v.onYou.map((a) => a.age_days).filter((x) => x != null);
+      const oldest = ages.length ? Math.max.apply(null, ages) : null;
+      const title = String((m.shown && m.shown.question) || (m.raw && m.raw.title) || '');
+      const name = (b && b.name) || s[0];
+      const aria = tier === 'settled' ? name + ': settled. ' + title
+        : v.onYou.length ? name + ': ' + v.onYou.length + ' ' + words('on_you', v.onYou.length) + (oldest != null ? ', the oldest ' + oldest + (oldest === 1 ? ' day' : ' days') : '') + '. ' + title
+          : v.others.length ? name + ': ' + v.others.length + ' ' + words('on_others', v.others.length) + '. ' + title
+            : name + ': ' + v.open.length + ' moving. ' + title;
+      pins.push({
+        key: String(m.id), building: s[0], state: tier, count: tier === 'settled' ? 0 : list.length, matters: list.map((a) => String(a.id)),
+        title: title, aria: aria, x: r1(top[0] - 15), y: r1(top[1] - 52), h: 52, gf: g.fill, gl: g.line, delay: -(n * 0.9),
+        age: tier === 'urgent' || tier === 'needs' ? (oldest != null ? Math.round(clamp01(oldest / AGE_FULL_DAYS) * 1000) / 1000 : 0) : null,
+        oldest_days: oldest,
+      });
+      n += 1;
+    });
+    return pins;
+  }
+
+  // ---------- the Lead plates, placed so none meets another or a pin ----------
+  // Most important first (asks on you, then a Lead, then the owner's): beside the top of the
+  // building, right then left, then a step lower; a plate with nowhere clear waits for the
+  // card, which always names who holds the building.
+  const PLATE_H = 18;
+  const plateWidth = (text) => Math.round(String(text).length * 6.1 + 16);
+  function placePlates(civic, pins, k) {
+    const boxes = pins.map((p) => ({ x0: p.x - 2, y0: p.y - 4, x1: p.x + 32, y1: p.y + 26, own: null }));
+    // another building's build site or ghost annex is never covered: it is the news on that roof
+    civic.forEach((c) => {
+      if (!c.site) return;
+      const h = (BUILD_FLOORS * FLOOR_H + 26) * k.S;
+      boxes.push({ x0: c.top[0] - 40, y0: c.top[1] + 6, x1: c.top[0] + 44, y1: c.top[1] + h, own: c.key });
+    });
+    const rank = (c) => (c.on_you > 0 ? 0 : c.plate.lead ? 1 : 2);
+    civic.map((c, i) => ({ c: c, i: i })).sort((a, b) => rank(a.c) - rank(b.c) || a.i - b.i).forEach((e) => {
+      const c = e.c, w = plateWidth(c.plate.text), tx = c.top[0], ty = c.top[1];
+      const hit = (b) => boxes.some((o) => o.own !== c.key && b.x0 < o.x1 && b.x1 > o.x0 && b.y0 < o.y1 && b.y1 > o.y0);
+      const tries = [[tx + 12, ty - 2], [tx - 12 - w, ty - 2], [tx + 12, ty - 20], [tx - 12 - w, ty - 20], [tx + 12, ty + 16], [tx - 12 - w, ty + 16]];
+      const at = tries.map((t) => ({ x0: t[0], y0: t[1] - PLATE_H / 2, x1: t[0] + w, y1: t[1] + PLATE_H / 2, own: null })).find((b) => !hit(b));
+      c.plate.w = w;
+      if (!at) { c.plate.hidden = true; return; }
+      boxes.push(at);
+      c.plate.x = r1(at.x0);
+      c.plate.y = r1((at.y0 + at.y1) / 2);
+      c.plate.hidden = false;
+    });
+  }
+
+  // ---------- the card a building opens in place ----------
+  const money =(n) => '$' + String(Math.round(Number(n) || 0)).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+  function factFor(b, living) {
+    const r = ((b && b.readings) || []).find((x) => x && x.status === 'live' && x.figure);
+    if (r) return { text: String(r.figure), line: String(r.line || '') };
+    const fence = living.city && living.city.fence;
+    if (b && b.key === 'automation' && fence) return { text: fence.enabled ? 'running unattended' : 'unattended off', line: '' };
+    if (b && b.agents > 0) return { text: b.agents + ' ' + words('agents_at_work', b.agents), line: '' };
+    if (b && b.decision && b.decision.rule_words) return { text: String(b.decision.rule_words), line: '' };
+    return { text: 'quiet', line: '' };
+  }
+  // The card is a row and two doors: every ask is answered on the deck, whose taps
+  // take the matter's real route (task 1004717: the card's in-place answer, which
+  // sent nothing, is gone). `seated`: who leads each building is known (GET
+  // /government/leads, task 1004709); without that read the card names nobody as
+  // holding the building, with it the Lead, or the owner.
+  function cardFor(b, v, living, seated) {
+    const key = b.key;
+    return {
+      key: key, name: String(b.name || key), plate: !seated ? null : b.lead ? String(b.lead.name || 'Lead') : 'owner', lead: !!seated && !!b.lead,
+      fact: factFor(b, living), on_you: v.onYou.length, on_others: v.others.length, open: v.open.length, agents: Number(b.agents) || 0,
+      deck_href: STREET_HREF + '#deck=' + key, enter_href: STREET_HREF + '#building=' + key,
+    };
+  }
+
+  // ---------- the gate plaque, the door and the line ----------
+  // The words are gov-living.js's COUNT_WORDS, the labels every surface prints.
+  const words = (key, n) => (Living ? Living.countWords(key, n) : { on_you: 'to do', on_others: n === 1 ? 'waits on others' : 'wait on others', agents_at_work: n === 1 ? 'agent working' : 'agents working' }[key]);
+  function plaqueFor(living, constitution, onYou) {
+    const ra = constitution && constitution.charter && constitution.charter.reads_as;
+    const laws = (living.city && living.city.laws) || [];
+    const month = living.city && living.city.spend ? living.city.spend.month_usd : null;
+    return [
+      ra && ra.name ? { key: 'form', figure: String(ra.name), words: 'government' } : null,
+      laws.length ? { key: 'laws', figure: String(laws.length), words: laws.length === 1 ? 'law' : 'laws' } : null,
+      onYou > 0 ? { key: 'you', figure: String(onYou), words: words('on_you', onYou) } : null,
+      month != null ? { key: 'spend', figure: money(month), words: 'this month' } : null,
+    ].filter(Boolean);
+  }
+  function ctaFor(onYou) {
+    return onYou > 0
+      ? { label: 'decide ' + onYou + ' in a row', href: STREET_HREF + '#deck', aria: 'Decide the ' + onYou + ' questions on you, one card at a time' }
+      : { label: 'start governing', href: STREET_HREF, aria: 'Start governing: enter the street view' };
+  }
+  function livingLine(onYou, others, agents) {
+    const parts = [onYou ? onYou + ' ' + words('on_you', onYou) : 'nothing to do'];
+    if (others) parts.push(others + ' ' + words('on_others', others));
+    if (agents) parts.push(agents + ' ' + words('agents_at_work', agents));
+    return parts.join(' · ');
+  }
+
   // The whole home view as data.
   //   docket   the GET /government/docket body, or null when it failed
   //   goals    GET /goals goals[] (any status; only 'open' ones are drawn)
   //   rollups  GET /goals/rollups rollups[] (goal_id → task counts)
   //   mode     'dark' | 'light'
   //   now      ms since the epoch (a deadline inside a day is urgent)
+  // and, for the living city (task 1004685):
+  //   living        GovLiving.livingModel() over the same reads (gov-living.js)
+  //   constitution  GET /government/constitution (the plaque's form of government)
+  //   answered      ask ids the viewer answered on this page (they leave the counts)
   function cityModel(input) {
     const opts = input || {};
     const docket = opts.docket && typeof opts.docket === 'object' ? opts.docket : null;
     const mode = opts.mode === 'light' ? 'light' : 'dark';
     const I = isoTheme(mode);
     const counts = docket && docket.counts ? docket.counts : { needs: 0, moving: 0, settled: 0 };
-    const evening = !!docket && !(Number(counts.needs) > 0);
+    const living = opts.living && Array.isArray(opts.living.buildings) ? Object.assign({}, opts.living, { byKey: {} }) : null;
+    if (living) living.buildings.forEach((b) => { if (b && b.key) living.byKey[b.key] = b; });
+    const answered = {};
+    (Array.isArray(opts.answered) ? opts.answered : []).forEach((id) => { answered[String(id)] = true; });
+    const views = {};
+    if (living) CIVIC_SLOTS.forEach((s) => { views[s[0]] = asksAt(living.byKey[s[0]], answered); });
+    // the page's numbers are gov-living.js's countsOf (opts.counts when the page already
+    // holds them), the same numbers the street, the deck and the shell's tally print
+    const tally = living ? (opts.counts || (Living ? Living.countsOf(living, { answered: Object.keys(answered) }) : null)) : null;
+    const onYou = tally && tally.on_you != null ? tally.on_you : living ? CIVIC_SLOTS.reduce((n2, s) => n2 + views[s[0]].onYou.length, 0) : 0;
+    // the windows light for the evening when nothing waits on you (in the living city: on your seats)
+    const evening = !!docket && (living ? onYou === 0 : !(Number(counts.needs) > 0));
     const k = isoKit(60, 30, 720, 176, 30 / 28, I, evening);
-    const P = k.P, r1 = (n) => Math.round(n * 10) / 10;
+    const P = k.P;
+    const kits = {};
+    const kitFor = (t) => (t > 0 ? (kits[t] = kits[t] || isoKit(60, 30, 720, 176, 30 / 28, hazeTheme(I, t, mode), evening)) : k);
 
     // ground, the ring road and its lanes, the plaza
     const flat = [];
@@ -406,15 +928,33 @@
 
     // the civic quarter, then the districts' work, painted back to front
     const blds = [];
+    const civicTop = {}, civicLive = {};
     CIVIC_SLOTS.forEach((s) => {
       const polys = [];
-      isoInstitution(polys, k, s[0], s[1], s[2], { fixes: rulesAtWork(docket) });
-      blds.push({ key: s[0], depth: s[1] + s[2] + 2, polys: polys });
+      const b = living ? living.byKey[s[0]] : null;
+      const quiet = !!living && isQuiet(b, views[s[0]]);
+      const kk = quiet ? kitFor(QUIET_HAZE) : k;
+      isoInstitution(polys, kk, s[0], s[1], s[2], { fixes: rulesAtWork(docket) });
+      const item = { key: s[0], depth: s[1] + s[2] + 2, polys: polys };
+      civicTop[s[0]] = ROOF[s[0]];
+      if (living && b) {
+        const civ = civicLiving(polys, kk, s, b, views[s[0]], living);
+        item.parts = civ.parts;
+        item.quiet = quiet;
+        civicTop[s[0]] = civ.top;
+        civicLive[s[0]] = civ;
+      }
+      blds.push(item);
     });
+    // the living city hazes the districts by depth band; one with an agent at work stands a band clearer
+    const agentsIn = {};
+    if (living) (living.districts || []).forEach((d) => { agentsIn[d.goal_id] = Number(d.agents) || 0; });
     districts.forEach((D) => {
+      D.haze = living ? Math.round(HAZE[hazeBand(D.lot)] * (agentsIn[D.goal_id] > 0 ? ACTIVE_HAZE : 1) * 100) / 100 : 0;
+      const kk = kitFor(D.haze);
       D.work.forEach((w) => {
         const polys = [];
-        isoWork(polys, k, w.gx, w.gy, w.kind, w.h);
+        isoWork(polys, kk, w.gx, w.gy, w.kind, w.h);
         blds.push({ key: w.gx + ',' + w.gy, depth: w.gx + w.gy + 1, polys: polys });
       });
     });
@@ -429,9 +969,12 @@
       if (!m || !slotOf[m.building]) return;
       (atBuilding[m.building] = atBuilding[m.building] || []).push(m);
     });
-    const pins = [];
+    let pins = [];
     let n = 0;
-    CIVIC_SLOTS.forEach((s) => {
+    // who leads each building is known: GET /government/leads was read (task 1004709)
+    const seated = !!(living && living.seats_real);
+    if (living) pins = livingPins(k, living, answered, civicTop);
+    else CIVIC_SLOTS.forEach((s) => {
       const bp = buildingPin(atBuilding[s[0]], opts.now);
       if (!bp) return;
       const top = P(s[1] + 1, s[2] + 1, ROOF[s[0]] + 8);
@@ -458,14 +1001,58 @@
     toReview.forEach((d, i) => { if (fed[i]) [0, 1].forEach((j) => parcels.push({ key: 'p' + i + j, d: d, dur: 12 + i, delay: -(i * 2.7 + j * 6.2), out: false })); });
     if (districts.length) [0, 1].forEach((j) => parcels.push({ key: 'out' + j, d: route([[10.6, 9.6], [11.5, 9.6], [11.5, 8], [11.5, 0]]), dur: 10, delay: -(j * 5), out: true }));
 
-    const line = docket && docket.line ? String(docket.line) : FALLBACK_LINE;
+    let line = docket && docket.line ? String(docket.line) : FALLBACK_LINE;
     const pinCount = { needs: 0, moving: 0, settled: 0 };
     pins.forEach((p) => { pinCount[p.state === 'urgent' ? 'needs' : p.state] += 1; });
-    const label = 'The governor city: the nine civic buildings round the plaza and '
+    let label = 'The governor city: the nine civic buildings round the plaza and '
       + (districts.length === 1 ? 'one district' : districts.length + ' districts') + ', one for each open goal'
       + (pins.length ? '. Pins: ' + pinCount.needs + ' need you, ' + pinCount.moving + ' moving, ' + pinCount.settled + ' settled.' : '.');
 
-    return { mode: mode, evening: evening, crate: { fill: I.crate.t, edge: I.crate.s }, flat: flat, blds: blds, pins: pins, parcels: parcels, districts: districts, unplaced: unplaced, line: line, label: label };
+    const out = { mode: mode, evening: evening, crate: { fill: I.crate.t, edge: I.crate.s }, flat: flat, blds: blds, pins: pins, parcels: parcels, districts: districts, unplaced: unplaced, line: line, label: label };
+    if (!living) return out;
+
+    // ---- the living city's three levels (task 1004685) ----
+    const spend = conduits(k, living, districts, opts.now);
+    // the conduit runs on the ground, over the plots and under every building
+    out.flat = flat.concat(spend.flat);
+    const lanes = skyLanes(k, living.city && living.city.traffic, districts, civicTop);
+    const sky = [];
+    lanes.forEach((L) => sky.push({ d: L.d, f: 'none', s: 'none', dash: 'none', w: 2, cls: 'city-lane', key: 'lane:' + L.key }));
+    spend.beacons.forEach((b) => sky.push(b));
+    const civic = CIVIC_SLOTS.map((s) => {
+      const b = living.byKey[s[0]];
+      if (!b) return null;
+      const v = views[s[0]], civ = civicLive[s[0]];
+      const top = P(s[1] + 1, s[2] + 1, civicTop[s[0]]);
+      const foot = P(s[1] + 2, s[2] + 2, 0);
+      return {
+        key: s[0], name: String(b.name || s[0]), top: [r1(top[0]), r1(top[1])],
+        hit: { x: r1(top[0] - 28), y: r1(top[1] - 6), w: 56, h: r1(foot[1] - top[1] + 6) },
+        plate: { text: b.lead ? String(b.lead.name || 'Lead') : 'owner', lead: !!b.lead, x: r1(top[0] + 10), y: r1(top[1] - 4) },
+        floors: civ.floors.map((f, i) => ({ kind: f.kind, seat: f.seat, name: f.name, on_you: civ.held[i] })),
+        body_on_you: civ.bodyYou, windows: civ.windows, site: civ.site, tally: civ.tally, shaft: civ.shaft, quiet: !!civ && blds.some((x) => x.key === s[0] && x.quiet),
+        on_you: v.onYou.length, on_others: v.others.length, open: v.open.length, card: cardFor(b, v, living, seated),
+      };
+    }).filter(Boolean);
+    placePlates(civic, pins, k);
+    // a plate names a Lead or the owner's seat: none where the real read does not say who
+    if (!seated) civic.forEach((c) => { c.plate.hidden = true; });
+    const others = tally && tally.on_others != null ? tally.on_others : CIVIC_SLOTS.reduce((n2, s) => n2 + views[s[0]].others.length, 0);
+    const agents = tally && tally.agents_at_work != null ? tally.agents_at_work : living.city && living.city.traffic ? Number(living.city.traffic.agents) || 0 : 0;
+    line = docket ? livingLine(onYou, others, agents) : FALLBACK_LINE;
+    label = 'The governor city: the nine civic buildings round the plaza, ' + (districts.length === 1 ? 'one district' : districts.length + ' districts')
+      + ' for the open goals, and ' + agents + (agents === 1 ? ' agent' : ' agents') + ' in the sky lanes. ' + line + '.';
+    const pods = lanes.reduce((n2, L) => n2 + L.pods.length, 0);
+    const shafts = civic.filter((c) => c.shaft).map((c) => c.shaft);
+    return Object.assign(out, {
+      line: line, label: label, living: true,
+      sky: sky, lanes: lanes, shafts: shafts, civic: civic,
+      spend: { rate_usd_per_day: spend.rate, width: spend.width, spurs: spend.spurs },
+      beacons: districts.filter((D) => D.beacon).map((D) => D.beacon),
+      plaque: plaqueFor(living, opts.constitution, onYou), cta: ctaFor(onYou),
+      counts: { on_you: onYou, on_others: others, open: onYou + others, agents_at_work: agents, moving: tally ? tally.moving : null },
+      motion: { pods: pods, sites: civic.filter((c) => c.site && c.site.kind === 'live').length * 3, shafts: shafts.length, parcels: parcels.length, pins: pins.length + pins.filter((p) => p.state === 'urgent').length },
+    });
   }
 
   // Where the start governing button goes: the street (task 1004525 builds it),
@@ -479,6 +1066,12 @@
     matterTier: matterTier, buildingPin: buildingPin, pinAria: pinAria, TIERS: TIERS, URGENT_MS: URGENT_MS,
     CIVIC_SLOTS: CIVIC_SLOTS, ROOF: ROOF, BASE_LOTS: BASE_LOTS, MAX_DISTRICTS: MAX_DISTRICTS,
     FALLBACK_LINE: FALLBACK_LINE, STREET_HREF: STREET_HREF,
+    // the living city (task 1004685)
+    hazeTheme: hazeTheme, mixToward: mixToward, hazeBand: hazeBand, structureFloors: structureFloors, asksAt: asksAt,
+    spendRate: spendRate, trunkWidth: trunkWidth, plaqueFor: plaqueFor, ctaFor: ctaFor, livingLine: livingLine,
+    FLOOR_H: FLOOR_H, BUILD_FLOORS: BUILD_FLOORS, CORE: CORE, BODY: BODY, LANE_PERIOD: LANE_PERIOD, POD_GAP: POD_GAP,
+    MAX_LANE_PODS: MAX_LANE_PODS, MAX_PODS: MAX_PODS, ACTIVE_HAZE: ACTIVE_HAZE,
+    AGE_FULL_DAYS: AGE_FULL_DAYS, HAZE: HAZE, QUIET_HAZE: QUIET_HAZE,
   };
   root.GovCity = api;
   if (typeof module !== 'undefined' && module.exports) module.exports = api;