@voltro/plugin-chat 0.0.0-stage → 0.88.0

package/dist/server.d.ts

@@ -0,0 +1,200 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { EvidenceCollectorInput } from '@voltro/plugin-sanctions/strategies';
+import { NotificationDeliveryGuard } from '@voltro/plugin-notifications';
+import { NotificationServiceShape } from '@voltro/plugin-notifications';
+import { OutboxEnqueue } from '@voltro/plugin-notifications';
+import { OutboxHandlerDefinition } from '@voltro/protocol';
+import { SanctionsError } from '@voltro/plugin-sanctions/errors';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { SubscriberDefinition } from '@voltro/runtime';
+import { YieldableError } from 'effect/Cause';
+
+/** Server integrations supply verified membership and transcripts, never browser rows. */
+export declare interface ArchiveMatchInput {
+    readonly tenantId: string;
+    readonly matchId: string;
+    readonly name: string;
+    readonly members: CreateChatChannelInput['members'];
+    readonly messages: ReadonlyArray<{
+        readonly id: string;
+        readonly authorId: string;
+        readonly body: string;
+        readonly at: number;
+    }>;
+    readonly retentionMs?: number | null;
+}
+
+declare const CHANNEL_KINDS: readonly ["global", "lobby", "party", "guild", "match", "dm", "custom"];
+
+export declare const CHAT_MENTION_NOTIFICATION_EFFECT = "voltro.chat.mention.notify";
+
+export declare const CHAT_MENTION_NOTIFICATION_GUARD = "chat.mention";
+
+/** App-bound server service. It borrows the plugin's SQL store and owns no connection. */
+export declare class ChatAdministration extends ChatAdministration_base {
+}
+
+declare const ChatAdministration_base: Context.ServiceClass<ChatAdministration, "@voltro/ChatAdministration", ChatAdministrationService>;
+
+export declare interface ChatAdministrationService {
+    readonly readReportEvidence: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly evidenceIds: ReadonlyArray<string>;
+    }) => Effect.Effect<ReadonlyArray<ChatEvidenceSnapshot>, ChatError>;
+    /** Server-only bounded capture; cases receive references, never transcript/author copies. */
+    readonly collectReportContext: (subject: Subject, input: ChatReportContextInput) => Effect.Effect<ChatReportContextEvidence, ChatError>;
+    /** One bounded, persisted sweep step. System scans app channels; service accounts only their tenant. */
+    readonly prune: (subject: Subject) => Effect.Effect<ChatRetentionBatch, ChatError>;
+    /** One bounded step deleting queued media blobs from plugin-storage; failed deletes stay queued. Same subject rules as prune. */
+    readonly sweepMedia: (subject: Subject) => Effect.Effect<ChatMediaSweep, ChatError>;
+    /** Check committed, retained mention ownership and current recipient authorization before delivery. */
+    readonly canNotifyMention: (subject: Subject, input: ChatMentionDeliveryInput) => Effect.Effect<boolean, ChatError>;
+    readonly createChannel: (subject: Subject, input: CreateChatChannelInput) => Effect.Effect<ChatChannel, ChatError>;
+    readonly addMember: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly channelId: string;
+        readonly subjectId: string;
+        readonly role: 'member' | 'mod';
+    }) => Effect.Effect<ChatMember, ChatError>;
+    readonly removeMember: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly channelId: string;
+        readonly subjectId: string;
+    }) => Effect.Effect<void, ChatError>;
+    readonly archiveMatch: (subject: Subject, input: ArchiveMatchInput) => Effect.Effect<ChatChannel, ChatError>;
+}
+
+declare type ChatChannel = typeof ChatChannelSchema.Type;
+
+declare const ChatChannelSchema: 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>;
+}>;
+
+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 interface ChatEvidenceSnapshot {
+    readonly id: string;
+    readonly channelId: string;
+    readonly messageId: string;
+    readonly messageVersion: number;
+    readonly kind: string;
+    readonly authorId: string | null;
+    readonly body: string | null;
+    readonly originalBody: string | null;
+    readonly createdAt: number;
+    readonly editedAt: number | null;
+    readonly deletedAt: number | null;
+    readonly capturedAt: number;
+    readonly expiresAt: number;
+    readonly erasedAt: number | null;
+}
+
+export declare interface ChatMediaSweep {
+    readonly removed: number;
+    readonly failed: number;
+    readonly remaining: boolean;
+}
+
+declare type ChatMember = typeof ChatMemberSchema.Type;
+
+declare const ChatMemberSchema: 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>;
+}>;
+
+export declare interface ChatMentionDeliveryInput {
+    readonly tenantId: string;
+    readonly channelId: string;
+    readonly messageId: string;
+    readonly recipientId: string;
+}
+
+export declare interface ChatMentionNotificationsOptions {
+    /** Trusted system or same-tenant chat:notifications:send service principal, never a browser identity. */
+    readonly subject: Subject;
+    /** Borrow the app runtime so actual ChatAdministration and Social services stay installed. */
+    readonly run: (effect: Effect.Effect<boolean, ChatError, ChatAdministration>) => Promise<boolean>;
+    readonly service: () => Pick<NotificationServiceShape, 'send'> | undefined;
+    /** The existing outbox facade must be bound to exactly this tenant. No independent connection. */
+    readonly outboxForTenant: (tenantId: string) => OutboxEnqueue;
+    readonly localeFor?: (recipientId: string, tenantId: string) => Promise<string | null>;
+}
+
+export declare interface ChatReportContextEvidence {
+    readonly kind: 'chat.context';
+    readonly channelId: string;
+    readonly anchorMessageId: string;
+    readonly observedAt: number;
+    readonly messages: ReadonlyArray<{
+        readonly evidenceId: string | null;
+        readonly messageId: string;
+        readonly version: number;
+        readonly createdAt: number;
+        readonly deletedAt: number | null;
+    }>;
+}
+
+export declare interface ChatReportContextInput {
+    readonly channelId: string;
+    readonly messageId: string;
+    readonly targetId: string;
+}
+
+export declare interface ChatRetentionBatch {
+    readonly deleted: number;
+    readonly evidenceDeleted: number;
+    readonly channelId: string | null;
+    readonly remainingInChannel: boolean;
+    readonly evidenceRemainingInChannel: boolean;
+    readonly cycleComplete: boolean;
+}
+
+/** Configure the existing Sanctions evidence slot. Human reports remain review-only. */
+export declare const chatSanctionEvidenceCollector: (input: EvidenceCollectorInput) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, SanctionsError>;
+
+declare interface CreateChatChannelInput {
+    readonly tenantId: string;
+    readonly kind: typeof CHANNEL_KINDS[number];
+    readonly refId: string;
+    readonly name: string;
+    readonly members: ReadonlyArray<{
+        readonly subjectId: string;
+        readonly role: ChatMember['role'];
+    }>;
+    readonly slowModeMs?: number;
+    readonly retentionMs?: number | null;
+    readonly maxMembers?: number;
+}
+
+/** Optional composition: export subscriber/outboxHandler in app discovery and register deliveryGuard with Notifications. */
+export declare const createChatMentionNotifications: (options: ChatMentionNotificationsOptions) => {
+    deliveryGuard: NotificationDeliveryGuard;
+    enqueue: (input: ChatMentionDeliveryInput) => Promise<string | null>;
+    outboxHandler: OutboxHandlerDefinition<never>;
+    subscriber: SubscriberDefinition;
+};
+
+export { }

package/dist/server.js

@@ -0,0 +1,6 @@
+import { CHAT_MENTION_NOTIFICATION_EFFECT as e, CHAT_MENTION_NOTIFICATION_GUARD as t, createChatMentionNotifications as n } from "./mentionNotifications.js";
+import { chatSanctionEvidenceCollector as r } from "./reportEvidence.js";
+import { Context as i } from "effect";
+// src/server.ts
+var a = class extends i.Service()("@voltro/ChatAdministration") {};
+export { e as CHAT_MENTION_NOTIFICATION_EFFECT, t as CHAT_MENTION_NOTIFICATION_GUARD, a as ChatAdministration, r as chatSanctionEvidenceCollector, n as createChatMentionNotifications };