@rocapine/community 0.1.0

package/templates/functions/broadcast-post/index.ts

@@ -0,0 +1,73 @@
+// Broadcast push for an official dashboard post: Rocactopus invokes this with
+// the service-role key after composing a post with "Send push notification"
+// checked. Sends an Expo push to every registered token (batches of 100).
+// Guarded by a service-role check — the public anon key passes the platform's
+// verify_jwt but must NOT be able to trigger a broadcast.
+
+import { adminClient } from "../_shared/client.ts";
+import { sendExpoPushBatch } from "../_shared/push.ts";
+import { BROADCAST_FALLBACK_TITLE } from "../_shared/config.ts";
+
+const supabase = adminClient();
+
+// The gateway (verify_jwt) has already validated the bearer's signature, so
+// only the role claim needs checking here. An exact string match against the
+// injected SUPABASE_SERVICE_ROLE_KEY broke when the project migrated to the
+// new API keys: the runtime now receives the sb_secret_* value while callers
+// still hold the legacy service_role JWT. Accept either proof.
+function isServiceCaller(req: Request): boolean {
+  const bearer = (req.headers.get("authorization") ?? "").replace(/^Bearer\s+/i, "");
+  if (bearer && bearer === Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")) return true;
+  try {
+    const payload = JSON.parse(
+      atob(bearer.split(".")[1].replace(/-/g, "+").replace(/_/g, "/")),
+    ) as { role?: string };
+    return payload.role === "service_role";
+  } catch {
+    return false;
+  }
+}
+
+Deno.serve(async (req) => {
+  if (!isServiceCaller(req)) {
+    return new Response("unauthorized", { status: 401 });
+  }
+
+  const { post_id } = (await req.json()) as { post_id?: string };
+  if (!post_id) return new Response("missing post_id", { status: 400 });
+
+  const { data: post } = await supabase
+    .from("posts")
+    .select("id, author_id, content, status")
+    .eq("id", post_id)
+    .single();
+  if (!post || post.status !== "visible") return new Response("skip: post not visible");
+
+  const { data: author } = await supabase
+    .from("profiles")
+    .select("username")
+    .eq("id", post.author_id)
+    .single();
+  const title = author?.username?.trim() || BROADCAST_FALLBACK_TITLE;
+  const excerpt = post.content.length > 140 ? `${post.content.slice(0, 137)}...` : post.content;
+
+  const { data: rows } = await supabase
+    .from("push_tokens")
+    .select("expo_push_token")
+    .not("expo_push_token", "is", null);
+  const tokens = (rows ?? []).map((r) => r.expo_push_token as string).filter(Boolean);
+
+  await sendExpoPushBatch(
+    tokens.map((to) => ({
+      to,
+      title,
+      body: excerpt,
+      data: { route: "/community", kind: "community_official_post" },
+      badge: 1,
+    })),
+  );
+
+  return new Response(JSON.stringify({ sent: tokens.length }), {
+    headers: { "Content-Type": "application/json" },
+  });
+});

package/templates/functions/daily-moderation/index.ts

@@ -0,0 +1,175 @@
+// Daily moderation batch + backstop. Runs every not-yet-moderated post/comment
+// through OpenAI's moderation endpoint (free): flagged -> soft-hide, clean
+// 'pending' -> promote to 'visible' (catches items whose synchronous
+// moderate-one call failed), clean 'visible' -> just stamp. Posts a Slack
+// summary (no-op if SLACK_WEBHOOK_URL is unset — see _shared/slack.ts). Never
+// deletes rows. App criticism is not a category (stays visible).
+
+import { adminClient } from "../_shared/client.ts";
+import {
+  assertModerationConfigured,
+  flaggedCategories,
+  type ModerationResult,
+} from "../_shared/moderation.ts";
+import { postToSlack } from "../_shared/slack.ts";
+
+assertModerationConfigured();
+
+const supabase = adminClient();
+
+interface Item {
+  id: string;
+  content: string;
+  author_id: string;
+  status: string;
+  profiles: {
+    username: string | null;
+    amplitude_id: string | null;
+    revenuecat_id: string | null;
+  } | null;
+  table: "posts" | "comments";
+}
+
+// Without generated DB types, supabase-js can't tell a `profiles!fk(...)`
+// embed is to-one, so its inferred type is an array; normalize it to a
+// single row (or null) to match Item.profiles above.
+function toOne<T>(v: T | T[] | null | undefined): T | null {
+  return Array.isArray(v) ? (v[0] ?? null) : (v ?? null);
+}
+
+Deno.serve(async () => {
+  const { data: posts, error: postsError } = await supabase
+    .from("posts")
+    .select(
+      "id, content, author_id, status, poll_options(idx, label), profiles!posts_author_id_fkey(username, amplitude_id, revenuecat_id)",
+    )
+    .is("moderated_at", null)
+    .in("status", ["pending", "visible"]);
+  const { data: comments, error: commentsError } = await supabase
+    .from("comments")
+    .select("id, content, author_id, status, profiles(username, amplitude_id, revenuecat_id)")
+    .is("moderated_at", null)
+    .in("status", ["pending", "visible"]);
+  if (postsError || commentsError) {
+    return new Response(JSON.stringify({ error: (postsError ?? commentsError)!.message }), {
+      status: 500,
+    });
+  }
+
+  // Poll option labels are user content: fold them into the post's moderated
+  // text (same treatment as the synchronous moderate-one function).
+  const items: Item[] = [
+    ...(posts ?? []).map((p) => ({
+      ...p,
+      profiles: toOne(p.profiles),
+      content: [
+        p.content,
+        ...(p.poll_options ?? [])
+          .sort((a: { idx: number }, b: { idx: number }) => a.idx - b.idx)
+          .map((o: { label: string }) => o.label),
+      ].join("\n"),
+      table: "posts" as const,
+    })),
+    ...(comments ?? []).map((c) => ({
+      ...c,
+      profiles: toOne(c.profiles),
+      table: "comments" as const,
+    })),
+  ];
+  if (items.length === 0) {
+    return new Response(JSON.stringify({ checked: 0, hidden: 0, failed_batches: 0 }));
+  }
+
+  // Moderate in batches of 100 (API limit). Only items whose batch succeeded
+  // get stamped moderated_at, so a transient failure is retried tomorrow.
+  const flagged: { item: Item; categories: string[] }[] = [];
+  const processed: Item[] = [];
+  let failedBatches = 0;
+  for (let i = 0; i < items.length; i += 100) {
+    const batch = items.slice(i, i + 100);
+    try {
+      const res = await fetch("https://api.openai.com/v1/moderations", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${Deno.env.get("OPENAI_API_KEY")}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          model: "omni-moderation-latest",
+          input: batch.map((it) => it.content),
+        }),
+      });
+      if (!res.ok) {
+        failedBatches++;
+        continue; // skip stamping; retried next run
+      }
+      const { results } = await res.json();
+      results.forEach((r: ModerationResult, idx: number) => {
+        const cats = flaggedCategories(r);
+        if (cats.length > 0) flagged.push({ item: batch[idx], categories: cats });
+      });
+      processed.push(...batch);
+    } catch {
+      failedBatches++; // network error; skip stamping, retried next run
+    }
+  }
+  const totalItems = items.length;
+
+  const flaggedIds = new Set(flagged.map((f) => f.item.id));
+  for (const { item, categories } of flagged) {
+    await supabase
+      .from(item.table)
+      .update({ status: "hidden", moderation_reason: categories.join(",") })
+      .eq("id", item.id);
+  }
+  // Backstop: promote clean 'pending' items to 'visible' (their synchronous
+  // moderate-one call must have failed).
+  const promote = processed.filter((i) => i.status === "pending" && !flaggedIds.has(i.id));
+  const promotePostIds = promote.filter((i) => i.table === "posts").map((i) => i.id);
+  const promoteCommentIds = promote.filter((i) => i.table === "comments").map((i) => i.id);
+  if (promotePostIds.length > 0) {
+    await supabase.from("posts").update({ status: "visible" }).in("id", promotePostIds);
+  }
+  if (promoteCommentIds.length > 0) {
+    await supabase.from("comments").update({ status: "visible" }).in("id", promoteCommentIds);
+  }
+  const now = new Date().toISOString();
+  const processedPostIds = processed.filter((i) => i.table === "posts").map((i) => i.id);
+  const processedCommentIds = processed.filter((i) => i.table === "comments").map((i) => i.id);
+  if (processedPostIds.length > 0) {
+    await supabase.from("posts").update({ moderated_at: now }).in("id", processedPostIds);
+  }
+  if (processedCommentIds.length > 0) {
+    await supabase.from("comments").update({ moderated_at: now }).in("id", processedCommentIds);
+  }
+
+  const lines = flagged.map(({ item, categories }) => {
+    const p = item.profiles;
+    return (
+      `* [${item.table}] *${p?.username ?? item.author_id}*, _${categories.join(", ")}_\n` +
+      `  > ${item.content.slice(0, 200)}\n` +
+      `  amplitude: \`${p?.amplitude_id ?? "?"}\` | revenuecat: \`${p?.revenuecat_id ?? "?"}\``
+    );
+  });
+  let summaryText: string;
+  if (failedBatches > 0) {
+    const uncheckedCount = totalItems - processed.length;
+    summaryText =
+      `Daily moderation: WARNING, ${failedBatches} batch(es) failed to reach the moderation API ` +
+      `(${uncheckedCount} of ${totalItems} items were not checked and will be retried). ` +
+      `${flagged.length} items hidden.`;
+  } else if (flagged.length === 0) {
+    summaryText = `Daily moderation: ${processed.length} items checked, nothing to report.`;
+  } else {
+    summaryText = `Daily moderation: ${flagged.length}/${processed.length} items hidden\n\n${lines.join("\n")}`;
+  }
+  await postToSlack({ text: summaryText });
+
+  return new Response(
+    JSON.stringify({
+      checked: processed.length,
+      hidden: flagged.length,
+      failed_batches: failedBatches,
+    }),
+  );
+});

package/templates/functions/moderate-one/index.ts

@@ -0,0 +1,62 @@
+// Synchronous single-item moderation. The client inserts a post/comment as
+// 'pending' (invisible to others) then calls this to get a verdict: clean ->
+// promoted to 'visible' (published); flagged -> 'hidden' (rejected) with the
+// reason. On an OpenAI error we fail closed (leave it pending); the daily
+// backstop re-checks stale pending items so nothing is silently lost.
+
+import { adminClient, json } from "../_shared/client.ts";
+import { assertModerationConfigured, moderateInput } from "../_shared/moderation.ts";
+
+assertModerationConfigured();
+
+const supabase = adminClient();
+
+Deno.serve(async (req) => {
+  const { kind, id } = (await req.json()) as { kind: "post" | "comment"; id: string };
+  if ((kind !== "post" && kind !== "comment") || !id) {
+    return json({ status: "error", error: "bad request" }, 400);
+  }
+  const table = kind === "post" ? "posts" : "comments";
+
+  const { data: row } = await supabase
+    .from(table)
+    .select("id, content, status")
+    .eq("id", id)
+    .single();
+  if (!row) return json({ status: "error", error: "not found" });
+  // Idempotent: only pending rows are moderated here.
+  if (row.status !== "pending") {
+    return json({ status: row.status === "visible" ? "published" : row.status });
+  }
+
+  // A poll post's option labels are user content too: moderate them together
+  // with the question, one verdict for the whole post.
+  let input = row.content;
+  if (kind === "post") {
+    const { data: options } = await supabase
+      .from("poll_options")
+      .select("label")
+      .eq("post_id", id)
+      .order("idx");
+    if (options && options.length > 0) {
+      input = [row.content, ...options.map((o) => o.label)].join("\n");
+    }
+  }
+
+  const verdict = await moderateInput(input);
+  if (!verdict) {
+    // Fail closed: leave pending, let the client retry / the daily sweep catch it.
+    return json({ status: "pending", error: "moderation unavailable" });
+  }
+
+  const now = new Date().toISOString();
+  if (verdict.flagged) {
+    await supabase
+      .from(table)
+      .update({ status: "hidden", moderation_reason: verdict.reason, moderated_at: now })
+      .eq("id", id);
+    return json({ status: "rejected", reason: verdict.reason });
+  }
+  await supabase.from(table).update({ status: "visible", moderated_at: now }).eq("id", id);
+  return json({ status: "published" });
+});

package/templates/functions/notify-comment/index.ts

@@ -0,0 +1,63 @@
+// Real-time comment notification: a pg_net trigger on comments posts the new
+// row here. We push to the post author (unless self, opted out, no token, or
+// the author has blocked the commenter).
+
+import { adminClient } from "../_shared/client.ts";
+import { sendExpoPush } from "../_shared/push.ts";
+import { FALLBACK_ACTOR_NAME } from "../_shared/config.ts";
+
+const supabase = adminClient();
+
+interface CommentRecord {
+  id: string;
+  post_id: string;
+  author_id: string;
+  content: string;
+}
+
+Deno.serve(async (req) => {
+  const { record } = (await req.json()) as { record: CommentRecord };
+
+  const { data: post } = await supabase
+    .from("posts")
+    .select("author_id")
+    .eq("id", record.post_id)
+    .single();
+  if (!post || post.author_id === record.author_id) return new Response("skip: self/none");
+
+  const { data: pref } = await supabase
+    .from("push_tokens")
+    .select("expo_push_token, notify_comments")
+    .eq("user_id", post.author_id)
+    .single();
+  if (!pref?.expo_push_token || !pref.notify_comments) return new Response("skip: no token/pref");
+
+  const { data: blocked } = await supabase
+    .from("blocks")
+    .select("blocker_id")
+    .eq("blocker_id", post.author_id)
+    .eq("blocked_id", record.author_id)
+    .maybeSingle();
+  if (blocked) return new Response("skip: blocked");
+
+  const { data: actor } = await supabase
+    .from("profiles")
+    .select("username")
+    .eq("id", record.author_id)
+    .single();
+  const name = actor?.username?.trim() || FALLBACK_ACTOR_NAME;
+  const excerpt =
+    record.content.length > 140 ? `${record.content.slice(0, 137)}...` : record.content;
+  // Title states the event; body is the commenter's name then the comment in
+  // quotes, e.g.  Marie: "So happy for you!".
+  const body = `${name}: "${excerpt}"`;
+
+  await sendExpoPush({
+    to: pref.expo_push_token,
+    title: "You received a comment",
+    body,
+    data: { route: "/community", kind: "community_comment" },
+    badge: 1,
+  });
+  return new Response("ok");
+});

package/templates/functions/notify-like/index.ts

@@ -0,0 +1,103 @@
+// Coalesced like notifications. Trigger path (body has record): apply a 10-min
+// per-post cooldown so bursts do not spam. Digest path (no record, from cron):
+// sweep posts with unnotified likes older than the cooldown. Either way, group
+// as "<name> liked your post" (1) or "<name> and N others liked your post".
+
+import { adminClient } from "../_shared/client.ts";
+import { sendExpoPush } from "../_shared/push.ts";
+import { FALLBACK_ACTOR_NAME } from "../_shared/config.ts";
+
+const supabase = adminClient();
+const COOLDOWN_MS = 10 * 60 * 1000;
+
+/** Notify the author for a single post's currently-unnotified likes, then
+ *  stamp them. Assumes the cooldown decision is already made. */
+async function flushPost(postId: string) {
+  const { data: post } = await supabase.from("posts").select("author_id").eq("id", postId).single();
+  if (!post) return;
+
+  const { data: pref } = await supabase
+    .from("push_tokens")
+    .select("expo_push_token, notify_likes")
+    .eq("user_id", post.author_id)
+    .single();
+
+  const { data: unnotified } = await supabase
+    .from("likes")
+    .select("user_id, created_at")
+    .eq("post_id", postId)
+    .is("notified_at", null)
+    .order("created_at", { ascending: false });
+  if (!unnotified || unnotified.length === 0) return;
+
+  // Stamp ALL unnotified likes for this post (clears the queue), regardless of
+  // whether they contribute to the message.
+  const now = new Date().toISOString();
+  await supabase
+    .from("likes")
+    .update({ notified_at: now })
+    .eq("post_id", postId)
+    .is("notified_at", null);
+
+  if (!pref?.expo_push_token || !pref.notify_likes) return;
+
+  // Contributors = likers who are not the author and not blocked by the author.
+  const { data: blocks } = await supabase
+    .from("blocks")
+    .select("blocked_id")
+    .eq("blocker_id", post.author_id);
+  const blockedSet = new Set((blocks ?? []).map((b) => b.blocked_id as string));
+  const contributors = unnotified.filter(
+    (l) => l.user_id !== post.author_id && !blockedSet.has(l.user_id as string),
+  );
+  if (contributors.length === 0) return;
+
+  const { data: actor } = await supabase
+    .from("profiles")
+    .select("username")
+    .eq("id", contributors[0].user_id)
+    .single();
+  const name = actor?.username?.trim() || FALLBACK_ACTOR_NAME;
+  const title =
+    contributors.length === 1
+      ? `${name} liked your post`
+      : `${name} and ${contributors.length - 1} others liked your post`;
+
+  await sendExpoPush({
+    to: pref.expo_push_token,
+    title,
+    data: { route: "/community", kind: "community_like" },
+    badge: 1,
+  });
+}
+
+Deno.serve(async (req) => {
+  const payload = (await req.json().catch(() => ({}))) as {
+    record?: { post_id: string };
+  };
+
+  if (payload.record?.post_id) {
+    const postId = payload.record.post_id;
+    // Cooldown: if any like on this post was notified within COOLDOWN_MS, hold.
+    const since = new Date(Date.now() - COOLDOWN_MS).toISOString();
+    const { count } = await supabase
+      .from("likes")
+      .select("*", { count: "exact", head: true })
+      .eq("post_id", postId)
+      .gt("notified_at", since);
+    if ((count ?? 0) > 0) return new Response("hold: cooldown");
+    await flushPost(postId);
+    return new Response("ok");
+  }
+
+  // Digest (cron): sweep posts whose oldest unnotified like is past the cooldown.
+  const cutoff = new Date(Date.now() - COOLDOWN_MS).toISOString();
+  const { data: stale } = await supabase
+    .from("likes")
+    .select("post_id")
+    .is("notified_at", null)
+    .lt("created_at", cutoff);
+  const postIds = [...new Set((stale ?? []).map((r) => r.post_id as string))];
+  for (const pid of postIds) await flushPost(pid);
+  return new Response(JSON.stringify({ swept: postIds.length }));
+});

package/templates/functions/notify-reaction/index.ts

@@ -0,0 +1,186 @@
+// Coalesced reaction notifications (generic "I stand with you" reaction — see
+// supabase/migrations/reaction/001_reactions.sql; the reaction's *meaning* is
+// 100% client-side, this function only sends the push). Trigger path (body
+// has record): 10-min per-post cooldown. Digest path (no record, from cron):
+// sweep posts with unnotified reactions older than the cooldown. Never
+// includes any reaction content — the reaction table carries no text.
+//
+// Push copy: the recipient's profiles.locale selects a built-in neutral
+// template for the common single-reactor case (COMMUNITY_REACTION_PUSH_TEXT
+// overrides that template for every locale, `{name}` substituted with the
+// reactor's display name — an app with its own reaction semantics sets its
+// own copy there). The multi-reactor case always uses the locale's own
+// "and N others" phrasing; there is no secret for it, only the built-in
+// translations below.
+//
+// NOTE: profiles.locale is not part of the SDK's core schema yet (task 16) —
+// it must exist before this function can run. See the internal port notes
+// for a reference migration adding it.
+
+import { adminClient } from "../_shared/client.ts";
+import { sendExpoPush } from "../_shared/push.ts";
+import { FALLBACK_ACTOR_NAME, REACTION_PUSH_TEXT } from "../_shared/config.ts";
+
+const supabase = adminClient();
+const COOLDOWN_MS = 10 * 60 * 1000;
+
+/**
+ * CLDR plural form for a count: 1 -> `one`, 2-4 -> `few`, 5+ -> `many` (the
+ * Polish rule, minus the fractional `other` case a push count never hits).
+ * Every other locale below needs only a singular/plural pair.
+ */
+function plForm(n: number, one: string, few: string, many: string) {
+  if (n === 1) return one;
+  const lastTwo = n % 100;
+  const inTeens = lastTwo >= 10 && lastTwo < 20;
+  return !inTeens && n % 10 >= 2 && n % 10 <= 4 ? few : many;
+}
+
+// Built-in neutral push copy per recipient locale (profiles.locale). Keys
+// mirror SupportedLanguage in host apps; unknown locales fall back to en.
+// `one` is only used when COMMUNITY_REACTION_PUSH_TEXT is unset (its default
+// already matches the `en` entry below).
+const COPY = {
+  en: {
+    fallbackName: "Someone",
+    one: (name: string) => `${name} is thinking of you`,
+    many: (name: string, extra: number) =>
+      `${name} and ${extra} ${extra === 1 ? "other" : "others"} are thinking of you`,
+  },
+  "pt-PT": {
+    fallbackName: "Alguém",
+    one: (name: string) => `${name} está a pensar em ti`,
+    many: (name: string, extra: number) =>
+      `${name} e mais ${extra} ${extra === 1 ? "pessoa está" : "pessoas estão"} a pensar em ti`,
+  },
+  "pt-BR": {
+    fallbackName: "Alguém",
+    one: (name: string) => `${name} está pensando em você`,
+    many: (name: string, extra: number) =>
+      `${name} e mais ${extra} ${extra === 1 ? "pessoa está" : "pessoas estão"} pensando em você`,
+  },
+  "es-ES": {
+    fallbackName: "Alguien",
+    one: (name: string) => `${name} está pensando en ti`,
+    many: (name: string, extra: number) =>
+      `${name} y ${extra} ${extra === 1 ? "persona más está" : "personas más están"} pensando en ti`,
+  },
+  "es-419": {
+    fallbackName: "Alguien",
+    one: (name: string) => `${name} está pensando en ti`,
+    many: (name: string, extra: number) =>
+      `${name} y ${extra} ${extra === 1 ? "persona más está" : "personas más están"} pensando en ti`,
+  },
+  it: {
+    fallbackName: "Qualcuno",
+    one: (name: string) => `${name} sta pensando a te`,
+    many: (name: string, extra: number) =>
+      `${name} e altre ${extra} ${extra === 1 ? "persona sta" : "persone stanno"} pensando a te`,
+  },
+  pl: {
+    fallbackName: "Ktoś",
+    one: (name: string) => `${name} myśli o tobie`,
+    many: (name: string, extra: number) =>
+      `${name} i ${plForm(extra, `${extra} inna osoba myśli`, `${extra} inne osoby myślą`, `${extra} innych osób myśli`)} o tobie`,
+  },
+} as const;
+
+function copyFor(locale: string | null | undefined) {
+  return COPY[(locale ?? "en") as keyof typeof COPY] ?? COPY.en;
+}
+
+async function flushPost(postId: string) {
+  const { data: post } = await supabase.from("posts").select("author_id").eq("id", postId).single();
+  if (!post) return;
+
+  const { data: recipient } = await supabase
+    .from("profiles")
+    .select("locale")
+    .eq("id", post.author_id)
+    .single();
+  const copy = copyFor(recipient?.locale);
+
+  const { data: pref } = await supabase
+    .from("push_tokens")
+    .select("expo_push_token, notify_reactions")
+    .eq("user_id", post.author_id)
+    .single();
+
+  const { data: unnotified } = await supabase
+    .from("post_reactions")
+    .select("user_id, created_at")
+    .eq("post_id", postId)
+    .is("notified_at", null)
+    .order("created_at", { ascending: false });
+  if (!unnotified || unnotified.length === 0) return;
+
+  const now = new Date().toISOString();
+  await supabase
+    .from("post_reactions")
+    .update({ notified_at: now })
+    .eq("post_id", postId)
+    .is("notified_at", null);
+
+  if (!pref?.expo_push_token || !pref.notify_reactions) return;
+
+  const { data: blocks } = await supabase
+    .from("blocks")
+    .select("blocked_id")
+    .eq("blocker_id", post.author_id);
+  const blockedSet = new Set((blocks ?? []).map((b) => b.blocked_id as string));
+  const contributors = unnotified.filter(
+    (l) => l.user_id !== post.author_id && !blockedSet.has(l.user_id as string),
+  );
+  if (contributors.length === 0) return;
+
+  const { data: actor } = await supabase
+    .from("profiles")
+    .select("username")
+    .eq("id", contributors[0].user_id)
+    .single();
+  // COMMUNITY_FALLBACK_NAME (the deployer-set env var, shared with
+  // notify-like/notify-comment and meant to match the client's
+  // anonymousAuthorFallback — see docs/backend-runbook.md) takes precedence
+  // over the locale table's own fallbackName default.
+  const name = actor?.username?.trim() || FALLBACK_ACTOR_NAME || copy.fallbackName;
+  const title =
+    contributors.length === 1
+      ? REACTION_PUSH_TEXT.replace("{name}", name)
+      : copy.many(name, contributors.length - 1);
+
+  await sendExpoPush({
+    to: pref.expo_push_token,
+    title,
+    data: { route: "/community", kind: "community_reaction" },
+    badge: 1,
+  });
+}
+
+Deno.serve(async (req) => {
+  const payload = (await req.json().catch(() => ({}))) as {
+    record?: { post_id: string };
+  };
+
+  if (payload.record?.post_id) {
+    const postId = payload.record.post_id;
+    const since = new Date(Date.now() - COOLDOWN_MS).toISOString();
+    const { count } = await supabase
+      .from("post_reactions")
+      .select("*", { count: "exact", head: true })
+      .eq("post_id", postId)
+      .gt("notified_at", since);
+    if ((count ?? 0) > 0) return new Response("hold: cooldown");
+    await flushPost(postId);
+    return new Response("ok");
+  }
+
+  const cutoff = new Date(Date.now() - COOLDOWN_MS).toISOString();
+  const { data: stale } = await supabase
+    .from("post_reactions")
+    .select("post_id")
+    .is("notified_at", null)
+    .lt("created_at", cutoff);
+  const postIds = [...new Set((stale ?? []).map((r) => r.post_id as string))];
+  for (const pid of postIds) await flushPost(pid);
+  return new Response(JSON.stringify({ swept: postIds.length }));
+});