@voltro/plugin-chat 0.0.0-stage → 0.87.0

package/dist/rpc.d.ts

@@ -0,0 +1,295 @@
+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 authorsDescriptor: QueryProcedureDescriptor<"chat.authors", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+    readonly subjectIds: Schema.$Array<Schema.NonEmptyString>;
+}>, Schema.$Array<Schema.Struct<{
+    readonly subjectId: Schema.String;
+    readonly displayName: Schema.String;
+    readonly avatar: Schema.NullOr<Schema.String>;
+}>>, typeof ChatError>;
+
+export declare const BASE_NAME = "@voltro/plugin-chat";
+
+export declare const channelDescriptor: QueryProcedureDescriptor<"chat.channel", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["global", "lobby", "party", "guild", "match", "dm", "custom"]>;
+    readonly refId: Schema.String;
+    readonly name: Schema.String;
+    readonly slowModeMs: Schema.Number;
+    readonly retentionMs: Schema.NullOr<Schema.Number>;
+    readonly maxMembers: Schema.Number;
+    readonly frozen: Schema.Boolean;
+    readonly createdAt: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof ChatError>;
+
+export declare const channelsDescriptor: QueryProcedureDescriptor<"chat.channels", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["global", "lobby", "party", "guild", "match", "dm", "custom"]>;
+    readonly refId: Schema.String;
+    readonly name: Schema.String;
+    readonly slowModeMs: Schema.Number;
+    readonly retentionMs: Schema.NullOr<Schema.Number>;
+    readonly maxMembers: Schema.Number;
+    readonly frozen: Schema.Boolean;
+    readonly createdAt: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>>, typeof ChatError>;
+
+declare class ChatError extends ChatError_base {
+}
+
+declare const ChatError_base: Schema.Class<ChatError, Schema.TaggedStruct<"ChatError", {
+    readonly code: Schema.Literals<readonly ["identity_required", "invalid_input", "not_found", "forbidden", "blocked", "sanctioned", "muted", "slow_mode", "rate_limited", "content_rejected", "conflict", "frozen", "member_limit", "unavailable", "export_limit"]>;
+}>, YieldableError>;
+
+export declare const chatRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const configureDescriptor: ActionProcedureDescriptor<"chat.configure", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+    readonly slowModeMs: Schema.optional<Schema.Number>;
+    readonly frozen: Schema.optional<Schema.Boolean>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["global", "lobby", "party", "guild", "match", "dm", "custom"]>;
+    readonly refId: Schema.String;
+    readonly name: Schema.String;
+    readonly slowModeMs: Schema.Number;
+    readonly retentionMs: Schema.NullOr<Schema.Number>;
+    readonly maxMembers: Schema.Number;
+    readonly frozen: Schema.Boolean;
+    readonly createdAt: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof ChatError>;
+
+export declare const dmDescriptor: ActionProcedureDescriptor<"chat.dm", Schema.Struct<{
+    readonly otherId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["global", "lobby", "party", "guild", "match", "dm", "custom"]>;
+    readonly refId: Schema.String;
+    readonly name: Schema.String;
+    readonly slowModeMs: Schema.Number;
+    readonly retentionMs: Schema.NullOr<Schema.Number>;
+    readonly maxMembers: Schema.Number;
+    readonly frozen: Schema.Boolean;
+    readonly createdAt: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof ChatError>;
+
+export declare const editDescriptor: ActionProcedureDescriptor<"chat.edit", Schema.Struct<{
+    readonly messageId: Schema.NonEmptyString;
+    readonly baseVersion: Schema.Number;
+    readonly body: Schema.String;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly channelId: Schema.String;
+    readonly authorId: Schema.NullOr<Schema.String>;
+    readonly kind: Schema.Literals<readonly ["text", "emote", "system", "media"]>;
+    readonly body: Schema.String;
+    readonly payload: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly replyToId: Schema.NullOr<Schema.String>;
+    readonly editedAt: Schema.NullOr<Schema.Number>;
+    readonly deletedAt: Schema.NullOr<Schema.Number>;
+    readonly flagged: Schema.Boolean;
+    readonly createdAt: Schema.Number;
+    readonly version: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof ChatError>;
+
+export declare const joinDescriptor: ActionProcedureDescriptor<"chat.join", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly channelId: Schema.String;
+    readonly subjectId: Schema.String;
+    readonly role: Schema.Literals<readonly ["member", "mod", "owner"]>;
+    readonly mutedUntil: Schema.NullOr<Schema.Number>;
+    readonly lastReadAt: Schema.Number;
+    readonly lastReadId: Schema.NullOr<Schema.String>;
+    readonly notify: Schema.Boolean;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof ChatError>;
+
+export declare const leaveDescriptor: ActionProcedureDescriptor<"chat.leave", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+}>, Schema.Void, typeof ChatError>;
+
+export declare const markReadDescriptor: ActionProcedureDescriptor<"chat.markRead", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+    readonly messageId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly channelId: Schema.String;
+    readonly subjectId: Schema.String;
+    readonly role: Schema.Literals<readonly ["member", "mod", "owner"]>;
+    readonly mutedUntil: Schema.NullOr<Schema.Number>;
+    readonly lastReadAt: Schema.Number;
+    readonly lastReadId: Schema.NullOr<Schema.String>;
+    readonly notify: Schema.Boolean;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof ChatError>;
+
+export declare const mediaUrlDescriptor: ActionProcedureDescriptor<"chat.mediaUrl", Schema.Struct<{
+    readonly messageId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly url: Schema.String;
+    readonly expiresAt: Schema.Number;
+}>, typeof ChatError>;
+
+export declare const membershipDescriptor: QueryProcedureDescriptor<"chat.membership", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly channelId: Schema.String;
+    readonly subjectId: Schema.String;
+    readonly role: Schema.Literals<readonly ["member", "mod", "owner"]>;
+    readonly mutedUntil: Schema.NullOr<Schema.Number>;
+    readonly lastReadAt: Schema.Number;
+    readonly lastReadId: Schema.NullOr<Schema.String>;
+    readonly notify: Schema.Boolean;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof ChatError>;
+
+export declare const mentionCandidatesDescriptor: QueryProcedureDescriptor<"chat.mentionCandidates", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+    readonly after: Schema.optional<Schema.NonEmptyString>;
+}>, Schema.Struct<{
+    readonly authors: Schema.$Array<Schema.Struct<{
+        readonly subjectId: Schema.String;
+        readonly displayName: Schema.String;
+        readonly avatar: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly after: Schema.NullOr<Schema.String>;
+}>, typeof ChatError>;
+
+export declare const messagesDescriptor: QueryProcedureDescriptor<"chat.messages", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+    readonly before: Schema.optional<Schema.Struct<{
+        readonly at: Schema.Number;
+        readonly id: Schema.NonEmptyString;
+    }>>;
+}>, Schema.Struct<{
+    readonly messages: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly channelId: Schema.String;
+        readonly authorId: Schema.NullOr<Schema.String>;
+        readonly kind: Schema.Literals<readonly ["text", "emote", "system", "media"]>;
+        readonly body: Schema.String;
+        readonly payload: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly replyToId: Schema.NullOr<Schema.String>;
+        readonly editedAt: Schema.NullOr<Schema.Number>;
+        readonly deletedAt: Schema.NullOr<Schema.Number>;
+        readonly flagged: Schema.Boolean;
+        readonly createdAt: Schema.Number;
+        readonly version: Schema.Number;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+    }>>;
+    readonly before: Schema.NullOr<Schema.Struct<{
+        readonly at: Schema.Number;
+        readonly id: Schema.String;
+    }>>;
+}>, typeof ChatError>;
+
+export declare const muteDescriptor: ActionProcedureDescriptor<"chat.mute", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+    readonly subjectId: Schema.NonEmptyString;
+    readonly mutedUntil: Schema.NullOr<Schema.Number>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly channelId: Schema.String;
+    readonly subjectId: Schema.String;
+    readonly role: Schema.Literals<readonly ["member", "mod", "owner"]>;
+    readonly mutedUntil: Schema.NullOr<Schema.Number>;
+    readonly lastReadAt: Schema.Number;
+    readonly lastReadId: Schema.NullOr<Schema.String>;
+    readonly notify: Schema.Boolean;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof ChatError>;
+
+export declare const originalDescriptor: ActionProcedureDescriptor<"chat.original", Schema.Struct<{
+    readonly messageId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly channelId: Schema.String;
+        readonly authorId: Schema.NullOr<Schema.String>;
+        readonly kind: Schema.Literals<readonly ["text", "emote", "system", "media"]>;
+        readonly body: Schema.String;
+        readonly payload: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly replyToId: Schema.NullOr<Schema.String>;
+        readonly editedAt: Schema.NullOr<Schema.Number>;
+        readonly deletedAt: Schema.NullOr<Schema.Number>;
+        readonly flagged: Schema.Boolean;
+        readonly createdAt: Schema.Number;
+        readonly version: Schema.Number;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+    }>;
+    readonly originalBody: Schema.String;
+}>, typeof ChatError>;
+
+export declare const removeDescriptor: ActionProcedureDescriptor<"chat.remove", Schema.Struct<{
+    readonly messageId: Schema.NonEmptyString;
+    readonly baseVersion: Schema.Number;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly channelId: Schema.String;
+    readonly authorId: Schema.NullOr<Schema.String>;
+    readonly kind: Schema.Literals<readonly ["text", "emote", "system", "media"]>;
+    readonly body: Schema.String;
+    readonly payload: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly replyToId: Schema.NullOr<Schema.String>;
+    readonly editedAt: Schema.NullOr<Schema.Number>;
+    readonly deletedAt: Schema.NullOr<Schema.Number>;
+    readonly flagged: Schema.Boolean;
+    readonly createdAt: Schema.Number;
+    readonly version: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof ChatError>;
+
+export declare const sendDescriptor: ActionProcedureDescriptor<"chat.send", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+    readonly requestId: Schema.NonEmptyString;
+    readonly body: Schema.String;
+    readonly replyToId: Schema.optional<Schema.NonEmptyString>;
+    readonly mediaId: Schema.optional<Schema.NonEmptyString>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly channelId: Schema.String;
+    readonly authorId: Schema.NullOr<Schema.String>;
+    readonly kind: Schema.Literals<readonly ["text", "emote", "system", "media"]>;
+    readonly body: Schema.String;
+    readonly payload: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly replyToId: Schema.NullOr<Schema.String>;
+    readonly editedAt: Schema.NullOr<Schema.Number>;
+    readonly deletedAt: Schema.NullOr<Schema.Number>;
+    readonly flagged: Schema.Boolean;
+    readonly createdAt: Schema.Number;
+    readonly version: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof ChatError>;
+
+export declare const setTypingDescriptor: ActionProcedureDescriptor<"chat.setTyping", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+    readonly active: Schema.Boolean;
+}>, Schema.Void, typeof ChatError>;
+
+export declare const transferOwnershipDescriptor: ActionProcedureDescriptor<"chat.transferOwnership", Schema.Struct<{
+    readonly channelId: Schema.NonEmptyString;
+    readonly targetId: Schema.NonEmptyString;
+}>, Schema.Void, typeof ChatError>;
+
+export declare const unreadDescriptor: QueryProcedureDescriptor<"chat.unread", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly channelId: Schema.String;
+    readonly count: Schema.Number;
+    readonly truncated: Schema.Boolean;
+}>>, typeof ChatError>;
+
+export { }

package/dist/rpc.js

@@ -0,0 +1,267 @@
+import { ChatError as e } from "./errors.js";
+import { CHANNELS_TABLE as t, ChatAuthorProjectionSchema as n, ChatChannelSchema as r, ChatMediaUrlSchema as i, ChatMemberSchema as a, ChatMentionCandidatesSchema as o, ChatMessagePageSchema as s, ChatMessageSchema as c, ChatOriginalSchema as l, ChatUnreadSchema as u, MEMBERS_TABLE as d, MESSAGES_TABLE as f } from "./contract.js";
+import { Schema as p } from "effect";
+import { defineAction as m, defineQuery as h } from "@voltro/protocol";
+//#region src/rpc.ts
+var g = "@voltro/plugin-chat", _ = "The handler verifies human identity, same-tenant channel membership and the required author/mod role; input is an intention only.", v = p.Number.pipe(p.check(p.isInt()), p.check(p.isGreaterThanOrEqualTo(0))), y = p.Struct({ channelId: p.NonEmptyString }), b = m({
+	name: "chat.setTyping",
+	input: p.Struct({
+		channelId: p.NonEmptyString,
+		active: p.Boolean
+	}),
+	output: p.Void,
+	error: e,
+	openAccess: _
+}), x = m({
+	name: "chat.dm",
+	input: p.Struct({ otherId: p.NonEmptyString }),
+	output: r,
+	error: e,
+	openAccess: _
+}), S = m({
+	name: "chat.send",
+	input: p.Struct({
+		channelId: p.NonEmptyString,
+		requestId: p.NonEmptyString,
+		body: p.String,
+		replyToId: p.optional(p.NonEmptyString),
+		mediaId: p.optional(p.NonEmptyString.pipe(p.check(p.isMaxLength(256))))
+	}),
+	output: c,
+	error: e,
+	openAccess: _
+}), C = m({
+	name: "chat.edit",
+	input: p.Struct({
+		messageId: p.NonEmptyString,
+		baseVersion: v,
+		body: p.String
+	}),
+	output: c,
+	error: e,
+	openAccess: _
+}), w = m({
+	name: "chat.remove",
+	input: p.Struct({
+		messageId: p.NonEmptyString,
+		baseVersion: v
+	}),
+	output: c,
+	error: e,
+	openAccess: _
+}), T = h({
+	name: "chat.messages",
+	input: p.Struct({
+		channelId: p.NonEmptyString,
+		before: p.optional(p.Struct({
+			at: v,
+			id: p.NonEmptyString
+		}))
+	}),
+	output: s,
+	source: [
+		f,
+		d,
+		t,
+		"_voltro_social_relations",
+		"_voltro_guild_members",
+		"_voltro_mm_party_members"
+	],
+	optionalSource: [
+		"_voltro_social_relations",
+		"_voltro_guild_members",
+		"_voltro_mm_party_members"
+	],
+	error: e,
+	openAccess: _
+}), E = h({
+	name: "chat.mentionCandidates",
+	input: p.Struct({
+		channelId: p.NonEmptyString,
+		after: p.optional(p.NonEmptyString.pipe(p.check(p.isMaxLength(256))))
+	}),
+	output: o,
+	source: [
+		d,
+		t,
+		"_voltro_players",
+		"_voltro_social_relations"
+	],
+	optionalSource: ["_voltro_players", "_voltro_social_relations"],
+	error: e,
+	openAccess: _
+}), D = h({
+	name: "chat.authors",
+	input: p.Struct({
+		channelId: p.NonEmptyString,
+		subjectIds: p.Array(p.NonEmptyString.pipe(p.check(p.isMaxLength(256)))).pipe(p.check(p.isMaxLength(128)))
+	}),
+	output: p.Array(n),
+	source: [
+		d,
+		t,
+		"_voltro_players",
+		"_voltro_social_relations"
+	],
+	optionalSource: ["_voltro_players", "_voltro_social_relations"],
+	error: e,
+	openAccess: _
+}), O = h({
+	name: "chat.channel",
+	input: y,
+	output: r,
+	source: [
+		t,
+		d,
+		"_voltro_guild_members",
+		"_voltro_mm_party_members"
+	],
+	optionalSource: ["_voltro_guild_members", "_voltro_mm_party_members"],
+	error: e,
+	openAccess: _
+}), k = h({
+	name: "chat.membership",
+	input: y,
+	output: a,
+	source: [
+		d,
+		t,
+		"_voltro_guild_members",
+		"_voltro_mm_party_members"
+	],
+	optionalSource: ["_voltro_guild_members", "_voltro_mm_party_members"],
+	error: e,
+	openAccess: _
+}), A = h({
+	name: "chat.channels",
+	input: p.Struct({}),
+	output: p.Array(r),
+	source: [
+		t,
+		d,
+		"_voltro_guild_members",
+		"_voltro_mm_party_members"
+	],
+	optionalSource: ["_voltro_guild_members", "_voltro_mm_party_members"],
+	error: e,
+	openAccess: _
+}), j = h({
+	name: "chat.unread",
+	input: p.Struct({}),
+	output: p.Array(u),
+	source: [
+		f,
+		d,
+		t,
+		"_voltro_social_relations",
+		"_voltro_guild_members",
+		"_voltro_mm_party_members"
+	],
+	optionalSource: [
+		"_voltro_social_relations",
+		"_voltro_guild_members",
+		"_voltro_mm_party_members"
+	],
+	error: e,
+	openAccess: _
+}), M = m({
+	name: "chat.original",
+	input: p.Struct({ messageId: p.NonEmptyString }),
+	output: l,
+	error: e,
+	openAccess: _
+}), N = m({
+	name: "chat.mediaUrl",
+	input: p.Struct({ messageId: p.NonEmptyString }),
+	output: i,
+	error: e,
+	openAccess: _
+}), P = m({
+	name: "chat.markRead",
+	input: p.Struct({
+		channelId: p.NonEmptyString,
+		messageId: p.NonEmptyString
+	}),
+	output: a,
+	error: e,
+	openAccess: _
+}), F = m({
+	name: "chat.mute",
+	input: p.Struct({
+		channelId: p.NonEmptyString,
+		subjectId: p.NonEmptyString,
+		mutedUntil: p.NullOr(v)
+	}),
+	output: a,
+	error: e,
+	openAccess: _
+}), I = m({
+	name: "chat.configure",
+	input: p.Struct({
+		channelId: p.NonEmptyString,
+		slowModeMs: p.optional(v),
+		frozen: p.optional(p.Boolean)
+	}),
+	output: r,
+	error: e,
+	openAccess: _
+}), L = m({
+	name: "chat.join",
+	input: y,
+	output: a,
+	error: e,
+	openAccess: "The handler admits only the verified caller, only into an open global channel of the caller's own tenant, behind the Sanctions checkpoint and member cap."
+}), R = m({
+	name: "chat.leave",
+	input: y,
+	output: p.Void,
+	error: e,
+	openAccess: _
+}), z = m({
+	name: "chat.transferOwnership",
+	input: p.Struct({
+		channelId: p.NonEmptyString,
+		targetId: p.NonEmptyString
+	}),
+	output: p.Void,
+	error: e,
+	openAccess: _
+}), B = [...[
+	"setTyping",
+	"dm",
+	"send",
+	"edit",
+	"remove",
+	"markRead",
+	"mute",
+	"configure",
+	"original",
+	"mediaUrl",
+	"join",
+	"leave",
+	"transferOwnership"
+].map((e) => ({
+	tag: "chat." + e,
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-chat/rpc",
+		name: e + "Descriptor"
+	}
+})), ...[
+	"mentionCandidates",
+	"authors",
+	"messages",
+	"channel",
+	"membership",
+	"channels",
+	"unread"
+].map((e) => ({
+	tag: "chat." + e,
+	kind: "query",
+	import: {
+		module: "@voltro/plugin-chat/rpc",
+		name: e + "Descriptor"
+	}
+}))];
+//#endregion
+export { g as BASE_NAME, D as authorsDescriptor, O as channelDescriptor, A as channelsDescriptor, B as chatRpcClientImports, I as configureDescriptor, x as dmDescriptor, C as editDescriptor, L as joinDescriptor, R as leaveDescriptor, P as markReadDescriptor, N as mediaUrlDescriptor, k as membershipDescriptor, E as mentionCandidatesDescriptor, T as messagesDescriptor, F as muteDescriptor, M as originalDescriptor, w as removeDescriptor, S as sendDescriptor, b as setTypingDescriptor, z as transferOwnershipDescriptor, j as unreadDescriptor };

package/dist/rpcRoutes.js

@@ -0,0 +1,97 @@
+import { chatError as e } from "./errors.js";
+import { typing as t } from "./events.js";
+import { authorsDescriptor as n, channelDescriptor as r, channelsDescriptor as i, configureDescriptor as a, dmDescriptor as o, editDescriptor as s, joinDescriptor as c, leaveDescriptor as l, markReadDescriptor as u, mediaUrlDescriptor as d, membershipDescriptor as f, mentionCandidatesDescriptor as p, messagesDescriptor as m, muteDescriptor as h, originalDescriptor as g, removeDescriptor as _, sendDescriptor as v, setTypingDescriptor as y, transferOwnershipDescriptor as b, unreadDescriptor as x } from "./rpc.js";
+import { Effect as S } from "effect";
+//#region src/rpcRoutes.ts
+var C = (C) => [
+	{
+		...y,
+		execute: (n, r) => {
+			let i = r.events;
+			if (!i) return S.fail(e("unavailable"));
+			let a = {
+				channelId: n.channelId,
+				active: n.active
+			};
+			return C.prepareTyping(r.request.subject, a).pipe(S.flatMap((n) => i.publish(t, { channelId: a.channelId }, n).pipe(S.asVoid, S.mapError(() => e("unavailable")), S.catchDefect(() => S.fail(e("unavailable"))))));
+		}
+	},
+	{
+		...p,
+		execute: (e, t) => C.mentionCandidates(t.request.subject, e)
+	},
+	{
+		...n,
+		execute: (e, t) => C.authors(t.request.subject, e)
+	},
+	{
+		...o,
+		execute: (e, t) => C.dm(t.request.subject, e.otherId)
+	},
+	{
+		...v,
+		execute: (e, t) => C.send(t.request.subject, e)
+	},
+	{
+		...s,
+		execute: (e, t) => C.edit(t.request.subject, e)
+	},
+	{
+		..._,
+		execute: (e, t) => C.remove(t.request.subject, e)
+	},
+	{
+		...m,
+		execute: (e, t) => C.messages(t.request.subject, e)
+	},
+	{
+		...r,
+		execute: (e, t) => C.channel(t.request.subject, e.channelId)
+	},
+	{
+		...f,
+		execute: (e, t) => C.membership(t.request.subject, e.channelId)
+	},
+	{
+		...i,
+		execute: (e, t) => C.channels(t.request.subject)
+	},
+	{
+		...x,
+		execute: (e, t) => C.unread(t.request.subject)
+	},
+	{
+		...g,
+		execute: (e, t) => C.original(t.request.subject, e.messageId)
+	},
+	{
+		...d,
+		execute: (e, t) => C.mediaUrl(t.request.subject, e.messageId)
+	},
+	{
+		...u,
+		execute: (e, t) => C.markRead(t.request.subject, e.channelId, e.messageId)
+	},
+	{
+		...h,
+		execute: (e, t) => C.moderateMember(t.request.subject, e)
+	},
+	{
+		...a,
+		execute: (e, t) => C.configure(t.request.subject, e)
+	},
+	{
+		...c,
+		execute: (e, t) => C.join(t.request.subject, e.channelId)
+	},
+	{
+		...l,
+		execute: (e, t) => C.leave(t.request.subject, e.channelId)
+	},
+	{
+		...b,
+		execute: (e, t) => C.transferOwnership(t.request.subject, e.channelId, e.targetId)
+	}
+];
+//#endregion
+export { C as chatRpcRoutes };