@takosjp/yurucommu-core 3.2.1 → 3.4.0

package/packages/api/src/types/call.ts

@@ -0,0 +1,298 @@
+/**
+ * Call signaling wire contract (voice + video).
+ *
+ * SINGLE SOURCE OF TRUTH shared by:
+ *   - the backend cross-instance signaling ingest (`/ap/rtc/signal`) + the
+ *     Signaling Durable Object (server-to-server + browser fan-out), and
+ *   - the browser `CallClient` (`../lib/rtc-client.ts`).
+ *
+ * Kept deliberately DOM-structural (no `RTCIceCandidateInit` / `RTCIceServer`
+ * imports) so the same file type-checks in the server context (which never runs
+ * the browser WebRTC APIs) and the browser bundle. The `CallClient` maps these
+ * structural shapes to/from the real DOM `RTCSessionDescriptionInit` /
+ * `RTCIceCandidateInit` / `RTCIceServer`, which are structurally compatible.
+ *
+ * Design: signaling travels over federation (server-to-server, HTTP-Signature
+ * authenticated) as `RtcSignalEnvelopeV1`; media is P2P WebRTC + STUN/TURN for
+ * 1:1 (`sfuFocus: null`) and a pluggable WHIP/WHEP SFU focus for group calls.
+ */
+
+export const RTC_SIGNAL_ENVELOPE_VERSION = 1 as const;
+
+/** Which media tracks a call carries. `video:false` => audio-only call. */
+export interface CallMediaKind {
+  audio: boolean;
+  video: boolean;
+}
+
+/** Cross-instance signaling message kinds (Matrix-VoIP inspired). */
+export type RtcSignalType =
+  "offer" | "answer" | "candidate" | "accept" | "reject" | "hangup" | "cancel";
+
+/**
+ * Selected SFU focus for a group call. `null`/absent means pure P2P (1:1).
+ * `kind` names the adapter (`whip` / `livekit` / `cloudflare-realtime` / ...);
+ * the client talks WHIP/WHEP so the SFU backend stays vendor-neutral.
+ */
+export interface SfuFocus {
+  kind: string;
+  /** WHIP (publish) / WHEP (subscribe) endpoint base, or SFU signaling URL. */
+  url: string;
+  /** Short-lived join token when the adapter requires one. */
+  token?: string;
+  room?: string;
+}
+
+/** Structural mirror of `RTCIceCandidateInit` (no DOM dependency). */
+export interface CallIceCandidate {
+  candidate: string;
+  sdpMid?: string | null;
+  sdpMLineIndex?: number | null;
+  usernameFragment?: string | null;
+}
+
+/** Structural mirror of `RTCIceServer` (no DOM dependency). */
+export interface IceServerConfig {
+  urls: string | string[];
+  username?: string;
+  credential?: string;
+}
+
+/**
+ * Server-to-server signaling envelope. Delivered by the sending instance to the
+ * recipient instance's `/ap/rtc/signal` endpoint, signed with the sender actor's
+ * HTTP Signature key (keyId-owner === `from`). `callId` doubles as the anti-
+ * replay nonce; `ts`/`ttlMs` bound its freshness (the DO drops stale frames).
+ */
+export interface RtcSignalEnvelopeV1 {
+  v: typeof RTC_SIGNAL_ENVELOPE_VERSION;
+  callId: string;
+  from: string;
+  to: string;
+  type: RtcSignalType;
+  media?: CallMediaKind;
+  /** SDP for `offer` / `answer`. */
+  sdp?: string;
+  /** Half-trickle ICE bundle for `offer` / `answer` / `candidate`. */
+  candidates?: CallIceCandidate[];
+  sfuFocus?: SfuFocus | null;
+  /** Free-text end/reject reason (`busy`, `declined`, `timeout`, ...). */
+  reason?: string;
+  ts: number;
+  ttlMs: number;
+}
+
+/** Lifecycle of a single call, mirrored client-side and in `call_sessions`. */
+export type CallState =
+  | "idle"
+  | "ringing"
+  | "connecting"
+  | "connected"
+  | "ended"
+  | "rejected"
+  | "missed"
+  | "failed"
+  | "cancelled";
+
+export type CallDirection = "incoming" | "outgoing";
+
+/** Terminal states — a call in one of these is over and not resumable. */
+export const TERMINAL_CALL_STATES: readonly CallState[] = [
+  "ended",
+  "rejected",
+  "missed",
+  "failed",
+  "cancelled",
+];
+
+export function isTerminalCallState(state: CallState): boolean {
+  return TERMINAL_CALL_STATES.includes(state);
+}
+
+// ---------------------------------------------------------------------------
+// Browser <-> Signaling Durable Object WebSocket frames
+// ---------------------------------------------------------------------------
+
+/** Frames the browser sends up to its own instance's Signaling DO. */
+export type ClientToHubFrame =
+  | { t: "hello" }
+  | { t: "invite"; callId: string; to: string; media: CallMediaKind }
+  | { t: "offer"; callId: string; sdp: string }
+  | { t: "answer"; callId: string; sdp: string }
+  | { t: "candidates"; callId: string; candidates: CallIceCandidate[] }
+  | { t: "accept"; callId: string }
+  | { t: "reject"; callId: string; reason?: string }
+  | { t: "hangup"; callId: string; reason?: string }
+  | { t: "resume"; callId: string }
+  | { t: "ping" };
+
+/** Frames the Signaling DO pushes down to the browser. */
+export type HubToClientFrame =
+  | { t: "ready" }
+  | { t: "ringing"; callId: string; from: string; media: CallMediaKind }
+  | { t: "offer"; callId: string; sdp: string; media?: CallMediaKind }
+  | { t: "answer"; callId: string; sdp: string }
+  | { t: "candidates"; callId: string; candidates: CallIceCandidate[] }
+  | { t: "peer-accepted"; callId: string }
+  | { t: "peer-rejected"; callId: string; reason?: string }
+  | { t: "peer-hangup"; callId: string; reason?: string }
+  | {
+      t: "ice-servers";
+      callId: string;
+      iceServers: IceServerConfig[];
+      sfuFocus?: SfuFocus | null;
+    }
+  | { t: "call-state"; callId: string; state: CallState }
+  | { t: "pong" }
+  | { t: "error"; code: string; message?: string };
+
+// ---------------------------------------------------------------------------
+// REST contract (start call / mint ICE / call history)
+// ---------------------------------------------------------------------------
+
+export interface StartCallRequest {
+  to: string;
+  media: CallMediaKind;
+}
+
+export interface StartCallResponse {
+  callId: string;
+  iceServers: IceServerConfig[];
+  sfuFocus?: SfuFocus | null;
+}
+
+export interface IceServersResponse {
+  iceServers: IceServerConfig[];
+}
+
+export interface CallSessionSummary {
+  id: string;
+  peer: string;
+  direction: CallDirection;
+  state: CallState;
+  media: CallMediaKind;
+  createdAt: string;
+  connectedAt?: string | null;
+  endedAt?: string | null;
+  endReason?: string | null;
+}
+
+// ---------------------------------------------------------------------------
+// Runtime validation (used by the backend ingest to reject malformed frames)
+// ---------------------------------------------------------------------------
+
+const SIGNAL_TYPES: readonly RtcSignalType[] = [
+  "offer",
+  "answer",
+  "candidate",
+  "accept",
+  "reject",
+  "hangup",
+  "cancel",
+];
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isCallMediaKind(value: unknown): value is CallMediaKind {
+  return (
+    isPlainObject(value) &&
+    typeof value.audio === "boolean" &&
+    typeof value.video === "boolean"
+  );
+}
+
+function parseCandidates(value: unknown): CallIceCandidate[] | undefined {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value)) return undefined;
+  const out: CallIceCandidate[] = [];
+  for (const raw of value) {
+    if (!isPlainObject(raw) || typeof raw.candidate !== "string") continue;
+    out.push({
+      candidate: raw.candidate,
+      sdpMid: typeof raw.sdpMid === "string" ? raw.sdpMid : null,
+      sdpMLineIndex:
+        typeof raw.sdpMLineIndex === "number" ? raw.sdpMLineIndex : null,
+      usernameFragment:
+        typeof raw.usernameFragment === "string" ? raw.usernameFragment : null,
+    });
+  }
+  return out;
+}
+
+function parseSfuFocus(value: unknown): SfuFocus | null | undefined {
+  if (value === undefined) return undefined;
+  if (value === null) return null;
+  if (!isPlainObject(value)) return undefined;
+  if (typeof value.kind !== "string" || typeof value.url !== "string") {
+    return undefined;
+  }
+  return {
+    kind: value.kind,
+    url: value.url,
+    token: typeof value.token === "string" ? value.token : undefined,
+    room: typeof value.room === "string" ? value.room : undefined,
+  };
+}
+
+/**
+ * Parse + validate an inbound cross-instance signaling envelope. Returns the
+ * normalized envelope or `null` when the shape is invalid. Callers additionally
+ * enforce that the HTTP-Signature signer equals `from` and that the recipient
+ * (`to`) is a local actor.
+ */
+export function parseRtcSignalEnvelope(
+  input: unknown,
+): RtcSignalEnvelopeV1 | null {
+  if (!isPlainObject(input)) return null;
+  if (input.v !== RTC_SIGNAL_ENVELOPE_VERSION) return null;
+  const { callId, from, to, type, ts, ttlMs } = input;
+  if (
+    typeof callId !== "string" ||
+    callId.length === 0 ||
+    callId.length > 200 ||
+    typeof from !== "string" ||
+    from.length === 0 ||
+    typeof to !== "string" ||
+    to.length === 0 ||
+    typeof type !== "string" ||
+    !SIGNAL_TYPES.includes(type as RtcSignalType) ||
+    typeof ts !== "number" ||
+    !Number.isFinite(ts) ||
+    typeof ttlMs !== "number" ||
+    !Number.isFinite(ttlMs) ||
+    ttlMs < 0
+  ) {
+    return null;
+  }
+  const sdp = typeof input.sdp === "string" ? input.sdp : undefined;
+  // Guard against absurd SDP blobs abusing the endpoint as a relay.
+  if (sdp !== undefined && sdp.length > 100_000) return null;
+  return {
+    v: RTC_SIGNAL_ENVELOPE_VERSION,
+    callId,
+    from,
+    to,
+    type: type as RtcSignalType,
+    media: isCallMediaKind(input.media) ? input.media : undefined,
+    sdp,
+    candidates: parseCandidates(input.candidates),
+    sfuFocus: parseSfuFocus(input.sfuFocus),
+    reason:
+      typeof input.reason === "string" ? input.reason.slice(0, 200) : undefined,
+    ts,
+    ttlMs,
+  };
+}
+
+/** True when the envelope is still within its freshness window. */
+export function isEnvelopeFresh(
+  envelope: RtcSignalEnvelopeV1,
+  now: number,
+): boolean {
+  // Reject frames from the future (clock skew tolerance) or past their TTL.
+  const skewToleranceMs = 30_000;
+  if (envelope.ts - now > skewToleranceMs) return false;
+  return now - envelope.ts <= envelope.ttlMs;
+}

package/packages/api/src/types/index.ts

@@ -1,3 +1,9 @@
+// Call signaling wire contract + browser<->hub frames (voice + video).
+export * from "./call.ts";
+
+// Realtime stream wire contract (per-user event feed + control frames).
+export * from "./realtime.ts";
+
 // ===== Yurucommu AP-Native Types =====
 
 // Actor represents a user (Person) in ActivityPub

package/packages/api/src/types/realtime.ts

@@ -0,0 +1,139 @@
+/**
+ * Realtime stream wire contract (browser <-> per-user RealtimeStreamDO).
+ *
+ * One authenticated WebSocket per user carries every live update the client
+ * used to poll for: talk messages, typing, read receipts, contact-list
+ * changes, new notifications, and the authoritative unread counters. The
+ * server pushes `RealtimeEvent` envelopes; the client sends only the small
+ * control frames below (writes stay on the REST API).
+ *
+ * Event ids are a per-user monotonic sequence assigned by the Durable Object.
+ * A reconnecting client offers its last seen id in `hello`; the DO replays the
+ * gap from its ring buffer, or answers `resync` when the gap is older than the
+ * buffer so the client re-fetches via the normal REST reads.
+ */
+
+export type RealtimeEventType =
+  | "talk.message"
+  | "talk.typing"
+  | "talk.read"
+  | "talk.contacts_changed"
+  | "notification.new"
+  | "unread";
+
+export interface RealtimeEvent {
+  /** Per-user monotonic sequence number (assigned by the stream DO). */
+  id: number;
+  type: RealtimeEventType;
+  data: Record<string, unknown>;
+}
+
+/** `talk.message` payload. `other_ap_id` is from the RECEIVING user's view. */
+export interface TalkMessageEventData {
+  kind: "dm" | "community";
+  /** DM: the counterpart actor (per-recipient). */
+  other_ap_id?: string;
+  /** Community chat: the community actor. */
+  community_ap_id?: string;
+  conversation_id?: string;
+  message: {
+    id: string;
+    sender: {
+      ap_id: string;
+      username: string;
+      preferred_username: string | null;
+      name: string | null;
+      icon_url: string | null;
+    };
+    content: string | null;
+    attachments?: unknown[];
+    created_at: string | null;
+  };
+}
+
+export interface TalkTypingEventData {
+  other_ap_id: string;
+  is_typing: boolean;
+  typed_at: string;
+}
+
+export interface TalkReadEventData {
+  other_ap_id: string;
+  conversation_id: string;
+  last_read_at: string;
+}
+
+/** Authoritative unread counters (server-computed; never client-derived). */
+export interface UnreadEventData {
+  dm: number;
+  community: number;
+  talk_total: number;
+  notifications: number;
+}
+
+// --- Client -> server frames -------------------------------------------------
+
+export type RealtimeClientFrame =
+  { t: "hello"; lastEventId?: number } | { t: "ping" } | { t: "pong" };
+
+// --- Server -> client frames -------------------------------------------------
+
+export type RealtimeServerFrame =
+  | { t: "hello_ok"; lastEventId: number }
+  | { t: "event"; event: RealtimeEvent }
+  /** The requested replay gap is older than the buffer: re-fetch via REST. */
+  | { t: "resync" }
+  | { t: "ping" }
+  | { t: "pong" };
+
+export function parseRealtimeClientFrame(
+  raw: unknown,
+): RealtimeClientFrame | null {
+  if (!raw || typeof raw !== "object") return null;
+  const frame = raw as { t?: unknown; lastEventId?: unknown };
+  if (frame.t === "ping" || frame.t === "pong") return { t: frame.t };
+  if (frame.t === "hello") {
+    const lastEventId =
+      typeof frame.lastEventId === "number" &&
+      Number.isFinite(frame.lastEventId) &&
+      frame.lastEventId >= 0
+        ? Math.floor(frame.lastEventId)
+        : undefined;
+    return { t: "hello", lastEventId };
+  }
+  return null;
+}
+
+export function parseRealtimeServerFrame(
+  raw: unknown,
+): RealtimeServerFrame | null {
+  if (!raw || typeof raw !== "object") return null;
+  const frame = raw as { t?: unknown; event?: unknown; lastEventId?: unknown };
+  if (frame.t === "ping" || frame.t === "pong" || frame.t === "resync") {
+    return { t: frame.t };
+  }
+  if (frame.t === "hello_ok" && typeof frame.lastEventId === "number") {
+    return { t: "hello_ok", lastEventId: frame.lastEventId };
+  }
+  if (frame.t === "event" && frame.event && typeof frame.event === "object") {
+    const event = frame.event as {
+      id?: unknown;
+      type?: unknown;
+      data?: unknown;
+    };
+    if (typeof event.id === "number" && typeof event.type === "string") {
+      return {
+        t: "event",
+        event: {
+          id: event.id,
+          type: event.type as RealtimeEventType,
+          data:
+            event.data && typeof event.data === "object"
+              ? (event.data as Record<string, unknown>)
+              : {},
+        },
+      };
+    }
+  }
+  return null;
+}

package/src/backend/index.ts

@@ -29,6 +29,9 @@ import { moderationRoutes } from "./routes/moderation.ts";
 import { appsApiRoutes, appsServeRoutes } from "./routes/apps.ts";
 import mobileRoutes from "./routes/mobile.ts";
 import notificationPusherRoutes from "./routes/notification-pushers.ts";
+import rtcRoutes from "./routes/rtc/index.ts";
+import realtimeRoutes from "./routes/realtime/index.ts";
+import { sweepRealtimeNotifications } from "./runtime/realtime-hub.ts";
 
 import { rateLimit, RateLimitConfigs } from "./middleware/rate-limit.ts";
 import { csrfProtection } from "./middleware/csrf.ts";
@@ -254,6 +257,7 @@ function buildSocialServerDiscovery(
       authProviders: `${appUrl}/api/auth/providers`,
       mobilePasswordLogin: `${appUrl}/api/auth/mobile/login`,
       mobileOidcExchange: `${appUrl}/api/auth/mobile/oidc`,
+      mobileLogout: `${appUrl}/api/auth/logout`,
       currentUser: `${appUrl}/api/auth/me`,
       timeline: `${appUrl}/api/timeline`,
       conversations: `${appUrl}/api/dm/contacts`,
@@ -506,6 +510,11 @@ function applyGlobalMiddleware(app: YurucommuApp): void {
   app.use("*", async (c, next) => {
     await next();
 
+    // A 101 Switching Protocols response carries a WebSocket and immutable
+    // headers (the /api/rtc/socket call upgrade). Mutating it throws and breaks
+    // the upgrade, so skip the security-header pass for it.
+    if (c.res.status === 101) return;
+
     const preserveRouteSecurityHeaders = c.req.path.startsWith("/hosted/");
     const setSecurityHeader = (name: string, value: string) => {
       if (preserveRouteSecurityHeaders && c.res.headers.has(name)) {
@@ -553,9 +562,11 @@ function applyGlobalMiddleware(app: YurucommuApp): void {
     setSecurityHeader("X-Content-Type-Options", "nosniff");
     setSecurityHeader("X-Frame-Options", "DENY");
     setSecurityHeader("Referrer-Policy", "strict-origin-when-cross-origin");
+    // Allow the app's OWN origin to use camera + microphone (WebRTC calls);
+    // still deny geolocation and deny camera/mic to any cross-origin frame.
     setSecurityHeader(
       "Permissions-Policy",
-      "camera=(), microphone=(), geolocation=()",
+      "camera=(self), microphone=(self), geolocation=()",
     );
     // HSTS: once a client has reached this host over HTTPS, keep it on HTTPS
     // (defeats SSL-strip / downgrade). Sent unconditionally — browsers ignore it
@@ -591,6 +602,9 @@ function applyGlobalMiddleware(app: YurucommuApp): void {
             error,
           });
         }
+        // Same choke point feeds the realtime stream: the push-jobs the inbox
+        // trigger wrote tell us exactly which users gained a notification.
+        await sweepRealtimeNotifications(c.env);
       })();
       // Prefer to run the sweep AFTER the response is sent (waitUntil) so its
       // 2-4 D1 round-trips never add latency to the request. `executionCtx`
@@ -693,6 +707,11 @@ function applyGlobalMiddleware(app: YurucommuApp): void {
     app.use(pattern, rateLimit(RateLimitConfigs.inbox));
   }
 
+  // Cross-instance call signaling ingest is unauthenticated at the network edge
+  // (it verifies an HTTP Signature inside the handler) and can be hit by any
+  // remote instance, so throttle it per-IP like the other federation endpoints.
+  app.use("/ap/rtc/signal", rateLimit(RateLimitConfigs.federationDiscovery));
+
   // Federation discovery endpoints are unauthenticated and can be probed by
   // any remote actor. Throttle them per-IP to mitigate enumeration / DoS.
   app.use(
@@ -766,6 +785,10 @@ function mountCoreRoutes(app: YurucommuApp): void {
   app.route("/api/moderation", moderationRoutes);
   app.route("/api/apps", appsApiRoutes);
   app.route("/hosted", appsServeRoutes);
+  // Realtime stream: capability probe + WS ticket + per-user socket upgrade.
+  app.route("/api/realtime", realtimeRoutes);
+  // Call feature: /api/rtc/* (session) + /ap/rtc/signal (server-to-server).
+  app.route("/", rtcRoutes);
   app.route("/", activitypubRoutes);
 }
 
@@ -933,6 +956,14 @@ type WorkerBindings = EnvVars & {
   ASSETS?: Fetcher;
   DELIVERY_QUEUE?: Queue<DeliveryQueueMessageV1>;
   DELIVERY_DLQ?: Queue<DeliveryDlqMessageV1>;
+  // Signaling hub Durable Object namespace (call feature). wrapCloudflareBindings
+  // spreads it through untouched (it is not DB/MEDIA/KV/ASSETS) so app code and
+  // the rtc routes read it as c.env.CALL_SIGNALING.
+  CALL_SIGNALING?: DurableObjectNamespace;
+  // Per-user realtime event stream Durable Object namespace. Same pass-through
+  // as CALL_SIGNALING; optional — when unbound the realtime routes answer 503
+  // and clients fall back to polling.
+  REALTIME_STREAM?: DurableObjectNamespace;
 };
 
 export default {

package/src/backend/lib/delivery/queue.ts

@@ -531,6 +531,10 @@ export async function handleDeliveryQueueBatch(
       error,
     });
   }
+  // Same choke point feeds the realtime stream (federated + fanout inserts).
+  const { sweepRealtimeNotifications } =
+    await import("../../runtime/realtime-hub.ts");
+  await sweepRealtimeNotifications(env);
 }
 
 export async function handleDeliveryDlqBatch(

package/src/backend/lib/rtc/call-store.ts

@@ -0,0 +1,101 @@
+/**
+ * Durable persistence for call sessions (history / missed-call / current state).
+ * Ephemeral SDP/ICE never touches this — only the call lifecycle does.
+ */
+
+import { and, desc, eq } from "drizzle-orm";
+import type { Database } from "../../../db/index.ts";
+import { callSessions, nowIso } from "../../../db/index.ts";
+import type {
+  CallSessionSummary,
+  CallDirection,
+  CallState,
+} from "../../../../packages/api/src/types/call.ts";
+import { isTerminalCallState } from "../../../../packages/api/src/types/call.ts";
+import type { CallRecord } from "../../runtime/call-hub-core.ts";
+
+/** Insert or update the durable row for a call transition. */
+export async function upsertCallSession(
+  db: Database,
+  localActorApId: string,
+  call: CallRecord,
+): Promise<void> {
+  const now = nowIso();
+  const terminal = isTerminalCallState(call.state);
+  const connectedAt = call.connectedAt
+    ? new Date(call.connectedAt).toISOString()
+    : null;
+  const sfuFocus = call.sfuFocus ? JSON.stringify(call.sfuFocus) : null;
+  await db
+    .insert(callSessions)
+    .values({
+      id: call.callId,
+      localActorApId,
+      peerActorApId: call.peerApId,
+      direction: call.direction,
+      state: call.state,
+      mediaAudio: call.media.audio ? 1 : 0,
+      mediaVideo: call.media.video ? 1 : 0,
+      sfuFocus,
+      peerSignalEndpoint: call.peerSignalEndpoint ?? null,
+      connectedAt,
+      endedAt: terminal ? now : null,
+    })
+    .onConflictDoUpdate({
+      target: callSessions.id,
+      set: {
+        state: call.state,
+        sfuFocus,
+        peerSignalEndpoint: call.peerSignalEndpoint ?? null,
+        connectedAt,
+        endedAt: terminal ? now : null,
+        updatedAt: now,
+      },
+    });
+}
+
+function toSummary(row: typeof callSessions.$inferSelect): CallSessionSummary {
+  return {
+    id: row.id,
+    peer: row.peerActorApId,
+    direction: row.direction as CallDirection,
+    state: row.state as CallState,
+    media: { audio: row.mediaAudio === 1, video: row.mediaVideo === 1 },
+    createdAt: row.createdAt,
+    connectedAt: row.connectedAt,
+    endedAt: row.endedAt,
+    endReason: row.endReason,
+  };
+}
+
+export async function listCallSessions(
+  db: Database,
+  localActorApId: string,
+  limit = 50,
+): Promise<CallSessionSummary[]> {
+  const rows = await db
+    .select()
+    .from(callSessions)
+    .where(eq(callSessions.localActorApId, localActorApId))
+    .orderBy(desc(callSessions.createdAt))
+    .limit(Math.min(Math.max(limit, 1), 200));
+  return rows.map(toSummary);
+}
+
+export async function getCallSession(
+  db: Database,
+  localActorApId: string,
+  callId: string,
+): Promise<CallSessionSummary | null> {
+  const row = await db
+    .select()
+    .from(callSessions)
+    .where(
+      and(
+        eq(callSessions.id, callId),
+        eq(callSessions.localActorApId, localActorApId),
+      ),
+    )
+    .get();
+  return row ? toSummary(row) : null;
+}