@bongos/core 1.21.53 → 1.21.55

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

@@ -49,8 +49,16 @@
 // the model as `row`, and render() draws row.actions and row.choices, sending
 // each act through request() with the row's own card. "more" opens the detail
 // in place (moreOf): the full text, who and when, and the record. Nothing on
-// the card links to an older page to decide; the one link left is a sign-off
-// that needs a recording ('record it'), which only the goal's page can take.
+// the card links to an older page to decide.
+//
+// THE RECORDED SIGN-OFF (task 1004579). A promise that needs a recording is
+// signed off here too: 'record it' opens one line where the recording is picked
+// or dropped, sent with its progress on that line, then signed off, through the
+// SAME two routes the goal page uses (POST /done-when/:id/uat/recording, then
+// POST /done-when/:id/uat). recordLine() says what the line shows in each
+// phase, recordRun() runs the two steps, recordStrip() draws the line for the
+// desk row and the card alike. A refused or failed upload says why on that
+// line, in one sentence, and offers to try again.
 
 (function (root) {
   'use strict';
@@ -653,6 +661,19 @@
     },
   };
   ACT_ROUTES.invite = { invite: function (id, inp) { return str(inp.option).trim() ? post('/access-requests/invite', { github_login: str(inp.option).trim() }) : null; } };
+  // The work categories, edited in place (task 1004580): the Project settings
+  // page's own two routes. A typed name renames (PATCH .../:id { label }) or
+  // adds (POST /work-categories { label }); retire and bring back flip whether
+  // new goals are offered it ({ active }); a move sets its place ({ sort_order },
+  // a whole number the desk works out from its neighbours). Nothing typed, or a
+  // place that is not a whole number, sends nothing.
+  ACT_ROUTES.work_category = {
+    rename: function (id, inp) { return str(inp.option).trim() ? call('PATCH', '/work-categories/' + id, { label: str(inp.option).trim() }) : null; },
+    retire: function (id) { return call('PATCH', '/work-categories/' + id, { active: false }); },
+    restore: function (id) { return call('PATCH', '/work-categories/' + id, { active: true }); },
+    move: function (id, inp) { return Number.isInteger(inp.sort_order) ? call('PATCH', '/work-categories/' + id, { sort_order: inp.sort_order }) : null; },
+    add: function (id, inp) { return str(inp.option).trim() ? post('/work-categories', { label: str(inp.option).trim() }) : null; },
+  };
   ACT_ROUTES.autonomy_fence = ACT_ROUTES.autobongos_fence;
   // The Planning desks (task 1004560). A blocker is decided by one of its chips,
   // whose words are the resolution note; a criterion proposal ratifies in one
@@ -779,8 +800,17 @@
     if (key === 'release') return { toast: cv && cv.source === 'gate_approvals' ? 'Released from the gate. It merges and goes live.' : 'Released. It goes live.', building: b, kind: 'rise', close: true };
     if (key === 'fine') return { toast: cv && cv.source === 'goal_join_requests' ? 'Noted. ' + who + ' joins the team.' : 'Noted. ' + who + ' is invited in.', building: b, kind: 'rise', close: false };
     if (key === 'refuse') return { toast: 'Noted. ' + who + ' is not let in.', building: b, kind: 'settle', close: false };
+    if (key === 'record') {
+      var goal = Array.isArray(r.achieved_goals) && r.achieved_goals.length;
+      return { toast: goal ? 'Signed off with the recording. That was the last promise: the goal is achieved.' : 'Signed off with the recording. The promise counts as kept.', building: b, kind: 'rise', close: true };
+    }
     if (key === 'take' && cv && cv.subject && cv.subject.kind === 'core_pin') return { toast: ACT_TOASTS.take_core, building: b, kind: 'rise', close: false };
     if (key === 'invite') return { toast: ACT_TOASTS.invite.replace('{who}', r.github_login || 'They'), building: b, kind: 'light', close: false };
+    if (key === 'add' && cv && cv.subject && cv.subject.kind === 'work_category') {
+      var made = r.category && r.category.label ? str(r.category.label) : 'It';
+      return { toast: r.created === false ? made + ' was already a category.' : made + ' is a category now. New goals can pick it.', building: b, kind: 'light', close: false };
+    }
+    if (key === 'rename' && r.category && r.category.label) return { toast: 'Renamed. Goals read ' + str(r.category.label) + ' now.', building: b, kind: 'light', close: false };
     if (ACT_TOASTS[key]) return { toast: ACT_TOASTS[key].replace('{who}', who), building: b, kind: ACT_KINDS[key] || 'light', close: false };
     return { toast: '', building: null, kind: null, close: false };
   }
@@ -799,8 +829,11 @@
     decide: 'Decided. The work it held moves again.', ratify: 'Ratified. The promise is on its version.', ratify_goal: 'Ratified. It is a goal now.',
     budget: '{who} has a new monthly limit.', unsign: 'Undone. The promise is open again.',
     recheck: 'Checking it again. The answer lands at Release when it is done.',
+    // task 1004580: the work categories
+    rename: 'Renamed.', retire: 'Retired. New goals are not offered it; goals that carry it keep it.',
+    restore: 'Brought back. New goals can pick it again.', move: 'Moved. New goals are offered the categories in this order.',
   };
-  var ACT_KINDS = { recheck: 'light', budget: 'light', unsign: 'settle', decide: 'rise', ratify: 'rise', ratify_goal: 'rise', check: 'light', rot: 'light', module_on: 'rise', module_off: 'settle', backup: 'light', confirm: 'settle', dispute: 'settle', fix: 'rise', remove: 'settle', keep: 'settle', signoff: 'rise', force: 'rise', switch_on: 'rise', switch_off: 'settle', allow: 'rise', disallow: 'settle', first: 'light', pause: 'settle', resume: 'rise', tier: 'light', deactivate: 'settle', give: 'light', take: 'settle' };
+  var ACT_KINDS = { rename: 'light', retire: 'settle', restore: 'rise', move: 'light', recheck: 'light', budget: 'light', unsign: 'settle', decide: 'rise', ratify: 'rise', ratify_goal: 'rise', check: 'light', rot: 'light', module_on: 'rise', module_off: 'settle', backup: 'light', confirm: 'settle', dispute: 'settle', fix: 'rise', remove: 'settle', keep: 'settle', signoff: 'rise', force: 'rise', switch_on: 'rise', switch_off: 'settle', allow: 'rise', disallow: 'settle', first: 'light', pause: 'settle', resume: 'rise', tier: 'light', deactivate: 'settle', give: 'light', take: 'settle' };
 
   // A refused act, in words. The server's own message wins when it has one.
   var REFUSALS = {
@@ -822,10 +855,14 @@
     bad_github_login: 'That does not look like a GitHub name.',
     backup_already_running: 'A backup is already running.',
     intent_conflict: 'Another core run is going. Try again when it settles.',
-    criterion_needs_recording: 'This one needs a recording. Sign it off on its goal page.',
+    criterion_needs_recording: 'This one needs a recording: record it here.',
     not_proposer: 'Only the person who put it up may withdraw it.',
     votes_cast: 'Someone has voted on it, so it is the sitting\'s to decide now.',
     item_changed: 'Someone voted just now, so it stays with the sitting.',
+    // task 1004580: the work categories
+    category_not_found: 'That category is gone. The floor reads it again.',
+    label_required: 'Type a name first.',
+    bad_slug: 'Use letters or digits in the name.',
   };
   function refusal(status, body) {
     var e = body && body.error ? body.error : {};
@@ -835,6 +872,185 @@
     return e.message && e.message !== code ? String(e.message) : 'It could not be done just now.';
   }
 
+  // ---------- the recorded sign-off (task 1004579) ----------
+  // The goal page's own limits (criterion-uat-ui.js; the server screens again).
+  var RECORD_TYPES = ['video/mp4', 'video/webm'];
+  var RECORD_MAX = 100 * 1024 * 1024;
+  // Why an upload or a sign-off was refused, in one short sentence a person can
+  // act on. The server's own sentence stands in for a code not named here.
+  var RECORD_WHY = {
+    bad_type: 'Only an mp4 or webm video can go.',
+    empty: 'That file is empty.',
+    too_big: 'Over the 100 MB cap. Record a shorter pass.',
+    sniff_mismatch: 'That file is not the video it says it is.',
+    recording_not_found: 'The upload was lost on the way. Send it again.',
+    signer_shipped_this_work: 'You built this, so someone else signs it off.',
+    work_not_live: 'It is not on the live site yet. Sign off once it is.',
+    criterion_already_satisfied: 'Someone has already signed this off.',
+    criterion_not_awaiting_uat: 'Some of its work is still open.',
+    criterion_is_backend_only: 'This one is signed off without a recording.',
+    live_attestation_required: 'Say that you tried it on the live site.',
+    preview_readonly: 'This preview records nothing.',
+  };
+  // A refusal no new file can fix is not offered again ("try again" would only
+  // be refused the same way); a file the server refused asks for another file.
+  var RECORD_FINAL = { signer_shipped_this_work: 1, criterion_already_satisfied: 1, criterion_not_awaiting_uat: 1, criterion_is_backend_only: 1, preview_readonly: 1 };
+  var RECORD_FILE = { bad_type: 1, empty: 1, too_big: 1, sniff_mismatch: 1 };
+  function recordCheck(file) {
+    if (!file) return 'Pick the recording first.';
+    if (RECORD_TYPES.indexOf(str(file.type)) < 0) return RECORD_WHY.bad_type;
+    if (!(Number(file.size) > 0)) return RECORD_WHY.empty;
+    if (Number(file.size) > RECORD_MAX) return RECORD_WHY.too_big;
+    return null;
+  }
+  function firstSentence(s) {
+    var t = norm(s);
+    var hit = /^.*?[.!?](\s|$)/.exec(t);
+    return clip(hit ? hit[0] : t, 72);
+  }
+  function recordWhy(status, body) {
+    var e = body && body.error ? body.error : {};
+    var code = str(e.code || (body && body.code));
+    if (RECORD_WHY[code]) return RECORD_WHY[code];
+    if (status === 413) return RECORD_WHY.too_big;
+    if (!status) return 'The upload broke off. Try again.';
+    if (e.message && e.message !== code) return firstSentence(e.message);
+    if (status === 403) return 'Only a reviewer who did not build it may sign off.';
+    return 'It did not go through. Try again.';
+  }
+  // The two routes, the goal page's own: the raw video, then the sign-off with
+  // the stored name. live_attested is what the "tested it live" chip says.
+  function recordRoutes(id) {
+    var e = encodeURIComponent(str(id));
+    return {
+      upload: API + '/done-when/' + e + '/uat/recording',
+      signoff: function (recording) { return post('/done-when/' + e + '/uat', { kind: 'uat', recording: str(recording), live_attested: true }); },
+    };
+  }
+  function sizeWords(n) {
+    var b = Number(n) || 0;
+    if (b >= 1024 * 1024) return (Math.round(b / 1024 / 102.4) / 10) + ' MB';
+    return Math.max(1, Math.round(b / 1024)) + ' KB';
+  }
+  function fileWords(f) { return f ? clip(str(f.name) || 'the recording', 28) : ''; }
+  // The line in each phase: { text, pct (while sending), busy, error, chips }.
+  // st { file, phase: 'empty'|'picked'|'uploading'|'signing'|'failed', pct, why, retry }
+  function recordLine(state) {
+    var st = state || {};
+    var name = fileWords(st.file);
+    var pick = { key: 'pick', label: st.file ? 'pick another' : 'pick or drop it' };
+    if (st.phase === 'uploading') return { text: name + ' · ' + Math.max(0, Math.min(100, Math.floor(Number(st.pct) || 0))) + '% sent', pct: Math.floor(Number(st.pct) || 0), busy: true, error: false, chips: [] };
+    if (st.phase === 'signing') return { text: name + ' · sent, signing off…', pct: 100, busy: true, error: false, chips: [] };
+    if (st.phase === 'failed') return { text: str(st.why) || 'It did not go through.', pct: null, busy: false, error: true, chips: (st.retry && st.file ? [{ key: 'send', label: 'try again' }] : []).concat(st.final ? [] : [pick]) };
+    if (st.file) return { text: name + ' · ' + sizeWords(st.file.size), pct: null, busy: false, error: false, chips: [pick, { key: 'send', label: 'tested it live' }] };
+    return { text: 'mp4 or webm, up to 100 MB', pct: null, busy: false, error: false, chips: [pick] };
+  }
+  // A file picked or dropped: checked at once, so a wrong one says why before
+  // anything is sent.
+  function recordPick(state, file) {
+    var st = state || {};
+    st.file = file || null;
+    st.recording = null; st.pct = 0;
+    var bad = recordCheck(file);
+    if (bad) { st.phase = 'failed'; st.why = bad; st.retry = false; st.final = false; } else { st.phase = 'picked'; st.why = ''; }
+    return st;
+  }
+  // Send it, then sign off. deps { upload(url, file, onPct) → {ok,status,body},
+  // send(req) → {ok,status,body}, change(st), progress(st) }. An upload that
+  // went through is kept, so trying again after a refused sign-off does not send
+  // the video twice. Resolves to the sign-off's answer, or the refusal.
+  function recordRun(id, state, deps) {
+    var st = state || {};
+    var d = deps || {};
+    var tell = function () { if (d.change) d.change(st); };
+    var fail = function (out) {
+      var code = str(out && out.body && out.body.error && out.body.error.code);
+      // a file the server refused (or one too big for the body parser) needs another file
+      var badFile = !!RECORD_FILE[code] || (out && out.status) === 413;
+      st.phase = 'failed';
+      st.why = recordWhy(out && out.status, out && out.body);
+      st.final = !!RECORD_FINAL[code];
+      st.retry = !st.final && !badFile;
+      if (code === 'recording_not_found' || badFile) st.recording = null;
+      tell();
+      return { ok: false, status: out && out.status || 0, body: out && out.body || {} };
+    };
+    var bad = recordCheck(st.file);
+    if (bad) { st.phase = 'failed'; st.why = bad; st.retry = false; st.final = false; tell(); return Promise.resolve({ ok: false, status: 0, body: {} }); }
+    var routes = recordRoutes(id);
+    var sent;
+    if (st.recording) sent = Promise.resolve({ ok: true, status: 201, body: { recording: st.recording } });
+    else {
+      st.phase = 'uploading'; st.pct = 0; st.why = '';
+      tell();
+      sent = Promise.resolve(d.upload(routes.upload, st.file, function (p) { st.pct = p; if (d.progress) d.progress(st); }));
+    }
+    return sent.then(function (up) {
+      if (!up || !up.ok) return fail(up);
+      var name = up.body && up.body.recording;
+      if (!name) return fail({ status: up.status, body: {} });
+      st.recording = str(name);
+      st.phase = 'signing'; st.pct = 100;
+      tell();
+      return Promise.resolve(d.send(routes.signoff(st.recording))).then(function (out) {
+        if (!out || !out.ok) return fail(out);
+        st.phase = 'done';
+        return out;
+      });
+    });
+  }
+  // The raw upload with its progress (fetch cannot report an upload's progress).
+  function uploadXhr(X, url, file, onPct) {
+    return new Promise(function (res) {
+      var x;
+      try { x = new X(); } catch (e) { res({ ok: false, status: 0, body: {} }); return; }
+      x.open('POST', url, true);
+      x.withCredentials = true;
+      x.setRequestHeader('Content-Type', str(file && file.type));
+      x.setRequestHeader('Accept', 'application/json');
+      if (x.upload) x.upload.onprogress = function (e) { if (e && e.lengthComputable && e.total) onPct(Math.min(99, Math.floor(e.loaded * 100 / e.total))); };
+      x.onload = function () {
+        var b = {};
+        try { b = JSON.parse(x.responseText || '{}') || {}; } catch (e) { b = {}; }
+        res({ ok: x.status >= 200 && x.status < 300, status: x.status, body: b });
+      };
+      x.onerror = function () { res({ ok: false, status: 0, body: {} }); };
+      x.onabort = x.onerror;
+      x.send(file);
+    });
+  }
+  // What the goal page showed above its form, from GET /done-when/:id/uat:
+  // the three checks, short. { facts: up to three, for the desk row; lines: for
+  // the card's "more" }.
+  function uatChecks(view) {
+    var v = view || {};
+    var c = v.checks || {};
+    var facts = [], lines = [];
+    facts.push(c.code ? 'code done' : 'code still open');
+    lines.push(c.code ? 'code · every linked task is done' : 'code · some linked work is still open');
+    var live = c.live;
+    if (live) {
+      if (!live.available) { facts.push('live: your word'); lines.push('live · this site cannot tell, so the sign-off says you tried it live'); }
+      else if (live.live) { facts.push('running live'); lines.push('live · running on the live site'); }
+      else { facts.push('not live yet'); lines.push('live · shipped but not on the live site yet'); }
+    }
+    var s = c.uat || null;
+    var who = function (x) { return str(x.signed_off_by_login || 'someone') + (dayOf(x.created_at) ? ' on ' + dayOf(x.created_at) : ''); };
+    if (s) { facts.push('signed off'); lines.push('sign-off · by ' + who(s)); }
+    else if (c.stale_uat) { facts.push('old sign-off lapsed'); lines.push('sign-off · an earlier one by ' + who(c.stale_uat) + ' no longer counts: more work shipped after it'); }
+    else { facts.push('not signed off yet'); lines.push('sign-off · not yet'); }
+    return { facts: facts.slice(0, 3), lines: lines };
+  }
+  // The checks under the card's "more", once read (or "reading…" until then).
+  function withChecks(cv, view, failed) {
+    if (!cv) return cv;
+    var mo = cv.more || { text: [], who: '', when: '', history: [] };
+    var words = view ? uatChecks(view).lines : [failed ? 'the checks could not be read just now' : 'reading the checks…'];
+    mo.text = mo.text.filter(function (x) { return !x.checks; }).concat(words.map(function (w, i) { return { label: i ? '' : 'the checks', words: w, checks: true }; }));
+    cv.more = mo;
+    return cv;
+  }
+
   // ---------- the DOM ----------
   function el(doc, tag, cls, text) {
     var n = doc.createElement(tag);
@@ -995,7 +1211,11 @@
     var box = el(doc, 'div', 'mcard-chips');
     box.setAttribute('data-chips', open);
     box.appendChild(el(doc, 'span', 'mcard-chips__ask', ch.ask));
-    if (ch.field) {
+    if (ch.file && on.record) {
+      var strip = recordStrip(doc, on.record.state(), on.record, 'card', u.busy);
+      if (on.record.painted) on.record.painted(strip);
+      box.appendChild(strip.node);
+    } else if (ch.field) {
       var input = el(doc, 'input', 'mcard-chips__field');
       input.setAttribute('id', 'mcardField');
       input.setAttribute('type', 'text');
@@ -1011,6 +1231,63 @@
     host.appendChild(box);
   }
 
+  // The recording's one line (task 1004579), for the desk row ('desk') and the
+  // card ('card'): what the line says, a thin bar while it is sent, and its
+  // chips. 'pick' is a label wrapping the file input, so a tap opens the file
+  // chooser and the keyboard reaches it; a drop on the line takes the file too.
+  // on { pick(file), send() }. Returns { node, paint(st) }: paint() moves the
+  // line and the bar in place, so progress never redraws the desk.
+  function recordStrip(doc, state, on, kind, busy) {
+    var desk = kind === 'desk';
+    var chipCls = desk ? 'desk-chip desk-chip--choice' : 'mcard-chip';
+    var ln = recordLine(state);
+    var box = el(doc, 'span', 'rec' + (ln.busy ? ' rec--busy' : '') + (ln.error ? ' rec--error' : ''));
+    box.setAttribute('data-record', ln.error ? 'failed' : (state && state.phase) || 'empty');
+    var line = el(doc, 'span', 'rec__line', ln.text);
+    line.setAttribute('role', ln.error ? 'alert' : 'status');
+    box.appendChild(line);
+    var bar = el(doc, 'span', 'rec__bar');
+    var fill = el(doc, 'span', 'rec__fill');
+    bar.setAttribute('aria-hidden', 'true');
+    bar.appendChild(fill);
+    if (ln.pct == null) bar.hidden = true;
+    else fill.style.setProperty('width', ln.pct + '%');
+    box.appendChild(bar);
+    ln.chips.forEach(function (c) {
+      if (c.key === 'pick') {
+        var lab = el(doc, 'label', chipCls + ' rec__pick');
+        lab.setAttribute('data-act', 'record-pick');
+        lab.appendChild(el(doc, 'span', '', c.label));
+        var input = el(doc, 'input', 'rec__file');
+        input.setAttribute('type', 'file');
+        input.setAttribute('accept', RECORD_TYPES.join(','));
+        input.setAttribute('aria-label', c.label + ': the recording, mp4 or webm');
+        if (busy) input.setAttribute('disabled', '');
+        input.addEventListener('change', function () { var f = input.files && input.files[0]; if (f) on.pick(f); });
+        lab.appendChild(input);
+        box.appendChild(lab);
+      } else {
+        box.appendChild(button(doc, chipCls + (c.key === 'send' && !ln.error ? ' rec__go' : ''), c.label, 'record-' + c.key, function () { on.send(); }, busy));
+      }
+    });
+    var stop = function (e) { if (e && e.preventDefault) e.preventDefault(); if (e && e.stopPropagation) e.stopPropagation(); };
+    box.addEventListener('dragover', function (e) { stop(e); box.className += /\brec--over\b/.test(box.className) ? '' : ' rec--over'; });
+    box.addEventListener('dragleave', function () { box.className = box.className.replace(/\s*rec--over\b/g, ''); });
+    box.addEventListener('drop', function (e) {
+      stop(e);
+      var f = e && e.dataTransfer && e.dataTransfer.files ? e.dataTransfer.files[0] : null;
+      if (f && !busy) on.pick(f);
+    });
+    return {
+      node: box,
+      paint: function (st) {
+        var now = recordLine(st);
+        line.textContent = now.text;
+        if (now.pct != null) { bar.hidden = false; fill.style.setProperty('width', now.pct + '%'); }
+      },
+    };
+  }
+
   // "more": the card grows in place with the detail (task 1004566). The toggle
   // says whether it is open (aria-expanded); the queue's other pieces of work
   // are listed there, each opening in this same card.
@@ -1078,6 +1355,9 @@
     API: API, SECTIONS: SECTIONS, needsRoom: needsRoom, itemIdOf: itemIdOf, subjectKind: subjectKind,
     model: model, actsCard: actsCard, moreOf: moreOf, request: request, orderRequest: orderRequest, check: check, answer: answer, refusal: refusal, render: render, pager: pager,
     memberWords: memberWords, windowWords: windowWords, LINE: LINE, compact: compact,
+    // the recorded sign-off from the card (task 1004579)
+    RECORD_TYPES: RECORD_TYPES, RECORD_MAX: RECORD_MAX, recordCheck: recordCheck, recordWhy: recordWhy, recordRoutes: recordRoutes,
+    recordLine: recordLine, recordPick: recordPick, recordRun: recordRun, recordStrip: recordStrip, uploadXhr: uploadXhr, uatChecks: uatChecks, withChecks: withChecks,
     // the wording change, for a drafted amendment's struck and inserted text (task 1004530)
     change: changeOf,
   };

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

@@ -171,9 +171,11 @@
     withdraw: 'withdraw',
     // task 1004566: a module version flagged by its security check, checked again
     recheck: 'check again',
+    // task 1004580: a work category renamed, retired, brought back, or a new one added
+    rename: 'rename', retire: 'retire', restore: 'bring back', add: 'add',
   });
   // What a row's chips ask, per act (a reason or an option is one tap, never text).
-  const ASKS = Object.freeze({ recheck: 'why', budget: 'monthly limit', unsign: 'why', decide: 'pick one', ratify_goal: 'which version', check: 'check', take_core: 'move to', rot: 'stale after', module_off: 'sure', invite: 'their GitHub name', object: 'why', force: 'why', switch_off: 'why', pause: 'why', deactivate: 'why', signoff: 'confirm', allow: 'which goal', tier: 'which tier', give: 'to whom', take: 'from whom' });
+  const ASKS = Object.freeze({ recheck: 'why', budget: 'monthly limit', unsign: 'why', decide: 'pick one', ratify_goal: 'which version', check: 'check', take_core: 'move to', rot: 'stale after', module_off: 'sure', invite: 'their GitHub name', object: 'why', force: 'why', switch_off: 'why', pause: 'why', deactivate: 'why', signoff: 'confirm', record: 'the recording', allow: 'which goal', tier: 'which tier', give: 'to whom', take: 'from whom', rename: 'new name', add: 'its name' });
   // How a floor counts rows nobody is waiting on (desk rows), by its desk.
   const DESK_NOUNS = Object.freeze({
     'people.builders': 'builders', 'people.ranks': 'ranks', 'disputes.confirmed': 'to fix',
@@ -287,7 +289,9 @@
   // 1004559). An act with options asks first, with its options as one-tap chips;
   // `pick: 'open_goals'` offers the open goals the street already reads; an act
   // whose chips come out empty is left off rather than drawn dead. 'record'
-  // goes to the matter's own page (a sign-off that needs a recording).
+  // (a sign-off that needs a recording) asks for the recording in place: its
+  // choice is the file line (`file: true`), drawn by GovMatterCard.recordStrip
+  // (task 1004579), never a link to the goal's page.
   function actedRow(acts, card, ctx) {
     const titles = new Map((ctx.goals || []).map((g) => [str(g.id), str(g.title || 'goal ' + g.id)]));
     // an act at a building a sitting decides is filed as its matter (task 1004561)
@@ -297,7 +301,7 @@
     // 'open' leaves for an older page: a row that can act here keeps its detail
     // in place (tap the name) and drops the link; only a row with no act of its
     // own may link out (owner standard, task 1004562)
-    const inPlace = acts.some((a) => a && a.key !== 'open' && a.key !== 'record');
+    const inPlace = acts.some((a) => a && a.key !== 'open');
     acts.forEach((a) => {
       if (a.key === 'open' && inPlace) return;
       // the core's 'take' is its own word ('take it'), not the rank's 'take back'
@@ -311,11 +315,13 @@
         if (!options.length) return;
       }
       options = options.slice(0, LIMITS.chips);
-      const goes = a.key === 'record' || a.key === 'open';
+      const goes = a.key === 'open';
       if (goes && !card.href) return;
       const field = a.field || null;
-      const ask = options.length > 0 || !!field;
-      if (ask) choices[a.key] = field ? { for: a.key, ask: ASKS[word] || 'which', field: field, options: [] } : { for: a.key, ask: ASKS[word] || 'which', options: options };
+      const file = a.key === 'record';
+      const ask = options.length > 0 || !!field || file;
+      if (file) choices[a.key] = { for: a.key, ask: ASKS[word], file: true, options: [] };
+      else if (ask) choices[a.key] = field ? { for: a.key, ask: ASKS[word] || 'which', field: field, options: [] } : { for: a.key, ask: ASKS[word] || 'which', options: options };
       actions.push({ key: a.key, label: ACT_WORDS[word], tone: actions.length ? 'quiet' : 'primary', go: goes ? card.href : null, ask: ask });
     });
     const first = actions.find((a) => a.ask);
@@ -326,6 +332,9 @@
 
   // A desk row (task 1004559): something on this floor the viewer may act on that
   // no one is waiting on, read by the module that owns its route.
+  // Task 1004580: a row that `stay`s is edited in place, not decided, so an act
+  // leaves it on the desk; a rename's field starts from its whole name; a row
+  // with a `seq` (a place in an order) is moved from its open detail.
   function deskRowOf(d, ctx) {
     const titles = new Map((ctx.goals || []).map((g) => [str(g.id), str(g.title || '')]));
     const hit = /^goal (\d+)$/.exec(str(d.name));
@@ -339,13 +348,45 @@
     if (age) add('since ' + age);
     const ref = d.ref || {};
     const card = C && C.actsCard ? C.actsCard({ key: d.id, kind: ref.type, id: ref.id, who: full, title: full, building: d.building, href: d.href }) : null;
-    return Object.assign(actedRow(d.acts || [], card || { href: null }, ctx), {
+    const acted = actedRow(d.acts || [], card || { href: null }, ctx);
+    if (acted.choices.rename && acted.choices.rename.field) acted.choices.rename.value = full;
+    return Object.assign(acted, {
       key: str(d.id), matter: str(d.id), ini: initials(name), name: name, fact: fit(d.fact, LIMITS.fact), facts: facts,
       needs: d.needs === true, source: d.desk, opened: d.opened_at || null, desk: true, tool: d.tool === true, over: d.over || null,
       order: d.set || null, goalId: d.set && ref.id != null ? str(ref.id) : null, full: full,
       pips: d.pips ? Array.from({ length: Math.min(d.pips.of, LIMITS.pips) }, (_, i) => ({ key: 'p' + i, on: i < d.pips.on })) : null,
+      stay: d.stay === true, seq: Number.isInteger(d.seq) ? d.seq : null,
     });
   }
+  // The rows of one floor that hold a place (`seq`), in their order: each learns
+  // whether it can move up or down (task 1004580).
+  function placed(rows) {
+    const set = rows.filter((r) => r.seq != null);
+    set.forEach((r, i) => { r.moves = { up: i > 0, down: i < set.length - 1 }; });
+    return rows;
+  }
+  // The writes that move one placed row a place up (-1) or down (+1): one, when a
+  // whole number sits between its new neighbours' places; else every place
+  // numbered again in tens, writing only those that change. [{ id, sort_order }],
+  // [] at an end. Pure (task 1004580).
+  function placeMoves(rows, key, by) {
+    const set = (rows || []).filter((r) => r && r.seq != null && r.card && r.card.subject);
+    const i = set.findIndex((r) => r.key === key);
+    const j = i + by;
+    if (i < 0 || (by !== -1 && by !== 1) || j < 0 || j >= set.length) return [];
+    const order = set.slice();
+    order.splice(i, 1);
+    order.splice(j, 0, set[i]);
+    const lo = j > 0 ? order[j - 1].seq : null;
+    const hi = j < order.length - 1 ? order[j + 1].seq : null;
+    let v = null;
+    if (lo == null) v = hi - 10;
+    else if (hi == null) v = lo + 10;
+    else if (hi - lo >= 2) v = Math.floor((lo + hi) / 2);
+    if (v != null) return [{ id: str(set[i].card.subject.id), sort_order: v }];
+    return order.map((r, k) => ({ id: str(r.card.subject.id), sort_order: (k + 1) * 10, was: r.seq }))
+      .filter((p) => p.sort_order !== p.was).map((p) => ({ id: p.id, sort_order: p.sort_order }));
+  }
   // The desk rows of one floor: those of the desk its PLAN entry names.
   function deskRows(key, floor, docket, ctx) {
     const plan = I && I.PLAN[key];
@@ -360,7 +401,7 @@
   function rowsFor(key, floor, docket, ctx) {
     const c = Object.assign({ docket: docket }, ctx || {});
     const done = c.done || {};
-    const desked = deskRows(key, floor, docket).filter((d) => !done[str(d.id)]).map((d) => deskRowOf(d, c)).filter((r) => r.actions.length);
+    const desked = placed(deskRows(key, floor, docket).filter((d) => !done[str(d.id)]).map((d) => deskRowOf(d, c)).filter((r) => r.actions.length));
     // a desk row that stands in for a source (the core update's check-then-take)
     // replaces that source's matter rows on this floor
     const over = desked.map((r) => r.over).filter(Boolean);
@@ -568,7 +609,7 @@
       if (r.actions.some((a) => a.ask) && !r.chips) bad('a reason without chips', r.name);
       Object.keys(r.choices || {}).forEach((k) => {
         const c = r.choices[k];
-        if ((!c.field && !c.options.length) || c.options.length > LIMITS.chips || c.options.some((x) => !x.label || x.label.length > LIMITS.chip)) bad('chips', c.options.map((x) => x.label));
+        if ((!c.field && !c.file && !c.options.length) || c.options.length > LIMITS.chips || c.options.some((x) => !x.label || x.label.length > LIMITS.chip)) bad('chips', c.options.map((x) => x.label));
       });
       if (r.actions.some((a) => a.ask && !(r.choices || {})[a.key])) bad('an ask without its own chips', r.name);
       if (r.pips && r.pips.length > LIMITS.pips) bad('more than twelve pips', r.pips.length);
@@ -588,7 +629,7 @@
 
   const api = {
     LIMITS: LIMITS, ACT_WORDS: ACT_WORDS, ASKS: ASKS, DESK_NOUNS: DESK_NOUNS, CHIPS: CHIPS, NOUNS: NOUNS, CLEAR: CLEAR,
-    fit: fit, ageWord: ageWord, floorMatters: floorMatters, firstNeeds: firstNeeds, rowsFor: rowsFor, cardFor: cardFor, deskModel: deskModel, breaks: breaks, todayPips: todayPips, moved: moved,
+    fit: fit, ageWord: ageWord, placeMoves: placeMoves, floorMatters: floorMatters, firstNeeds: firstNeeds, rowsFor: rowsFor, cardFor: cardFor, deskModel: deskModel, breaks: breaks, todayPips: todayPips, moved: moved,
   };
   root.GovDesk = api;
   if (typeof module !== 'undefined' && module.exports) module.exports = api;

package/modules/hall-ui/public/street.css

@@ -343,6 +343,8 @@ html[data-fullscreen="on"] .street-top { padding-right: 184px; }
 .desk-save__line { font-size: 13.5px; color: var(--ink-soft); margin-right: auto; }
 .desk-facts, .desk-choices { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; padding: 10px 0 2px 52px; animation: street-enter 300ms cubic-bezier(.16,1,.3,1) both; }
 .desk-fact { font-size: 13px; color: var(--ink-soft); background: var(--street-wash); border-radius: 6px; padding: 6px 10px; white-space: nowrap; }
+/* a place in an order moves from the open detail: its two chips wrap together (task 1004580) */
+.desk-moves { display: inline-flex; gap: 8px; flex-wrap: wrap; }
 .desk-choices__ask { font-size: 12.5px; color: var(--ink-faint); margin-right: 4px; }
 .desk-quiet { min-height: 168px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 12px; border-top: 1px solid var(--street-rule); text-align: center; animation: street-enter 300ms cubic-bezier(.16,1,.3,1) both; }
 .desk-quiet__tick { display: block; fill: none; stroke: var(--ink); stroke-width: 1.4; stroke-linecap: round; animation: desk-pop 420ms cubic-bezier(.2,.7,.3,1) both; }

package/modules/hall-ui/public/street.html

@@ -12,7 +12,7 @@
        (tests/hall_tokens.mjs: no hall page hardcodes a web-font stylesheet). -->
   <link rel="stylesheet" href="/builders/style.css?v=2026-07-02-shell1">
   <link rel="stylesheet" href="/builders/street.css?v=2026-10-04-pins1">
-  <link rel="stylesheet" href="/builders/street-card.css?v=2026-10-04-pins1">
+  <link rel="stylesheet" href="/builders/street-card.css?v=2026-10-04-record1">
 </head>
 <!-- THE STREET (task 1004525, goal 1000125, R03). The street view of
      docs/design/mocks/governor-city/Street.dc.html (renderVals' street branch,
@@ -210,10 +210,10 @@
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/city-draw.js?v=2026-10-04-pins1"></script>
 <script src="/builders/street-draw.js?v=2026-10-04-pins1"></script>
-<script src="/builders/street-card.js?v=2026-10-04-pins1"></script>
+<script src="/builders/street-card.js?v=2026-10-04-record1"></script>
 <script src="/builders/street-inside.js?v=2026-10-03-desk1"></script>
-<script src="/builders/street-desk.js?v=2026-10-03-desk1"></script>
+<script src="/builders/street-desk.js?v=2026-10-04-record1"></script>
 <script src="/builders/street-amend.js?v=2026-10-02-amend1"></script>
-<script src="/builders/street.js?v=2026-10-04-pins1"></script>
+<script src="/builders/street.js?v=2026-10-04-record1"></script>
 </body>
 </html>