@bongos/core 1.25.15 → 1.25.16

package/modules/public-landing/public/assets/guide-scene.js

@@ -0,0 +1,566 @@
+/* assets/guide-scene.js — THE START-A-PROJECT GUIDE, game version (task 1005275, goal 1000106).
+
+   When the front-door-guide module is on and its server says it can talk, the landing's
+   "Start a project" doors open a scene in the game's look (Helm: the night panel, the name
+   voice, the cut corner, the segment) instead of going straight to the create page: a guide
+   (the Patron sprite) the visitor talks with for a few capped messages, the count of
+   messages left, the plan, and "Sign up and get started", which goes on to the create page
+   exactly where the door always went. The server and its contract are
+   modules/front-door-guide (CLAUDE.md there: tasks 1005272 chat, 1005273 plan).
+
+   The flow: start → talk → the chat ends (the cap, the visitor's budget, or "Make my plan")
+   → the plan is asked for once (POST …/plan) → the plan shows beside the talk and the one
+   closing action is "Sign up and get started". The chat's id and token are kept in local
+   storage (STORE_KEY), so a visitor who reloads or comes back later resumes the same chat
+   (GET …/conversations/:id on load) instead of spending a new one, and the sign-up hand-off
+   (task 1005274) finds them there.
+
+   What it never does:
+   - change a door when the module is off, the status read fails or answers "form", or the
+     visitor is signed in (the page's /me read takes data-guide-door off the doors): the
+     click then is the plain link it always was;
+   - show an error where the visitor has nowhere to go: a spent budget, a missing key or a
+     chat the server lost is the plain fallback, a line and the create door;
+   - break the server's client rules: the hidden `website` field is sent as it stands (empty
+     unless a bot filled it), the first message waits MIN_FIRST_MS after the chat started,
+     and the plan is read as optional (no plan, no panel content beyond one line);
+   - write innerHTML, or move anything from script: the waiting dots are CSS, so the world's
+     reduced-motion switch (world.css) stops them.
+
+   The state machine (reduce) and the plan reader (readPlan) are pure and exported for
+   tests/landing_guide_scene.mjs; boot() is the DOM half and runs only in a browser. */
+(function (factory) {
+  'use strict';
+  var api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+    window.GuideScene = api;
+    api.boot(window, document);
+  }
+})(function () {
+  'use strict';
+
+  var API = '/api/bongos/front-door-guide';
+  var MODULE_KEY = 'front-door-guide';
+  // the server refuses a first message sooner than 1500ms after the start (a bot); wait a
+  // little longer so a clock edge never turns a person into one
+  var MIN_FIRST_MS = 1600;
+  // the chat's { id, token } in local storage: the server's contract keeps it there, not in
+  // session storage, so a closed browser comes back to the same chat
+  var STORE_KEY = 'cb-front-door-guide';
+  var HELM_FONTS = 'https://fonts.googleapis.com/css2?family=Barlow+Condensed:wght@400;500;600&family=Barlow:wght@400;500&display=swap';
+  var SIGN_UP = 'Sign up and get started';
+
+  // Every sentence the scene says on its own. The guide's replies are the server's.
+  var COPY = {
+    fallback: 'The guide is resting right now. You can still start your project.',
+    lost: 'This chat has ended. You can still start your project.',
+    failed: 'That did not send. Try again.',
+    planFailed: 'Your plan did not come through. Try again.',
+    tooEarly: 'Tell the guide a little about your project first.',
+    empty: 'Type a message first.',
+    tooLong: function (n) { return 'That is too long. Keep it under ' + n + ' characters.'; },
+    tooFast: function (s) { return 'Too quick. Try again in ' + s + (s === 1 ? ' second.' : ' seconds.'); },
+    left: function (left, total) {
+      if (left <= 0) return 'No messages left';
+      return left + ' of ' + total + (total === 1 ? ' message left' : ' messages left');
+    },
+    waitTalk: 'Your guide is thinking',
+    waitPlan: 'Your guide is writing your plan',
+  };
+
+  /* ── is the guide on for this page? The module set the server injected. ── */
+  function guideOn(mods) {
+    return !!(mods && mods.enabled && mods.enabled[MODULE_KEY] === true);
+  }
+
+  /* ── the plan, read leniently. The server's Plan (modules/front-door-guide/plan.js) is
+     { summary, project_type, how_it_works[], modules[{label, summary, why}], steps[{title,
+     detail}], needs[{item, detail}], open_questions[], cost_and_time }: each list becomes a
+     section under its own heading, in that order. Anything else it carries is read as text
+     where it can be and dropped where it cannot; no plan at all is null. ── */
+  var SECTIONS = [
+    ['how_it_works', 'How it works'],
+    ['steps', 'Steps'],
+    ['modules', 'Modules to start with'],
+    ['needs', 'You will need'],
+    ['open_questions', 'Still to decide'],
+  ];
+  function asText(v) {
+    if (typeof v === 'string') return v.trim();
+    if (typeof v === 'number') return String(v);
+    if (v && typeof v === 'object') {
+      var head = [v.title, v.label, v.item, v.name, v.heading].filter(function (s) { return typeof s === 'string' && s.trim(); })[0];
+      var body = [v.why, v.detail, v.text, v.summary, v.description].filter(function (s) { return typeof s === 'string' && s.trim(); })[0];
+      return [head, body].filter(Boolean).map(function (s) { return s.trim(); }).join(': ');
+    }
+    return '';
+  }
+  function asItems(arr) {
+    return (Array.isArray(arr) ? arr : []).map(asText).filter(Boolean).slice(0, 12);
+  }
+  function readPlan(raw) {
+    if (raw == null) return null;
+    if (typeof raw === 'string') return raw.trim() ? { summary: raw.trim(), sections: [], note: '' } : null;
+    if (typeof raw !== 'object' || Array.isArray(raw)) return null;
+    var plan = { summary: asText(raw.summary || ''), sections: [], note: typeof raw.cost_and_time === 'string' ? raw.cost_and_time.trim() : '' };
+    var seen = {};
+    SECTIONS.forEach(function (s) {
+      seen[s[0]] = true;
+      var its = asItems(raw[s[0]]);
+      if (its.length) plan.sections.push({ heading: s[1], items: its });
+    });
+    Object.keys(raw).forEach(function (k) {
+      if (seen[k] || !Array.isArray(raw[k])) return;
+      var its = asItems(raw[k]);
+      if (its.length) plan.sections.push({ heading: '', items: its });
+    });
+    return plan.summary || plan.sections.length ? plan : null;
+  }
+
+  /* ── the state machine. One state object; every event returns a new one. ──
+     phase: closed · starting · chat · sending · planning · ended · fallback
+     A chat that has ended with no plan yet (the plan call failed, or a resumed chat never
+     asked) is 'ended' with plan null: the end strip then offers "Make my plan" again. */
+  function initial() {
+    return { phase: 'closed', messages: [], left: 0, total: 0, maxChars: 1000, plan: null, error: '', fallback: '', conv: null, startedAt: 0, restore: '', saved: '', next: SIGN_UP, sent: 0 };
+  }
+  function copyState(s) {
+    var n = {};
+    Object.keys(s).forEach(function (k) { n[k] = s[k]; });
+    n.messages = s.messages.slice();
+    return n;
+  }
+  function conversationCounts(n, c) {
+    if (!c || typeof c !== 'object') return;
+    if (typeof c.messages_left === 'number') n.left = Math.max(0, c.messages_left);
+    if (typeof c.messages_used === 'number') n.sent = c.messages_used;
+    if (typeof c.messages_used === 'number' && typeof c.messages_left === 'number') n.total = Math.max(n.total, c.messages_used + c.messages_left);
+    if (typeof c.max_message_chars === 'number') n.maxChars = c.max_message_chars;
+  }
+  function takeExtras(n, b) {
+    if (b.saved && typeof b.saved.message === 'string' && b.saved.message) n.saved = b.saved.message;
+    if (b.next && typeof b.next.label === 'string' && b.next.label) n.next = b.next.label;
+    var p = readPlan(b.plan);
+    if (p) n.plan = p;
+  }
+  function toFallback(n, message) {
+    n.phase = 'fallback';
+    n.fallback = message || COPY.fallback;
+    n.error = '';
+    n.restore = '';
+    return n;
+  }
+  function dropLastVisitor(n) {
+    for (var i = n.messages.length - 1; i >= 0; i--) {
+      if (n.messages[i].role === 'visitor') { n.restore = n.messages[i].text; n.messages.splice(i, 1); n.sent = Math.max(0, n.sent - 1); return; }
+    }
+  }
+  function errCode(body) {
+    return body && (body.error && typeof body.error === 'object' ? body.error.code : body.error || body.code);
+  }
+  function reduce(state, ev) {
+    var n = copyState(state || initial());
+    n.restore = '';
+    var b = (ev && ev.body) || {};
+    var ok = ev && ev.status >= 200 && ev.status < 300;
+    switch (ev && ev.type) {
+      case 'start':
+        n.phase = 'starting';
+        n.error = '';
+        return n;
+      case 'started':
+        if (ok && b.mode === 'chat' && b.conversation && b.conversation.id && b.conversation.token) {
+          n.phase = 'chat';
+          n.conv = { id: String(b.conversation.id), token: String(b.conversation.token) };
+          n.startedAt = ev.now || 0;
+          n.total = 0;
+          conversationCounts(n, b.conversation);
+          n.messages = typeof b.greeting === 'string' && b.greeting ? [{ role: 'guide', text: b.greeting }] : [];
+          takeExtras(n, b);
+          return n;
+        }
+        return toFallback(n, b.mode === 'form' ? b.message : '');
+      case 'resumed': {
+        // GET /conversations/:id on load: the transcript (no greeting), the plan if written
+        if (!ok || !b.conversation || !Array.isArray(b.transcript)) return initial();
+        n.conv = ev.conv;
+        n.total = 0;
+        conversationCounts(n, b.conversation);
+        n.messages = b.transcript
+          .filter(function (m) { return m && typeof m.text === 'string' && (m.role === 'visitor' || m.role === 'guide'); })
+          .map(function (m) { return { role: m.role, text: m.text }; });
+        n.sent = Math.max(n.sent, n.messages.filter(function (m) { return m.role === 'visitor'; }).length);
+        takeExtras(n, b);
+        n.phase = b.conversation.status === 'ended' || n.plan ? 'ended' : 'chat';
+        // a resumed chat with nothing said yet is new enough for the bot check to apply
+        n.startedAt = n.sent ? 0 : (ev.now || 0);
+        return n;
+      }
+      case 'send':
+        n.phase = 'sending';
+        n.error = '';
+        n.sent += 1;
+        n.messages.push({ role: 'visitor', text: ev.text });
+        return n;
+      case 'answer': {
+        if (ok) {
+          takeExtras(n, b);
+          if (b.mode === 'chat') {
+            if (b.reply && typeof b.reply.text === 'string') n.messages.push({ role: 'guide', text: b.reply.text });
+            conversationCounts(n, b.conversation);
+            n.phase = n.left > 0 ? 'chat' : 'planning';
+            return n;
+          }
+          if (b.mode === 'ended') {
+            if (b.reply && typeof b.reply.text === 'string') n.messages.push({ role: 'guide', text: b.reply.text });
+            conversationCounts(n, b.conversation);
+            n.left = 0;
+            if (typeof b.message === 'string' && b.message) n.messages.push({ role: 'note', text: b.message });
+            // next_step 'plan': ask for it now; 'sign_up': it already exists
+            n.phase = b.next_step === 'sign_up' && n.plan ? 'ended' : 'planning';
+            return n;
+          }
+          return toFallback(n, b.mode === 'form' ? b.message : '');
+        }
+        var code = errCode(b);
+        if (ev.status === 404) return toFallback(n, COPY.lost);
+        dropLastVisitor(n);
+        n.phase = 'chat';
+        if (ev.status === 400 && code === 'too_long') {
+          n.maxChars = Number(b.max_message_chars) || n.maxChars;
+          n.error = COPY.tooLong(n.maxChars);
+        } else if (ev.status === 400 && code === 'empty') {
+          n.error = COPY.empty;
+        } else if (ev.status === 429) {
+          n.error = COPY.tooFast(Math.max(1, Math.ceil(Number(b.retry_after_seconds) || 5)));
+        } else {
+          n.error = COPY.failed;
+        }
+        return n;
+      }
+      case 'failed':
+        dropLastVisitor(n);
+        n.phase = n.conv ? 'chat' : 'fallback';
+        if (n.phase === 'fallback') n.fallback = COPY.fallback;
+        else n.error = COPY.failed;
+        return n;
+      case 'plan':
+        n.phase = 'planning';
+        n.error = '';
+        return n;
+      case 'planned': {
+        if (ok && b.mode === 'plan') {
+          takeExtras(n, b);
+          conversationCounts(n, b.conversation);
+          n.left = 0;
+          n.phase = 'ended';
+          return n;
+        }
+        if (ok && b.mode === 'form') return toFallback(n, b.message);
+        if (ev.status === 404) return toFallback(n, COPY.lost);
+        if (ev.status === 409 && errCode(b) === 'too_early') { n.phase = 'chat'; n.error = COPY.tooEarly; return n; }
+        // anything else: the chat is over but the plan can be asked for again
+        n.phase = 'ended';
+        n.error = ev.status === 429 ? COPY.tooFast(Math.max(1, Math.ceil(Number(b.retry_after_seconds) || 5))) : COPY.planFailed;
+        return n;
+      }
+      default:
+        return n;
+    }
+  }
+
+  // how long the first send must still wait (0 once the bot check is behind us)
+  function firstSendWait(state, now) {
+    if (state.sent || !state.startedAt) return 0;
+    return Math.max(0, state.startedAt + MIN_FIRST_MS - now);
+  }
+
+  function readStore(win) {
+    try {
+      var raw = JSON.parse(win.localStorage.getItem(STORE_KEY) || 'null');
+      return raw && typeof raw.id === 'string' && typeof raw.token === 'string' ? raw : null;
+    } catch (e) { return null; }
+  }
+  function writeStore(win, conv) {
+    try {
+      if (conv) win.localStorage.setItem(STORE_KEY, JSON.stringify({ id: conv.id, token: conv.token }));
+      else win.localStorage.removeItem(STORE_KEY);
+    } catch (e) { /* storage off: the chat still works, it just does not come back */ }
+  }
+
+  /* ──────────────────────────── the DOM half ──────────────────────────── */
+  function boot(win, doc) {
+    var scene = doc.getElementById('guide');
+    if (!scene || !guideOn(win.__MODULES__)) return;
+    var $ = function (name) { return scene.querySelector('[data-gd="' + name + '"]'); };
+    var log = $('log'), err = $('err'), form = $('form'), text = $('text'), hp = $('website');
+    var send = $('send'), end = $('end'), go = $('go'), left = $('left'), segs = $('segs');
+    var planBody = $('plan-body'), planToggle = $('plan-toggle'), planClose = $('plan-close');
+    var makePlan = $('make-plan'), againPlan = $('plan-again'), saved = $('saved');
+    var state = initial();
+    var chatOK = false;      // the status read said 'chat'
+    var opener = null;
+    var limits = null;
+
+    function json(method, url, body, headers) {
+      var h = { accept: 'application/json' };
+      if (body) h['content-type'] = 'application/json';
+      Object.keys(headers || {}).forEach(function (k) { h[k] = headers[k]; });
+      return win.fetch(url, { method: method, credentials: 'same-origin', headers: h, body: body ? JSON.stringify(body) : undefined })
+        .then(function (res) {
+          return res.json().then(function (b) { return { status: res.status, body: b || {} }; }, function () { return { status: res.status, body: {} }; });
+        });
+    }
+    function convUrl(suffix) { return API + '/conversations/' + encodeURIComponent(state.conv.id) + (suffix || ''); }
+
+    // ask once, on load, whether the guide can talk: a click must never wait on it
+    json('GET', API + '/status').then(function (r) {
+      chatOK = r.status === 200 && r.body.mode === 'chat';
+      limits = r.body.limits;
+    }, function () { chatOK = false; });
+    // and pick up a chat this browser already holds
+    var held = readStore(win);
+    if (held) {
+      json('GET', API + '/conversations/' + encodeURIComponent(held.id), null, { 'x-guide-token': held.token }).then(function (r) {
+        if (state.phase !== 'closed') return;
+        if (r.status === 404 || r.status === 400) { writeStore(win, null); return; }
+        state = reduce(state, { type: 'resumed', status: r.status, body: r.body, conv: held, now: Date.now() });
+        // a held chat can always be shown, even once the day's budget says 'form'
+        if (state.conv) chatOK = true;
+      }, function () { /* offline: a click starts fresh or falls back */ });
+    }
+
+    function el(tag, cls, txt) {
+      var e = doc.createElement(tag);
+      if (cls) e.className = cls;
+      if (txt != null) e.textContent = txt;
+      return e;
+    }
+    function clear(node) { while (node.firstChild) node.removeChild(node.firstChild); }
+
+    function waitLine(words) {
+      var wait = el('li', 'gd__msg gd__msg--guide gd__msg--wait');
+      wait.appendChild(el('span', 'gd__who', 'Guide'));
+      var p = el('p', 'gd__words');
+      p.appendChild(el('span', 'vh', words));
+      for (var i = 0; i < 3; i++) { var d = el('span', 'gd__dot'); d.setAttribute('aria-hidden', 'true'); p.appendChild(d); }
+      wait.appendChild(p);
+      return wait;
+    }
+    function paintLog() {
+      clear(log);
+      state.messages.forEach(function (m) {
+        var li = el('li', 'gd__msg gd__msg--' + m.role);
+        if (m.role !== 'note') li.appendChild(el('span', 'gd__who', m.role === 'guide' ? 'Guide' : 'You'));
+        li.appendChild(el('p', 'gd__words', m.text));
+        log.appendChild(li);
+      });
+      if (state.phase === 'starting' || state.phase === 'sending') log.appendChild(waitLine(COPY.waitTalk));
+      if (state.phase === 'planning') log.appendChild(waitLine(COPY.waitPlan));
+      if (state.phase === 'fallback') {
+        var fb = el('li', 'gd__msg gd__msg--guide');
+        fb.appendChild(el('span', 'gd__who', 'Guide'));
+        fb.appendChild(el('p', 'gd__words', state.fallback));
+        log.appendChild(fb);
+      }
+      log.scrollTop = log.scrollHeight;
+    }
+
+    function paintCount() {
+      var total = state.total || (limits && limits.max_messages) || 0;
+      var shown = state.phase !== 'fallback' && state.phase !== 'starting' && total > 0;
+      left.hidden = !shown;
+      segs.hidden = !shown;
+      if (!shown) return;
+      left.textContent = COPY.left(state.left, total);
+      clear(segs);
+      for (var i = 0; i < total; i++) segs.appendChild(el('span', 'gd__seg' + (i < total - state.left ? ' gd__seg--used' : '')));
+    }
+
+    function paintPlan() {
+      clear(planBody);
+      var plan = state.plan;
+      if (!plan) {
+        var wait = state.phase === 'planning' ? 'Your guide is writing your plan.'
+          : state.phase === 'ended' ? 'No plan yet.'
+          : state.phase === 'fallback' ? 'No plan to show.'
+          : 'When the chat ends, your guide writes your plan here.';
+        planBody.appendChild(el('p', 'gd__planwait', wait));
+      } else {
+        if (plan.summary) planBody.appendChild(el('p', 'gd__plansum', plan.summary));
+        plan.sections.forEach(function (s) {
+          if (s.heading) planBody.appendChild(el('p', 'gd__planh4', s.heading));
+          var ul = el('ul', 'gd__planlist');
+          s.items.forEach(function (t) { ul.appendChild(el('li', null, t)); });
+          planBody.appendChild(ul);
+        });
+        if (plan.note) planBody.appendChild(el('p', 'gd__plannote', plan.note));
+      }
+      saved.textContent = state.saved;
+      saved.hidden = !state.saved || state.phase === 'fallback';
+    }
+
+    function paint() {
+      scene.setAttribute('data-phase', state.phase);
+      paintLog();
+      paintCount();
+      paintPlan();
+      var talking = state.phase === 'chat' || state.phase === 'sending' || state.phase === 'starting';
+      form.hidden = !talking;
+      end.hidden = talking;
+      text.disabled = state.phase !== 'chat';
+      send.disabled = state.phase !== 'chat';
+      makePlan.hidden = !(state.phase === 'chat' && state.sent > 0);
+      againPlan.hidden = !(state.phase === 'ended' && !state.plan && state.conv);
+      go.hidden = state.phase === 'planning';
+      text.maxLength = state.maxChars;
+      err.hidden = !state.error;
+      err.textContent = state.error;
+      go.textContent = state.phase === 'fallback' ? 'Start a project' : state.next;
+      if (state.restore && !text.value) text.value = state.restore;
+      scene.classList.toggle('gd--done', state.phase === 'ended' && !!state.plan);
+    }
+
+    function dispatch(ev) {
+      state = reduce(state, ev);
+      if (ev.type === 'started' && state.conv) writeStore(win, state.conv);
+      if (state.phase === 'fallback' && (ev.status === 404)) writeStore(win, null);
+      paint();
+      if (state.phase === 'planning' && ev.type !== 'plan') askPlan();
+    }
+
+    /* the Helm faces: loaded the first time the scene opens, never on a plain visit */
+    function loadFaces() {
+      if (doc.querySelector('link[data-gd-faces]')) return;
+      var l = doc.createElement('link');
+      l.rel = 'stylesheet';
+      l.href = HELM_FONTS;
+      l.setAttribute('data-gd-faces', '');
+      doc.head.appendChild(l);
+    }
+
+    function focusables() {
+      return Array.prototype.filter.call(
+        scene.querySelectorAll('a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]):not([tabindex="-1"])'),
+        function (n) { return n.offsetParent !== null; });
+    }
+
+    function open(door) {
+      opener = door;
+      loadFaces();
+      scene.hidden = false;
+      doc.documentElement.classList.add('gd-open');
+      if (state.phase === 'closed') {
+        dispatch({ type: 'start' });
+        json('POST', API + '/conversations', { website: hp.value }).then(function (r) {
+          dispatch({ type: 'started', status: r.status, body: r.body, now: Date.now() });
+          focusFirst();
+        }, function () {
+          dispatch({ type: 'started', status: 0, body: {} });
+          focusFirst();
+        });
+      } else {
+        paint();
+      }
+      focusFirst();
+    }
+    function focusFirst() {
+      if (scene.hidden) return;
+      var target = !text.disabled && !form.hidden ? text : (!end.hidden && !go.hidden ? go : $('close'));
+      try { target.focus(); } catch (e) { /* not focusable yet */ }
+    }
+    function close() {
+      scene.hidden = true;
+      setPlan(false);
+      doc.documentElement.classList.remove('gd-open');
+      if (opener) { try { opener.focus(); } catch (e) { /* gone */ } }
+    }
+    function setPlan(on) {
+      scene.classList.toggle('gd--plan', !!on);
+      planToggle.setAttribute('aria-expanded', on ? 'true' : 'false');
+      if (on) { try { planClose.focus(); } catch (e) { /* hidden */ } }
+    }
+
+    function submit() {
+      if (state.phase !== 'chat') return;
+      var words = text.value.trim();
+      if (!words) { state.error = COPY.empty; paint(); return; }
+      var wait = firstSendWait(state, Date.now());
+      var conv = state.conv;
+      text.value = '';
+      dispatch({ type: 'send', text: words });
+      win.setTimeout(function () {
+        json('POST', API + '/conversations/' + encodeURIComponent(conv.id) + '/messages', { token: conv.token, text: words, website: hp.value })
+          .then(function (r) { dispatch({ type: 'answer', status: r.status, body: r.body }); },
+                function () { dispatch({ type: 'failed' }); })
+          .then(focusFirst);
+      }, wait);
+    }
+
+    // the plan: asked for once the chat ends (or the visitor presses "Make my plan");
+    // the server writes it once and re-reads it for free after that
+    var asking = false;
+    function askPlan() {
+      if (asking || !state.conv) return;
+      asking = true;
+      if (state.phase !== 'planning') dispatch({ type: 'plan' });
+      json('POST', convUrl('/plan'), { token: state.conv.token, website: hp.value })
+        .then(function (r) { asking = false; dispatch({ type: 'planned', status: r.status, body: r.body }); },
+              function () { asking = false; dispatch({ type: 'planned', status: 0, body: {} }); })
+        .then(function () {
+          focusFirst();
+          // one column: the plan is the reward, so it opens by itself
+          if (state.plan && planToggle.offsetParent !== null) setPlan(true);
+        });
+    }
+
+    /* the doors: a click is the guide only when everything says it can talk */
+    doc.addEventListener('click', function (e) {
+      var door = e.target && e.target.closest && e.target.closest('[data-guide-door]');
+      if (!door || !chatOK || e.defaultPrevented || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+      e.preventDefault();
+      open(door);
+    });
+
+    form.addEventListener('submit', function (e) { e.preventDefault(); submit(); });
+    text.addEventListener('keydown', function (e) {
+      if (e.key === 'Enter' && !e.shiftKey && !e.isComposing) { e.preventDefault(); submit(); }
+    });
+    makePlan.addEventListener('click', askPlan);
+    againPlan.addEventListener('click', askPlan);
+    $('close').addEventListener('click', close);
+    planToggle.addEventListener('click', function () { setPlan(planToggle.getAttribute('aria-expanded') !== 'true'); });
+    planClose.addEventListener('click', function () { setPlan(false); try { planToggle.focus(); } catch (e) { /* hidden */ } });
+    scene.addEventListener('click', function (e) { if (e.target === scene) close(); });
+    scene.addEventListener('keydown', function (e) {
+      if (e.key === 'Escape') {
+        e.preventDefault();
+        if (scene.classList.contains('gd--plan')) { setPlan(false); try { planToggle.focus(); } catch (x) { /* hidden */ } }
+        else close();
+        return;
+      }
+      if (e.key !== 'Tab') return;
+      var f = focusables();
+      if (!f.length) return;
+      var first = f[0], last = f[f.length - 1];
+      if (e.shiftKey && doc.activeElement === first) { e.preventDefault(); last.focus(); }
+      else if (!e.shiftKey && doc.activeElement === last) { e.preventDefault(); first.focus(); }
+    });
+    var face = scene.querySelector('.gd__face img');
+    if (face) face.addEventListener('error', function () { face.hidden = true; });
+  }
+
+  return {
+    API: API,
+    MIN_FIRST_MS: MIN_FIRST_MS,
+    STORE_KEY: STORE_KEY,
+    COPY: COPY,
+    guideOn: guideOn,
+    readPlan: readPlan,
+    initial: initial,
+    reduce: reduce,
+    firstSendWait: firstSendWait,
+    boot: boot,
+  };
+});