@simon-says-build/demo-player 0.10.0 → 0.12.0

package/index.d.ts

@@ -30,7 +30,11 @@ export const PLAYER_VERSION: string;
 /** The changes a demo's last card offers to approve or discuss: one per `job:<id>` feature. */
 export function reviewChangesOf(demo: unknown): { jobId: string; title: string }[];
 /** A release's demo (0.4.0): the session merge its review card releases, or null. */
-export function releaseOf(demo: unknown): { jobId: string; label: string; note: string } | null;
+export function releaseOf(demo: unknown): { jobId: string; label: string; note: string; reviews: ReleaseReviews } | null;
+/** A release's review requests (0.11.0), read for the demo's person. */
+export type ReleaseReviewRequest = { to: string; by: string; status: 'pending' | 'approved' | 'discussed' | 'withdrawn'; at?: string; note?: string; decisionNote?: string; revisedAt?: string; release?: boolean };
+export type ReleaseReviews = { mode: 'off' | 'optional' | 'required'; requests: ReleaseReviewRequest[]; mine: ReleaseReviewRequest | null; waiting: string[]; candidates: string[]; canAsk: boolean; mustAsk: boolean; last: boolean };
+export function releaseReviewsOf(demo: unknown): ReleaseReviews;
 
 /**
  * React Navigation (an app without expo-router): a path is the chain of route

package/index.js

@@ -1,3 +1,3 @@
 export { DemoHost } from './src/DemoHost.js';
-export { demoConfig, findTarget, handlerFor, phoneSteps, scalePoint, playDemo, currentDemo, onDemo, reviewChangesOf, releaseOf, PLAYER_VERSION } from './src/core.js';
+export { demoConfig, findTarget, handlerFor, phoneSteps, scalePoint, playDemo, currentDemo, onDemo, reviewChangesOf, releaseOf, releaseReviewsOf, PLAYER_VERSION } from './src/core.js';
 export { navigationRoute, navigationRouter, navigateArgs, pathOfState } from './src/navigation.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simon-says-build/demo-player",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "SimonSays mobile demo player: walks a preview's viewer through a job's change, inside the app. Renders nothing unless the bundle carries a demo.",
   "repository": {
     "type": "git",

package/src/DemoHost.js

@@ -13,12 +13,13 @@
 //
 // No JSX, so it needs nothing from the app's Babel setup beyond React Native's.
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { Linking, Pressable, ScrollView, StyleSheet, Text, TextInput, View, useWindowDimensions } from 'react-native';
+import { Linking, NativeModules, Pressable, ScrollView, StyleSheet, Text, TextInput, View, useWindowDimensions } from 'react-native';
 import { pageName } from './page-name.js';
 import { OVERLAY_ID, cardBox, currentDemo, demoConfig, findTarget, handlerFor, introBody, introOf, onDemo, phoneSteps, playDemo, releaseOf, reviewChangesOf, scalePoint, rescueNote, screenCandidates, stepTitle, targetOfKey } from './core.js';
 import { demoApi, tourOf } from './api.js';
 import { signInFirst, openInApp } from './signin.js';
 import { runEvent, fillStep } from './events.js';
+import { nativeRuntime, buildGap, needLinks, openNeed, staleBody } from './build-gate.js';
 
 const h = React.createElement;
 const FIND_FOR_MS = 8000;      // a step's element may appear after a navigation settles
@@ -83,11 +84,25 @@ function Player({ config, router, insets, onClose, children }) {
   const [flash, setFlash] = useState(null);       // "Now navigating to the walk page", said before a goto opens it
   const [rescued, setRescued] = useState(null);   // { for: index, status: asking|moved|gone, target?, why? }
   const asked = useRef(new Set());                // steps already rescued once (by index)
+  const [stale, setStale] = useState(null);       // { gap, links, appName }: this dev build is not the review's (build-gate.js)
 
   useEffect(() => {
     let live = true;
     api.load()
-      .then((d) => { if (live) { setSteps(phoneSteps(tourOf(d, { here: !!config.here })).concat()); setChanges(reviewChangesOf(d)); setRelease(releaseOf(d)); setIntro(introOf(d)); } })
+      .then((d) => {
+        if (!live) return;
+        // THE BUILD FIRST (0.12.0): a review made for another native build of
+        // this dev app never starts here — the person is sent to install the
+        // right one (build-gate.js). Nothing else runs: no sign-in, no steps.
+        const gap = config.here ? null : buildGap(d, nativeRuntime(globalThis.expo?.modules, NativeModules));
+        if (gap) {
+          const links = needLinks({ demo: d, gap, demoId: config.id, token: config.token });
+          setStale({ gap, links, appName: d.projectName || d.appName || 'the app' });
+          openNeed(links, (u) => Linking.openURL(u));
+          return;
+        }
+        setSteps(phoneSteps(tourOf(d, { here: !!config.here })).concat()); setChanges(reviewChangesOf(d)); setRelease(releaseOf(d)); setIntro(introOf(d));
+      })
       .catch((e) => { if (live) setError(e.message); });
     return () => { live = false; };
   }, [api]);
@@ -184,7 +199,8 @@ function Player({ config, router, insets, onClose, children }) {
 
   // AND NOW… (an `event` step, 0.8.0): SSB runs the helper on the copy; its
   // outputs fill `{name}` in this person's later steps. A failure stays on the
-  // card, said, with Next; never a silent skip.
+  // card, said, with Try again (0.12.0: never Next — what follows depends on it).
+  const [eventTry, setEventTry] = useState(0);
   useEffect(() => {
     setEvent(null);
     if (step?.kind !== 'event' || done) return undefined;
@@ -197,11 +213,13 @@ function Player({ config, router, insets, onClose, children }) {
       else setIndex(index + 1);
     });
     return () => { live = false; };
-  }, [step?.kind, step?.helper, index, done]);
+  }, [step?.kind, step?.helper, index, done, eventTry]);
 
   // SIGN THIS PERSON IN FIRST (a `signin` step, tourOf): open the link, let
   // the app sign in and route, then start their part on that screen. A link
-  // that can't be had or opened leaves the card saying who to be (stage 1).
+  // that can't be had or opened, or a sign-in whose first screen never comes
+  // up, stops the tour with Try again (0.12.0).
+  const [signInTry, setSignInTry] = useState(0);  // "Try again" re-runs the sign-in
   useEffect(() => {
     setSignIn(null);
     if (step?.kind !== 'signin' || done) return undefined;
@@ -217,10 +235,16 @@ function Player({ config, router, insets, onClose, children }) {
       else setIndex(index + 1);
     });
     return () => { live = false; };
-  }, [step, done]);
+  }, [step, done, signInTry]);
 
   const overlay = (() => {
     if (error) return h(Card, { at: null, screen, insets, card, setCard, title: 'Demo', body: `The demo didn't load: ${error}` });
+    if (stale) {
+      return h(Card, {
+        at: null, screen, insets, card, setCard, title: 'Guided Review', body: staleBody(stale.gap, stale.appName),
+        actions: [{ label: 'Open SimonSays', onPress: () => openNeed(stale.links, (u) => Linking.openURL(u)), primary: true }],
+      });
+    }
     if (!steps) return null;
     if (intro && !tucked && !done) {
       return h(Card, {
@@ -241,18 +265,22 @@ function Player({ config, router, insets, onClose, children }) {
     }
     if (!step && changes.length) return h(Review, { api, changes, release, screen, insets, onBack: null, onDone: finish, onHide: () => setTucked(true) });
     if (!step) return h(Card, { at: null, screen, insets, card, setCard, title: 'Demo', body: 'This demo has no steps a phone can play.' });
+    // A FAILED SETUP OR SIGN-IN STOPS THE TOUR (0.12.0, Michael 2026-11-05:
+    // "the tour is theoretically continuable… we need a way to make the tour
+    // aware that an important step failed"). What follows depends on it, so
+    // there is no Next: Try again, or Hide.
     if (step.kind === 'event') {
       return h(Card, {
         at: null, screen, insets, card, setCard, title: `${index + 1} of ${steps.length}`,
-        body: event ? `The demo couldn't set this up: ${event.error}` : step.caption,
-        actions: event ? [{ label: 'Hide', onPress: () => setTucked(true) }, { label: 'Next', onPress: next, primary: true }] : [],
+        body: event ? `The review couldn't set this up, and the rest of it depends on it: ${event.error}` : step.caption,
+        actions: event ? [{ label: 'Hide', onPress: () => setTucked(true) }, { label: 'Try again', onPress: () => setEventTry((n) => n + 1), primary: true }] : [],
       });
     }
     if (step.kind === 'signin') {
       return h(Card, {
         at: null, screen, insets, card, setCard, title: `${index + 1} of ${steps.length}`,
-        body: signIn ? step.fallback : step.caption,
-        actions: signIn ? [{ label: 'Hide', onPress: () => setTucked(true) }, { label: 'Next', onPress: next, primary: true }] : [],
+        body: signIn ? `SSB couldn't sign you in, and the review needs it: ${signIn.error}.` : step.caption,
+        actions: signIn ? [{ label: 'Hide', onPress: () => setTucked(true) }, { label: 'Try again', onPress: () => setSignInTry((n) => n + 1), primary: true }] : [],
       });
     }
     const canDo = (step.kind === 'click' || step.kind === 'fill') && found && (step.kind === 'click' ? handlerFor(found, 'onPress') : handlerFor(found, 'onChangeText'));
@@ -301,11 +329,66 @@ function Review({ api, changes, release, screen, insets, onBack, onDone, onHide
     api.discuss(id, text).then(() => set(id, { state: 'sent' })).catch((e) => set(id, { state: 'discussing', error: e.message }));
   };
   const left = release ? 0 : changes.filter((c) => !['approved', 'sent'].includes(rows[c.jobId]?.state)).length;
+  // REVIEW REQUESTS (0.11.0, docs/REVIEW-REQUESTS.md): asked to review it, the
+  // person answers here — Approve, or Discuss with a note, which holds the
+  // release until it is revised; otherwise they may approve and ask someone
+  // else first. `rq.state`: idle | picking | asking | discussing | sending | done.
+  const rv = release?.reviews || null;
+  const [rq, setRq] = useState({ state: 'idle', picked: [], note: '', error: null, said: '' });
+  const rqSet = (patch) => setRq((r) => ({ ...r, ...patch }));
+  const answer = (decision) => {
+    rqSet({ state: 'sending', error: null });
+    api.answerReview(decision, decision === 'discuss' ? rq.note.trim() : '')
+      .then((r) => rqSet({ state: 'done', said: decision === 'discuss' ? 'Sent — it waits for the revision and your approval.' : r?.released ? 'Approved — it is releasing now.' : r?.waiting ? `Approved. ${r.waiting}` : 'Approved.' }))
+      .catch((e) => rqSet({ state: decision === 'discuss' ? 'discussing' : 'idle', error: e.message }));
+  };
+  const askFor = () => {
+    if (!rq.picked.length) return;
+    rqSet({ state: 'sending', error: null });
+    api.approveAndAsk(rq.picked, rq.note.trim())
+      .then(() => rqSet({ state: 'done', said: `Approved — it goes live once ${rq.picked.join(', ')} ${rq.picked.length === 1 ? 'approves' : 'approve'}.` }))
+      .catch((e) => rqSet({ state: 'picking', error: e.message }));
+  };
+  const toggle = (e) => rqSet({ picked: rq.picked.includes(e) ? rq.picked.filter((x) => x !== e) : [...rq.picked, e] });
+  const reviewsBlock = !rv ? null : rq.state === 'done' ? h(Text, { style: s.changeState, testID: 'ssb-review-request-done' }, rq.said)
+    : rv.mine ? h(View, { style: s.change, testID: 'ssb-review-mine' },
+      h(Text, { style: s.changeTitle }, `${rv.mine.by} asked you to review this release.`),
+      rv.mine.note ? h(Text, { style: s.body }, `“${rv.mine.note}”`) : null,
+      rv.mine.status === 'discussed' && rv.mine.revisedAt ? h(Text, { style: s.body }, 'It was revised since you asked for changes.') : null,
+      rq.state === 'discussing' || (rq.state === 'sending' && rq.note) ? h(View, null,
+        h(TextInput, { style: s.input, value: rq.note, onChangeText: (note) => rqSet({ note }), placeholder: 'What should change before it goes live?', placeholderTextColor: '#8E8E93', multiline: true, autoFocus: true, accessibilityLabel: 'What should change before it goes live', testID: 'ssb-review-discuss-note' }),
+        h(View, { style: s.actions }, button('Cancel', () => rqSet({ state: 'idle', note: '' })), button(rq.state === 'sending' ? 'Sending…' : 'Send', rq.note.trim() && rq.state !== 'sending' ? () => answer('discuss') : () => {}, true))) : null)
+    : rv.waiting.length ? h(Text, { style: s.body, testID: 'ssb-review-waiting' }, `Waiting on ${rv.waiting.join(', ')}'s review before it goes live.`)
+    : rq.state === 'picking' || (rq.state === 'sending' && rq.picked.length) ? h(View, { style: s.change, testID: 'ssb-review-ask' },
+      h(Text, { style: s.changeTitle }, 'Request a review from…'),
+      ...rv.candidates.map((e) => h(Pressable, { key: e, onPress: () => toggle(e), accessibilityRole: 'checkbox', accessibilityState: { checked: rq.picked.includes(e) }, accessibilityLabel: e, style: s.pick },
+        h(Text, { style: s.body }, `${rq.picked.includes(e) ? '☑' : '☐'} ${e}`))),
+      h(TextInput, { style: s.input, value: rq.note, onChangeText: (note) => rqSet({ note }), placeholder: 'A note for them (optional)', placeholderTextColor: '#8E8E93', multiline: true, accessibilityLabel: 'A note for the reviewer' }),
+      h(View, { style: s.actions }, button('Cancel', () => rqSet({ state: 'idle', picked: [] })), button(rq.state === 'sending' ? 'Asking…' : 'Approve & ask', rq.picked.length && rq.state !== 'sending' ? askFor : () => {}, true)))
+    : rv.mustAsk ? h(Text, { style: s.body }, 'This project needs a review before every release — request one.') : null;
+  // What the foot's main button does on a release.
+  // What the foot's buttons are on a release, beside Hide (flat: one row).
+  const releaseMain = !release || rel.state === 'released' ? []
+    : rq.state === 'done' ? [button(left ? `Done (${left} undecided)` : 'Done', onDone, true)]
+    : rv?.mine ? (rq.state === 'discussing' ? [] : [
+        button('💬 Discuss', () => rqSet({ state: 'discussing' })),
+        button(rq.state === 'sending' ? 'Approving…' : rv.last ? release.label : 'Approve', rq.state === 'sending' ? () => {} : () => answer('approve'), true)])
+    : rv?.waiting.length ? [button('Done', onDone, true)]
+    : rq.state === 'picking' ? []
+    : [
+        rv?.canAsk ? button('Request a review', () => rqSet({ state: 'picking' }), !!rv?.mustAsk) : null,
+        rv?.mustAsk ? null : button(rel.state === 'releasing' ? 'Approving…' : release.label, rel.state === 'releasing' ? () => {} : doRelease, true),
+      ].filter(Boolean);
+  // The card's lead line, for where the release stands.
+  const lead = !release ? 'Approve what looks right. Anything that should be different, say so — SSB revises it.'
+    : rv?.mine ? 'Approve it, or say what should change — the release waits for your answer.'
+    : rv?.waiting.length ? 'It goes out once the review is in. Anything that should be different, say so — SSB revises it.'
+    : rv?.mustAsk ? 'This project needs a review before it goes out. Anything that should be different, say so — SSB revises it.'
+    : `Happy with it? ${release.label} sends them out together. Anything that should be different, say so — SSB revises it.`;
   return h(View, { style: [s.card, s.review, { top: insets.top + 12, maxHeight: screen.height - insets.top - insets.bottom - 24, maxWidth: screen.width - 32, left: Math.max(16, (screen.width - Math.min(360, screen.width - 32)) / 2) }], testID: 'ssb-demo-review' },
     h(Text, { style: s.title }, release ? (changes.length === 1 ? 'The next release: 1 change' : `The next release: ${changes.length} changes`)
       : changes.length === 1 ? 'Review the change' : `Review ${changes.length} changes`),
-    h(Text, { style: s.body }, release ? `Happy with it? ${release.label} sends them out together. Anything that should be different, say so — SSB revises it.`
-      : 'Approve what looks right. Anything that should be different, say so — SSB revises it.'),
+    h(Text, { style: s.body }, lead),
     h(ScrollView, { style: s.changes, keyboardShouldPersistTaps: 'handled' }, ...changes.map((c) => {
       const r = rows[c.jobId] || {};
       const state = r.state || 'idle';
@@ -318,18 +401,20 @@ function Review({ api, changes, release, screen, insets, onBack, onDone, onHide
           h(View, { style: s.actions },
             button('Cancel', () => set(c.jobId, { state: 'idle', error: null })),
             button('Send', () => send(c.jobId), true))) : null,
-        state === 'idle' ? h(View, { style: s.actions },
+        state === 'idle' && !rv?.mine ? h(View, { style: s.actions },
           button('💬 Discuss', () => set(c.jobId, { state: 'discussing' })),
           release ? null : button('✓ Approve', () => approve(c.jobId), true)) : null);
     })),
+    reviewsBlock,
+    rq.error ? h(Text, { style: s.error }, rq.error) : null,
     release && rel.state === 'released' ? h(Text, { style: s.changeState, testID: 'ssb-release-done' }, 'Approved — it goes out in 5 minutes. Undo it on the release page in SimonSays if you need to.') : null,
     release && rel.error ? h(Text, { style: s.error }, rel.error) : null,
     h(View, { style: [s.actions, s.reviewFoot] },
       button('Hide', onHide),
       onBack ? button('Back', onBack) : null,
-      release && rel.state !== 'released'
-        ? button(rel.state === 'releasing' ? 'Approving…' : release.label, rel.state === 'releasing' ? () => {} : doRelease, true)
-        : button(left ? `Done (${left} undecided)` : 'Done', onDone, !left)));
+      ...(release && rel.state !== 'released'
+        ? releaseMain
+        : [button(left ? `Done (${left} undecided)` : 'Done', onDone, !left)])));
 }
 
 const button = (label, onPress, primary = false) => h(Pressable, {
@@ -373,6 +458,7 @@ const s = StyleSheet.create({
   review: { width: 360 },
   changes: { flexGrow: 0 },
   reviewFoot: { marginTop: 16 },
+  pick: { flexDirection: 'row', paddingVertical: 6 },
   change: { marginTop: 14, paddingTop: 12, borderTopWidth: StyleSheet.hairlineWidth, borderTopColor: '#3A3A3C' },
   changeTitle: { color: '#FFFFFF', fontSize: 15, fontWeight: '600' },
   changeState: { color: '#AEAEB2', fontSize: 13, marginTop: 4 },

package/src/api.js

@@ -23,6 +23,11 @@ export function demoApi({ api, id, token }, fetchImpl = globalThis.fetch) {
     // A release's demo (0.4.0): approve and release the session, as the person
     // the demo was made for, after the five-minute cool-off.
     release: () => call('/release', { method: 'POST', body: '{}' }),
+    // REVIEW REQUESTS (0.11.0, docs/REVIEW-REQUESTS.md): approve and ask others
+    // to review it first (the last approval releases it); or, asked yourself,
+    // answer — approve, or discuss with a note, which holds it until revised.
+    approveAndAsk: (to, note) => call('/approve', { method: 'POST', body: JSON.stringify({ requestReview: { to, ...(note ? { note } : {}), release: true } }) }),
+    answerReview: (decision, note) => call('/review-requests/decide', { method: 'POST', body: JSON.stringify({ decision, ...(note ? { note } : {}) }) }),
     // A phone's private copy (0.6.0): the link that signs this person in.
     signin: (actorIndex) => call('/signin', { method: 'POST', body: JSON.stringify({ actorIndex }) }),
     // A planned review (0.8.0): run a helper on the private copy, then read how it went.

package/src/build-gate.js

@@ -0,0 +1,62 @@
+// THE DEV BUILD MUST MATCH THE REVIEW (0.12.0, docs/TOUR-LINKS.md "6. The
+// bundle checks itself"). Pure, so node --test runs it.
+//
+// A phone review's copy is Metro serving the session's JS, made for ONE native
+// build of the app's dev client: `demo.preview.fingerprint`, the build SSB put
+// in the library for it. A dev client loads whatever JS it is pointed at, so
+// on an older build the review's code ran anyway and failed half-way: Michael's
+// phone (2026-11-05) opened Connie Ho's Profile photos review on a Walk2Gether
+// Dev build older than c316 and its sign-in died "auth/network-request-failed".
+// Every check before that point (the notification's install step, the
+// overlay's ssb-tour gate) was skipped — no install record, a dev-client link.
+//
+// The structural answer is the bundle itself: the player knows what native
+// build the review needs (the demo record) and what native build it is running
+// on (expo-updates' runtimeVersion — under the fingerprint policy, the native
+// fingerprint; the dev builds read it from EXUpdates.bundle/fingerprint). A
+// mismatch never starts the review: it hands the person to the SimonSays app's
+// "need" screen (`simonsays://need?…`, which offers the build SSB made), and
+// the website's /need page when the app is not there. A build that cannot say
+// its runtime, or a review that names none, plays as before.
+
+/** This build's native runtime (expo-updates' runtimeVersion), or null. */
+export function nativeRuntime(mods = globalThis.expo?.modules, nativeModules = {}) {
+  const u = mods?.ExpoUpdates || nativeModules?.ExpoUpdates || {};
+  return typeof u.runtimeVersion === 'string' && u.runtimeVersion && !u.runtimeVersion.startsWith('file:') ? u.runtimeVersion : null;
+}
+
+/** What the review needs that this build is not: null = play it, else { need, have }. */
+export function buildGap(demo, have) {
+  const need = demo?.platform === 'ios' && typeof demo?.preview?.fingerprint === 'string' ? demo.preview.fingerprint : null;
+  if (!need || !have) return null;
+  return need === have ? null : { need, have };
+}
+
+// The dev app's scheme, from the link the copy was opened with
+// (`walk2gether-dev://expo-development-client/?url=…`).
+const schemeOf = (url) => /^([a-z][a-z0-9+.-]*):\/\//i.exec(String(url || ''))?.[1] || undefined;
+const qs = (o) => Object.entries(o).filter(([, v]) => v !== undefined && v !== '').map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join('&');
+
+/**
+ * Where to send the person: the SimonSays app's need screen, else the site's.
+ * The query is schemas/tour-link.mjs needUrl's (test/build-gate.test.mjs holds
+ * them equal): app, scheme, tour, rt, haveRt.
+ */
+export function needLinks({ demo = {}, gap, demoId, token, site = 'https://simonsays.build' }) {
+  const q = qs({
+    app: demo.appId, scheme: schemeOf(demo.preview?.url), tour: demoId && token ? `${demoId}.${token}` : undefined,
+    rt: gap?.need, haveRt: gap?.have || undefined,
+  });
+  return { app: `simonsays://need?${q}`, web: `${site.replace(/\/$/, '')}/need?${q}` };
+}
+
+/** Open the app's need screen, falling through to the site. `openURL` is Linking.openURL. */
+export async function openNeed(links, openURL) {
+  try { await openURL(links.app); return 'app'; } catch { /* no SimonSays app */ }
+  try { await openURL(links.web); return 'web'; } catch { return null; }
+}
+
+/** The card's words. */
+export function staleBody(gap, appName = 'the app') {
+  return `This review needs a newer ${appName} Dev build (it needs ${gap.need.slice(0, 7)}; this phone has ${gap.have.slice(0, 7)}). Opening the SimonSays app to install it.`;
+}

package/src/core.js

@@ -10,7 +10,7 @@ import { bubbleBox } from './step-place.js';
 // What this player is, said when the app registers for "Ready to see"
 // (packages/ssb-overlay sends it; functions/in-app-notify.mjs clientOf). Kept
 // equal to package.json by test/core.test.mjs.
-export const PLAYER_VERSION = '0.10.0';
+export const PLAYER_VERSION = '0.12.0';
 
 export const HOST = 5;
 export const TEXT = 6;
@@ -217,7 +217,32 @@ export function reviewChangesOf(demo) {
 export function releaseOf(demo) {
   const sm = demo?.sessionMerge;
   if (!sm || typeof sm.jobId !== 'string' || !sm.jobId) return null;
-  return { jobId: sm.jobId, label: String(sm.label || 'Approve & release'), note: String(sm.note || '') };
+  return { jobId: sm.jobId, label: String(sm.label || 'Approve & release'), note: String(sm.note || ''), reviews: releaseReviewsOf(demo) };
+}
+
+// REVIEW REQUESTS ON A RELEASE (0.11.0, docs/REVIEW-REQUESTS.md): the demo's
+// `sessionMerge.reviews` (functions/review-requests.mjs releaseReviewsForDemo),
+// read for the person the demo was made for (`createdBy`). Pure.
+//   mine      the request addressed to them that is still theirs to answer, or null
+//   waiting   others whose review it still waits on
+//   canAsk    they may request a review (the setting is not off, someone to ask)
+//   mustAsk   the project requires a review and none is approved: no release without one
+//   last      their approval would be the last one, and a release was asked for
+export function releaseReviewsOf(demo) {
+  const rv = demo?.sessionMerge?.reviews;
+  const me = String(demo?.createdBy || '').trim().toLowerCase();
+  const requests = Array.isArray(rv?.requests) ? rv.requests.filter((r) => r && typeof r.to === 'string') : [];
+  const open = requests.filter((r) => r.status === 'pending' || r.status === 'discussed');
+  const mine = open.find((r) => r.to === me) || null;
+  const waiting = open.filter((r) => r.to !== me).map((r) => r.to);
+  const candidates = (Array.isArray(rv?.candidates) ? rv.candidates : []).filter((e) => typeof e === 'string' && e !== me && !open.some((r) => r.to === e));
+  const mode = rv?.mode === 'off' || rv?.mode === 'required' ? rv.mode : 'optional';
+  return {
+    mode, requests, mine, waiting, candidates,
+    canAsk: mode !== 'off' && candidates.length > 0,
+    mustAsk: mode === 'required' && !requests.some((r) => r.status === 'approved') && !open.length,
+    last: !!mine && waiting.length === 0 && requests.some((r) => r.release),
+  };
 }
 
 // THE FIRST SCREEN OF A REVIEW (0.10.0, Michael 2026-11-03): a very brief

package/src/signin.js

@@ -6,7 +6,7 @@
 // only then starts the tour, on that screen. Pure, so node --test runs it.
 
 const SETTLE_MIN_MS = 1500;   // the app's handler signs in and routes before anything is looked for
-const SETTLE_MAX_MS = 12000;  // then the tour starts anyway: a step finds its own element for 8s more
+const SETTLE_MAX_MS = 12000;  // and then the sign-in has not taken: said, the tour stops (0.12.0)
 const POLL_MS = 250;
 
 const pause = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -38,8 +38,8 @@ export const signsIn = (demo, { here = false } = {}) => !here && demo?.platform
 /**
  * Sign `actorIndex` in, then resolve once the app has settled. `openURL` is
  * Linking.openURL; `settled()` says the first screen is up (its element is
- * found). → { ok: true } | { ok: false, error } (the player falls back to
- * saying who to sign in as).
+ * found). → { ok: true } | { ok: false, error } (the player stops the tour
+ * with Try again).
  */
 export async function signInFirst({ api, actorIndex, openURL, settled = () => true, sleep = pause, minMs = SETTLE_MIN_MS, maxMs = SETTLE_MAX_MS }) {
   let link;
@@ -51,6 +51,12 @@ export async function signInFirst({ api, actorIndex, openURL, settled = () => tr
     return { ok: false, error: e?.message || String(e) };
   }
   await sleep(minMs);
-  for (let waited = minMs; waited < maxMs && !settled(); waited += POLL_MS) await sleep(POLL_MS);
+  let ok = false;
+  for (let waited = minMs; waited < maxMs; waited += POLL_MS) { if ((ok = !!settled())) break; await sleep(POLL_MS); }
+  // CONFIRMED, NOT ASSUMED (0.12.0): the first screen past sign-in never came
+  // up, so the sign-in did not take — the app's own handler failed (2026-11-05:
+  // "Failed to verify token: [auth/network-request-failed]" while the tour
+  // carried on to Next and Take me there). Said, and the tour stops.
+  if (!ok) return { ok: false, error: "the app didn't sign in (its first screen never appeared)" };
   return { ok: true };
 }