@voltro/plugin-chat 0.0.0-stage → 0.88.0

package/dist/typingLease.js

@@ -0,0 +1,58 @@
+import { CHAT_TYPING_TTL_MS as e, ChatTypingSchema as t } from "./contract.js";
+import { Schema as n } from "effect";
+var r = Object.freeze([]), i = class {
+	#e;
+	#t = /* @__PURE__ */ new Map();
+	#n = /* @__PURE__ */ new Set();
+	#r = r;
+	#i;
+	constructor(e) {
+		this.#e = e ?? {
+			wall: Date.now,
+			monotonic: () => performance.now(),
+			schedule: (e, t) => setTimeout(e, t),
+			cancel: (e) => clearTimeout(e)
+		};
+	}
+	getSnapshot = () => this.#r;
+	getServerSnapshot = () => r;
+	subscribe = (e) => (this.#n.add(e), () => {
+		this.#n.delete(e);
+	});
+	receive(r) {
+		if (!n.is(t)(r) || r.subjectId.includes("\0") || r.subjectId.startsWith("~")) return;
+		let i = this.#r;
+		if (this.#a(), !r.active) this.#t.delete(r.subjectId);
+		else {
+			let t = Math.min(e, r.expiresAt - this.#e.wall());
+			Number.isFinite(t) && t > 0 && (this.#t.has(r.subjectId) || this.#t.size < 128) && this.#t.set(r.subjectId, this.#e.monotonic() + t);
+		}
+		this.#o(i), this.#s();
+	}
+	clear = () => {
+		this.#i !== void 0 && this.#e.cancel(this.#i), this.#i = void 0, this.#t.clear(), this.#o();
+	};
+	#a() {
+		let e = this.#e.monotonic(), t = !1;
+		for (let [n, r] of this.#t) r <= e && (this.#t.delete(n), t = !0);
+		t && (this.#r = this.#t.size === 0 ? r : Object.freeze([...this.#t.keys()].sort()));
+	}
+	#o(e = this.#r) {
+		let t = [...this.#t.keys()].sort();
+		if (!(t.length === e.length && t.every((t, n) => t === e[n]))) {
+			this.#r = t.length === 0 ? r : Object.freeze(t);
+			for (let e of this.#n) e();
+		}
+	}
+	#s() {
+		if (this.#i !== void 0 && this.#e.cancel(this.#i), this.#i = void 0, this.#t.size === 0) return;
+		let e = Math.max(0, Math.min(...this.#t.values()) - this.#e.monotonic());
+		this.#i = this.#e.schedule(() => {
+			this.#i = void 0;
+			let e = this.#r;
+			if (this.#a(), e !== this.#r) for (let e of this.#n) e();
+			this.#s();
+		}, e);
+	}
+};
+export { i as TypingLeaseStore };

package/dist/typingPublisher.js

@@ -0,0 +1,58 @@
+// src/typingPublisher.ts
+var e = Object.freeze({
+	pending: !1,
+	error: void 0
+}), t = class {
+	#e;
+	#t;
+	#n;
+	#r = /* @__PURE__ */ new Set();
+	#i;
+	#a = e;
+	#o = -Infinity;
+	#s = !1;
+	#c = !1;
+	constructor(e, t, n = () => performance.now()) {
+		this.#e = e, this.#t = t, this.#n = n;
+	}
+	getSnapshot = () => this.#a;
+	getServerSnapshot = () => e;
+	subscribe = (e) => (this.#r.add(e), () => {
+		this.#r.delete(e);
+	});
+	activate() {
+		this.#i === void 0 && (this.#i = new AbortController());
+	}
+	close = () => {
+		let e = this.#i;
+		this.#i = void 0, this.#c = !1, this.#s = !1, e?.abort();
+	};
+	activity = (e) => {
+		if (this.#i === void 0 || this.#i.signal.aborted) return !1;
+		if (!e) {
+			if (!this.#s) return !1;
+			if (this.#a.pending) return this.#c = !0, !1;
+		} else if (this.#n() < this.#o) return !1;
+		return this.#t.owner === void 0 && (this.#u(e, this.#i), !0);
+	};
+	#l(e) {
+		this.#a = e;
+		for (let e of this.#r) e();
+	}
+	#u(e, t) {
+		let n = {};
+		this.#t.owner = n, this.#c = !1, e ? (this.#o = this.#n() + 2e3, this.#s = !0) : this.#s = !1, this.#l({
+			pending: !0,
+			error: void 0
+		}), Promise.resolve().then(() => {
+			if (!t.signal.aborted) return this.#e(e, t.signal);
+		}).then(() => this.#d(t, n, void 0), (e) => this.#d(t, n, e));
+	}
+	#d(t, n, r) {
+		this.#t.owner === n && (this.#t.owner = void 0), this.#i === t ? (this.#l({
+			pending: !1,
+			error: r
+		}), this.#c && !t.signal.aborted && this.activity(!1)) : this.#l(e);
+	}
+};
+export { t as TypingPublisher };

package/dist/useChatTypingPublisher.js

@@ -0,0 +1,32 @@
+import { BASE_NAME as e } from "./rpc.js";
+import { TypingPublisher as t } from "./typingPublisher.js";
+import { Effect as n } from "effect";
+import { pluginTag as r } from "@voltro/protocol";
+import { isUnresolvedApi as i, resolveByTag as a, useFrameworkApi as o } from "@voltro/client";
+import { useLayoutEffect as s, useMemo as c, useRef as l, useSyncExternalStore as u } from "react";
+import { runRpcPromise as d } from "@voltro/client/runtime";
+// src/useChatTypingPublisher.ts
+var f = (f, p = "app") => {
+	let m = o(p), h = l({ owner: void 0 }), g = c(() => new t(async (t, o) => {
+		if (f === null || i(m) || m.subjectSignal?.aborted) return;
+		let s = a(m.client, r(e, "setTyping"));
+		await d(m.runtime, n.suspend(() => s({
+			channelId: f,
+			active: t
+		})).pipe(n.timeout("1 second")), { signal: o });
+	}, h.current), [
+		f,
+		p,
+		m.cache
+	]), _ = u(g.subscribe, g.getSnapshot, g.getServerSnapshot);
+	return s(() => {
+		let e = m.subjectSignal ?? m.recovery?.subjectSignal;
+		if (!(f === null || i(m) || e?.aborted)) return g.activate(), e?.addEventListener("abort", g.close, { once: !0 }), () => {
+			e?.removeEventListener("abort", g.close), g.close();
+		};
+	}, [g]), {
+		..._,
+		activity: g.activity
+	};
+};
+export { f as useChatTypingPublisher };

package/dist/useTyping.js

@@ -0,0 +1,23 @@
+import { typing as e } from "./events.js";
+import { TypingLeaseStore as t } from "./typingLease.js";
+import { useEvent as n, useFrameworkApi as r } from "@voltro/client";
+import { useEffect as i, useLayoutEffect as a, useMemo as o, useSyncExternalStore as s } from "react";
+// src/useTyping.ts
+var c = Object.freeze([]), l = (l, u = "app") => {
+	let d = r(u), f = o(() => new t(), [
+		l,
+		u,
+		d.cache
+	]), p = n(e, l === null ? null : { channelId: l }, (e) => f.receive(e), {
+		apiName: u,
+		onMissed: f.clear
+	}), m = s(f.subscribe, f.getSnapshot, f.getServerSnapshot);
+	return a(() => {
+		p.status !== "live" && f.clear();
+	}, [f, p.status]), i(() => () => f.clear(), [f]), {
+		channelId: l,
+		subjects: p.status === "live" ? m : c,
+		status: p.status
+	};
+};
+export { l as useTyping };

package/dist/web.d.ts

@@ -0,0 +1,354 @@
+import { ActionState } from '@voltro/client';
+import { EventStatus } from '@voltro/client';
+import { ReactNode } from 'react';
+import { Schema } from 'effect';
+import { SubscriptionState } from '@voltro/client';
+
+/** Native buttons are channel navigation; no incomplete ARIA tab keyboard model. */
+export declare const ChannelTabs: ({ channels, selectedId, onSelect, unread, labels, disabled }: ChannelTabsProps) => ReactNode;
+
+export declare interface ChannelTabsProps {
+    readonly channels: ReadonlyArray<ChatChannel>;
+    readonly selectedId: string | null;
+    readonly onSelect: (channelId: string) => void;
+    readonly unread?: ReadonlyArray<ChatUnread> | undefined;
+    readonly labels?: ChatLabels | undefined;
+    readonly disabled?: boolean | undefined;
+}
+
+/** Trusted identity comes from a server Players projection joined by subject ID. */
+export declare interface ChatAuthor {
+    readonly subjectId: string;
+    readonly displayName: string;
+}
+
+export declare type ChatAuthorProjection = typeof ChatAuthorProjectionSchema.Type;
+
+/** Roster-only identity; displayName already includes the Players tag. */
+declare const ChatAuthorProjectionSchema: Schema.Struct<{
+    readonly subjectId: Schema.String;
+    readonly displayName: Schema.String;
+    readonly avatar: Schema.NullOr<Schema.String>;
+}>;
+
+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>;
+}>;
+
+export declare interface ChatLabels {
+    readonly title: string;
+    readonly empty: string;
+    readonly loading: string;
+    readonly failed: string;
+    readonly deleted: string;
+    readonly unknown: string;
+    readonly edited: string;
+    readonly flagged: string;
+    readonly draft: string;
+    readonly send: string;
+    readonly sending: string;
+    readonly older: string;
+    readonly report: string;
+    readonly unread: string;
+    readonly more: string;
+    readonly choose: string;
+    /** Optional so existing custom label sets keep compiling; English is the fallback. */
+    readonly media?: string;
+    readonly openMedia?: string;
+}
+
+export declare const chatLabels: Readonly<Record<'en' | 'de', ChatLabels>>;
+
+export declare interface ChatMentionLabels {
+    readonly title: string;
+    readonly empty: string;
+    readonly loading: string;
+    readonly more: string;
+    readonly help: string;
+}
+
+export declare const chatMentionLabels: Readonly<Record<'en' | 'de', ChatMentionLabels>>;
+
+declare type ChatMessage = typeof ChatMessageSchema.Type;
+
+declare const ChatMessageSchema: 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>;
+}>;
+
+export declare const ChatPanel: ({ scopeKey, dataScopeKey, channelId, messages, authors, labels, locale, loading, onReport, onOpenMedia, canLoadOlder, onLoadOlder, typing, typingLabels, ...composer }: ChatPanelProps) => ReactNode;
+
+export declare interface ChatPanelProps extends MessageListProps, ComposerProps {
+    readonly scopeKey: string;
+    readonly dataScopeKey: string;
+    readonly channelId: string;
+    readonly typing?: ChatTypingState | undefined;
+    readonly typingLabels?: ChatTypingLabels | undefined;
+    readonly canLoadOlder?: boolean | undefined;
+    readonly onLoadOlder?: (() => void) | undefined;
+}
+
+export declare interface ChatTypingLabels {
+    readonly typing: string;
+    readonly peopleTyping: string;
+    readonly someoneTyping: string;
+}
+
+export declare const chatTypingLabels: Readonly<Record<'en' | 'de', ChatTypingLabels>>;
+
+export declare interface ChatTypingPublisherState extends TypingPublisherSnapshot {
+    /** Call from actual input activity; false on blur/send. No active hint is queued. */
+    readonly activity: (active: boolean) => boolean;
+}
+
+export declare interface ChatTypingState {
+    readonly channelId: string | null;
+    readonly subjects: ReadonlyArray<string>;
+    readonly status: EventStatus;
+}
+
+declare type ChatUnread = typeof ChatUnreadSchema.Type;
+
+declare const ChatUnreadSchema: Schema.Struct<{
+    readonly channelId: Schema.String;
+    readonly count: Schema.Number;
+    readonly truncated: Schema.Boolean;
+}>;
+
+/** Parent retains draft, request ID and uncertain send state; this component never retries or clears them. */
+export declare const Composer: ({ value, onChange, onSend, onTyping, mentionCandidates, mentionLabels, mentionsLoading, onLoadMoreMentions, pending, disabled, error, labels, maxBodyLength }: ComposerProps) => ReactNode;
+
+export declare interface ComposerProps {
+    readonly value: string;
+    readonly onChange: (body: string) => void;
+    readonly onSend: (body: string) => void;
+    readonly onTyping?: ((active: boolean) => void) | undefined;
+    readonly mentionCandidates?: ReadonlyArray<ChatAuthor> | undefined;
+    readonly mentionLabels?: ChatMentionLabels | undefined;
+    readonly mentionsLoading?: boolean | undefined;
+    readonly onLoadMoreMentions?: (() => void) | undefined;
+    readonly pending?: boolean | undefined;
+    readonly disabled?: boolean | undefined;
+    readonly error?: unknown | undefined;
+    readonly labels?: ChatLabels | undefined;
+    readonly maxBodyLength?: number | undefined;
+}
+
+declare interface DeleteChatInput {
+    readonly messageId: string;
+    readonly baseVersion: number;
+}
+
+declare interface EditChatInput {
+    readonly messageId: string;
+    readonly baseVersion: number;
+    readonly body: string;
+}
+
+/** Variable-height windowing preserves a focused row and does not move the reader on live updates. */
+export declare const MessageList: ({ messages, authors, labels, locale, loading, onReport, onOpenMedia }: MessageListProps) => ReactNode;
+
+export declare interface MessageListProps {
+    readonly messages: ReadonlyArray<ChatMessage>;
+    readonly authors: ReadonlyArray<ChatAuthor>;
+    readonly labels?: ChatLabels | undefined;
+    readonly locale?: string | undefined;
+    readonly loading?: boolean | undefined;
+    readonly onReport?: ((messageId: string) => void) | undefined;
+    /** Called for a visible media message; resolve its URL with `chat.mediaUrl` and show it. */
+    readonly onOpenMedia?: ((messageId: string) => void) | undefined;
+}
+
+/** `mediaId` names a `_voltro_storage_refs` row the sender uploaded; the body is then an optional caption. */
+declare interface SendChatInput {
+    readonly channelId: string;
+    readonly requestId: string;
+    readonly body: string;
+    readonly replyToId?: string | undefined;
+    readonly mediaId?: string | undefined;
+}
+
+declare interface SetChatTypingInput {
+    readonly channelId: string;
+    readonly active: boolean;
+}
+
+/** Never display raw subject IDs or names supplied by a typing event. */
+export declare const TypingIndicator: ({ subjects, authors, labels, locale }: TypingIndicatorProps) => ReactNode;
+
+export declare interface TypingIndicatorProps {
+    readonly subjects: ReadonlyArray<string>;
+    readonly authors: ReadonlyArray<ChatAuthor>;
+    readonly labels?: ChatTypingLabels | undefined;
+    readonly locale?: string | undefined;
+}
+
+declare interface TypingPublisherSnapshot {
+    readonly pending: boolean;
+    readonly error: unknown | undefined;
+}
+
+export declare const useChannel: (channelId: string, apiName?: string) => SubscriptionState<{
+    readonly id: string;
+    readonly kind: "custom" | "match" | "global" | "lobby" | "party" | "guild" | "dm";
+    readonly refId: string;
+    readonly name: string;
+    readonly slowModeMs: number;
+    readonly retentionMs: number | null;
+    readonly maxMembers: number;
+    readonly frozen: boolean;
+    readonly createdAt: number;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+}>;
+
+export declare const useChannelList: (apiName?: string) => SubscriptionState<readonly {
+    readonly id: string;
+    readonly kind: "custom" | "match" | "global" | "lobby" | "party" | "guild" | "dm";
+    readonly refId: string;
+    readonly name: string;
+    readonly slowModeMs: number;
+    readonly retentionMs: number | null;
+    readonly maxMembers: number;
+    readonly frozen: boolean;
+    readonly createdAt: number;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+}[]>;
+
+export declare const useChatAuthors: (channelId: string, subjectIds: ReadonlyArray<string>, apiName?: string) => SubscriptionState<readonly {
+    readonly subjectId: string;
+    readonly displayName: string;
+    readonly avatar: string | null;
+}[]>;
+
+export declare const useChatEdit: (apiName?: string) => ActionState<EditChatInput, unknown>;
+
+export declare const useChatJoin: (apiName?: string) => ActionState<{
+    channelId: string;
+}, {
+    readonly id: string;
+    readonly channelId: string;
+    readonly subjectId: string;
+    readonly role: "member" | "owner" | "mod";
+    readonly mutedUntil: number | null;
+    readonly lastReadAt: number;
+    readonly lastReadId: string | null;
+    readonly notify: boolean;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+}>;
+
+export declare const useChatLeave: (apiName?: string) => ActionState<{
+    channelId: string;
+}, unknown>;
+
+export declare const useChatMarkRead: (apiName?: string) => ActionState<{
+    channelId: string;
+    messageId: string;
+}, unknown>;
+
+export declare const useChatMembership: (channelId: string, apiName?: string) => SubscriptionState<{
+    readonly id: string;
+    readonly channelId: string;
+    readonly subjectId: string;
+    readonly role: "member" | "owner" | "mod";
+    readonly mutedUntil: number | null;
+    readonly lastReadAt: number;
+    readonly lastReadId: string | null;
+    readonly notify: boolean;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+}>;
+
+export declare const useChatMentionCandidates: (channelId: string, after?: string, apiName?: string) => SubscriptionState<{
+    readonly authors: readonly {
+        readonly subjectId: string;
+        readonly displayName: string;
+        readonly avatar: string | null;
+    }[];
+    readonly after: string | null;
+}>;
+
+export declare const useChatMessages: (channelId: string, before?: {
+    at: number;
+    id: string;
+}, apiName?: string) => SubscriptionState<{
+    readonly messages: readonly {
+        readonly id: string;
+        readonly channelId: string;
+        readonly authorId: string | null;
+        readonly kind: "text" | "system" | "emote" | "media";
+        readonly body: string;
+        readonly payload: {
+            readonly [x: string]: unknown;
+        };
+        readonly replyToId: string | null;
+        readonly editedAt: number | null;
+        readonly deletedAt: number | null;
+        readonly flagged: boolean;
+        readonly createdAt: number;
+        readonly version: number;
+        readonly metadata: {
+            readonly [x: string]: unknown;
+        };
+    }[];
+    readonly before: {
+        readonly at: number;
+        readonly id: string;
+    } | null;
+}>;
+
+export declare const useChatOriginal: (apiName?: string) => ActionState<{
+    messageId: string;
+}, unknown>;
+
+export declare const useChatRemove: (apiName?: string) => ActionState<DeleteChatInput, unknown>;
+
+export declare const useChatSend: (apiName?: string) => ActionState<SendChatInput, unknown>;
+
+export declare const useChatSetTyping: (apiName?: string) => ActionState<SetChatTypingInput, unknown>;
+
+export declare const useChatTransferOwnership: (apiName?: string) => ActionState<{
+    channelId: string;
+    targetId: string;
+}, unknown>;
+
+export declare const useChatTypingPublisher: (channelId: string | null, apiName?: string) => ChatTypingPublisherState;
+
+/** Private hints expire within five local monotonic seconds; never persisted. */
+export declare const useTyping: (channelId: string | null, apiName?: string) => ChatTypingState;
+
+export declare const useUnread: (apiName?: string) => SubscriptionState<readonly {
+    readonly channelId: string;
+    readonly count: number;
+    readonly truncated: boolean;
+}[]>;
+
+export { }

package/dist/web.js

@@ -0,0 +1,18 @@
+import { BASE_NAME as e } from "./rpc.js";
+import { ChannelTabs as t, ChatPanel as n, Composer as r, MessageList as i, TypingIndicator as a, chatLabels as o, chatMentionLabels as s, chatTypingLabels as c } from "./components.js";
+import { useTyping as l } from "./useTyping.js";
+import { useChatTypingPublisher as u } from "./useChatTypingPublisher.js";
+import { pluginTag as d } from "@voltro/protocol";
+import { useAction as f, useSubscription as p } from "@voltro/client";
+// src/web.ts
+var m = (t, n, r = "app") => p(r, d(e, "mentionCandidates"), {
+	channelId: t,
+	...n === void 0 ? {} : { after: n }
+}), h = (t, n, r = "app") => p(r, d(e, "authors"), {
+	channelId: t,
+	subjectIds: n
+}), g = (t, n = "app") => p(n, d(e, "channel"), { channelId: t }), _ = (t, n = "app") => p(n, d(e, "membership"), { channelId: t }), v = (t = "app") => p(t, d(e, "channels"), {}), y = (t, n, r = "app") => p(r, d(e, "messages"), {
+	channelId: t,
+	...n === void 0 ? {} : { before: n }
+}), b = (t = "app") => f(t, d(e, "send")), x = (t = "app") => f(t, d(e, "edit")), S = (t = "app") => f(t, d(e, "remove")), C = (t = "app") => p(t, d(e, "unread"), {}), w = (t = "app") => f(t, d(e, "markRead")), T = (t = "app") => f(t, d(e, "original")), E = (t = "app") => f(t, d(e, "join")), D = (t = "app") => f(t, d(e, "leave")), O = (t = "app") => f(t, d(e, "transferOwnership")), k = (t = "app") => f(t, d(e, "setTyping"));
+export { t as ChannelTabs, n as ChatPanel, r as Composer, i as MessageList, a as TypingIndicator, o as chatLabels, s as chatMentionLabels, c as chatTypingLabels, g as useChannel, v as useChannelList, h as useChatAuthors, x as useChatEdit, E as useChatJoin, D as useChatLeave, w as useChatMarkRead, _ as useChatMembership, m as useChatMentionCandidates, y as useChatMessages, T as useChatOriginal, S as useChatRemove, b as useChatSend, k as useChatSetTyping, O as useChatTransferOwnership, u as useChatTypingPublisher, l as useTyping, C as useUnread };

package/package.json

@@ -1,6 +1,100 @@
 {
   "name": "@voltro/plugin-chat",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.88.0",
+  "description": "Membership-filtered durable chat with configurable moderation, rate and retention strategies",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./errors": {
+      "types": "./dist/errors.d.ts",
+      "import": "./dist/errors.js",
+      "default": "./dist/errors.js"
+    },
+    "./rpc": {
+      "types": "./dist/rpc.d.ts",
+      "import": "./dist/rpc.js",
+      "default": "./dist/rpc.js"
+    },
+    "./strategies": {
+      "types": "./dist/strategies.d.ts",
+      "import": "./dist/strategies.js",
+      "default": "./dist/strategies.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js",
+      "default": "./dist/testing.js"
+    },
+    "./web": {
+      "types": "./dist/web.d.ts",
+      "import": "./dist/web.js",
+      "default": "./dist/web.js"
+    },
+    "./events": {
+      "types": "./dist/events.d.ts",
+      "import": "./dist/events.js",
+      "default": "./dist/events.js"
+    },
+    "./events/server": {
+      "types": "./dist/eventProducer.d.ts",
+      "import": "./dist/eventProducer.js",
+      "default": "./dist/eventProducer.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "default": "./dist/server.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@voltro/protocol": "0.88.0",
+    "@voltro/database": "0.88.0",
+    "@voltro/client": "0.88.0",
+    "@voltro/runtime": "0.88.0",
+    "@voltro/plugin-ratelimit": "0.88.0",
+    "@voltro/plugin-moderation": "0.88.0",
+    "@voltro/plugin-social": "0.88.0",
+    "@voltro/plugin-players": "0.88.0",
+    "@voltro/plugin-notifications": "0.88.0",
+    "@voltro/kv": "0.88.0",
+    "@voltro/ui-shadcn": "0.88.0",
+    "@voltro/plugin-sanctions": "0.88.0",
+    "@voltro/plugin-licensing": "0.88.0",
+    "@voltro/plugin-storage": "0.88.0",
+    "@voltro/plugin-guilds": "0.88.0",
+    "@voltro/plugin-matchmaking": "0.88.0"
+  },
+  "peerDependencies": {
+    "effect": "4.1.0",
+    "react": "^19.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}