synabun 2.0.0-beta → 2.0.5

package/neural-interface/public/shared/synabun-mascot.js

@@ -8,11 +8,13 @@
 // the face, plus one prop drawn in the face's own pill geometry. Rigs draw
 // from the shared ticker (shared/synabun-ticker.js): 30 fps while a pose
 // loops, 60 fps for blends and reactions, no frames at all while still. One
-// pointermove listener and one IntersectionObserver serve every rig, and only
-// one rig at a time plays a pose loop (the one posed most recently); the
-// others hold their pose's still frame. Under prefers-reduced-motion every
-// pose is its still frame and changes are instant. A rig tears itself down
-// once its SVG leaves the document.
+// loop, one pointermove listener and one IntersectionObserver serve every rig,
+// and every rig that is active and on screen plays its own pose: N rigs move
+// at once, each on its own clock. No rig waits for another; a host that wants
+// one moving character among several of its own (an Assistant panel's hero,
+// stage and "Thinking" row) says so with setActive(). Under
+// prefers-reduced-motion every pose is its still frame and changes are
+// instant. A rig tears itself down once its SVG leaves the document.
 //
 // v1 callers are unchanged: createMascot(container, opts) → { el, destroy,
 // look, blink }, idle, blinking every 3-7 s and following the cursor.
@@ -307,7 +309,7 @@ const MINIS = [
 ];
 
 /**
- * motion: 'loop' (30 fps while it leads), 'blink' (still between slow blinks),
+ * motion: 'loop' (30 fps), 'blink' (still between slow blinks),
  * 'once' (plays `settle` ms, then still; `hold` before opts.then), 'still'.
  * blinks: random blinks every 3-7 s. tracks: follows the cursor.
  * look: follows look(), easing with this time constant (ms).
@@ -994,26 +996,15 @@ export function paintMascot(svg, frame) {
   painter.paint(frame);
 }
 
-// ── Shared runtime: one observer, one motion listener, one lead ──
+// ── Shared runtime: one observer and one motion listener for every rig ──
+// Nothing here picks a rig: each one decides from its own state (active, on
+// screen, motion allowed) whether it moves.
 
 const rigs = new Set();
-let leadRig = null;
-let promoteSeq = 0;
 let stopMotionWatch = null;
 let io = null;
 const ioRigs = new WeakMap();
 
-/** Only one rig plays a pose loop: the most recently posed one that wants to. */
-function elect() {
-  let best = null;
-  for (const rig of rigs) if (rig.wantsLead() && (!best || rig.promotedAt() > best.promotedAt())) best = rig;
-  if (best === leadRig) return;
-  const prev = leadRig;
-  leadRig = best;
-  prev?.leadChanged();
-  best?.leadChanged();
-}
-
 function observe(el, rig) {
   if (typeof IntersectionObserver !== 'function') return;
   try {
@@ -1034,13 +1025,11 @@ function register(rig) {
   rigs.add(rig);
   stopMotionWatch ||= onReducedMotionChange(() => {
     for (const r of Array.from(rigs)) r.motionChanged();
-    elect();
   });
 }
 
 function unregister(rig) {
   rigs.delete(rig);
-  if (leadRig === rig) { leadRig = null; elect(); }
   if (!rigs.size && stopMotionWatch) { stopMotionWatch(); stopMotionWatch = null; }
 }
 
@@ -1088,14 +1077,12 @@ export function createMascot(container, options) {
   let active = startActive !== false;
   let visible = true;
   let seenConnected = svg.isConnected;
-  let promotedAt = (promoteSeq += 1);
   let clock = 0; // rig time in ms: the ticker's dt while drawing, real time while still
   let frozenAt = tickerNow(); // while not drawing: when the clock was last brought up to date; -1 while drawing
   let pose = { name: 'idle', raw: {}, start: 0, then: null };
   let settled = false; // a one-shot's opts.then has fired
   let blend = null; // { from, start, dur }
   let lastFrame = null; // the last frame before blinks and reactions
-  let drawn = false; // has drawn a live frame (a never-drawn rig has nothing to blend from)
   let look = { x: 0, y: 0 }; // eased gaze
   let track = { x: 0, y: 0 }; // idle: where the cursor (or look()) points
   let hostLook = { x: 0, y: 0 };
@@ -1119,10 +1106,10 @@ export function createMascot(container, options) {
 
   const def = () => POSES[pose.name];
   const animating = () => !destroyed && active && visible && !isReducedMotion();
-  const isLead = () => leadRig === rig;
   const poseTime = () => clock - pose.start;
 
-  function wantsLead() {
+  /** This pose moves on its own right now: a loop, a patient pose, a one-shot still playing. */
+  function playing() {
     if (!animating()) return false;
     const { motion, settle } = def();
     if (motion === 'loop' || motion === 'blink') return true;
@@ -1186,7 +1173,6 @@ export function createMascot(container, options) {
   function nextRate() {
     if (!animating()) return 0;
     if (blend || blinkStart >= 0 || reactions.length || aim || easing() || miniPopping()) return 60;
-    if (!isLead()) return 0;
     const d = def();
     const t = poseTime();
     if (d.motion === 'loop') return 30;
@@ -1208,9 +1194,9 @@ export function createMascot(container, options) {
     const d = def();
     const at0 = tickerNow();
     let at = Infinity;
-    if (d.blinks && (d.motion === 'still' || isLead())) at = Math.min(at, nextBlinkAt);
+    if (d.blinks) at = Math.min(at, nextBlinkAt);
     if (d.tracks) at = Math.min(at, nextGlanceAt, nextFidgetAt, glance ? glance.until : Infinity);
-    if (d.motion === 'blink' && isLead()) at = Math.min(at, at0 + d.idleFor(poseTime()));
+    if (d.motion === 'blink') at = Math.min(at, at0 + d.idleFor(poseTime()));
     if (d.motion === 'once' && pose.then && !settled) at = Math.min(at, at0 + Math.max(0, d.settle + (d.hold || 0) - poseTime()));
     if (!Number.isFinite(at)) return;
     wakeTimer = setTimeout(() => {
@@ -1243,15 +1229,15 @@ export function createMascot(container, options) {
   function handleDue() {
     const d = def();
     const t = tickerNow();
-    if (d.blinks && (d.motion === 'still' || isLead()) && t >= nextBlinkAt) {
+    if (d.blinks && t >= nextBlinkAt) {
       nextBlinkAt = t + rand(3000, 7000);
       startBlink();
     }
     if (d.tracks) {
       if (glance && t >= glance.until) glance = null;
       if (t >= nextGlanceAt) {
-        // Only while the cursor is still and no other rig is busy.
-        if (t - pointerAt < 2500 || leadRig) nextGlanceAt = t + 3000;
+        // Only while the cursor is still.
+        if (t - pointerAt < 2500) nextGlanceAt = t + 3000;
         else {
           const [x, y] = GLANCES[Math.floor(Math.random() * GLANCES.length)];
           glance = { x, y, until: t + rand(700, 1000) };
@@ -1261,7 +1247,6 @@ export function createMascot(container, options) {
       if (t >= nextFidgetAt) {
         const quietFor = t - Math.max(lastInputAt(), pointerAt);
         if (quietFor < 20000) nextFidgetAt = t + (20000 - quietFor) + rand(0, 5000);
-        else if (leadRig) nextFidgetAt = t + 10000;
         else {
           nextFidgetAt = t + rand(45000, 75000);
           startReaction(Math.random() < 0.5 ? 'hop' : 'wiggle');
@@ -1303,8 +1288,7 @@ export function createMascot(container, options) {
 
   /** The pose frame this rig would draw now, before blends and overlays. */
   function frameNow() {
-    const loopOn = isLead() && def().motion !== 'still';
-    return poseFrame(pose.name, poseTime(), { ...pose.raw, look, range, ticks, still: !loopOn });
+    return poseFrame(pose.name, poseTime(), { ...pose.raw, look, range, ticks, still: !playing() });
   }
 
   /** Ease from what is on screen to what comes next, unless they already match. */
@@ -1400,10 +1384,7 @@ export function createMascot(container, options) {
     handleDue();
     if (aim) { aimAt(aim); aim = null; }
     easeLook(dt);
-    const wasLead = isLead();
     painter.paint(compose());
-    drawn = true;
-    if (wasLead && def().motion === 'once' && poseTime() >= def().settle) elect();
     const rate = nextRate();
     setRate(rate);
     if (!rate) armWake();
@@ -1497,9 +1478,7 @@ export function createMascot(container, options) {
       }
       scheduleIdle();
     }
-    promotedAt = (promoteSeq += 1);
     if (animating()) requestFrames(BLEND_MS);
-    elect();
     refresh();
     return api;
   }
@@ -1537,8 +1516,7 @@ export function createMascot(container, options) {
     const next = !!on;
     if (destroyed || next === active) return api;
     active = next;
-    if (active) { promotedAt = (promoteSeq += 1); revive(); }
-    elect();
+    if (active) revive();
     refresh();
     return api;
   }
@@ -1560,18 +1538,6 @@ export function createMascot(container, options) {
   }
 
   const rig = {
-    promotedAt: () => promotedAt,
-    wantsLead,
-    leadChanged() {
-      if (destroyed) return;
-      // Gaining or losing the loop swaps the still frame for the live one: blend
-      // when they differ (a patient pose between blinks, a settled one-shot: no).
-      if (drawn && animating()) {
-        syncClock();
-        blendIn();
-      }
-      refresh();
-    },
     visibilityChanged(inView) {
       if (destroyed) return;
       if (svg.isConnected) seenConnected = true;
@@ -1579,7 +1545,6 @@ export function createMascot(container, options) {
       const was = visible;
       visible = inView;
       if (visible && !was) revive();
-      elect();
       refresh(); // also wakes a rig that was built before it was attached
     },
     motionChanged() {
@@ -1619,7 +1584,6 @@ export function createMascot(container, options) {
       if (p) aim = p;
     }
   }
-  elect();
   refresh();
   return api;
 }

package/neural-interface/public/shared/term-ready.js

@@ -0,0 +1,307 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Terminal readiness
+// When a freshly opened terminal can take a typed command, and how to hand it
+// over. DOM-free: ui-terminal.js feeds it the output stream and does the I/O.
+// ═══════════════════════════════════════════
+
+// CSI, OSC (BEL or ST terminated), charset selection, and the two-byte escapes.
+const ESCAPES_RE = /\x1b\[[\x20-\x3f]*[\x40-\x7e]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()][AB012]|\x1b[=>78MDEHNOc]/g;
+
+// What _sendOnceReady has always stripped and matched for the CLIs (Claude
+// Code, Codex, …). Kept as it was: the loops depend on this exact reading.
+const CLI_ANSI_RE = /\x1b\[[\x20-\x3f]*[\x40-\x7e]|\x1b\][^\x07]*\x07|\x1b[()][AB012]/g;
+const CLI_READY_PATTERNS = [
+  /^>\s*$/m,        // Claude Code prompt: ">" on its own line
+  /\n>\s*$/,        // ">" after newline at end of output
+  />\s*$/,          // ">" at end of buffer (catch partial lines)
+  /❯/,         // ❯ (some CLI prompts)
+  /\$ $/,           // Shell prompt fallback
+];
+
+// The line editor (zsh's ZLE, readline in bash 5, fish) turns bracketed paste
+// on when it starts reading a line and off when a command runs.
+const PASTE_ON = '\x1b[?2004h';
+const PASTE_OFF = '\x1b[?2004l';
+// Shell integration marks (FinalTerm / OSC 133): B = the prompt has ended,
+// C = a command is running.
+const MARK_PROMPT_END = '\x1b]133;B';
+const MARK_RUNNING = '\x1b]133;C';
+
+// The character a prompt ends in: zsh %, bash/sh $, root #, cmd.exe / PowerShell
+// / fish >, and the arrows the common themes use. A reconnect snapshot trims the
+// trailing space, so the space is optional.
+const PROMPT_TAIL_RE = /[%$#>❯➜»›→▶λ][ \t]*$/;
+
+const BUFFER_MAX = 16384;
+const BUFFER_KEEP = 8192;
+
+// capMs runs from the moment the terminal's socket is open, never from the
+// call: a socket that takes its time must not eat into the wait for a prompt.
+// openGraceMs is how much longer than that a socket may take to open at all.
+export const READY_LIMITS = Object.freeze({
+  // A shell takes typeahead, so its limits are short: the worst case is a
+  // command typed a moment before the prompt is drawn, never a lost one.
+  shell: Object.freeze({ quietMs: 350, capMs: 5000, settleMs: 40, openGraceMs: 2000 }),
+  // A CLI started inside the shell swallows input typed before its own prompt.
+  cli: Object.freeze({ quietMs: 0, capMs: 15000, settleMs: 500, openGraceMs: 2000 }),
+});
+
+/** Which reading a terminal profile gets. */
+export function readinessKind(profile) {
+  return profile === 'shell' ? 'shell' : 'cli';
+}
+
+export function stripEscapes(text) {
+  return String(text || '').replace(ESCAPES_RE, '');
+}
+
+function lastOn(raw, on, off) {
+  const at = raw.lastIndexOf(on);
+  return at >= 0 && at > raw.lastIndexOf(off);
+}
+
+/**
+ * Read everything a terminal printed so far. Returns the reason it is ready
+ * ('line-editor', 'prompt-mark', 'prompt') or null.
+ */
+export function readySignal(raw, kind = 'shell') {
+  const text = String(raw || '');
+  if (!text) return null;
+  if (kind !== 'shell') {
+    const clean = text.replace(CLI_ANSI_RE, '');
+    return CLI_READY_PATTERNS.some(p => p.test(clean)) ? 'prompt' : null;
+  }
+  if (lastOn(text, PASTE_ON, PASTE_OFF)) return 'line-editor';
+  if (lastOn(text, MARK_PROMPT_END, MARK_RUNNING)) return 'prompt-mark';
+  // The line the cursor is on: zsh draws its prompt after "\r \r", so a
+  // carriage return starts a line here just like a newline does.
+  const clean = stripEscapes(text);
+  const line = clean.slice(Math.max(clean.lastIndexOf('\n'), clean.lastIndexOf('\r')) + 1);
+  return line.trim() && PROMPT_TAIL_RE.test(line) ? 'prompt' : null;
+}
+
+/**
+ * Watch one terminal until it can take input, then call onReady(reason) once.
+ *   output(text)  — output arrived (live bytes, or what was already buffered)
+ *   replace(text) — a snapshot replaced the screen (connect / reconnect)
+ *   poke()        — the emulator parsed something: re-read its line-editor mode
+ *   start()       — the wait begins
+ *   opened()      — the terminal's socket is open
+ *   cancel()
+ * Nothing is decided before opened(): the readiness window (capMs, and the
+ * quiet rule) runs from there, in full, however late the socket opens. What
+ * was fed in earlier is read at that moment. A socket that never opens ends
+ * the wait capMs + openGraceMs after start().
+ * Reasons: 'line-editor' | 'prompt-mark' | 'prompt' | 'quiet' | 'timeout'.
+ */
+export function createReadyWatch({
+  kind = 'shell',
+  onReady,
+  lineEditorActive = null,
+  limits = READY_LIMITS[kind] || READY_LIMITS.cli,
+  timers = { set: (fn, ms) => setTimeout(fn, ms), clear: (id) => clearTimeout(id) },
+} = {}) {
+  let buf = '';
+  let done = false;
+  let started = false;
+  let open = false;
+  let sawOutput = false;
+  let quietTimer = null;
+  let capTimer = null;
+  let openTimer = null;
+
+  function clearTimers() {
+    if (quietTimer) timers.clear(quietTimer);
+    if (capTimer) timers.clear(capTimer);
+    if (openTimer) timers.clear(openTimer);
+    quietTimer = capTimer = openTimer = null;
+  }
+
+  function finish(reason) {
+    if (done) return;
+    done = true;
+    clearTimers();
+    try { onReady?.(reason); } catch {}
+  }
+
+  // Something a person could see. A connect snapshot of an empty screen and a
+  // shell's terminal queries are escape codes only: not a sign of life yet.
+  function noteOutput(text) {
+    if (!sawOutput && /\S/.test(stripEscapes(text))) sawOutput = true;
+  }
+
+  function armQuiet() {
+    if (done || !open || !sawOutput || !(limits.quietMs > 0)) return;
+    if (quietTimer) timers.clear(quietTimer);
+    quietTimer = timers.set(() => { quietTimer = null; finish('quiet'); }, limits.quietMs);
+  }
+
+  function evaluate() {
+    if (done || !open) return;
+    const signal = readySignal(buf, kind);
+    if (signal) { finish(signal); return; }
+    if (kind === 'shell' && lineEditorActive) {
+      let active = false;
+      try { active = lineEditorActive() === true; } catch {}
+      if (active) { finish('line-editor'); return; }
+    }
+    armQuiet();
+  }
+
+  return {
+    output(text) {
+      if (done || !text) return;
+      noteOutput(text);
+      buf += text;
+      if (buf.length > BUFFER_MAX) buf = buf.slice(-BUFFER_KEEP);
+      evaluate();
+    },
+    replace(text) {
+      if (done) return;
+      buf = String(text || '');
+      noteOutput(buf);
+      evaluate();
+    },
+    poke() {
+      if (done || !open || kind !== 'shell' || !lineEditorActive) return;
+      let active = false;
+      try { active = lineEditorActive() === true; } catch {}
+      if (active) finish('line-editor');
+    },
+    start() {
+      if (done || started) return;
+      started = true;
+      if (open) return;
+      openTimer = timers.set(() => { openTimer = null; finish('timeout'); }, limits.capMs + (limits.openGraceMs || 0));
+    },
+    opened() {
+      if (done || open) return; // a reconnect later on does not restart the window
+      started = true;
+      open = true;
+      if (openTimer) timers.clear(openTimer);
+      openTimer = null;
+      capTimer = timers.set(() => { capTimer = null; finish('timeout'); }, limits.capMs);
+      evaluate();
+    },
+    cancel() {
+      if (done) return;
+      done = true;
+      clearTimers();
+    },
+    get done() { return done; },
+    get open() { return open; },
+  };
+}
+
+/** Split typed input into the writes the PTY gets (ConPTY drops long ones). */
+export function inputChunks(text, size = 256) {
+  const full = String(text ?? '');
+  const out = [];
+  for (let i = 0; i < full.length; i += size) out.push(full.slice(i, i + size));
+  return out;
+}
+
+/**
+ * Type `text` into a terminal: every chunk in order, each through the socket
+ * that is current at that moment (a reconnect swaps it). Waits for an open
+ * socket instead of dropping the input, and stops for good the moment a chunk
+ * cannot be delivered — a command with a hole in it must never reach Enter.
+ *   socket()     → the session's current socket ({ readyState, send }) or null
+ *   alive()      → false once the terminal is gone
+ * Resolves { ok, sent, chunks, reason? } with reason 'closed' | 'no-socket'.
+ */
+export async function typeInto({
+  socket,
+  alive = () => true,
+  text,
+  chunkSize = 256,
+  gapMs = 30,
+  openWaitMs = 10000,
+  pollMs = 25,
+  OPEN = 1,
+  sleep = (ms) => new Promise(r => setTimeout(r, ms)),
+  now = () => Date.now(),
+} = {}) {
+  const chunks = inputChunks(text, chunkSize);
+  let sent = 0;
+  for (const chunk of chunks) {
+    const deadline = now() + openWaitMs;
+    let ws = socket();
+    while (alive() && (!ws || ws.readyState !== OPEN) && now() < deadline) {
+      // Mid-command the wait is over: what follows a gap would be a different command.
+      if (sent > 0) return { ok: false, sent, chunks: chunks.length, reason: 'closed' };
+      await sleep(pollMs);
+      ws = socket();
+    }
+    if (!alive()) return { ok: false, sent, chunks: chunks.length, reason: 'closed' };
+    if (!ws || ws.readyState !== OPEN) return { ok: false, sent, chunks: chunks.length, reason: 'no-socket' };
+    try { ws.send(JSON.stringify({ type: 'input', data: chunk })); }
+    catch { return { ok: false, sent, chunks: chunks.length, reason: 'closed' }; }
+    sent++;
+    if (sent < chunks.length) await sleep(gapMs);
+  }
+  return { ok: true, sent, chunks: chunks.length };
+}
+
+/**
+ * The whole hand-over of one message: wait until the terminal can take it, let
+ * it settle, type it. Everything that touches the page is handed in, so this
+ * runs the same under a test clock.
+ *   socket()            → the session's current socket (a reconnect swaps it)
+ *   alive()             → false once the terminal is gone
+ *   lineEditorActive()  → the emulator's bracketed-paste mode
+ *   buffered            → output that arrived before this call
+ *   subscribe({ output(text, replaced), opened(), parsed() }) → unsubscribe
+ *                         output for every chunk, opened whenever a socket of
+ *                         this session opens, parsed after the emulator parsed
+ *   onReady(reason, waitedMs)
+ * Resolves { ok: true, reason, waitedMs } or { ok: false, reason, sent, chunks }.
+ */
+export function typeWhenReady({
+  kind = 'shell',
+  text,
+  socket,
+  alive = () => true,
+  lineEditorActive = null,
+  buffered = '',
+  subscribe = null,
+  onReady = () => {},
+  OPEN = 1,
+  limits = READY_LIMITS[kind] || READY_LIMITS.cli,
+  timers = { set: (fn, ms) => setTimeout(fn, ms), clear: (id) => clearTimeout(id) },
+  now = () => Date.now(),
+  sleep = (ms) => new Promise(r => timers.set(r, ms)),
+} = {}) {
+  return new Promise((resolve) => {
+    const t0 = now();
+    let unsubscribe = null;
+    const watch = createReadyWatch({
+      kind,
+      lineEditorActive,
+      limits,
+      timers,
+      onReady: (reason) => {
+        try { unsubscribe?.(); } catch {}
+        unsubscribe = null;
+        const waitedMs = Math.round(now() - t0);
+        try { onReady(reason, waitedMs); } catch {}
+        timers.set(async () => {
+          const result = await typeInto({ socket, alive, text, OPEN, sleep, now });
+          resolve(result.ok
+            ? { ok: true, reason, waitedMs }
+            : { ok: false, reason: result.reason, sent: result.sent, chunks: result.chunks });
+        }, limits.settleMs);
+      },
+    });
+    // Subscribed before anything can be decided: no verdict comes before opened().
+    unsubscribe = subscribe?.({
+      output: (chunk, replaced) => { if (replaced) watch.replace(chunk); else watch.output(chunk); },
+      opened: () => watch.opened(),
+      parsed: () => watch.poke(),
+    }) || null;
+    if (buffered) watch.output(buffered);
+    watch.start();
+    const ws = socket?.();
+    if (ws && ws.readyState === OPEN) watch.opened();
+  });
+}