@voltro/plugin-social 0.0.0-stage → 0.88.0

package/dist/index.js

@@ -0,0 +1,134 @@
+import { SocialError as e, socialError as t } from "./errors.js";
+import { SocialBlockPort as n } from "./port.js";
+import { socialRelationsTable as r } from "./relations.entity.js";
+import { socialRecentTable as i } from "./recent.entity.js";
+import { socialSettingsTable as a } from "./settings.entity.js";
+import { dataStoreSocial as o } from "./service.js";
+import { BASE_NAME as s, socialRpcClientImports as c } from "./rpc.js";
+import { socialRpcRoutes as l } from "./rpcRoutes.js";
+import { defaultSocialStrategies as u, resolveSocialOptions as d } from "./strategies.js";
+import { socialStatus as f } from "./inspect.js";
+import { accepted as p, requested as m } from "./events.js";
+import { defineLicensedGamePlugin as h } from "@voltro/plugin-licensing/gate";
+import { Effect as g, Layer as _ } from "effect";
+import { fileURLToPath as v } from "node:url";
+import { replicaEvidence as y } from "@voltro/protocol/identity";
+import { redisStore as b } from "@voltro/plugin-ratelimit";
+// src/index.ts
+var x = {
+	slots: {
+		suggestions: {
+			defaultExport: "mutualMatchSuggestions",
+			fixtureExport: "socialSuggestionsFixture"
+		},
+		requestPolicy: {
+			defaultExport: "recipientRequestPolicy",
+			fixtureExport: "socialRequestPolicyFixture"
+		},
+		recentPolicy: {
+			defaultExport: "distinctRecentPeers",
+			fixtureExport: "socialRecentPolicyFixture"
+		}
+	},
+	ports: { socialBlock: {
+		tagExport: "SocialBlockPort",
+		fakeLayerExport: "socialBlockFakeLayer",
+		fixtureExport: "socialBlockPortFixture"
+	} },
+	events: [m.name, p.name]
+}, S = (u = {}) => {
+	let p = d(u), m = b(p.rateLimit), x, S, C = !1, w = (e) => g.suspend(() => S === void 0 ? g.fail(t("unavailable")) : e(S));
+	return h({
+		name: s,
+		description: "SQL-owned social graph and symmetric block admission.",
+		permissions: ["store:write", "inspect:read"],
+		services: _.succeed(n, {
+			isBlocked: (e, t) => w((n) => n.blockPort.isBlocked(e, t)),
+			blockPairs: (e, t) => w((n) => n.blockPort.blockPairs(e, t)),
+			canMessage: (e, t) => w((n) => n.blockPort.canMessage(e, t)),
+			canInvite: (e, t) => w((n) => n.blockPort.canInvite(e, t)),
+			recordRecent: (e, t) => w((n) => n.blockPort.recordRecent(e, t))
+		}),
+		sources: v(new URL("./social-app", "" + import.meta.url)),
+		routes: l({
+			request: (e, t) => w((n) => n.service.request(e, t)),
+			accept: (e, t) => w((n) => n.service.accept(e, t)),
+			decline: (e, t) => w((n) => n.service.decline(e, t)),
+			cancel: (e, t) => w((n) => n.service.cancel(e, t)),
+			remove: (e, t) => w((n) => n.service.remove(e, t)),
+			block: (e, t) => w((n) => n.service.block(e, t)),
+			unblock: (e, t) => w((n) => n.service.unblock(e, t)),
+			favorite: (e, t, n) => w((r) => r.service.favorite(e, t, n)),
+			setSettings: (e, t) => w((n) => n.service.setSettings(e, t)),
+			getSettings: (e) => w((t) => t.service.getSettings(e)),
+			friends: (e) => w((t) => t.service.friends(e)),
+			requests: (e) => w((t) => t.service.requests(e)),
+			blocked: (e) => w((t) => t.service.blocked(e)),
+			favorites: (e) => w((t) => t.service.favorites(e)),
+			recent: (e) => w((t) => t.service.recent(e)),
+			suggestions: (e) => w((t) => t.service.suggestions(e))
+		}),
+		rpcClientDescriptors: c,
+		errorSchemas: [{
+			schema: e,
+			import: {
+				module: "@voltro/plugin-social/errors",
+				name: "SocialError"
+			}
+		}],
+		extendSchema: { tables: [
+			r,
+			i,
+			a
+		] },
+		subjectPrivacy: {
+			tables: [
+				r.tableName,
+				i.tableName,
+				a.tableName
+			],
+			kinds: ["user", "guest"]
+		},
+		inspectEndpoints: [{
+			method: "GET",
+			path: "/status",
+			scope: "process",
+			description: "Configuration and binding observation, no graph records or SQL/Redis health claim.",
+			handler: () => g.try({
+				try: () => ({
+					kind: "json",
+					data: f(p, S !== void 0, C)
+				}),
+				catch: () => t("unavailable")
+			})
+		}],
+		bindDataStore: (e) => {
+			if (x !== void 0 && x !== e) throw Error("Social plugin instance cannot cross app stores");
+			x = e, S = o(e, p, m);
+		},
+		onActivate: (e) => g.tryPromise({
+			try: async () => {
+				if (p.rateLimit?.hotStore !== void 0 && y(e.env) !== null) throw t("unavailable");
+				await m.activate(e.env, e.connectionRegistry), C = !0;
+			},
+			catch: () => t("unavailable")
+		}),
+		onExport: (e, t) => w((n) => n.exportSubject({
+			subjectId: e,
+			tenantId: t.tenantId,
+			kind: t.kind
+		})),
+		onErase: (e, t) => w((n) => n.eraseSubject({
+			subjectId: e,
+			tenantId: t.tenantId,
+			kind: t.kind
+		})),
+		onDeactivate: () => g.tryPromise({
+			try: async () => {
+				C = !1, S = void 0, x = void 0, await m.deactivate();
+			},
+			catch: () => t("unavailable")
+		})
+	});
+};
+export { n as SocialBlockPort, e as SocialError, o as dataStoreSocial, u as defaultSocialStrategies, d as resolveSocialOptions, S as socialPlugin, i as socialRecentTable, r as socialRelationsTable, a as socialSettingsTable, x as socialSystemContract };

package/dist/inspect.js

@@ -0,0 +1,27 @@
+import { socialError as e } from "./errors.js";
+import { RECENT_TABLE as t, RELATIONS_TABLE as n, SETTINGS_TABLE as r } from "./contract.js";
+import { defaultSocialStrategies as i } from "./strategies.js";
+// src/inspect.ts
+var a = (a, o, s) => {
+	let c = a.now();
+	if (!Number.isSafeInteger(c) || c < 0 || c > 864e13) throw e("unavailable");
+	return {
+		observedAt: c,
+		bound: o,
+		rateActive: s,
+		maxFriends: a.maxFriends,
+		maxPendingRequests: a.maxPendingRequests,
+		recentLimit: a.recentLimit,
+		recentRetentionMs: a.recentRetentionMs,
+		requestLimit: a.requestLimit,
+		requestWindowMs: a.requestWindowMs,
+		suggestionLimit: a.suggestionLimit,
+		slots: Object.fromEntries(Object.entries(i).map(([e, t]) => [e, a.strategies[e] === t ? "default" : "custom"])),
+		tables: [
+			n,
+			t,
+			r
+		]
+	};
+};
+export { a as socialStatus };

package/dist/port.d.ts

@@ -0,0 +1,35 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+declare interface RecordRecentInput {
+    readonly tenantId: string;
+    readonly participants: ReadonlyArray<string>;
+    readonly context: string;
+    readonly at?: number;
+}
+
+export declare class SocialBlockPort extends SocialBlockPort_base {
+}
+
+declare const SocialBlockPort_base: Context.ServiceClass<SocialBlockPort, "@voltro/SocialBlockPort", SocialBlockService>;
+
+/** Chat, matchmaking and party admission depend on this port, never Social SQL. */
+export declare interface SocialBlockService {
+    readonly isBlocked: (subject: Subject, otherId: string) => Effect.Effect<boolean, SocialError>;
+    readonly blockPairs: (subject: Subject, subjectIds: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<readonly [string, string]>, SocialError>;
+    readonly canMessage: (subject: Subject, otherId: string) => Effect.Effect<boolean, SocialError>;
+    readonly canInvite: (subject: Subject, otherId: string) => Effect.Effect<boolean, SocialError>;
+    readonly recordRecent: (subject: Subject, input: RecordRecentInput) => Effect.Effect<void, SocialError>;
+}
+
+declare class SocialError extends SocialError_base {
+}
+
+declare const SocialError_base: Schema.Class<SocialError, Schema.TaggedStruct<"SocialError", {
+    readonly code: Schema.Literals<readonly ["identity_required", "invalid_input", "blocked", "request_refused", "not_found", "friend_limit", "pending_limit", "rate_limited", "unavailable", "export_limit"]>;
+}>, YieldableError>;
+
+export { }

package/dist/port.js

@@ -0,0 +1,4 @@
+import { Context as e } from "effect";
+// src/port.ts
+var t = class extends e.Service()("@voltro/SocialBlockPort") {};
+export { t as SocialBlockPort };

package/dist/recent.entity.js

@@ -0,0 +1,17 @@
+import { RECENT_TABLE as e } from "./contract.js";
+import { id as t, json as n, table as r, text as i, timestamp as a } from "@voltro/database";
+// src/recent.entity.ts
+var o = r(e, {
+	id: t({ prefix: "srecent" }),
+	tenantId: i().maxLength(256).externalId().sensitive("pii"),
+	ownerId: i().maxLength(256).externalId().sensitive("pii"),
+	otherId: i().maxLength(256).externalId().sensitive("pii"),
+	context: i().maxLength(256).sensitive("pii"),
+	at: a().safe(),
+	metadata: n().sensitive("pii")
+}).index([
+	"tenantId",
+	"ownerId",
+	"at"
+]).index(["tenantId", "otherId"]);
+export { o as socialRecentTable };

package/dist/relations.entity.js

@@ -0,0 +1,29 @@
+import { RELATIONS_TABLE as e } from "./contract.js";
+import { id as t, json as n, table as r, text as i, timestamp as a } from "@voltro/database";
+// src/relations.entity.ts
+var o = r(e, {
+	id: t({ prefix: "srel" }),
+	tenantId: i().maxLength(256).externalId().sensitive("pii"),
+	fromId: i().maxLength(256).externalId().sensitive("pii"),
+	toId: i().maxLength(256).externalId().sensitive("pii"),
+	pairKey: i().maxLength(64).serverOnly(),
+	kind: i().maxLength(16).oneOf([
+		"request",
+		"friend",
+		"block",
+		"favorite"
+	]).safe(),
+	createdAt: a().safe(),
+	respondedAt: a().nullable().safe(),
+	note: i().nullable().sensitive("pii"),
+	metadata: n().sensitive("pii")
+}).unique(["pairKey", "kind"]).index([
+	"tenantId",
+	"fromId",
+	"kind"
+]).index([
+	"tenantId",
+	"toId",
+	"kind"
+]);
+export { o as socialRelationsTable };

package/dist/rpc.d.ts

@@ -0,0 +1,150 @@
+import { ActionProcedureDescriptor } from '@voltro/protocol';
+import { PluginRpcClientDescriptor } from '@voltro/protocol';
+import { QueryProcedureDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare const acceptDescriptor: ActionProcedureDescriptor<"social.accept", Schema.Struct<{
+    readonly otherId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly fromId: Schema.String;
+    readonly toId: Schema.String;
+    readonly kind: Schema.Literals<readonly ["request", "friend", "block", "favorite"]>;
+    readonly createdAt: Schema.Number;
+    readonly respondedAt: Schema.NullOr<Schema.Number>;
+    readonly note: Schema.NullOr<Schema.String>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof SocialError>;
+
+export declare const BASE_NAME = "@voltro/plugin-social";
+
+export declare const blockDescriptor: ActionProcedureDescriptor<"social.block", Schema.Struct<{
+    readonly otherId: Schema.NonEmptyString;
+}>, Schema.Void, typeof SocialError>;
+
+export declare const blockedDescriptor: QueryProcedureDescriptor<"social.blocked", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly fromId: Schema.String;
+    readonly toId: Schema.String;
+    readonly kind: Schema.Literals<readonly ["request", "friend", "block", "favorite"]>;
+    readonly createdAt: Schema.Number;
+    readonly respondedAt: Schema.NullOr<Schema.Number>;
+    readonly note: Schema.NullOr<Schema.String>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>>, typeof SocialError>;
+
+export declare const cancelDescriptor: ActionProcedureDescriptor<"social.cancel", Schema.Struct<{
+    readonly otherId: Schema.NonEmptyString;
+}>, Schema.Void, typeof SocialError>;
+
+export declare const declineDescriptor: ActionProcedureDescriptor<"social.decline", Schema.Struct<{
+    readonly otherId: Schema.NonEmptyString;
+}>, Schema.Void, typeof SocialError>;
+
+export declare const favoriteDescriptor: ActionProcedureDescriptor<"social.favorite", Schema.Struct<{
+    readonly otherId: Schema.NonEmptyString;
+    readonly enabled: Schema.Boolean;
+}>, Schema.Void, typeof SocialError>;
+
+export declare const favoritesDescriptor: QueryProcedureDescriptor<"social.favorites", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly fromId: Schema.String;
+    readonly toId: Schema.String;
+    readonly kind: Schema.Literals<readonly ["request", "friend", "block", "favorite"]>;
+    readonly createdAt: Schema.Number;
+    readonly respondedAt: Schema.NullOr<Schema.Number>;
+    readonly note: Schema.NullOr<Schema.String>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>>, typeof SocialError>;
+
+export declare const friendsDescriptor: QueryProcedureDescriptor<"social.friends", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly fromId: Schema.String;
+    readonly toId: Schema.String;
+    readonly kind: Schema.Literals<readonly ["request", "friend", "block", "favorite"]>;
+    readonly createdAt: Schema.Number;
+    readonly respondedAt: Schema.NullOr<Schema.Number>;
+    readonly note: Schema.NullOr<Schema.String>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>>, typeof SocialError>;
+
+export declare const recentDescriptor: QueryProcedureDescriptor<"social.recent", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly otherId: Schema.String;
+    readonly context: Schema.String;
+    readonly at: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>>, typeof SocialError>;
+
+export declare const removeDescriptor: ActionProcedureDescriptor<"social.remove", Schema.Struct<{
+    readonly otherId: Schema.NonEmptyString;
+}>, Schema.Void, typeof SocialError>;
+
+export declare const requestDescriptor: ActionProcedureDescriptor<"social.request", Schema.Struct<{
+    readonly otherId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly fromId: Schema.String;
+    readonly toId: Schema.String;
+    readonly kind: Schema.Literals<readonly ["request", "friend", "block", "favorite"]>;
+    readonly createdAt: Schema.Number;
+    readonly respondedAt: Schema.NullOr<Schema.Number>;
+    readonly note: Schema.NullOr<Schema.String>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof SocialError>;
+
+export declare const requestsDescriptor: QueryProcedureDescriptor<"social.requests", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly fromId: Schema.String;
+    readonly toId: Schema.String;
+    readonly kind: Schema.Literals<readonly ["request", "friend", "block", "favorite"]>;
+    readonly createdAt: Schema.Number;
+    readonly respondedAt: Schema.NullOr<Schema.Number>;
+    readonly note: Schema.NullOr<Schema.String>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>>, typeof SocialError>;
+
+export declare const setSettingsDescriptor: ActionProcedureDescriptor<"social.setSettings", Schema.Struct<{
+    readonly requestsFrom: Schema.optional<Schema.Literals<readonly ["anyone", "friends-of-friends", "nobody"]>>;
+    readonly showOnline: Schema.optional<Schema.Boolean>;
+    readonly showActivity: Schema.optional<Schema.Boolean>;
+    readonly allowPartyInvites: Schema.optional<Schema.Literals<readonly ["friends", "anyone"]>>;
+}>, Schema.Struct<{
+    readonly ownerId: Schema.String;
+    readonly requestsFrom: Schema.Literals<readonly ["anyone", "friends-of-friends", "nobody"]>;
+    readonly showOnline: Schema.Boolean;
+    readonly showActivity: Schema.Boolean;
+    readonly allowPartyInvites: Schema.Literals<readonly ["friends", "anyone"]>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof SocialError>;
+
+export declare const settingsDescriptor: QueryProcedureDescriptor<"social.settings", Schema.Struct<{}>, Schema.Struct<{
+    readonly ownerId: Schema.String;
+    readonly requestsFrom: Schema.Literals<readonly ["anyone", "friends-of-friends", "nobody"]>;
+    readonly showOnline: Schema.Boolean;
+    readonly showActivity: Schema.Boolean;
+    readonly allowPartyInvites: Schema.Literals<readonly ["friends", "anyone"]>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof SocialError>;
+
+declare class SocialError extends SocialError_base {
+}
+
+declare const SocialError_base: Schema.Class<SocialError, Schema.TaggedStruct<"SocialError", {
+    readonly code: Schema.Literals<readonly ["identity_required", "invalid_input", "blocked", "request_refused", "not_found", "friend_limit", "pending_limit", "rate_limited", "unavailable", "export_limit"]>;
+}>, YieldableError>;
+
+export declare const socialRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const suggestionsDescriptor: QueryProcedureDescriptor<"social.suggestions", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly subjectId: Schema.String;
+    readonly mutualFriends: Schema.Number;
+    readonly recentMatches: Schema.Number;
+}>>, typeof SocialError>;
+
+export declare const unblockDescriptor: ActionProcedureDescriptor<"social.unblock", Schema.Struct<{
+    readonly otherId: Schema.NonEmptyString;
+}>, Schema.Void, typeof SocialError>;
+
+export { }

package/dist/rpc.js

@@ -0,0 +1,154 @@
+import { SocialError as e } from "./errors.js";
+import { RECENT_TABLE as t, RELATIONS_TABLE as n, RecentPlayerSchema as r, SETTINGS_TABLE as i, SocialRelationSchema as a, SocialSettingsSchema as o, SuggestionSchema as s } from "./contract.js";
+import { Schema as c } from "effect";
+import { defineAction as l, defineQuery as u } from "@voltro/protocol";
+// src/rpc.ts
+var d = "@voltro/plugin-social", f = "The handler requires a verified human subject and uses its tenant and identity; callers supply only intentions.", p = c.Struct({ otherId: c.NonEmptyString }), m = l({
+	name: "social.request",
+	input: p,
+	output: a,
+	error: e,
+	openAccess: f
+}), h = l({
+	name: "social.accept",
+	input: p,
+	output: a,
+	error: e,
+	openAccess: f
+}), g = l({
+	name: "social.decline",
+	input: p,
+	output: c.Void,
+	error: e,
+	openAccess: f
+}), _ = l({
+	name: "social.cancel",
+	input: p,
+	output: c.Void,
+	error: e,
+	openAccess: f
+}), v = l({
+	name: "social.remove",
+	input: p,
+	output: c.Void,
+	error: e,
+	openAccess: f
+}), y = l({
+	name: "social.block",
+	input: p,
+	output: c.Void,
+	error: e,
+	openAccess: f
+}), b = l({
+	name: "social.unblock",
+	input: p,
+	output: c.Void,
+	error: e,
+	openAccess: f
+}), x = l({
+	name: "social.favorite",
+	input: c.Struct({
+		otherId: c.NonEmptyString,
+		enabled: c.Boolean
+	}),
+	output: c.Void,
+	error: e,
+	openAccess: f
+}), S = l({
+	name: "social.setSettings",
+	input: c.Struct({
+		requestsFrom: c.optional(c.Literals([
+			"anyone",
+			"friends-of-friends",
+			"nobody"
+		])),
+		showOnline: c.optional(c.Boolean),
+		showActivity: c.optional(c.Boolean),
+		allowPartyInvites: c.optional(c.Literals(["friends", "anyone"]))
+	}),
+	output: o,
+	error: e,
+	openAccess: f
+}), C = u({
+	name: "social.settings",
+	input: c.Struct({}),
+	output: o,
+	source: i,
+	error: e,
+	openAccess: f
+}), w = u({
+	name: "social.friends",
+	input: c.Struct({}),
+	output: c.Array(a),
+	source: n,
+	error: e,
+	openAccess: f
+}), T = u({
+	name: "social.favorites",
+	input: c.Struct({}),
+	output: c.Array(a),
+	source: n,
+	error: e,
+	openAccess: f
+}), E = u({
+	name: "social.requests",
+	input: c.Struct({}),
+	output: c.Array(a),
+	source: n,
+	error: e,
+	openAccess: f
+}), D = u({
+	name: "social.blocked",
+	input: c.Struct({}),
+	output: c.Array(a),
+	source: n,
+	error: e,
+	openAccess: f
+}), O = u({
+	name: "social.recent",
+	input: c.Struct({}),
+	output: c.Array(r),
+	source: t,
+	error: e,
+	openAccess: f
+}), k = u({
+	name: "social.suggestions",
+	input: c.Struct({}),
+	output: c.Array(s),
+	source: n,
+	error: e,
+	openAccess: f
+}), A = [...[
+	"request",
+	"accept",
+	"decline",
+	"cancel",
+	"remove",
+	"block",
+	"unblock",
+	"favorite",
+	"setSettings"
+].map((e) => ({
+	tag: "social." + e,
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-social/rpc",
+		name: e + "Descriptor"
+	}
+})), ...[
+	"settings",
+	"friends",
+	"favorites",
+	"requests",
+	"blocked",
+	"recent",
+	"suggestions"
+].map((e) => ({
+	tag: "social." + e,
+	kind: "query",
+	import: {
+		module: "@voltro/plugin-social/rpc",
+		name: e + "Descriptor"
+	}
+}))];
+export { d as BASE_NAME, h as acceptDescriptor, y as blockDescriptor, D as blockedDescriptor, _ as cancelDescriptor, g as declineDescriptor, x as favoriteDescriptor, T as favoritesDescriptor, w as friendsDescriptor, O as recentDescriptor, v as removeDescriptor, m as requestDescriptor, E as requestsDescriptor, S as setSettingsDescriptor, C as settingsDescriptor, A as socialRpcClientImports, k as suggestionsDescriptor, b as unblockDescriptor };

package/dist/rpcRoutes.js

@@ -0,0 +1,69 @@
+import { acceptDescriptor as e, blockDescriptor as t, blockedDescriptor as n, cancelDescriptor as r, declineDescriptor as i, favoriteDescriptor as a, favoritesDescriptor as o, friendsDescriptor as s, recentDescriptor as c, removeDescriptor as l, requestDescriptor as u, requestsDescriptor as d, setSettingsDescriptor as f, settingsDescriptor as p, suggestionsDescriptor as m, unblockDescriptor as h } from "./rpc.js";
+// src/rpcRoutes.ts
+var g = (g) => [
+	{
+		...u,
+		execute: (e, t) => g.request(t.request.subject, e.otherId)
+	},
+	{
+		...e,
+		execute: (e, t) => g.accept(t.request.subject, e.otherId)
+	},
+	{
+		...i,
+		execute: (e, t) => g.decline(t.request.subject, e.otherId)
+	},
+	{
+		...r,
+		execute: (e, t) => g.cancel(t.request.subject, e.otherId)
+	},
+	{
+		...l,
+		execute: (e, t) => g.remove(t.request.subject, e.otherId)
+	},
+	{
+		...t,
+		execute: (e, t) => g.block(t.request.subject, e.otherId)
+	},
+	{
+		...h,
+		execute: (e, t) => g.unblock(t.request.subject, e.otherId)
+	},
+	{
+		...a,
+		execute: (e, t) => g.favorite(t.request.subject, e.otherId, e.enabled)
+	},
+	{
+		...f,
+		execute: (e, t) => g.setSettings(t.request.subject, e)
+	},
+	{
+		...p,
+		execute: (e, t) => g.getSettings(t.request.subject)
+	},
+	{
+		...s,
+		execute: (e, t) => g.friends(t.request.subject)
+	},
+	{
+		...o,
+		execute: (e, t) => g.favorites(t.request.subject)
+	},
+	{
+		...d,
+		execute: (e, t) => g.requests(t.request.subject)
+	},
+	{
+		...n,
+		execute: (e, t) => g.blocked(t.request.subject)
+	},
+	{
+		...c,
+		execute: (e, t) => g.recent(t.request.subject)
+	},
+	{
+		...m,
+		execute: (e, t) => g.suggestions(t.request.subject)
+	}
+];
+export { g as socialRpcRoutes };