autopreso 0.1.1

package/src/settings-store.js

@@ -0,0 +1,137 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { readCodexCliAuthSync } from "./codex-auth.js";
+
+export const DEFAULT_SETTINGS = Object.freeze({
+  agent: {
+    provider: "openai",
+    openai: { model: "gpt-5.5", reasoningEffort: "low" },
+    codex: { model: "gpt-5.5", baseURL: "https://chatgpt.com/backend-api/codex" },
+    ollama: { model: "", baseURL: "http://localhost:11434/v1" },
+  },
+  transcription: {
+    provider: "moonshine",
+    moonshine: { model: "medium" },
+    openai: { model: "gpt-realtime-whisper" },
+  },
+  apiKeys: {
+    openai: "",
+  },
+});
+
+export function createSettingsStore({ filePath, env = process.env, readCodexAuth = readCodexCliAuthSync }) {
+  let cached = null;
+
+  async function readFromDisk() {
+    try {
+      const raw = await fs.readFile(filePath, "utf8");
+      return deepMerge(cloneDefaults(), JSON.parse(raw));
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+  }
+
+  async function writeToDisk(settings) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+    try {
+      await fs.chmod(filePath, 0o600);
+    } catch {}
+  }
+
+  async function load() {
+    if (cached) return cached;
+    const fromDisk = await readFromDisk();
+    if (fromDisk) {
+      cached = fromDisk;
+      return cached;
+    }
+    const seeded = seedFromEnv(cloneDefaults(), env, readCodexAuth);
+    await writeToDisk(seeded);
+    cached = seeded;
+    return cached;
+  }
+
+  async function save(partial) {
+    if (!cached) await load();
+    cached = deepMerge(cached, partial);
+    await writeToDisk(cached);
+    return cached;
+  }
+
+  async function getSanitized() {
+    const settings = await load();
+    const { apiKeys, ...rest } = settings;
+    return {
+      ...rest,
+      hasOpenAIKey: Boolean(apiKeys?.openai),
+    };
+  }
+
+  return { load, save, getSanitized };
+}
+
+function cloneDefaults() {
+  return JSON.parse(JSON.stringify(DEFAULT_SETTINGS));
+}
+
+function deepMerge(target, source) {
+  if (!source || typeof source !== "object") return target;
+  const result = Array.isArray(target) ? [...target] : { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = deepMerge(result[key] ?? {}, value);
+    } else if (value !== undefined) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+function seedFromEnv(settings, env, readCodexAuth) {
+  const next = settings;
+  const openaiKey = trimOrEmpty(env.OPENAI_API_KEY);
+  if (openaiKey) next.apiKeys.openai = openaiKey;
+
+  const openaiModel = trimOrEmpty(env.OPENAI_MODEL);
+  if (openaiModel) next.agent.openai.model = openaiModel;
+
+  const reasoningEffort = trimOrEmpty(env.OPENAI_REASONING_EFFORT);
+  if (reasoningEffort) next.agent.openai.reasoningEffort = reasoningEffort;
+
+  const codexModel = trimOrEmpty(env.CODEX_MODEL);
+  if (codexModel) next.agent.codex.model = codexModel;
+
+  const codexBaseURL = trimOrEmpty(env.CODEX_BASE_URL);
+  if (codexBaseURL) next.agent.codex.baseURL = codexBaseURL;
+
+  const ollamaModel = trimOrEmpty(env.OLLAMA_MODEL);
+  if (ollamaModel) next.agent.ollama.model = ollamaModel;
+
+  const ollamaBaseURL = trimOrEmpty(env.OLLAMA_BASE_URL);
+  if (ollamaBaseURL) next.agent.ollama.baseURL = ollamaBaseURL;
+
+  const codexAuth = safeReadCodexAuth(readCodexAuth, env);
+  if (codexAuth) next.agent.provider = "codex";
+  else if (ollamaModel) next.agent.provider = "ollama";
+  else next.agent.provider = "openai";
+
+  if (openaiKey) next.transcription.provider = "openai";
+
+  return next;
+}
+
+function safeReadCodexAuth(readCodexAuth, env) {
+  try {
+    return readCodexAuth(env);
+  } catch {
+    return null;
+  }
+}
+
+function trimOrEmpty(value) {
+  if (typeof value !== "string") return "";
+  return value.trim();
+}

package/src/simulator-agent-provider.js

@@ -0,0 +1,24 @@
+import { DEFAULT_CODEX_BASE_URL } from "./codex-auth.js";
+import { resolveAgentProviderFromSettings } from "./agent-provider.js";
+
+export function resolveSimulatorAgentProvider(env = process.env) {
+  const requested = env.CODEX_MODEL?.trim() || env.OPENAI_MODEL?.trim() || "gpt-5.5";
+  const model = stripFastMode(requested);
+  return resolveAgentProviderFromSettings({
+    settings: {
+      agent: {
+        provider: "codex",
+        openai: { model: "gpt-5.5", reasoningEffort: "low" },
+        codex: { model, baseURL: DEFAULT_CODEX_BASE_URL },
+        ollama: { model: "", baseURL: "" },
+      },
+      apiKeys: { openai: "" },
+    },
+    env,
+  });
+}
+
+function stripFastMode(model) {
+  if (model.endsWith("-fast")) return model.slice(0, -"-fast".length);
+  return model;
+}

package/src/simulator-options.js

@@ -0,0 +1,76 @@
+const DEFAULT_CHROME_BIN = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+
+export function parseSimulatorArgs(args, env = process.env) {
+  const options = {
+    host: "127.0.0.1",
+    port: 0,
+    chunkIntervalMs: 500,
+    speakingWordsPerMinute: 160,
+    chromeBin: env.CHROME_BIN ?? DEFAULT_CHROME_BIN,
+    agentTimeoutMs: 90_000,
+    help: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      return options;
+    }
+    if (arg === "--transcript") {
+      options.transcriptPath = readValue(args, ++index, arg);
+      continue;
+    }
+    if (arg === "--out") {
+      options.outDir = readValue(args, ++index, arg);
+      continue;
+    }
+    if (arg === "--chrome-bin") {
+      options.chromeBin = readValue(args, ++index, arg);
+      continue;
+    }
+    if (arg === "--chunk-interval-ms") {
+      options.chunkIntervalMs = parseNonNegativeInteger(readValue(args, ++index, arg), arg);
+      continue;
+    }
+    if (arg === "--speaking-words-per-minute") {
+      options.speakingWordsPerMinute = parsePositiveInteger(readValue(args, ++index, arg), arg);
+      continue;
+    }
+    if (arg === "--agent-timeout-ms") {
+      options.agentTimeoutMs = parsePositiveInteger(readValue(args, ++index, arg), arg);
+      continue;
+    }
+    if (arg === "--host") {
+      options.host = readValue(args, ++index, arg);
+      continue;
+    }
+    if (arg === "--port") {
+      options.port = parseNonNegativeInteger(readValue(args, ++index, arg), arg);
+      continue;
+    }
+    throw new Error(`Unknown option: ${arg}`);
+  }
+
+  if (!options.transcriptPath) throw new Error("--transcript is required");
+  if (!options.outDir) throw new Error("--out is required");
+  return options;
+}
+
+function readValue(args, index, flag) {
+  const value = args[index];
+  if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
+function parseNonNegativeInteger(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) throw new Error(`${flag} must be a non-negative integer`);
+  return parsed;
+}
+
+function parsePositiveInteger(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${flag} must be a positive integer`);
+  return parsed;
+}

package/src/transcript-chunker.js

@@ -0,0 +1,22 @@
+const DEFAULT_PUNCTUATION = new Set([".", "!", "?", ";", ":", ","]);
+
+export function chunkTranscriptAtPunctuation(transcript, punctuation = DEFAULT_PUNCTUATION) {
+  const chunks = [];
+  let current = "";
+
+  for (const char of String(transcript ?? "")) {
+    current += char;
+    if (punctuation.has(char)) {
+      pushChunk(chunks, current);
+      current = "";
+    }
+  }
+
+  pushChunk(chunks, current);
+  return chunks;
+}
+
+function pushChunk(chunks, text) {
+  const trimmed = text.trim();
+  if (trimmed) chunks.push(trimmed);
+}

package/src/transcript-turn-queue.js

@@ -0,0 +1,78 @@
+export function createTranscriptTurnQueue({ runTurn, debounceMs = 150, isReady = () => true }) {
+  let running = false;
+  let buffered = [];
+  let current = Promise.resolve();
+  // Pending bucket holds chunks that arrived too recently to fire yet. Waiting
+  // a short window lets bursts of small transcript chunks coalesce into one
+  // turn. The isReady predicate gates whether the accumulated buffer has
+  // enough substantive content to actually fire - if not, we keep accumulating
+  // until the next chunk arrives.
+  let pending = [];
+  let debounceTimer = null;
+
+  function flushPending({ force = false } = {}) {
+    debounceTimer = null;
+    if (pending.length === 0) return;
+    const text = pending.join("\n");
+    if (!force && !isReady(text)) {
+      // Not enough content yet - keep pending, wait for more chunks. The next
+      // enqueue will restart the debounce timer and we'll re-check then.
+      return;
+    }
+    pending = [];
+    if (running) {
+      buffered.push(text);
+    } else {
+      current = drain(text);
+    }
+  }
+
+  async function drain(text) {
+    running = true;
+    try {
+      await runTurn(text);
+    } finally {
+      if (buffered.length > 0) {
+        const next = buffered.join("\n");
+        buffered = [];
+        current = drain(next);
+      } else {
+        running = false;
+        // If pending arrived during the turn and is now ready, flush it. If
+        // it's still not ready (only fillers), leave it accumulating.
+        if (pending.length > 0) {
+          if (debounceTimer) clearTimeout(debounceTimer);
+          flushPending();
+        }
+      }
+    }
+  }
+
+  function enqueue(text) {
+    const trimmed = text.trim();
+    if (!trimmed) return current;
+    pending.push(trimmed);
+    if (debounceMs > 0) {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(flushPending, debounceMs);
+    } else {
+      flushPending();
+    }
+    return current;
+  }
+
+  async function idle() {
+    // Force-flush any pending content (bypassing isReady) so idle() always
+    // terminates - tests and shutdown paths shouldn't hang on a buffer that
+    // happens to contain only fillers.
+    while (debounceTimer || running || buffered.length > 0 || pending.length > 0) {
+      if (debounceTimer || pending.length > 0) {
+        if (debounceTimer) clearTimeout(debounceTimer);
+        flushPending({ force: true });
+      }
+      await current;
+    }
+  }
+
+  return { enqueue, idle };
+}

package/src/whiteboard-elements.js

@@ -0,0 +1,74 @@
+export function normalizeWhiteboardElements(elements) {
+  if (!Array.isArray(elements)) return [];
+
+  return elements;
+}
+
+const SHAPE_TYPES = new Set(["rectangle", "ellipse", "diamond"]);
+const CHAR_WIDTH_RATIO = 0.6;
+const PADDING_PER_SIDE = 24;
+
+function rectanglesOverlap(a, b) {
+  return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+}
+
+function estimateTextBox(text, fontSize) {
+  const fs = fontSize ?? 18;
+  const lines = String(text ?? "").split("\n");
+  const longest = lines.reduce((max, line) => Math.max(max, line.length), 0);
+  return {
+    width: Math.ceil(longest * fs * CHAR_WIDTH_RATIO),
+    height: Math.ceil(lines.length * fs * 1.25),
+  };
+}
+
+export function detectMalformedLayoutWarnings(elements) {
+  if (!Array.isArray(elements) || elements.length === 0) return [];
+  const warnings = [];
+  const shapes = elements.filter((el) => SHAPE_TYPES.has(el?.type));
+  const texts = elements.filter((el) => el?.type === "text");
+
+  // 1. Standalone text overlapping a shape -> should have been a label.
+  for (const text of texts) {
+    if (typeof text.x !== "number" || typeof text.y !== "number") continue;
+    const estimated = estimateTextBox(text.text, text.fontSize);
+    const textBox = {
+      x: text.x,
+      y: text.y,
+      width: typeof text.width === "number" ? text.width : estimated.width,
+      height: typeof text.height === "number" ? text.height : estimated.height,
+    };
+    for (const shape of shapes) {
+      if (typeof shape.width !== "number" || typeof shape.height !== "number") continue;
+      if (rectanglesOverlap(textBox, shape)) {
+        const preview = (text.text ?? "").slice(0, 40);
+        warnings.push(
+          `LAYOUT WARNING: standalone text "${preview}" (id "${text.id}") overlaps shape "${shape.id}". Excalidraw renders standalone text by your literal coordinates, so it bleeds outside the shape. Replace the text element with a label on the shape: { "type": "${shape.type}", "id": "${shape.id}", ..., "label": { "text": "${preview}", "fontSize": ${text.fontSize ?? 18} } }. Then Excalidraw will center it inside the shape and wrap correctly.`,
+        );
+        break;
+      }
+    }
+  }
+
+  // 2. Labeled shape too narrow / short for its label.
+  for (const shape of shapes) {
+    const labelText = shape?.label?.text;
+    if (typeof labelText !== "string" || labelText.length === 0) continue;
+    const fontSize = shape.label.fontSize ?? 18;
+    const estimated = estimateTextBox(labelText, fontSize);
+    const minWidth = estimated.width + PADDING_PER_SIDE * 2;
+    const minHeight = estimated.height + PADDING_PER_SIDE * 2;
+    if (typeof shape.width === "number" && shape.width < minWidth) {
+      warnings.push(
+        `LAYOUT WARNING: shape "${shape.id}" is ${shape.width}px wide but its label "${labelText.slice(0, 40)}" needs about ${minWidth}px (text + padding). Either widen the shape or shorten the label - otherwise the label text will overflow the shape's edges.`,
+      );
+    }
+    if (typeof shape.height === "number" && shape.height < minHeight) {
+      warnings.push(
+        `LAYOUT WARNING: shape "${shape.id}" is ${shape.height}px tall but its label "${labelText.slice(0, 40)}" needs about ${minHeight}px. Either grow the shape or shorten the label.`,
+      );
+    }
+  }
+
+  return warnings;
+}

package/src/whiteboard-session.js

@@ -0,0 +1,235 @@
+import { WebSocket } from "ws";
+
+import { createTranscriptTurnQueue } from "./transcript-turn-queue.js";
+
+const FILLER_WORDS = new Set([
+  "uh", "uhh", "uhhh", "um", "umm", "ummm", "ah", "ahh", "er", "erm",
+  "hmm", "hm", "huh", "mm", "mhm",
+  "yeah", "yep", "yup", "yes", "ok", "okay", "right", "alright",
+  "so", "well", "like",
+]);
+
+export function isTrivialTranscript(text) {
+  if (typeof text !== "string") return true;
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return true;
+  // Strip common punctuation and lowercase, then split into words.
+  const cleaned = trimmed.replace(/[.,!?;:'"()\-]/g, " ").toLowerCase();
+  const words = cleaned.split(/\s+/).filter((w) => w.length > 0);
+  if (words.length === 0) return true;
+  // Single word: skip if it's filler or very short (1-2 chars).
+  if (words.length === 1) {
+    return FILLER_WORDS.has(words[0]) || words[0].length <= 2;
+  }
+  // 2-3 words and ALL are filler: skip ("you know", "uh well").
+  if (words.length <= 3 && words.every((w) => FILLER_WORDS.has(w))) return true;
+  return false;
+}
+
+// Default backoff between warmup attempts (after attempt N completes, wait
+// delays[N-1] ms before the next). Total budget with 8 attempts: ~120s.
+const DEFAULT_WARMUP_DELAYS = [2000, 4000, 8000, 16000, 30000, 30000, 30000];
+const DEFAULT_WARMUP_MAX_ATTEMPTS = 8;
+
+export function createWhiteboardSession({ options, wss, runAgent }) {
+  const state = {
+    mode: "staging",
+    elements: seedElements(),
+    agentHistory: [],
+    agentStatus: "idle",
+    agentBusy: false,
+    warmupBusy: false,
+    latestScreenshot: undefined,
+    warmupPromise: Promise.resolve(),
+    // Snapshot of the warmup loop state, also broadcast to clients via WS.
+    warmupState: { state: "idle", attempt: 0, maxAttempts: DEFAULT_WARMUP_MAX_ATTEMPTS },
+    // True iff the canvas was edited since the last time a screenshot was
+    // sent to the agent. We only attach the live screenshot when this is true
+    // (saves ~7-10k tokens per turn on DONE-only turns when nothing changed).
+    canvasDirtyForAgent: false,
+  };
+
+  let warmupCancelled = false;
+  let warmupRunning = false;
+
+  function publishAgentStatus() {
+    const status = (state.agentBusy || state.warmupBusy) ? "thinking" : "idle";
+    if (state.agentStatus === status) return;
+    state.agentStatus = status;
+    broadcast(wss, { type: "agent:status", status });
+  }
+
+  const queue = createTranscriptTurnQueue({
+    // A turn is "ready" only when the accumulated buffer has at least one
+    // substantive (non-filler) word. Pure fillers ("uh", "uh um") keep
+    // accumulating until the speaker says something real, then fire as one
+    // combined turn ("uh\num\nOpenAI just released...").
+    isReady: (text) => !isTrivialTranscript(text),
+    runTurn: async (transcript) => {
+      if (state.mode !== "live") return;
+      // Wait for any in-flight prompt-cache warmup so the cache is primed
+      // before we send the first real transcript turn through.
+      try { await state.warmupPromise; } catch { /* warmup errors are logged elsewhere */ }
+      if (state.mode !== "live") return;
+      state.agentBusy = true;
+      publishAgentStatus();
+      options.onAgentEvent?.({ type: "turn:start", transcript, timestamp: new Date().toISOString() });
+      try {
+        await runAgent({ transcript, state, wss, options });
+        options.onAgentEvent?.({ type: "turn:end", transcript, timestamp: new Date().toISOString() });
+      } catch (error) {
+        console.error("Whiteboard agent failed:", error);
+        broadcast(wss, { type: "error", message: `Whiteboard agent failed: ${error.message}` });
+        options.onAgentEvent?.({ type: "turn:error", transcript, error: error.message, timestamp: new Date().toISOString() });
+      } finally {
+        state.agentBusy = false;
+        publishAgentStatus();
+      }
+    },
+  });
+
+  state.queueTranscript = (text) => queue.enqueue(text);
+  state.idle = () => queue.idle();
+  state.updateLatestScreenshot = (image) => {
+    state.latestScreenshot = image;
+    // A fresh screenshot means the canvas changed (either the agent just
+    // edited or the user drew something pre-listening). Mark dirty so the
+    // next agent turn includes it.
+    state.canvasDirtyForAgent = true;
+  };
+  state.reset = () => {
+    state.elements = seedElements();
+    state.agentHistory = [];
+    state.latestScreenshot = undefined;
+  };
+  state.startPreso = ({ primerMessage }) => {
+    state.mode = "live";
+    state.elements = seedElements();
+    state.latestScreenshot = undefined;
+    state.agentHistory = [primerMessage];
+    state.warmupPromise = Promise.resolve();
+    state.canvasDirtyForAgent = false;
+    // Reset warmup state for this preso. The startWarmupLoop call that follows
+    // will publish the first "running" broadcast.
+    state.warmupState = { state: "idle", attempt: 0, maxAttempts: DEFAULT_WARMUP_MAX_ATTEMPTS };
+  };
+  function publishWarmupState(next) {
+    state.warmupState = { ...state.warmupState, ...next };
+    broadcast(wss, { type: "warmup", ...state.warmupState });
+  }
+
+  state.startWarmupLoop = ({
+    runOnce,
+    delays = DEFAULT_WARMUP_DELAYS,
+    maxAttempts = DEFAULT_WARMUP_MAX_ATTEMPTS,
+    primingMessages = null,
+  }) => {
+    // Ignore overlapping calls. The previous loop must finish (or be cancelled)
+    // before a new one starts, otherwise multiple loops would race for cache
+    // confirmation on the same session.
+    if (warmupRunning) return state.warmupPromise;
+
+    warmupRunning = true;
+    warmupCancelled = false;
+    state.warmupBusy = true;
+    publishAgentStatus();
+
+    const promise = (async () => {
+      try {
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+          if (warmupCancelled) {
+            publishWarmupState({ state: "cancelled", attempt: attempt - 1, maxAttempts });
+            return;
+          }
+          publishWarmupState({ state: "running", attempt, maxAttempts });
+          let cached = 0;
+          let input = 0;
+          try {
+            const result = await runOnce({ attempt, maxAttempts });
+            cached = Number(result?.usage?.cached) || 0;
+            input = Number(result?.usage?.input) || 0;
+          } catch (error) {
+            // Swallow per-attempt errors; loop should still progress to the
+            // next attempt. The actual error is logged by the caller.
+            cached = 0;
+            input = 0;
+          }
+          if (warmupCancelled) {
+            publishWarmupState({ state: "cancelled", attempt, maxAttempts });
+            return;
+          }
+          // Require >=50% of the prefix to be cached. A small `cached` value
+          // (e.g., the static system+tools chunk only) doesn't mean the primer
+          // and warmup_user prefix are primed, so keep retrying.
+          if (input > 0 && cached >= input * 0.5) {
+            publishWarmupState({ state: "confirmed", attempt, maxAttempts });
+            return;
+          }
+          if (attempt >= maxAttempts) {
+            publishWarmupState({ state: "exhausted", attempt, maxAttempts });
+            return;
+          }
+          // Wait before the next attempt, but bail early if cancelled mid-sleep.
+          const delay = delays[attempt - 1] ?? delays.at(-1) ?? 0;
+          await sleepCancellable(delay, () => warmupCancelled);
+        }
+      } finally {
+        // Append the priming pair AFTER all warmup attempts finish (regardless
+        // of confirmed/exhausted/cancelled). This makes every subsequent turn's
+        // request prefix start with the EXACT bytes warmup just wrote to cache:
+        //   warmup wrote: [primer, warmup_user_msg]
+        //   turn sends:   [primer, warmup_user_msg, assistant("UNDERSTOOD"), transcript, currentBoard]
+        // Without this, turn 1 diverges from warmup at messages[1] and never
+        // hits the cache that warmup just primed.
+        if (Array.isArray(primingMessages) && primingMessages.length > 0) {
+          state.agentHistory = [...state.agentHistory, ...primingMessages];
+        }
+        warmupRunning = false;
+        state.warmupBusy = false;
+        publishAgentStatus();
+      }
+    })();
+
+    state.warmupPromise = promise;
+    return promise;
+  };
+
+  state.cancelWarmup = () => {
+    if (!warmupRunning) return;
+    warmupCancelled = true;
+  };
+
+  state.backToStaging = () => {
+    state.mode = "staging";
+    state.cancelWarmup();
+  };
+  return state;
+}
+
+function sleepCancellable(ms, isCancelled) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const tick = () => {
+      if (isCancelled() || Date.now() - start >= ms) return resolve();
+      setTimeout(tick, Math.min(50, ms));
+    };
+    tick();
+  });
+}
+
+export function broadcast(wss, message) {
+  const serialized = JSON.stringify(message);
+  for (const client of wss.clients) {
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(serialized);
+    }
+  }
+}
+
+function seedElements() {
+  // Live canvas starts blank. The user may draw on it before clicking Start
+  // listening; those edits are pushed to the server via whiteboard:user-elements
+  // and will be in state.elements by the first transcript turn.
+  return [];
+}