@takosjp/yurucommu-core 3.3.0 → 3.4.1

package/src/backend/routes/auth.ts

@@ -7,6 +7,7 @@ import {
   fetchUserInfo,
   getAuthConfig,
   getClientCredentials,
+  getMobileOidcAudience,
   getProvider,
 } from "../lib/oauth-providers.ts";
 import { verifyOidcIdToken } from "../lib/oidc-id-token.ts";
@@ -296,7 +297,7 @@ auth.post("/mobile/oidc", async (c) => {
   }
 
   try {
-    const { clientId } = getClientCredentials(c.env, "takos");
+    const clientId = getMobileOidcAudience(c.env);
     const claims = await verifyOidcIdToken(idToken, {
       issuer: provider.issuer,
       clientId,

package/src/backend/routes/communities/messages.ts

@@ -23,6 +23,12 @@ import {
 } from "../../lib/attachments.ts";
 import { communityRequiresMembership } from "../../lib/community-visibility.ts";
 import { rateLimit, RateLimitConfigs } from "../../middleware/rate-limit.ts";
+import {
+  emitRealtimeBestEffort,
+  emitUnreadSnapshot,
+  isRealtimeAvailable,
+  runRealtimeAfterResponse,
+} from "../../runtime/realtime-hub.ts";
 import {
   deleteObjectCascade,
   purgeMediaBlobs,
@@ -408,24 +414,54 @@ messagesRouter.post(
       ...pushJobStatements,
     ]);
 
-    return c.json(
-      {
-        message: {
-          id: objectApId,
-          sender: {
-            ap_id: actor.ap_id,
-            username: formatUsername(actor.ap_id),
-            preferred_username: actor.preferred_username,
-            name: actor.name,
-            icon_url: actor.icon_url,
-          },
-          content,
-          attachments,
-          created_at: now,
-        },
+    const messagePayload = {
+      id: objectApId,
+      sender: {
+        ap_id: actor.ap_id,
+        username: formatUsername(actor.ap_id),
+        preferred_username: actor.preferred_username,
+        name: actor.name,
+        icon_url: actor.icon_url,
       },
-      201,
-    );
+      content,
+      attachments,
+      created_at: now,
+    };
+
+    // Realtime fanout to LOCAL members (best-effort, after the response).
+    // Community talk has no inbox row, so the shared notification sweep never
+    // sees it — this direct emit is the only realtime path. Membership rows
+    // exist only for local members (remote membership is a follows edge), and
+    // the fanout is capped so a huge community cannot stall the writer.
+    if (isRealtimeAvailable(c.env)) {
+      const communityApIdForEmit = community.apId;
+      await runRealtimeAfterResponse(c, async () => {
+        const members = await db
+          .select({ actorApId: communityMembers.actorApId })
+          .from(communityMembers)
+          .where(eq(communityMembers.communityApId, communityApIdForEmit))
+          .limit(200);
+        await emitRealtimeBestEffort(
+          c.env,
+          members.map(({ actorApId }) => ({
+            actorApId,
+            type: "talk.message",
+            data: {
+              kind: "community",
+              community_ap_id: communityApIdForEmit,
+              message: messagePayload,
+            },
+          })),
+        );
+        await Promise.all(
+          members
+            .filter(({ actorApId }) => actorApId !== actor.ap_id)
+            .map(({ actorApId }) => emitUnreadSnapshot(c.env, actorApId)),
+        );
+      });
+    }
+
+    return c.json({ message: messagePayload }, 201);
   },
 );
 

package/src/backend/routes/dm/messages.ts

@@ -35,6 +35,10 @@ import {
   resolveConversationId,
 } from "./query-helpers.ts";
 import { enqueueDeliveryToActor } from "../../lib/delivery/queue.ts";
+import {
+  emitRealtimeBestEffort,
+  runRealtimeAfterResponse,
+} from "../../runtime/realtime-hub.ts";
 import { feedCursorWhere } from "../../lib/feed-cursor.ts";
 import { toApAttachments } from "../../lib/activitypub-helpers.ts";
 import { validateChatAttachments } from "../../lib/attachments.ts";
@@ -600,15 +604,51 @@ dm.post("/user/:encodedApId/messages", async (c) => {
     await enqueueDeliveryToActor(c.env, deliveryActivityId, otherApId);
   }
 
+  const messagePayload = {
+    id: apId,
+    sender: buildSenderFromActor(actor),
+    content,
+    attachments,
+    created_at: now,
+  };
+
+  // Realtime fanout (best-effort, after the response): the recipient's open
+  // thread gets the message body without polling; the sender's OTHER tabs and
+  // devices stay in sync too. `other_ap_id` is per-recipient (each side sees
+  // the counterpart). Unread counters flow via the shared post-response sweep
+  // (the inbox trigger wrote a push job for the local recipient).
+  await runRealtimeAfterResponse(c, () =>
+    emitRealtimeBestEffort(c.env, [
+      ...(isRecipientLocal
+        ? [
+            {
+              actorApId: otherApId,
+              type: "talk.message",
+              data: {
+                kind: "dm",
+                other_ap_id: actor.ap_id,
+                conversation_id: conversationId,
+                message: messagePayload,
+              },
+            },
+          ]
+        : []),
+      {
+        actorApId: actor.ap_id,
+        type: "talk.message",
+        data: {
+          kind: "dm",
+          other_ap_id: otherApId,
+          conversation_id: conversationId,
+          message: messagePayload,
+        },
+      },
+    ]),
+  );
+
   return c.json(
     {
-      message: {
-        id: apId,
-        sender: buildSenderFromActor(actor),
-        content,
-        attachments,
-        created_at: now,
-      },
+      message: messagePayload,
       conversation_id: conversationId,
     },
     201,

package/src/backend/routes/dm/read-archive.ts

@@ -11,6 +11,11 @@ import {
   objects,
 } from "../../../db/index.ts";
 import { resolveConversationId } from "./query-helpers.ts";
+import {
+  emitRealtimeBestEffort,
+  emitUnreadSnapshot,
+  runRealtimeAfterResponse,
+} from "../../runtime/realtime-hub.ts";
 import {
   buildActorInfoMap,
   byTimeDesc,
@@ -54,6 +59,23 @@ readArchive.post("/user/:encodedApId/read", async (c) => {
       set: { lastReadAt: now },
     });
 
+  // Live read receipt for the partner's open thread + refreshed unread badge
+  // for the reader's OTHER tabs/devices.
+  await runRealtimeAfterResponse(c, async () => {
+    await emitRealtimeBestEffort(c.env, [
+      {
+        actorApId: otherApId,
+        type: "talk.read",
+        data: {
+          other_ap_id: actor.ap_id,
+          conversation_id: conversationId,
+          last_read_at: now,
+        },
+      },
+    ]);
+    await emitUnreadSnapshot(c.env, actor.ap_id);
+  });
+
   return c.json({ success: true, last_read_at: now });
 });
 
@@ -108,6 +130,11 @@ readArchive.post("/community/:encodedApId/read", async (c) => {
       set: { lastReadAt: now },
     });
 
+  // Refresh the reader's unread badge on their other tabs/devices.
+  await runRealtimeAfterResponse(c, () =>
+    emitUnreadSnapshot(c.env, actor.ap_id),
+  );
+
   return c.json({ success: true, last_read_at: now });
 });
 

package/src/backend/routes/dm/typing.ts

@@ -3,6 +3,10 @@
 import { Hono } from "hono";
 import { and, eq } from "drizzle-orm";
 import { dmTyping } from "../../../db/index.ts";
+import {
+  emitRealtimeBestEffort,
+  runRealtimeAfterResponse,
+} from "../../runtime/realtime-hub.ts";
 import { type HonoEnv, parseOtherApId } from "./conversations-helpers.ts";
 
 const typing = new Hono<HonoEnv>();
@@ -28,6 +32,18 @@ typing.post("/user/:encodedApId/typing", async (c) => {
       set: { lastTypedAt: now },
     });
 
+  // Push the indicator to the partner's live sockets; the GET endpoint stays
+  // as the fallback-polling read.
+  await runRealtimeAfterResponse(c, () =>
+    emitRealtimeBestEffort(c.env, [
+      {
+        actorApId: otherApId,
+        type: "talk.typing",
+        data: { other_ap_id: actor.ap_id, is_typing: true, typed_at: now },
+      },
+    ]),
+  );
+
   return c.json({ success: true, typed_at: now });
 });
 

package/src/backend/routes/notifications.ts

@@ -35,6 +35,10 @@ import {
   NOTIFICATION_ACTIVITY_TYPES,
   notificationEligibilityWhere,
 } from "../lib/notification-eligibility.ts";
+import {
+  emitUnreadSnapshot,
+  runRealtimeAfterResponse,
+} from "../runtime/realtime-hub.ts";
 
 const notifications = new Hono<{ Bindings: Env; Variables: Variables }>();
 
@@ -622,6 +626,11 @@ notifications.post("/read", async (c) => {
     );
   }
 
+  // Sync the reader's OTHER tabs/devices: push the fresh authoritative badge.
+  await runRealtimeAfterResponse(c, () =>
+    emitUnreadSnapshot(c.env, actor.ap_id),
+  );
+
   return c.json({ success: true });
 });
 
@@ -681,6 +690,11 @@ notifications.post("/archive", async (c) => {
     ARCHIVE_CREATE_BATCH_SIZE,
   );
 
+  // Archiving an unread notification removes it from the badge count.
+  await runRealtimeAfterResponse(c, () =>
+    emitUnreadSnapshot(c.env, actor.ap_id),
+  );
+
   return c.json({ success: true, archived_count });
 });
 
@@ -716,6 +730,11 @@ notifications.delete("/archive", async (c) => {
       ),
     );
 
+  // Unarchiving can resurface unread rows into the badge count.
+  await runRealtimeAfterResponse(c, () =>
+    emitUnreadSnapshot(c.env, actor.ap_id),
+  );
+
   return c.json({ success: true });
 });
 
@@ -758,6 +777,12 @@ notifications.post("/archive/all", async (c) => {
     rows,
     ARCHIVE_CREATE_BATCH_SIZE,
   );
+
+  // Archive-all clears the whole badge; sync the reader's other tabs/devices.
+  await runRealtimeAfterResponse(c, () =>
+    emitUnreadSnapshot(c.env, actor.ap_id),
+  );
+
   return c.json({ success: true, archived_count });
 });
 

package/src/backend/routes/posts/post-helpers.ts

@@ -15,7 +15,10 @@ import {
   communities,
   communityMembers,
   inbox as inboxTable,
+  insertMany,
   objects,
+  runBatch,
+  type D1Statement,
 } from "../../../db/index.ts";
 import { and, eq, inArray, isNull, or, sql } from "drizzle-orm";
 import type { Database } from "../../../db/index.ts";
@@ -666,33 +669,49 @@ export async function processMentions(
   }
 
   if (activitiesToCreate.length > 0) {
+    // A mention notification is one invariant: its activity and inbox edge
+    // either both exist or neither does. Build D1-safe chunked INSERT
+    // statements, then commit each bounded page as one atomic batch. This
+    // avoids both the 100-bind ceiling and the old activity-without-inbox
+    // partial state when the second independent INSERT failed.
+    const MENTION_NOTIFICATION_PAGE_SIZE = 200;
     try {
-      await db.insert(activities).values(activitiesToCreate);
-    } catch (e) {
-      log.error("Failed to persist mention activities", {
-        event: "posts.mention.activity_persist_failed",
-        error: e,
-      });
-      mentionFailures.push({
-        mention: "__batch__",
-        stage: "persist_activity",
-        reason: "mention_activity_persist_failed",
-      });
-    }
-  }
-  if (inboxEntriesToCreate.length > 0) {
-    try {
-      await db.insert(inboxTable).values(inboxEntriesToCreate);
+      for (
+        let offset = 0;
+        offset < activitiesToCreate.length;
+        offset += MENTION_NOTIFICATION_PAGE_SIZE
+      ) {
+        const activityPage = activitiesToCreate.slice(
+          offset,
+          offset + MENTION_NOTIFICATION_PAGE_SIZE,
+        );
+        const inboxPage = inboxEntriesToCreate.slice(
+          offset,
+          offset + MENTION_NOTIFICATION_PAGE_SIZE,
+        );
+        const statements = [
+          ...insertMany(db, activities, activityPage),
+          ...insertMany(db, inboxTable, inboxPage),
+        ];
+        await runBatch(db, statements as [D1Statement, ...D1Statement[]]);
+      }
     } catch (e) {
-      log.error("Failed to persist mention inbox entries", {
-        event: "posts.mention.inbox_persist_failed",
+      log.error("Failed to atomically persist mention notifications", {
+        event: "posts.mention.notification_persist_failed",
         error: e,
       });
-      mentionFailures.push({
-        mention: "__batch__",
-        stage: "persist_inbox",
-        reason: "mention_inbox_persist_failed",
-      });
+      mentionFailures.push(
+        {
+          mention: "__batch__",
+          stage: "persist_activity",
+          reason: "mention_activity_persist_failed",
+        },
+        {
+          mention: "__batch__",
+          stage: "persist_inbox",
+          reason: "mention_inbox_persist_failed",
+        },
+      );
     }
   }
 

package/src/backend/routes/realtime/index.ts

@@ -0,0 +1,67 @@
+/**
+ * Realtime stream routes.
+ *
+ *   GET  /api/realtime/config   capability probe ({ available }) — clients
+ *                               gate their fallback polling on this
+ *   POST /api/realtime/ticket   mint a one-time short-lived WS ticket
+ *   GET  /api/realtime/socket   browser WebSocket upgrade -> per-user stream
+ *
+ * Two upgrade auth paths, both terminating in the worker BEFORE the DO is
+ * reached (the DO binding is the trust boundary):
+ *   - session: the same-origin browser sends its session cookie; the /api/*
+ *     middleware resolved the actor already.
+ *   - ticket: a cross-origin or bearer-auth client (the browser WebSocket API
+ *     cannot set an Authorization header) first POSTs /ticket over the normal
+ *     authenticated fetch path, then connects with ?actor=&ticket=. The ticket
+ *     is minted inside — and re-verified + consumed by — the target user's own
+ *     stream DO, so it is single-use, expires in ~60s, and never carries the
+ *     raw session credential in a URL.
+ */
+
+import { Hono } from "hono";
+import type { Env, Variables } from "../../types.ts";
+import {
+  getRealtimeHub,
+  isRealtimeAvailable,
+} from "../../runtime/realtime-hub.ts";
+
+const realtime = new Hono<{ Bindings: Env; Variables: Variables }>();
+
+realtime.get("/config", (c) => {
+  return c.json({ available: isRealtimeAvailable(c.env) });
+});
+
+realtime.post("/ticket", async (c) => {
+  const actor = c.get("actor");
+  if (!actor) return c.json({ error: "unauthorized" }, 401);
+  if (!isRealtimeAvailable(c.env)) {
+    return c.json({ error: "realtime_unavailable" }, 503);
+  }
+  const ticket = await getRealtimeHub(c.env).mintTicket(actor.ap_id);
+  if (!ticket) return c.json({ error: "ticket_mint_failed" }, 500);
+  return c.json({ ticket, actor_ap_id: actor.ap_id });
+});
+
+realtime.get("/socket", async (c) => {
+  if (!isRealtimeAvailable(c.env)) {
+    return c.json({ error: "realtime_unavailable" }, 503);
+  }
+  const hub = getRealtimeHub(c.env);
+
+  const sessionActor = c.get("actor");
+  if (sessionActor) {
+    return hub.upgrade(c.req.raw, sessionActor.ap_id, "session");
+  }
+
+  const actorParam = c.req.query("actor")?.trim();
+  const ticket = c.req.query("ticket")?.trim();
+  if (actorParam && ticket) {
+    // The actor param only selects WHICH stream DO verifies the ticket; a
+    // forged actor value fails inside that DO (it never minted the ticket).
+    return hub.upgrade(c.req.raw, actorParam, "ticket", ticket);
+  }
+
+  return c.json({ error: "unauthorized" }, 401);
+});
+
+export default realtime;

package/src/backend/routes/rtc/index.ts

@@ -139,7 +139,11 @@ rtc.get("/api/rtc/calls", async (c) => {
 rtc.get("/api/rtc/calls/:id", async (c) => {
   const actor = c.get("actor");
   if (!actor) return c.json({ error: "unauthorized" }, 401);
-  const call = await getCallSession(c.get("db"), actor.ap_id, c.req.param("id"));
+  const call = await getCallSession(
+    c.get("db"),
+    actor.ap_id,
+    c.req.param("id"),
+  );
   if (!call) return c.json({ error: "not_found" }, 404);
   return c.json({ call });
 });

package/src/backend/runtime/call-hub-core.ts

@@ -98,7 +98,9 @@ export class CallHub {
 
   /** Snapshot of active (non-terminal) calls — used by the DO to persist. */
   activeCalls(): CallRecord[] {
-    return [...this.calls.values()].filter((c) => !isTerminalCallState(c.state));
+    return [...this.calls.values()].filter(
+      (c) => !isTerminalCallState(c.state),
+    );
   }
 
   /** Restore calls from durable storage after DO hibernation. */
@@ -175,7 +177,11 @@ export class CallHub {
         conn.send({ t: "ready" });
         // Re-announce any active calls so a reconnecting tab resyncs.
         for (const call of this.activeCalls()) {
-          conn.send({ t: "call-state", callId: call.callId, state: call.state });
+          conn.send({
+            t: "call-state",
+            callId: call.callId,
+            state: call.state,
+          });
         }
         return;
       case "ping":
@@ -401,7 +407,11 @@ export class CallHub {
     const call = this.calls.get(envelope.callId);
     if (!call || !envelope.sdp) return;
     if (call.state === "ringing") this.transition(call, "connecting");
-    this.port.broadcast({ t: "answer", callId: call.callId, sdp: envelope.sdp });
+    this.port.broadcast({
+      t: "answer",
+      callId: call.callId,
+      sdp: envelope.sdp,
+    });
   }
 
   private onPeerCandidate(envelope: RtcSignalEnvelopeV1): void {

package/src/backend/runtime/cloudflare.ts

@@ -8,6 +8,8 @@ import type {
   D1Database,
   Fetcher,
   KVNamespace,
+  MessageBatch,
+  Queue,
   R2Bucket,
   R2Object,
 } from "@cloudflare/workers-types";
@@ -20,6 +22,13 @@ import type {
   ObjectMetadata,
   StorageObject,
 } from "./types.ts";
+import type {
+  IQueueBatch,
+  IQueueMessage,
+  IQueueProducer,
+  QueueBatchItem,
+  QueueSendOptions,
+} from "./queue.ts";
 
 /**
  * Cloudflare R2 Storage Adapter
@@ -170,6 +179,46 @@ class CloudflareAssets implements IStaticAssets {
   }
 }
 
+class CloudflareQueueProducer<T> implements IQueueProducer<T> {
+  constructor(private readonly queue: Queue<T>) {}
+
+  async send(body: T, options?: QueueSendOptions): Promise<void> {
+    await this.queue.send(body, options);
+  }
+
+  async sendBatch(
+    messages: readonly QueueBatchItem<T>[],
+    options?: QueueSendOptions,
+  ): Promise<void> {
+    await this.queue.sendBatch([...messages], options);
+  }
+}
+
+export function wrapCloudflareQueue<T>(queue: Queue<T>): IQueueProducer<T> {
+  return new CloudflareQueueProducer(queue);
+}
+
+export function wrapCloudflareMessageBatch<T>(
+  batch: MessageBatch<T>,
+): IQueueBatch<T> {
+  const messages: readonly IQueueMessage<T>[] = batch.messages.map(
+    (message) => ({
+      id: message.id,
+      timestamp: message.timestamp,
+      body: message.body,
+      attempts: message.attempts,
+      ack: () => message.ack(),
+      retry: (options) => message.retry(options),
+    }),
+  );
+  return {
+    queue: batch.queue,
+    messages,
+    ackAll: () => batch.ackAll(),
+    retryAll: (options) => batch.retryAll(options),
+  };
+}
+
 /**
  * Wrap a native Cloudflare Workers binding env into the app's runtime
  * `Env` shape. The Hono app and all helper functions speak the runtime
@@ -182,21 +231,33 @@ export function wrapCloudflareBindings<
     MEDIA?: R2Bucket;
     KV: KVNamespace;
     ASSETS?: Fetcher;
+    DELIVERY_QUEUE?: Queue<unknown>;
+    DELIVERY_DLQ?: Queue<unknown>;
   },
 >(
   bindings: T,
-): Omit<T, "DB" | "MEDIA" | "KV" | "ASSETS"> & {
+): Omit<
+  T,
+  "DB" | "MEDIA" | "KV" | "ASSETS" | "DELIVERY_QUEUE" | "DELIVERY_DLQ"
+> & {
   DB_INSTANCE: ReturnType<typeof getDb>;
   MEDIA?: IObjectStorage;
   KV: IKeyValueStore;
   ASSETS?: IStaticAssets;
+  DELIVERY_QUEUE?: IQueueProducer<unknown>;
+  DELIVERY_DLQ?: IQueueProducer<unknown>;
 } {
-  const { DB, MEDIA, KV, ASSETS, ...rest } = bindings;
+  const { DB, MEDIA, KV, ASSETS, DELIVERY_QUEUE, DELIVERY_DLQ, ...rest } =
+    bindings;
   return {
     ...rest,
     DB_INSTANCE: getDb(DB),
     MEDIA: MEDIA ? new CloudflareStorage(MEDIA) : undefined,
     KV: new CloudflareKV(KV),
     ASSETS: ASSETS ? new CloudflareAssets(ASSETS) : undefined,
+    DELIVERY_QUEUE: DELIVERY_QUEUE
+      ? wrapCloudflareQueue(DELIVERY_QUEUE)
+      : undefined,
+    DELIVERY_DLQ: DELIVERY_DLQ ? wrapCloudflareQueue(DELIVERY_DLQ) : undefined,
   };
 }