@vibes.diy/api-svc 5.0.1 → 5.2.2

package/public/social-flow.js

@@ -0,0 +1,765 @@
+import { Result, Option, EventoResult, exception2Result } from "@adviser/cement";
+import { isReqSocialFollow, isReqSocialUnfollow, isReqSocialApprove, isReqSocialRemoveFollower, isReqSocialBlock, isReqSocialUnblock, isReqSocialList, isReqSocialRelationship, isReqSocialSetPrivacy, isReqSocialRedeem, isReqSubscribeSocial, isReqSocialImportFriendEdges, isReqAudienceArmState, isReqSetAudienceArm, isReqSetAudiencePolicy, isReqListAudienceArms, } from "@vibes.diy/api-types";
+import { and, eq } from "drizzle-orm/sql/expressions";
+import { unwrapMsgBase } from "../unwrap-msg-base.js";
+import { checkAuth } from "../check-auth.js";
+import { patchAudienceKeys, subscribedDbPrefixes } from "./audience-key-patch.js";
+import { audienceSubjectFromChannel } from "./audience-channels.js";
+import { isArmed as isAudienceArmed, getArmState, setArm, listArmsForSubject } from "./audience-arms-store.js";
+import { getAppPrivacySensitive } from "./audience-derived-trigger.js";
+import { resolveActiveHandle } from "./resolve-active-handle.js";
+import { ensureUserSlug, persistDefaultUserSlug } from "../intern/ensure-slug-binding.js";
+import { notifySocialEdge } from "../intern/notify-social-edge.js";
+import { followHandle, unfollowHandle, removeFollower, approveFollower, blockHandle, unblockHandle, getRelationship, listSocial, isHandlePrivate, setHandlePrivacy, getAudiencePolicy, setAudiencePolicy, SocialBlockedError, SelfFollowError, importFriendEdges, establishMutualActiveEdges, } from "./social-store.js";
+import { markInviteRedeemed, selectPendingInviteByToken } from "./social-invite-store.js";
+import { adminUserIdSet } from "./ensure-app-settings.js";
+function clientWsSend(ctx) {
+    return ctx.send.provider;
+}
+export function socialSubscriptionKey(handle) {
+    return `social/${handle}`;
+}
+async function sendSocialEdgeEvent(vctx, value, senderConnId) {
+    const evt = {
+        ...value,
+        type: "vibes.diy.evt-social-edge",
+    };
+    await vctx.postQueue({
+        payload: evt,
+        tid: "queue-event",
+        src: "social-flow",
+        dst: "vibes-service",
+        ttl: 1,
+    });
+    if (vctx.notifySocialEdgeChanged) {
+        vctx.notifySocialEdgeChanged(evt, senderConnId ?? "").catch((e) => console.error("social-edge fan-out error:", e));
+    }
+}
+async function selectEdge(vctx, pair) {
+    const t = vctx.sql.tables.socialEdges;
+    const row = await vctx.sql.db
+        .select()
+        .from(t)
+        .where(and(eq(t.followerHandle, pair.follower), eq(t.followeeHandle, pair.followee)))
+        .limit(1)
+        .then((r) => r[0]);
+    if (row === undefined)
+        return undefined;
+    return {
+        followerHandle: row.followerHandle,
+        followeeHandle: row.followeeHandle,
+        state: row.state,
+        created: row.created,
+        updated: row.updated,
+    };
+}
+const NO_HANDLE_ERROR = {
+    type: "vibes.diy.res-error",
+    error: { message: "no handle bound to this user", code: "social-no-handle" },
+};
+async function patchLocalAudienceKeys(vctx, conn, patch) {
+    let armLookup;
+    if (patch.op === "add") {
+        const cache = new Map();
+        for (const prefix of subscribedDbPrefixes(conn)) {
+            const [ownerHandle, appSlug] = prefix.split("/");
+            for (const ch of patch.channels) {
+                const subject = audienceSubjectFromChannel(ch);
+                if (subject === undefined)
+                    continue;
+                const cacheKey = `${ownerHandle}/${appSlug}/${subject}`;
+                if (cache.has(cacheKey))
+                    continue;
+                cache.set(cacheKey, await isAudienceArmed(vctx, { subjectHandle: subject, ownerHandle, appSlug }));
+            }
+        }
+        armLookup = (ownerHandle, appSlug, subjectHandle) => cache.get(`${ownerHandle}/${appSlug}/${subjectHandle}`) ?? false;
+    }
+    patchAudienceKeys(conn, patch, {
+        register: (key) => vctx.registerDocSubscription?.(key) ?? Promise.resolve(),
+        deregister: (key) => vctx.deregisterDocSubscription?.(key) ?? Promise.resolve(),
+        isArmed: armLookup,
+    });
+}
+async function reconcileAudienceKeys(vctx, edge, op) {
+    const follower = edge.followerHandle;
+    const followee = edge.followeeHandle;
+    let mutual = op === "remove";
+    if (op === "add") {
+        const rReverse = await exception2Result(() => selectEdge(vctx, { follower: followee, followee: follower }));
+        if (rReverse.isErr()) {
+            console.error("audience reconciliation reverse-edge lookup failed (mutuals skipped):", rReverse.Err());
+        }
+        else {
+            mutual = rReverse.Ok()?.state === "active";
+        }
+    }
+    const followerChannels = [`~aud:followers:${followee}`];
+    if (mutual)
+        followerChannels.push(`~aud:mutuals:${followee}`);
+    const followeeChannels = mutual ? [`~aud:mutuals:${follower}`] : [];
+    if (op === "add" && vctx.registerAudienceReader !== undefined) {
+        const patchTargets = new Set();
+        for (const conn of vctx.connections) {
+            if (conn.subscribedDocHandle === follower)
+                patchTargets.add(follower);
+            if (conn.subscribedDocHandle === followee && followeeChannels.length > 0)
+                patchTargets.add(followee);
+        }
+        for (const handle of patchTargets) {
+            const rReg = await exception2Result(() => vctx.registerAudienceReader?.(handle) ?? Promise.resolve());
+            if (rReg.isErr())
+                console.error("aud-reader registration failed (local add leg):", rReg.Err());
+        }
+    }
+    for (const conn of vctx.connections) {
+        if (conn.subscribedDocHandle === follower) {
+            await patchLocalAudienceKeys(vctx, conn, { op, channels: followerChannels });
+        }
+        if (conn.subscribedDocHandle === followee && followeeChannels.length > 0) {
+            await patchLocalAudienceKeys(vctx, conn, { op, channels: followeeChannels });
+        }
+    }
+    const fan = vctx.patchAudienceKeysRemote;
+    if (fan !== undefined && op === "remove") {
+        const rFollower = await exception2Result(() => fan(follower, { op, channels: followerChannels }));
+        if (rFollower.isErr())
+            console.error("cross-shard audience-key fan failed (follower):", rFollower.Err());
+        if (followeeChannels.length > 0) {
+            const rFollowee = await exception2Result(() => fan(followee, { op, channels: followeeChannels }));
+            if (rFollowee.isErr())
+                console.error("cross-shard audience-key fan failed (followee):", rFollowee.Err());
+        }
+    }
+}
+export const socialFollowEvento = {
+    hash: "social-follow",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSocialFollow(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const pair = { follower: actingHandle, followee: req.targetHandle };
+        const rFollow = await followHandle(vctx, pair);
+        if (rFollow.isErr()) {
+            const err = rFollow.Err();
+            if (err instanceof SocialBlockedError || err instanceof SelfFollowError) {
+                await ctx.send.send(ctx, {
+                    type: "vibes.diy.res-error",
+                    error: { message: err.message, code: "social-follow-refused" },
+                });
+                return Result.Ok(EventoResult.Continue);
+            }
+            return Result.Err(rFollow);
+        }
+        const edge = await selectEdge(vctx, pair);
+        if (edge !== undefined) {
+            await sendSocialEdgeEvent(vctx, { op: "upsert", edge }, clientWsSend(ctx).connId);
+            if (edge.state === "active") {
+                await reconcileAudienceKeys(vctx, edge, "add");
+            }
+            if (rFollow.Ok().created === true) {
+                const rNotify = await exception2Result(() => notifySocialEdge(vctx, {
+                    kind: edge.state === "active" ? "follower-added" : "follow-request",
+                    followerHandle: pair.follower,
+                    followeeHandle: pair.followee,
+                }));
+                if (rNotify.isErr())
+                    console.error("social notification emit failed (follow):", rNotify.Err());
+            }
+        }
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-social-follow",
+            targetHandle: req.targetHandle,
+            state: rFollow.Ok().state,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const socialRedeemEvento = {
+    hash: "social-redeem",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSocialRedeem(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        let redeemerHandle = await resolveActiveHandle(vctx, userId);
+        if (redeemerHandle === undefined) {
+            const claims = req._auth.verifiedAuth.claims;
+            const rEnsured = await ensureUserSlug(vctx, claims, { userId });
+            if (rEnsured.isOk()) {
+                await persistDefaultUserSlug(vctx, userId, rEnsured.Ok().ownerHandle);
+                redeemerHandle = await resolveActiveHandle(vctx, userId);
+            }
+            if (redeemerHandle === undefined) {
+                await ctx.send.send(ctx, NO_HANDLE_ERROR);
+                return Result.Ok(EventoResult.Continue);
+            }
+        }
+        const nowIso = new Date().toISOString();
+        const invite = await selectPendingInviteByToken(vctx.sql, req.token);
+        const sendStatus = async (status, inviterHandle) => {
+            await ctx.send.send(ctx, {
+                type: "vibes.diy.res-social-redeem",
+                status,
+                ...(inviterHandle ? { inviterHandle } : {}),
+            });
+            return Result.Ok(EventoResult.Continue);
+        };
+        if (invite === undefined)
+            return sendStatus("invalid");
+        if (invite.inviterHandle === redeemerHandle)
+            return sendStatus("invalid", invite.inviterHandle);
+        const completeMutual = async () => {
+            const rEdges = await establishMutualActiveEdges(vctx, invite.inviterHandle, redeemerHandle);
+            if (rEdges.isErr())
+                console.error("redeem edge establishment failed:", rEdges.Err());
+            const changed = rEdges.isOk() ? rEdges.Ok().activeEdges : [];
+            const fwd = await selectEdge(vctx, { follower: invite.inviterHandle, followee: redeemerHandle });
+            const rev = await selectEdge(vctx, { follower: redeemerHandle, followee: invite.inviterHandle });
+            if (fwd?.state !== "active" || rev?.state !== "active") {
+                console.error("[social-invite] redeem formed no mutual edge (blocked pair):", invite.inviterHandle, redeemerHandle);
+                return sendStatus("invalid", invite.inviterHandle);
+            }
+            for (const pair of changed) {
+                const edge = await selectEdge(vctx, pair);
+                if (edge === undefined)
+                    continue;
+                await sendSocialEdgeEvent(vctx, { op: "upsert", edge }, clientWsSend(ctx).connId);
+                const rRecon = await exception2Result(() => reconcileAudienceKeys(vctx, edge, "add"));
+                if (rRecon.isErr())
+                    console.error("redeem audience reconcile failed:", rRecon.Err());
+            }
+            if (changed.length > 0) {
+                const rNotify = await exception2Result(() => notifySocialEdge(vctx, {
+                    kind: "follow-approved",
+                    followerHandle: invite.inviterHandle,
+                    followeeHandle: redeemerHandle,
+                }));
+                if (rNotify.isErr())
+                    console.error("social notification emit failed (redeem):", rNotify.Err());
+            }
+            return sendStatus("redeemed", invite.inviterHandle);
+        };
+        if (invite.state === "redeemed") {
+            if (invite.redeemedByUserId === userId)
+                return completeMutual();
+            return sendStatus("already-redeemed", invite.inviterHandle);
+        }
+        if (invite.state !== "pending" || invite.expires <= nowIso)
+            return sendStatus("expired", invite.inviterHandle);
+        const rRedeem = await markInviteRedeemed(vctx.sql, { token: req.token, redeemedByUserId: userId, nowIso });
+        if (rRedeem.redeemed === true)
+            return completeMutual();
+        const after = await selectPendingInviteByToken(vctx.sql, req.token);
+        if (after === undefined)
+            return sendStatus("invalid");
+        if (after.state === "redeemed" && after.redeemedByUserId === userId)
+            return completeMutual();
+        if (after.state === "redeemed")
+            return sendStatus("already-redeemed", invite.inviterHandle);
+        if (after.state === "expired" || after.expires <= nowIso)
+            return sendStatus("expired", invite.inviterHandle);
+        return sendStatus("already-redeemed", invite.inviterHandle);
+    }),
+};
+export const socialUnfollowEvento = {
+    hash: "social-unfollow",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSocialUnfollow(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const pair = { follower: actingHandle, followee: req.targetHandle };
+        const edge = await selectEdge(vctx, pair);
+        const rUnfollow = await unfollowHandle(vctx, pair);
+        if (rUnfollow.isErr())
+            return Result.Err(rUnfollow);
+        if (edge !== undefined) {
+            await sendSocialEdgeEvent(vctx, { op: "delete", edge }, clientWsSend(ctx).connId);
+            await reconcileAudienceKeys(vctx, edge, "remove");
+        }
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-social-unfollow",
+            targetHandle: req.targetHandle,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const socialApproveEvento = {
+    hash: "social-approve",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSocialApprove(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const pair = { follower: req.followerHandle, followee: actingHandle };
+        const pending = await selectEdge(vctx, pair);
+        if (pending === undefined || pending.state !== "requested") {
+            await ctx.send.send(ctx, {
+                type: "vibes.diy.res-error",
+                error: {
+                    message: `no pending follow request from ${req.followerHandle} to ${actingHandle}`,
+                    code: "social-approve-not-found",
+                },
+            });
+            return Result.Ok(EventoResult.Continue);
+        }
+        const rApprove = await approveFollower(vctx, pair);
+        if (rApprove.isErr())
+            return Result.Err(rApprove);
+        const edge = await selectEdge(vctx, pair);
+        if (edge === undefined || edge.state !== "active") {
+            await ctx.send.send(ctx, {
+                type: "vibes.diy.res-error",
+                error: {
+                    message: `approve refused: ${req.followerHandle} -> ${actingHandle}`,
+                    code: "social-approve-refused",
+                },
+            });
+            return Result.Ok(EventoResult.Continue);
+        }
+        await sendSocialEdgeEvent(vctx, { op: "upsert", edge }, clientWsSend(ctx).connId);
+        await reconcileAudienceKeys(vctx, edge, "add");
+        const rNotify = await exception2Result(() => notifySocialEdge(vctx, {
+            kind: "follow-approved",
+            followerHandle: req.followerHandle,
+            followeeHandle: actingHandle,
+        }));
+        if (rNotify.isErr())
+            console.error("social notification emit failed (approve):", rNotify.Err());
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-social-approve",
+            followerHandle: req.followerHandle,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const socialRemoveFollowerEvento = {
+    hash: "social-remove-follower",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSocialRemoveFollower(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const pair = { follower: req.followerHandle, followee: actingHandle };
+        const edge = await selectEdge(vctx, pair);
+        const rRemove = await removeFollower(vctx, pair);
+        if (rRemove.isErr())
+            return Result.Err(rRemove);
+        if (edge !== undefined) {
+            await sendSocialEdgeEvent(vctx, { op: "delete", edge }, clientWsSend(ctx).connId);
+            await reconcileAudienceKeys(vctx, edge, "remove");
+        }
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-social-remove-follower",
+            followerHandle: req.followerHandle,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const socialBlockEvento = {
+    hash: "social-block",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSocialBlock(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const outgoing = await selectEdge(vctx, { follower: actingHandle, followee: req.targetHandle });
+        const incoming = await selectEdge(vctx, { follower: req.targetHandle, followee: actingHandle });
+        const rBlock = await blockHandle(vctx, { blocker: actingHandle, blocked: req.targetHandle });
+        if (rBlock.isErr())
+            return Result.Err(rBlock);
+        const senderConnId = clientWsSend(ctx).connId;
+        for (const edge of [outgoing, incoming]) {
+            if (edge !== undefined) {
+                await sendSocialEdgeEvent(vctx, { op: "delete", edge }, senderConnId);
+                await reconcileAudienceKeys(vctx, edge, "remove");
+            }
+        }
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-social-block",
+            targetHandle: req.targetHandle,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const socialUnblockEvento = {
+    hash: "social-unblock",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSocialUnblock(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const rUnblock = await unblockHandle(vctx, { blocker: actingHandle, blocked: req.targetHandle });
+        if (rUnblock.isErr())
+            return Result.Err(rUnblock);
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-social-unblock",
+            targetHandle: req.targetHandle,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const socialListEvento = {
+    hash: "social-list",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSocialList(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const lists = await listSocial(vctx, actingHandle);
+        const priv = await isHandlePrivate(vctx, actingHandle);
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-social-list",
+            handle: actingHandle,
+            private: priv,
+            following: lists.following.map((e) => ({
+                followerHandle: actingHandle,
+                followeeHandle: e.handle,
+                state: e.state,
+                created: e.created,
+                updated: e.updated,
+            })),
+            followers: lists.followers.map((e) => ({
+                followerHandle: e.handle,
+                followeeHandle: actingHandle,
+                state: e.state,
+                created: e.created,
+                updated: e.updated,
+            })),
+            requests: lists.requests.map((e) => ({
+                followerHandle: e.handle,
+                followeeHandle: actingHandle,
+                state: e.state,
+                created: e.created,
+                updated: e.updated,
+            })),
+            blocked: lists.blocked,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const socialRelationshipEvento = {
+    hash: "social-relationship",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSocialRelationship(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const rel = await getRelationship(vctx, { self: actingHandle, other: req.targetHandle });
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-social-relationship",
+            targetHandle: req.targetHandle,
+            following: rel.following,
+            followedBy: rel.followedBy,
+            blocked: rel.blocked,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const socialSetPrivacyEvento = {
+    hash: "social-set-privacy",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSocialSetPrivacy(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const rSet = await setHandlePrivacy(vctx, { handle: actingHandle, private: req.private, userId });
+        if (rSet.isErr())
+            return Result.Err(rSet);
+        const senderConnId = clientWsSend(ctx).connId;
+        for (const edge of rSet.Ok().activated) {
+            await sendSocialEdgeEvent(vctx, { op: "upsert", edge }, senderConnId);
+            await reconcileAudienceKeys(vctx, edge, "add");
+            const rNotify = await exception2Result(() => notifySocialEdge(vctx, {
+                kind: "follow-approved",
+                followerHandle: edge.followerHandle,
+                followeeHandle: edge.followeeHandle,
+            }));
+            if (rNotify.isErr())
+                console.error("social notification emit failed (privacy-flip activation):", rNotify.Err());
+        }
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-social-set-privacy",
+            private: req.private,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const subscribeSocialEvento = {
+    hash: "subscribe-social",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSubscribeSocial(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const wsSend = clientWsSend(ctx);
+        const subscriptionKey = socialSubscriptionKey(actingHandle);
+        for (const key of [...wsSend.subscribedSocialKeys]) {
+            if (key === subscriptionKey)
+                continue;
+            wsSend.subscribedSocialKeys.delete(key);
+            vctx.deregisterSocialSubscription?.(key).catch((e) => console.error("social-key deregistration error:", e));
+        }
+        wsSend.subscribedSocialKeys.add(subscriptionKey);
+        if (vctx.registerSocialSubscription) {
+            vctx
+                .registerSocialSubscription(subscriptionKey)
+                .catch((e) => console.error("social subscription registration error:", e));
+        }
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-subscribe-social",
+            status: "ok",
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export async function socialImportFriendEdges(vctx, req) {
+    const callerUserId = req._auth.verifiedAuth.claims.userId;
+    if (adminUserIdSet(vctx).has(callerUserId) === false) {
+        return Result.Err("social-import-friend-edges: admin only");
+    }
+    const dryRun = req.dryRun === true;
+    const counts = await importFriendEdges(vctx, {
+        ownerHandle: req.ownerHandle,
+        appSlug: req.appSlug,
+        dbName: req.dbName,
+        dryRun,
+    });
+    return Result.Ok({ type: "vibes.diy.res-social-import-friend-edges", dryRun, counts });
+}
+export const socialImportFriendEdgesEvento = {
+    hash: "social-import-friend-edges",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSocialImportFriendEdges(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const r = await socialImportFriendEdges(vctx, ctx.validated.payload);
+        if (r.isErr())
+            return Result.Err(r);
+        await ctx.send.send(ctx, r.Ok());
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const audienceArmStateEvento = {
+    hash: "audience-arm-state",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqAudienceArmState(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const [state, policy, sensitive] = await Promise.all([
+            getArmState(vctx, { subjectHandle: actingHandle, ownerHandle: req.ownerHandle, appSlug: req.appSlug }),
+            getAudiencePolicy(vctx, actingHandle),
+            getAppPrivacySensitive(vctx, { ownerHandle: req.ownerHandle, appSlug: req.appSlug }),
+        ]);
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-audience-arm-state",
+            ownerHandle: req.ownerHandle,
+            appSlug: req.appSlug,
+            state,
+            policy,
+            sensitive,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const setAudienceArmEvento = {
+    hash: "set-audience-arm",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSetAudienceArm(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        await setArm(vctx, { subjectHandle: actingHandle, ownerHandle: req.ownerHandle, appSlug: req.appSlug, state: req.state });
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-set-audience-arm",
+            ownerHandle: req.ownerHandle,
+            appSlug: req.appSlug,
+            state: req.state,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const setAudiencePolicyEvento = {
+    hash: "set-audience-policy",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqSetAudiencePolicy(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        await setAudiencePolicy(vctx, { handle: actingHandle, policy: req.policy, userId });
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-set-audience-policy",
+            policy: req.policy,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+export const listAudienceArmsEvento = {
+    hash: "list-audience-arms",
+    validate: unwrapMsgBase(async (msg) => {
+        if (isReqListAudienceArms(msg.payload)) {
+            return Result.Ok(Option.Some({ ...msg, payload: msg.payload }));
+        }
+        return Result.Ok(Option.None());
+    }),
+    handle: checkAuth(async (ctx) => {
+        const req = ctx.validated.payload;
+        const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
+        const userId = req._auth.verifiedAuth.claims.userId;
+        const actingHandle = await resolveActiveHandle(vctx, userId);
+        if (actingHandle === undefined) {
+            await ctx.send.send(ctx, NO_HANDLE_ERROR);
+            return Result.Ok(EventoResult.Continue);
+        }
+        const [policy, arms] = await Promise.all([getAudiencePolicy(vctx, actingHandle), listArmsForSubject(vctx, actingHandle)]);
+        await ctx.send.send(ctx, {
+            type: "vibes.diy.res-list-audience-arms",
+            policy,
+            arms,
+        });
+        return Result.Ok(EventoResult.Continue);
+    }),
+};
+//# sourceMappingURL=social-flow.js.map