@voltro/plugin-chat 0.0.0-stage → 0.87.0

package/dist/strategies.d.ts

@@ -0,0 +1,148 @@
+import { Effect } from 'effect';
+import { RedisStoreOptions } from '@voltro/plugin-ratelimit';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare const channelChatRetention: (channel: ChatChannel) => number | null;
+
+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 ChatMediaInput {
+    readonly subject: Subject;
+    /** Facts read from plugin-storage for a ref the sender owns in this tenant. */
+    readonly ref: {
+        readonly id: string;
+        readonly contentType: string;
+        readonly size: number;
+        readonly width: number | null;
+        readonly height: number | null;
+    };
+    readonly contentTypes: ReadonlyArray<string>;
+    readonly maxBytes: number;
+}
+
+export declare interface ChatMediaVerdict {
+    readonly allowed: boolean;
+    readonly flagged: boolean;
+}
+
+export declare interface ChatMentionInput {
+    readonly body: string;
+    readonly subject: Subject;
+    readonly maxMentions?: number;
+}
+
+export declare interface ChatModerationInput {
+    readonly body: string;
+    readonly denyWords: ReadonlyArray<string>;
+    readonly action: 'block' | 'flag';
+}
+
+export declare interface ChatModerationResult {
+    readonly body: string;
+    readonly flagged: boolean;
+    readonly allowed: boolean;
+}
+
+export declare interface ChatOptions {
+    readonly maxBodyLength?: number;
+    readonly pageSize?: number;
+    readonly maxMembers?: number;
+    readonly maxChannelsPerSubject?: number;
+    readonly retentionMs?: number | null;
+    readonly evidenceRetentionMs?: number;
+    readonly perChannelRate?: number;
+    readonly globalRate?: number;
+    readonly maxMentions?: number;
+    readonly maxExportRows?: number;
+    readonly denyWords?: ReadonlyArray<string>;
+    readonly moderationAction?: 'block' | 'flag';
+    readonly strategies?: Partial<ChatStrategies>;
+    readonly mediaContentTypes?: ReadonlyArray<string>;
+    readonly maxMediaBytes?: number;
+    readonly mediaUrlTtlSec?: number;
+    readonly rateLimit?: RedisStoreOptions;
+    readonly now?: () => number;
+}
+
+export declare interface ChatRateInput {
+    readonly channel: ChatChannel;
+    readonly perChannel: number;
+    readonly global: number;
+}
+
+export declare interface ChatStrategies {
+    readonly moderate: typeof keywordChatModeration;
+    readonly rateLimit: typeof fixedChatRateBudgets;
+    readonly mentionResolver: typeof playerChatMentions;
+    readonly retention: typeof channelChatRetention;
+    readonly moderateMedia: typeof typedChatMedia;
+}
+
+export declare const defaultChatStrategies: ChatStrategies;
+
+export declare const fixedChatRateBudgets: (input: ChatRateInput) => {
+    readonly perChannel: number;
+    readonly global: number;
+};
+
+/** Composition over the existing moderation provider, not another classifier. */
+export declare const keywordChatModeration: (input: ChatModerationInput) => Effect.Effect<ChatModerationResult, ChatError>;
+
+/** Exact Name#Tag claims from Players; Chat still admits every result against its channel. */
+export declare const playerChatMentions: (input: ChatMentionInput) => Effect.Effect<ReadonlyArray<string>, ChatError>;
+
+export declare const resolveChatOptions: (options?: ChatOptions) => Readonly<{
+    maxBodyLength: number;
+    pageSize: number;
+    maxMembers: number;
+    evidenceRetentionMs: number;
+    maxChannelsPerSubject: number;
+    retentionMs: number | null;
+    perChannelRate: number;
+    globalRate: number;
+    maxMentions: number;
+    maxExportRows: number;
+    denyWords: readonly string[];
+    moderationAction: "flag" | "block";
+    mediaContentTypes: readonly string[];
+    maxMediaBytes: number;
+    mediaUrlTtlSec: number;
+    strategies: Readonly<{
+        moderate: typeof keywordChatModeration;
+        rateLimit: typeof fixedChatRateBudgets;
+        mentionResolver: typeof playerChatMentions;
+        retention: typeof channelChatRetention;
+        moderateMedia: typeof typedChatMedia;
+    }>;
+    rateLimit: RedisStoreOptions | undefined;
+    now: () => number;
+}>;
+
+export declare type ResolvedChatOptions = ReturnType<typeof resolveChatOptions>;
+
+/** Declared type and size bounds only. Image classification is an integration: replace this slot to call a provider. */
+export declare const typedChatMedia: (input: ChatMediaInput) => Effect.Effect<ChatMediaVerdict, ChatError>;
+
+export { }

package/dist/strategies.js

@@ -0,0 +1,90 @@
+import { chatError as e } from "./errors.js";
+import { Effect as t } from "effect";
+import { PlayersPort as n } from "@voltro/plugin-players/port";
+import { keywordProvider as r } from "@voltro/plugin-moderation";
+//#region src/strategies.ts
+var i = (e) => r(e.denyWords)(e.body).pipe(t.map((t) => ({
+	body: e.body,
+	flagged: t.flagged,
+	allowed: !t.flagged || e.action === "flag"
+}))), a = (e) => ({
+	perChannel: e.perChannel,
+	global: e.global
+}), o = (r) => t.gen(function* () {
+	let i = r.maxMentions ?? 20;
+	if (!Number.isSafeInteger(i) || i < 1 || i > 100 || typeof r.body != "string" || r.body.length > 4e4) return yield* t.fail(e("invalid_input"));
+	let a = [], o = /* @__PURE__ */ new Set();
+	for (let n of r.body.matchAll(/(?:^|[\s(\[{])@([^@#\r\n]{1,256})#([0-9]{4})(?![\p{L}\p{N}_])/gu)) {
+		let r = n[1] + "#" + n[2];
+		if (!o.has(r)) {
+			if (a.length === i) return yield* t.fail(e("invalid_input"));
+			o.add(r), a.push({
+				name: n[1],
+				tag: n[2]
+			});
+		}
+	}
+	let s = yield* t.serviceOption(n);
+	if (s._tag === "None") return [];
+	let c = /* @__PURE__ */ new Set();
+	for (let n of a) {
+		let i = yield* t.suspend(() => s.value.resolveName(r.subject, n.name, n.tag)).pipe(t.catch((n) => n.code === "invalid_name" || n.code === "reserved_name" || n.code === "name_rejected" ? t.succeed(null) : t.fail(e("unavailable"))), t.catchDefect(() => t.fail(e("unavailable"))));
+		i !== null && c.add(i.subjectId);
+	}
+	return [...c];
+}), s = (e) => e.retentionMs, c = (e) => t.succeed({
+	allowed: e.contentTypes.includes(e.ref.contentType) && e.ref.size <= e.maxBytes,
+	flagged: !1
+}), l = Object.freeze({
+	moderate: i,
+	rateLimit: a,
+	mentionResolver: o,
+	retention: s,
+	moderateMedia: c
+}), u = (t = {}) => {
+	let n = {
+		maxBodyLength: t.maxBodyLength ?? 2e3,
+		pageSize: t.pageSize ?? 50,
+		maxMembers: t.maxMembers ?? 500,
+		evidenceRetentionMs: t.evidenceRetentionMs ?? 2592e6,
+		maxChannelsPerSubject: t.maxChannelsPerSubject ?? 100,
+		retentionMs: t.retentionMs === void 0 ? 6048e5 : t.retentionMs,
+		perChannelRate: t.perChannelRate ?? 2,
+		globalRate: t.globalRate ?? 10,
+		maxMentions: t.maxMentions ?? 20,
+		maxExportRows: t.maxExportRows ?? 1e4,
+		denyWords: Object.freeze([...t.denyWords ?? []]),
+		moderationAction: t.moderationAction ?? "block",
+		mediaContentTypes: Object.freeze([...t.mediaContentTypes ?? [
+			"image/png",
+			"image/jpeg",
+			"image/webp",
+			"image/gif"
+		]]),
+		maxMediaBytes: t.maxMediaBytes ?? 10485760,
+		mediaUrlTtlSec: t.mediaUrlTtlSec ?? 300,
+		strategies: Object.freeze({
+			...l,
+			...t.strategies
+		}),
+		rateLimit: t.rateLimit,
+		now: t.now ?? Date.now
+	};
+	for (let [t, r] of [
+		[n.evidenceRetentionMs, 31536e6],
+		[n.maxBodyLength, 2e4],
+		[n.pageSize, 200],
+		[n.maxMembers, 1e4],
+		[n.maxChannelsPerSubject, 1e4],
+		[n.perChannelRate, 1e3],
+		[n.globalRate, 1e4],
+		[n.maxMentions, 100],
+		[n.maxExportRows, 1e5],
+		[n.maxMediaBytes, 104857600],
+		[n.mediaUrlTtlSec, 3600]
+	]) if (!Number.isSafeInteger(t) || t < 1 || t > r) throw e("invalid_input");
+	if (n.retentionMs !== null && (!Number.isSafeInteger(n.retentionMs) || n.retentionMs < 1 || n.retentionMs > 31536e7) || n.denyWords.length > 1e3 || !["block", "flag"].includes(n.moderationAction) || n.denyWords.some((e) => typeof e != "string" || !e.trim() || e.length > 256) || n.mediaContentTypes.length > 64 || n.mediaContentTypes.some((e) => typeof e != "string" || !/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/.test(e)) || Object.values(n.strategies).some((e) => typeof e != "function") || typeof n.now != "function") throw e("invalid_input");
+	return Object.freeze(n);
+};
+//#endregion
+export { s as channelChatRetention, l as defaultChatStrategies, a as fixedChatRateBudgets, i as keywordChatModeration, o as playerChatMentions, u as resolveChatOptions, c as typedChatMedia };

package/dist/testing.d.ts

@@ -0,0 +1,139 @@
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+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>;
+
+declare interface ChatMediaInput {
+    readonly subject: Subject;
+    /** Facts read from plugin-storage for a ref the sender owns in this tenant. */
+    readonly ref: {
+        readonly id: string;
+        readonly contentType: string;
+        readonly size: number;
+        readonly width: number | null;
+        readonly height: number | null;
+    };
+    readonly contentTypes: ReadonlyArray<string>;
+    readonly maxBytes: number;
+}
+
+export declare const chatMediaModerationFixture: {
+    kind: "slot";
+    defaultImplementation: (input: ChatMediaInput) => Effect.Effect< ChatMediaVerdict, ChatError>;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean, ChatError, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<boolean, ChatError, never>;
+        expected: boolean;
+    };
+};
+
+declare interface ChatMediaVerdict {
+    readonly allowed: boolean;
+    readonly flagged: boolean;
+}
+
+declare interface ChatMentionInput {
+    readonly body: string;
+    readonly subject: Subject;
+    readonly maxMentions?: number;
+}
+
+export declare const chatMentionResolverFixture: {
+    kind: "slot";
+    defaultImplementation: (input: ChatMentionInput) => Effect.Effect<ReadonlyArray<string>, ChatError>;
+    defaultProbe: {
+        run: () => Effect.Effect<readonly string[], ChatError, never>;
+        expected: never[];
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<readonly string[], ChatError, never>;
+        expected: string[];
+    };
+};
+
+export declare const chatModerationFixture: {
+    kind: "slot";
+    defaultImplementation: (input: ChatModerationInput) => Effect.Effect< ChatModerationResult, ChatError>;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean, ChatError, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<boolean, ChatError, never>;
+        expected: boolean;
+    };
+};
+
+declare interface ChatModerationInput {
+    readonly body: string;
+    readonly denyWords: ReadonlyArray<string>;
+    readonly action: 'block' | 'flag';
+}
+
+declare interface ChatModerationResult {
+    readonly body: string;
+    readonly flagged: boolean;
+    readonly allowed: boolean;
+}
+
+declare interface ChatRateInput {
+    readonly channel: ChatChannel;
+    readonly perChannel: number;
+    readonly global: number;
+}
+
+export declare const chatRateLimitFixture: {
+    kind: "slot";
+    defaultImplementation: (input: ChatRateInput) => {
+        readonly perChannel: number;
+        readonly global: number;
+    };
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+};
+
+export declare const chatRetentionFixture: {
+    kind: "slot";
+    defaultImplementation: (channel: ChatChannel) => number | null;
+    defaultProbe: {
+        run: () => Effect.Effect<number | null, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number | null, never, never>;
+        expected: number;
+    };
+};
+
+export { }

package/dist/testing.js

@@ -0,0 +1,111 @@
+import { channelChatRetention as e, fixedChatRateBudgets as t, keywordChatModeration as n, playerChatMentions as r, resolveChatOptions as i, typedChatMedia as a } from "./strategies.js";
+import { Effect as o } from "effect";
+//#region src/testing.ts
+var s = {
+	id: "channel",
+	kind: "custom",
+	refId: "fixture",
+	name: "Fixture",
+	slowModeMs: 0,
+	retentionMs: 6048e5,
+	maxMembers: 2,
+	frozen: !1,
+	createdAt: 1,
+	metadata: {}
+}, c = {
+	body: "blocked",
+	denyWords: ["blocked"],
+	action: "block"
+}, l = {
+	kind: "slot",
+	defaultImplementation: n,
+	defaultProbe: {
+		run: () => n(c).pipe(o.map((e) => e.allowed)),
+		expected: !1
+	},
+	overrideProbe: {
+		run: () => i({ strategies: { moderate: (e) => n({
+			...e,
+			action: "flag"
+		}) } }).strategies.moderate(c).pipe(o.map((e) => e.allowed)),
+		expected: !0
+	}
+}, u = {
+	channel: s,
+	perChannel: 2,
+	global: 10
+}, d = {
+	kind: "slot",
+	defaultImplementation: t,
+	defaultProbe: {
+		run: () => o.sync(() => t(u).perChannel),
+		expected: 2
+	},
+	overrideProbe: {
+		run: () => o.sync(() => i({ strategies: { rateLimit: (e) => ({
+			...t(e),
+			perChannel: 1
+		}) } }).strategies.rateLimit(u).perChannel),
+		expected: 1
+	}
+}, f = {
+	body: "@Player#0001",
+	subject: {
+		type: "user",
+		id: "one",
+		tenantId: "tenant"
+	}
+}, p = {
+	kind: "slot",
+	defaultImplementation: r,
+	defaultProbe: {
+		run: () => r(f),
+		expected: []
+	},
+	overrideProbe: {
+		run: () => i({ strategies: { mentionResolver: () => o.succeed(["trusted-resolved-id"]) } }).strategies.mentionResolver(f),
+		expected: ["trusted-resolved-id"]
+	}
+}, m = {
+	kind: "slot",
+	defaultImplementation: e,
+	defaultProbe: {
+		run: () => o.sync(() => e(s)),
+		expected: 6048e5
+	},
+	overrideProbe: {
+		run: () => o.sync(() => i({ strategies: { retention: () => 864e5 } }).strategies.retention(s)),
+		expected: 864e5
+	}
+}, h = {
+	subject: {
+		type: "user",
+		id: "one",
+		tenantId: "tenant"
+	},
+	ref: {
+		id: "file_fixture",
+		contentType: "image/png",
+		size: 1024,
+		width: 8,
+		height: 8
+	},
+	contentTypes: ["image/png"],
+	maxBytes: 2048
+}, g = {
+	kind: "slot",
+	defaultImplementation: a,
+	defaultProbe: {
+		run: () => a(h).pipe(o.map((e) => e.allowed)),
+		expected: !0
+	},
+	overrideProbe: {
+		run: () => i({ strategies: { moderateMedia: () => o.succeed({
+			allowed: !1,
+			flagged: !0
+		}) } }).strategies.moderateMedia(h).pipe(o.map((e) => e.allowed)),
+		expected: !1
+	}
+};
+//#endregion
+export { g as chatMediaModerationFixture, p as chatMentionResolverFixture, l as chatModerationFixture, d as chatRateLimitFixture, m as chatRetentionFixture };

package/dist/typing.js

@@ -0,0 +1,88 @@
+import { chatError as e } from "./errors.js";
+import { CHAT_TYPING_TTL_MS as t, ChatTypingSchema as n } from "./contract.js";
+import { createTypingInvalidation as r } from "./typingInvalidation.js";
+import { typing as i } from "./events.js";
+import { Effect as a, Schema as o } from "effect";
+import { createHash as s } from "node:crypto";
+//#region src/typing.ts
+var c = (c) => {
+	let l = (t) => {
+		if (!t || typeof t != "object" || Array.isArray(t)) throw e("invalid_input");
+		let n = Object.getOwnPropertyDescriptor(t, "channelId");
+		if (!n || !("value" in n) || typeof n.value != "string" || !n.value.trim() || n.value.length > 256 || n.value.includes("\0") || n.value === "~") throw e("invalid_input");
+		return n.value;
+	}, u = (t) => a.try({
+		try: t,
+		catch: () => e("invalid_input")
+	}), d = (n, r) => {
+		let i, o, d;
+		try {
+			i = structuredClone(n), o = l(r);
+			let t = Object.getOwnPropertyDescriptor(r, "active");
+			if (!t || !("value" in t) || typeof t.value != "boolean") throw e("invalid_input");
+			d = t.value;
+		} catch {
+			return a.fail(e("invalid_input"));
+		}
+		return a.gen(function* () {
+			let n = yield* c.readAccess(i, o), r = yield* u(c.now), l = yield* c.social;
+			if (n.channel.kind === "dm" && !l) return yield* a.fail(e("forbidden"));
+			if (d) {
+				if (n.channel.frozen) return yield* a.fail(e("frozen"));
+				if (n.member.mutedUntil !== null && n.member.mutedUntil > r) return yield* a.fail(e("muted"));
+				yield* c.sanctioned(i, o);
+			}
+			let f = c.options.strategies.rateLimit({
+				channel: n.channel,
+				perChannel: c.options.perChannelRate,
+				global: c.options.globalRate
+			});
+			if (![f.perChannel, f.global].every((e) => Number.isSafeInteger(e) && e > 0 && e <= 1e4)) return yield* a.fail(e("unavailable"));
+			for (let [t, l] of [[[
+				i.tenantId,
+				n.member.subjectId,
+				o
+			], f.perChannel], [[i.tenantId, n.member.subjectId], f.global]]) {
+				let n = s("sha256").update(JSON.stringify(t)).digest("hex"), i = yield* c.limiter.consume("chat:typing:" + n, {
+					limit: l,
+					windowMs: 1e3,
+					algorithm: "fixed-window",
+					burst: l
+				}, r).pipe(a.mapError(() => e("unavailable")), a.catchDefect(() => a.fail(e("unavailable"))));
+				if (i.failOpenReason !== void 0) return yield* a.fail(e("unavailable"));
+				if (!i.allowed) return yield* a.fail(e("rate_limited"));
+			}
+			let p = d ? r + t : r;
+			return !Number.isSafeInteger(p) || p > 864e13 ? yield* a.fail(e("unavailable")) : Object.freeze({
+				subjectId: n.member.subjectId,
+				active: d,
+				expiresAt: p
+			});
+		}).pipe(a.catchDefect(() => a.fail(e("unavailable"))));
+	}, f = (e) => a.gen(function* () {
+		if (e.event !== i.name) return !1;
+		let t = yield* u(() => l(e.key));
+		return yield* c.readAccess(e.subject, t), !0;
+	}).pipe(a.catch(() => a.succeed(!1)), a.catchDefect(() => a.succeed(!1))), p = (t) => a.gen(function* () {
+		if (t.event !== i.name) return "deny";
+		let r = yield* u(() => l(t.key)), s = yield* o.decodeUnknownEffect(n)(t.payload).pipe(a.mapError(() => e("invalid_input"))), d = yield* c.readAccess(t.subject, r, s.subjectId), f = yield* u(c.now);
+		if (s.subjectId === d.member.subjectId || d.peer === null || !Number.isSafeInteger(s.expiresAt) || s.expiresAt > f + 5e3 || s.expiresAt < f - 5e3 || s.active && s.expiresAt <= f || s.active && (d.channel.frozen || d.peer.mutedUntil !== null && d.peer.mutedUntil > f)) return "drop";
+		let p = yield* c.social;
+		return d.channel.kind === "dm" && !p ? "deny" : p && (yield* p.isBlocked(t.subject, s.subjectId).pipe(a.mapError(() => e("unavailable")))) ? "drop" : "allow";
+	}).pipe(a.catch(() => a.succeed("deny")), a.catchDefect(() => a.succeed("deny"))), m = r(c.store);
+	return {
+		prepare: d,
+		policy: {
+			id: i.clientPolicy,
+			admit: f,
+			deliver: p,
+			monitor: (t) => u(() => {
+				if (t.event !== i.name) throw e("forbidden");
+				return l(t.key);
+			}).pipe(a.flatMap((e) => m(structuredClone(t.subject), e)))
+		},
+		close: m.close
+	};
+};
+//#endregion
+export { c as createChatTyping };

package/dist/typingInvalidation.js

@@ -0,0 +1,86 @@
+import { chatError as e } from "./errors.js";
+import "./contract.js";
+import { Deferred as t, Effect as n } from "effect";
+import { socialRelationsTable as r } from "@voltro/plugin-social";
+//#region src/typingInvalidation.ts
+var i = (e, t) => e instanceof Date && t instanceof Date ? e.getTime() === t.getTime() : e === t, a = (e, t, n) => e !== null && t !== null && n.every((n) => i(e[n], t[n])), o = (i) => {
+	let o = /* @__PURE__ */ new Set(), s = !1, c, l, u = (e, t) => {
+		if (![
+			"_voltro_chat_channels",
+			"_voltro_chat_members",
+			r.tableName
+		].includes(e.table)) return !1;
+		if (e.oversized !== void 0 || e.netChange || !e.old && !e.new) return !0;
+		let n = [e.old, e.new].filter((e) => e !== null);
+		return n.some((e) => e.tenantId === t.tenant || e.tenantId === void 0) ? e.table === "_voltro_chat_channels" ? !a(e.old, e.new, [
+			"id",
+			"tenantId",
+			"kind",
+			"frozen"
+		]) && n.some((e) => e.id === t.channel || e.id === void 0) : e.table === "_voltro_chat_members" ? !a(e.old, e.new, [
+			"id",
+			"tenantId",
+			"channelId",
+			"subjectId",
+			"role",
+			"mutedUntil"
+		]) && n.some((e) => e.channelId === t.channel || e.channelId === void 0) : n.some((e) => (e.kind === "block" || e.kind === void 0) && (e.fromId === t.subject || e.toId === t.subject || e.fromId === void 0 || e.toId === void 0)) : !1;
+	}, d = (e) => {
+		if (o.delete(e), o.size === 0) {
+			let e = c, t = l;
+			c = void 0, l = void 0;
+			try {
+				e?.();
+			} finally {
+				t?.();
+			}
+		}
+	}, f = (e) => {
+		try {
+			d(e);
+		} finally {
+			e.revoke();
+		}
+	};
+	return Object.assign((r, a) => n.gen(function* () {
+		if (r.type !== "user") return yield* n.fail(e("identity_required"));
+		let p = yield* t.make();
+		return yield* n.acquireRelease(n.try({
+			try: () => {
+				if (s || o.size >= 4096) throw e("unavailable");
+				let m = {
+					tenant: r.tenantId,
+					subject: r.id,
+					channel: a,
+					revoke: () => {
+						n.runSync(t.succeed(p, void 0));
+					}
+				};
+				o.add(m);
+				try {
+					c ??= i.onChange((e) => {
+						for (let t of [...o]) u(e, t) && f(t);
+					}), i.onChangeStreamGap !== void 0 && l === void 0 && (l = i.onChangeStreamGap(() => {
+						for (let e of [...o]) f(e);
+					})), o.size === 0 && d(m);
+				} catch {
+					throw d(m), e("unavailable");
+				}
+				return m;
+			},
+			catch: () => e("unavailable")
+		}), (e) => n.sync(() => d(e))), t.await(p);
+	}), { close: () => {
+		if (s) return;
+		s = !0;
+		let t = !1;
+		for (let e of [...o]) try {
+			f(e);
+		} catch {
+			t = !0;
+		}
+		if (t) throw e("unavailable");
+	} });
+};
+//#endregion
+export { o as createTypingInvalidation };