@opengeni/react 1.4.4 → 1.4.5-canary.37458084490001

package/src/model-policy.ts

@@ -55,7 +55,11 @@ const AVAILABILITY_REASON_LABELS: Record<string, string> = {
 };
 
 export function billingClassForModel(model: ClientModel): PickerBillingClass {
-  if (model.provider === "organization-gateway" || model.provider === "organization-openrouter") {
+  if (
+    model.provider === "organization-gateway" ||
+    model.provider === "organization-openrouter" ||
+    model.provider === "organization-opper"
+  ) {
     return "organization_byok";
   }
   if (
@@ -63,7 +67,11 @@ export function billingClassForModel(model: ClientModel): PickerBillingClass {
     model.provider?.startsWith("workspace-azure-openai-")
   )
     return "byok";
-  if (model.provider === "workspace-gateway" || model.provider === "workspace-openrouter") {
+  if (
+    model.provider === "workspace-gateway" ||
+    model.provider === "workspace-openrouter" ||
+    model.provider === "workspace-opper"
+  ) {
     return "byok";
   }
   return modelPickerBillingClassFor(model);
@@ -116,6 +124,30 @@ export function coerceReasoningEffortForModel(
   return defaultEffortForModel(model);
 }
 
+/** Whether the composer offers (and therefore labels) a reasoning-effort choice. */
+export function modelOffersEffortChoice(model: ClientModel): boolean {
+  return (
+    effortOptionsForModel(model).length > 1 && model.capabilities?.reasoning.runnable !== false
+  );
+}
+
+/**
+ * The composer model pill at phone width: the catalog's compact name (falling
+ * back to the display name) and the effort label when effort is a choice.
+ */
+export function compactModelPill(
+  models: readonly ClientModel[],
+  modelId: string,
+  effort: ReasoningEffort | null | undefined,
+): { name: string; effort: string | null } {
+  const row = findPickerRow(projectClientModelRows([...models]), modelId);
+  return {
+    name: row?.shortLabel ?? row?.label ?? modelDisplayName(modelId),
+    effort:
+      row && effort && modelOffersEffortChoice(row.catalog) ? labelReasoningEffort(effort) : null,
+  };
+}
+
 export function runnableLatencyModesForModel(model: ClientModel): LatencyModeId[] {
   const modes = model.capabilities?.latencyModes ?? [];
   return modes.filter((mode) => mode.runnable).map((mode) => mode.id);
@@ -212,6 +244,9 @@ export function advancedSourceSummary(model: ClientModel): string | null {
     if (model.provider === "workspace-openrouter") {
       return "Workspace OpenRouter connection";
     }
+    if (model.provider === "workspace-opper") {
+      return "Workspace Opper connection";
+    }
     if (model.provider === "workspace-gateway" || model.source === "workspace_gateway") {
       return "Workspace Vercel AI Gateway";
     }
@@ -233,6 +268,9 @@ function workspaceProviderPayerSummary(model: ClientModel): string {
   if (model.provider === "workspace-openrouter") {
     return "Billed to the workspace OpenRouter account";
   }
+  if (model.provider === "workspace-opper") {
+    return "Billed to the workspace Opper account";
+  }
   if (model.provider === "workspace-gateway" || model.source === "workspace_gateway") {
     return "Billed to the workspace Vercel account";
   }
@@ -247,6 +285,9 @@ function organizationProviderPayerSummary(model: ClientModel): string {
   if (model.provider === "organization-openrouter") {
     return "Billed to the organization OpenRouter account";
   }
+  if (model.provider === "organization-opper") {
+    return "Billed to the organization Opper account";
+  }
   if (model.provider === "organization-gateway") {
     return "Billed to the organization Vercel account";
   }

package/src/organization-model.ts

@@ -0,0 +1,118 @@
+// Pure organization and workspace selection rules shared by the web rail's
+// switcher and native renderers. The wire model has no account *name*, so a
+// display label is derived from the access grant — preferring the account
+// name, falling back to a short, stable id fragment. No DOM, no React.
+import type { AccessContext, AccountGrant, Workspace } from "@opengeni/sdk";
+
+export type OrgOption = {
+  accountId: string;
+  label: string;
+  /** Whether the subject has the owner/admin authority required by organization settings. */
+  canManage: boolean;
+};
+
+/** Organizations the subject administers (owner or admin), sorted by id. */
+export function organizationAdministrationAccountIds(accessContext: AccessContext): string[] {
+  return accessContext.accountGrants
+    .filter(
+      (grant) =>
+        grant.subjectId === accessContext.subjectId &&
+        (grant.role === "owner" || grant.role === "admin"),
+    )
+    .map((grant) => grant.accountId)
+    .sort();
+}
+
+/** A short, stable id fragment for an account that has no human name. */
+export function shortAccountId(accountId: string): string {
+  return accountId.length > 8 ? accountId.slice(0, 8) : accountId;
+}
+
+/** The organization's real name, or null when the API sent none. */
+export function orgName(accountId: string, grants: AccountGrant[]): string | null {
+  const grant = grants.find((candidate) => candidate.accountId === accountId);
+  const label =
+    grant?.metadata && typeof grant.metadata.accountName === "string"
+      ? grant.metadata.accountName
+      : undefined;
+  return label?.trim() || null;
+}
+
+/** Human label for an organization: the grant's subjectLabel, else a short id. */
+export function orgLabel(accountId: string, grants: AccountGrant[]): string {
+  return orgName(accountId, grants) ?? `Org ${shortAccountId(accountId)}`;
+}
+
+/**
+ * The organizations the subject belongs to, in a stable order (default org
+ * first, then by name). Derived from account grants, unioned with the accounts
+ * that own the accessible workspaces so an org always shows even without an
+ * explicit grant.
+ */
+export function organizationsForSubject(
+  context: AccessContext,
+  workspaces: Workspace[],
+): OrgOption[] {
+  const administeredIds = new Set(organizationAdministrationAccountIds(context));
+  const ids = new Set<string>();
+  for (const grant of context.accountGrants) {
+    ids.add(grant.accountId);
+  }
+  for (const workspace of workspaces) {
+    ids.add(workspace.accountId);
+  }
+  const options = [...ids].map((accountId) => ({
+    accountId,
+    label: orgLabel(accountId, context.accountGrants),
+    canManage: administeredIds.has(accountId),
+  }));
+  return options.sort((a, b) => {
+    if (a.accountId === context.defaultAccountId) {
+      return -1;
+    }
+    if (b.accountId === context.defaultAccountId) {
+      return 1;
+    }
+    return a.label.localeCompare(b.label) || a.accountId.localeCompare(b.accountId);
+  });
+}
+
+/** Workspaces that belong to a given organization, ordered by name. */
+export function workspacesInOrg(workspaces: Workspace[], accountId: string): Workspace[] {
+  return workspaces
+    .filter((workspace) => workspace.accountId === accountId)
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/** Organization settings remain anchored to an accessible workspace in that organization. */
+export function organizationSettingsWorkspaceId(
+  workspaces: Workspace[],
+  accountId: string,
+  activeWorkspaceId: string,
+): string | null {
+  const candidates = workspacesInOrg(workspaces, accountId);
+  return (
+    candidates.find((workspace) => workspace.id === activeWorkspaceId)?.id ??
+    candidates[0]?.id ??
+    null
+  );
+}
+
+/**
+ * Where switching to an organization lands: the workspace last used there
+ * while it is still open to the person, else its first shared workspace, else
+ * their Personal workspace there. Null when nothing in it is open to them.
+ */
+export function organizationLandingWorkspaceId(
+  workspaces: Workspace[],
+  accountId: string,
+  rememberedWorkspaceId?: string | null,
+): string | null {
+  const candidates = workspacesInOrg(workspaces, accountId);
+  return (
+    candidates.find((workspace) => workspace.id === rememberedWorkspaceId)?.id ??
+    candidates.find((workspace) => workspace.kind !== "personal")?.id ??
+    candidates[0]?.id ??
+    null
+  );
+}

package/src/queue-presentation-model.ts

@@ -0,0 +1,464 @@
+/**
+ * Queue presentation shared by the web queue surface and native docks: the
+ * bounded head/tail previews of queued prompts, and the reorder plan and its
+ * optimistic projection. No DOM, no React.
+ */
+import type { SessionQueueSnapshot, SessionTurn } from "@opengeni/sdk";
+import { QUEUE_ITEM_CONTENT_UNAVAILABLE, queueItemContent } from "./components/queue-item-content";
+
+export { QUEUE_ITEM_CONTENT_UNAVAILABLE, queueItemContent };
+
+export const QUEUE_ROW_PREVIEW_CHARACTERS = 360;
+export const QUEUE_COLLAPSED_PREVIEW_CHARACTERS = 180;
+const QUEUE_PREVIEW_GRAPHEME_CONTEXT_CHARACTERS = 32;
+const QUEUE_PREVIEW_REFERENCE_SAMPLE_CHARACTERS = 32;
+const QUEUE_VISIBLE_END_IDENTITY_CHARACTERS = 18;
+const QUEUE_PREVIEW_SEPARATOR = " … ";
+// Hermes (React Native) has no Intl.Segmenter; there, previews fall back to
+// code points, which keeps every boundary rule except grapheme joining.
+let queuePreviewSegmenterCache: Intl.Segmenter | null | undefined;
+function queuePreviewSegments(sample: string): string[] {
+  if (queuePreviewSegmenterCache === undefined) {
+    queuePreviewSegmenterCache =
+      typeof Intl !== "undefined" && typeof Intl.Segmenter === "function"
+        ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
+        : null;
+  }
+  if (!queuePreviewSegmenterCache) return Array.from(sample);
+  return Array.from(queuePreviewSegmenterCache.segment(sample), (part) => part.segment);
+}
+const queuePromptNonRenderingCodePoint =
+  /[\p{White_Space}\p{Control}\p{Default_Ignorable_Code_Point}]/u;
+
+type BoundedPromptSample = {
+  value: string;
+  characters: number;
+  truncated: boolean;
+};
+
+export type QueuePromptPreview = {
+  summary: string;
+  collapsedVisual: string;
+  visibleStart: string;
+  visibleIdentity: string | null;
+  visibleIdentityLabel: "End" | "Safe boundary" | null;
+  isFallback: boolean;
+};
+
+function labelQueuePreview(summary: string): QueuePromptPreview {
+  return {
+    summary,
+    collapsedVisual: summary,
+    visibleStart: summary,
+    visibleIdentity: null,
+    visibleIdentityLabel: null,
+    isFallback: false,
+  };
+}
+
+export function queueTurnPreview(
+  turn: SessionTurn | undefined,
+  maxCharacters: number,
+): QueuePromptPreview {
+  if (!turn) return queuePromptPreview("", maxCharacters);
+  return queueContentPreview(turn.prompt, turn.annotations?.length ?? 0, maxCharacters);
+}
+
+export function queueContentPreview(
+  prompt: string,
+  annotationCount: number,
+  maxCharacters: number,
+): QueuePromptPreview {
+  switch (queueItemContent(prompt, annotationCount)) {
+    case "text":
+      return queuePromptPreview(prompt, maxCharacters);
+    case "annotations":
+      return labelQueuePreview(
+        `${annotationCount} timeline ${annotationCount === 1 ? "annotation" : "annotations"}`,
+      );
+    case "unavailable":
+      return labelQueuePreview(QUEUE_ITEM_CONTENT_UNAVAILABLE);
+  }
+}
+
+/**
+ * Build a bounded head/tail summary of an arbitrary queued prompt. Sampling
+ * both ends distinguishes prompts with equal long prefixes. Each sampled edge
+ * has a small amount of grapheme context so ordinary emoji/combining sequences
+ * can be retained whole. A cluster that exceeds that context is omitted rather
+ * than fragmented, and malformed UTF-16 is replaced only in the summary. The
+ * durable prompt remains exact and no operation scans or copies it in full.
+ */
+export function queuePromptPreview(prompt: string, maxCharacters: number): QueuePromptPreview {
+  const wholePromptProbe = samplePromptStart(prompt, maxCharacters + 1);
+  if (!wholePromptProbe.truncated && wholePromptProbe.characters <= maxCharacters) {
+    const summary = replaceLoneSurrogates(wholePromptProbe.value);
+    return hasVisiblePromptContent(summary)
+      ? {
+          summary,
+          collapsedVisual: summary,
+          visibleStart: summary,
+          visibleIdentity: null,
+          visibleIdentityLabel: null,
+          isFallback: false,
+        }
+      : fallbackPromptPreview(prompt.length, wholePromptProbe.value, wholePromptProbe.value);
+  }
+
+  const suffixCharacters = Math.min(Math.floor(maxCharacters / 3), 120);
+  const prefixCharacters =
+    maxCharacters - codePointLength(QUEUE_PREVIEW_SEPARATOR) - suffixCharacters;
+  const prefixSample = samplePromptStart(
+    prompt,
+    prefixCharacters + QUEUE_PREVIEW_GRAPHEME_CONTEXT_CHARACTERS,
+  );
+  const suffixSample = samplePromptEnd(
+    prompt,
+    suffixCharacters + QUEUE_PREVIEW_GRAPHEME_CONTEXT_CHARACTERS,
+  );
+  const prefixSegments = segmentPromptSample(prefixSample.value);
+  const suffixSegments = segmentPromptSample(suffixSample.value);
+
+  // A cluster at a truncated sampling edge may continue outside the sample.
+  // Prefix sampling starts at the true source start, so only its last segment
+  // is ambiguous. Suffix sampling ends at the true source end, so its first is.
+  if (prefixSample.truncated) prefixSegments.pop();
+  if (suffixSample.truncated) {
+    let ambiguousSegment = suffixSegments.shift();
+    // A locally segmented leading fragment ending in ZWJ can join the next
+    // pictographic segment when omitted left context supplies its base. Keep
+    // backing off until that uncertainty no longer propagates to the right.
+    while (ambiguousSegment?.endsWith("\u200d") && suffixSegments.length > 0) {
+      ambiguousSegment = suffixSegments.shift();
+    }
+    // Regional Indicator pairing depends on the parity of the preceding run.
+    // If that run reaches the unknown sample boundary, omit all of its visible
+    // leading segments rather than potentially recombining halves of flags.
+    while (suffixSegments[0] && startsWithRegionalIndicator(suffixSegments[0])) {
+      suffixSegments.shift();
+    }
+  }
+
+  const prefix = takeWholeGraphemesFromStart(prefixSegments, prefixCharacters);
+  const suffix = takeWholeGraphemesFromEnd(suffixSegments, suffixCharacters);
+  const reference = boundedPromptSampleReference(
+    prompt.length,
+    prefixSample.value,
+    suffixSample.value,
+  );
+
+  if (!hasVisiblePromptContent(prefix) && !hasVisiblePromptContent(suffix)) {
+    return fallbackPromptPreview(prompt.length, prefixSample.value, suffixSample.value);
+  }
+
+  const safeSuffix = hasVisiblePromptContent(suffix)
+    ? suffix
+    : promptPreviewFallbackLabel(reference);
+  const summary = `${prefix}${QUEUE_PREVIEW_SEPARATOR}${safeSuffix}`;
+  if (!hasVisiblePromptContent(prefix)) {
+    return {
+      summary,
+      collapsedVisual: summary,
+      visibleStart: safeSuffix,
+      visibleIdentity: null,
+      visibleIdentityLabel: null,
+      isFallback: false,
+    };
+  }
+
+  const endIdentity = takeWholeGraphemesFromEnd(
+    suffixSegments,
+    QUEUE_VISIBLE_END_IDENTITY_CHARACTERS,
+  );
+  return {
+    summary,
+    collapsedVisual: summary,
+    visibleStart: prefix,
+    visibleIdentity: hasVisiblePromptContent(endIdentity) ? endIdentity : `ref ${reference}`,
+    visibleIdentityLabel: hasVisiblePromptContent(endIdentity) ? "End" : "Safe boundary",
+    isFallback: false,
+  };
+}
+
+function fallbackPromptPreview(
+  promptLength: number,
+  startSample: string,
+  endSample: string,
+): QueuePromptPreview {
+  const reference = boundedPromptSampleReference(promptLength, startSample, endSample);
+  const summary = promptPreviewFallbackLabel(reference);
+  return {
+    summary,
+    collapsedVisual: `Omitted · ${reference}`,
+    // The complete fallback remains the canonical accessible summary. Narrow
+    // collapsed/row layouts paint the bounded reference in a compact truthful
+    // form so ellipsis cannot hide the only identifying portion.
+    visibleStart: `Omitted · ${reference}`,
+    visibleIdentity: null,
+    visibleIdentityLabel: null,
+    isFallback: true,
+  };
+}
+
+function promptPreviewFallbackLabel(reference: string): string {
+  return `Content omitted at safe boundary · ref ${reference}`;
+}
+
+function boundedPromptSampleReference(
+  promptLength: number,
+  startSample: string,
+  endSample: string,
+): string {
+  const head = samplePromptStart(startSample, QUEUE_PREVIEW_REFERENCE_SAMPLE_CHARACTERS).value;
+  const tail = samplePromptEnd(endSample, QUEUE_PREVIEW_REFERENCE_SAMPLE_CHARACTERS).value;
+  let hash = 0x811c9dc5;
+  for (const value of [String(promptLength), head, tail]) {
+    for (let index = 0; index < value.length; index += 1) {
+      hash ^= value.charCodeAt(index);
+      hash = Math.imul(hash, 0x01000193);
+    }
+    hash ^= 0xffff;
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0").toUpperCase();
+}
+
+function hasVisiblePromptContent(value: string): boolean {
+  // Callers pass only the already-bounded whole/head/tail preview samples.
+  // Default-ignorables and controls can survive trim() while painting no row
+  // identity at all (for example ZWJ, VS16, bidi controls, and tag characters).
+  for (const character of value) {
+    if (!queuePromptNonRenderingCodePoint.test(character)) return true;
+  }
+  return false;
+}
+
+function samplePromptStart(prompt: string, maxCharacters: number): BoundedPromptSample {
+  let end = 0;
+  let characters = 0;
+  while (end < prompt.length && characters < maxCharacters) {
+    const first = prompt.charCodeAt(end);
+    end +=
+      isHighSurrogate(first) &&
+      end + 1 < prompt.length &&
+      isLowSurrogate(prompt.charCodeAt(end + 1))
+        ? 2
+        : 1;
+    characters += 1;
+  }
+  return { value: prompt.slice(0, end), characters, truncated: end < prompt.length };
+}
+
+function samplePromptEnd(prompt: string, maxCharacters: number): BoundedPromptSample {
+  let start = prompt.length;
+  let characters = 0;
+  while (start > 0 && characters < maxCharacters) {
+    start -= 1;
+    if (
+      isLowSurrogate(prompt.charCodeAt(start)) &&
+      start > 0 &&
+      isHighSurrogate(prompt.charCodeAt(start - 1))
+    ) {
+      start -= 1;
+    }
+    characters += 1;
+  }
+  return { value: prompt.slice(start), characters, truncated: start > 0 };
+}
+
+function segmentPromptSample(sample: string): string[] {
+  return queuePreviewSegments(replaceLoneSurrogates(sample));
+}
+
+function replaceLoneSurrogates(value: string): string {
+  let sanitized = "";
+  for (let index = 0; index < value.length; index += 1) {
+    const current = value.charCodeAt(index);
+    if (
+      isHighSurrogate(current) &&
+      index + 1 < value.length &&
+      isLowSurrogate(value.charCodeAt(index + 1))
+    ) {
+      sanitized += value.slice(index, index + 2);
+      index += 1;
+    } else if (isHighSurrogate(current) || isLowSurrogate(current)) {
+      sanitized += "�";
+    } else {
+      sanitized += value[index];
+    }
+  }
+  return sanitized;
+}
+
+function takeWholeGraphemesFromStart(segments: string[], maxCharacters: number): string {
+  const selected: string[] = [];
+  let characters = 0;
+  for (const segment of segments) {
+    const segmentCharacters = codePointLength(segment);
+    if (characters + segmentCharacters > maxCharacters) break;
+    selected.push(segment);
+    characters += segmentCharacters;
+  }
+  while (selected.at(-1)?.trim().length === 0) selected.pop();
+  return selected.join("");
+}
+
+function takeWholeGraphemesFromEnd(segments: string[], maxCharacters: number): string {
+  const selected: string[] = [];
+  let characters = 0;
+  for (let index = segments.length - 1; index >= 0; index -= 1) {
+    const segment = segments[index];
+    if (!segment) continue;
+    const segmentCharacters = codePointLength(segment);
+    if (characters + segmentCharacters > maxCharacters) break;
+    selected.unshift(segment);
+    characters += segmentCharacters;
+  }
+  while (selected[0]?.trim().length === 0) selected.shift();
+  while (selected.at(-1)?.trim().length === 0) selected.pop();
+  return selected.join("");
+}
+
+function codePointLength(value: string): number {
+  let characters = 0;
+  for (const _character of value) characters += 1;
+  return characters;
+}
+
+function startsWithRegionalIndicator(value: string): boolean {
+  const codePoint = value.codePointAt(0);
+  return codePoint !== undefined && codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff;
+}
+
+function isHighSurrogate(codeUnit: number): boolean {
+  return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+
+function isLowSurrogate(codeUnit: number): boolean {
+  return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
+}
+
+/** Move one item, as dnd-kit's arrayMove does. */
+export function moveQueueItem<T>(items: readonly T[], from: number, to: number): T[] {
+  const next = items.slice();
+  const [item] = next.splice(from, 1);
+  if (item === undefined) return next;
+  next.splice(to < 0 ? next.length + to : to, 0, item);
+  return next;
+}
+
+export type QueueMovePlan = {
+  /** The turn ids in their new order. */
+  turnIds: string[];
+  /** The server anchor: the turn the moved one now precedes, null for last. */
+  beforeTurnId: string | null;
+  /** The bounded destination index. */
+  index: number;
+};
+
+/** The reorder request for moving a queued turn to an index, or null for a no-op. */
+export function queueMovePlan(
+  queue: readonly SessionTurn[],
+  turnId: string,
+  nextIndex: number,
+): QueueMovePlan | null {
+  const oldIndex = queue.findIndex((turn) => turn.id === turnId);
+  if (oldIndex < 0) return null;
+  const index = Math.max(0, Math.min(nextIndex, queue.length - 1));
+  if (oldIndex === index) return null;
+  const ordered = moveQueueItem(queue, oldIndex, index);
+  return {
+    turnIds: ordered.map((turn) => turn.id),
+    beforeTurnId: ordered[index + 1]?.id ?? null,
+    index,
+  };
+}
+
+export type PendingQueueMove = { baseVersion: number | null; turnIds: string[] };
+
+/**
+ * The queue as shown while a move is in flight: the optimistic order, unless
+ * any authoritative change arrived. A projection never omits or invents a row.
+ */
+export function projectPendingQueueMove(
+  queue: SessionTurn[],
+  pendingMove: PendingQueueMove | null,
+  snapshot: Pick<SessionQueueSnapshot, "version"> | null,
+): SessionTurn[] {
+  if (
+    !pendingMove ||
+    pendingMove.baseVersion === null ||
+    snapshot?.version !== pendingMove.baseVersion
+  ) {
+    return queue;
+  }
+  const byId = new Map(queue.map((turn) => [turn.id, turn]));
+  const projected = pendingMove.turnIds.map((turnId) => byId.get(turnId));
+  if (projected.some((turn) => !turn) || projected.length !== queue.length) {
+    return queue;
+  }
+  return projected as SessionTurn[];
+}
+
+/** Copy for the "replace your draft with this queued prompt" confirmation. */
+export const QUEUE_REPLACE_DRAFT_COPY = {
+  title: "Your composer already has a draft. Replace it with this queued prompt?",
+  detail:
+    "The current draft will be permanently discarded; this queued prompt is preserved until you confirm.",
+  keep: "Keep current draft",
+  replace: "Replace and edit",
+} as const;
+
+export type QueuedTurnPresentation = {
+  kind: "prompt" | "realtime_voice" | "realtime_voice_handoff";
+  text: string;
+};
+
+function objectValue(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+/** What a queued row shows: the prompt, or the transcript of a voice request. */
+export function queuedTurnPresentation(turn: SessionTurn): QueuedTurnPresentation {
+  const realtimeDelegation = objectValue(turn.metadata.realtimeDelegation);
+  const inputTranscript = realtimeDelegation?.inputTranscript;
+  if (typeof inputTranscript === "string" && inputTranscript.trim()) {
+    return { kind: "realtime_voice", text: inputTranscript.trim() };
+  }
+  if (objectValue(turn.metadata.realtimeTailFlush)) {
+    return { kind: "realtime_voice_handoff", text: "Remaining voice context" };
+  }
+  return { kind: "prompt", text: turn.prompt };
+}
+
+export function isSteeringTurn(turn: SessionTurn): boolean {
+  return turn.metadata.delivery === "steer";
+}
+
+/** A queued turn that is really waiting: not already a steer in flight. */
+export function isAuthoritativeQueuedTurn(
+  turn: SessionTurn,
+  mutationFor: (turnId: string) => string | null,
+): boolean {
+  return !isSteeringTurn(turn) && mutationFor(turn.id) !== "steer";
+}
+
+export function countAuthoritativeQueuedTurns(
+  turns: readonly SessionTurn[],
+  mutationFor: (turnId: string) => string | null,
+): number {
+  return turns.filter((turn) => isAuthoritativeQueuedTurn(turn, mutationFor)).length;
+}
+
+/** The move anchors for one row's Move up / Move down. */
+export function queueNeighborAnchors(
+  turns: readonly SessionTurn[],
+  index: number,
+): { beforeUp: string | null; beforeDown: string | null } {
+  return {
+    beforeUp: index > 0 ? (turns[index - 1]?.id ?? null) : null,
+    beforeDown: index < turns.length - 1 ? (turns[index + 2]?.id ?? null) : null,
+  };
+}