@voltro/plugin-sanctions 0.0.0-stage → 0.88.0

package/dist/admission.server.js

@@ -0,0 +1,96 @@
+import { POINTS as e } from "./contract.js";
+import { sanctionsError as t } from "./errors.js";
+// src/admission.server.ts
+var n = (e, n) => {
+	if (!e || typeof e != "object" || Array.isArray(e) || ![Object.prototype, null].includes(Object.getPrototypeOf(e))) throw t("invalid_input");
+	let r = Object.create(null);
+	for (let i of Reflect.ownKeys(e)) {
+		let a = Object.getOwnPropertyDescriptor(e, i);
+		if (typeof i != "string" || !n.includes(i) || !a || !("value" in a) || !a.enumerable) throw t("invalid_input");
+		r[i] = a.value;
+	}
+	return Object.freeze(r);
+}, r = (r, i) => {
+	let a = n(r, i ? [
+		"point",
+		"at",
+		"context",
+		"expected"
+	] : [
+		"point",
+		"at",
+		"context"
+	]);
+	if (!e.includes(a.point) || typeof a.at != "number" || !Number.isSafeInteger(a.at) || a.at < 0 || a.at > 864e13) throw t("invalid_input");
+	let o = a.context === void 0 ? {} : n(a.context, ["channelId", "queueId"]), s = {};
+	for (let e of ["channelId", "queueId"]) if (o[e] !== void 0) {
+		let n = o[e];
+		if (typeof n != "string" || !n.trim() || n.length > 256 || n.includes("\0") || n === "~") throw t("invalid_input");
+		s[e] = n;
+	}
+	let c;
+	if (i) {
+		let e = n(a.expected, ["allowed", "trustScore"]);
+		if (typeof e.allowed != "boolean" || typeof e.trustScore != "number" || !Number.isSafeInteger(e.trustScore) || e.trustScore < 0 || e.trustScore > 100) throw t("invalid_input");
+		c = Object.freeze({
+			allowed: e.allowed,
+			trustScore: e.trustScore
+		});
+	}
+	return Object.freeze({
+		point: a.point,
+		at: a.at,
+		context: Object.freeze(s),
+		expected: c
+	});
+}, i = (e) => {
+	let i = n(e, [
+		"tenantId",
+		"participants",
+		"point",
+		"at",
+		"context"
+	]), a = i.tenantId;
+	if (typeof a != "string" || !a.trim() || a.length > 256 || a.includes("\0") || a === "~" || !Array.isArray(i.participants) || i.participants.length < 1 || i.participants.length > 32) throw t("invalid_input");
+	let o = Object.getOwnPropertyDescriptors(i.participants);
+	if (Reflect.ownKeys(o).length !== i.participants.length + 1) throw t("invalid_input");
+	let s = [];
+	for (let e = 0; e < i.participants.length; e++) {
+		let a = o[String(e)];
+		if (!a || !("value" in a) || !a.enumerable) throw t("invalid_input");
+		let c = n(a.value, ["ownerId", "expected"]), l = c.ownerId;
+		if (typeof l != "string" || !l.trim() || l.length > 256 || l.includes("\0") || l === "~") throw t("invalid_input");
+		let u = r({
+			point: i.point,
+			at: i.at,
+			context: i.context,
+			expected: c.expected
+		}, !0);
+		if (!u.expected) throw t("invalid_input");
+		s.push(Object.freeze({
+			ownerId: l,
+			expected: u.expected
+		}));
+	}
+	if (new Set(s.map((e) => e.ownerId)).size !== s.length) throw t("invalid_input");
+	let c = r({
+		point: i.point,
+		at: i.at,
+		context: i.context
+	}, !1);
+	return Object.freeze({
+		tenantId: a,
+		point: c.point,
+		at: c.at,
+		context: c.context,
+		participants: Object.freeze(s)
+	});
+}, a = (e) => {
+	if (e instanceof Date) return JSON.stringify(e.toISOString());
+	if (Array.isArray(e)) return "[" + e.map(a).join(",") + "]";
+	if (typeof e == "object" && e) return "{" + Object.keys(e).sort().map((t) => JSON.stringify(t) + ":" + a(e[t])).join(",") + "}";
+	let n = JSON.stringify(e);
+	if (n === void 0) throw t("unavailable");
+	return n;
+};
+export { a as canonicalSanctionsRecords, r as captureSanctionsAdmission, i as captureSanctionsAdmissionBatch };

package/dist/components.js

@@ -0,0 +1,282 @@
+import { CATEGORIES as e } from "./contract.js";
+import { useId as t } from "react";
+import { Button as n, Textarea as r } from "@voltro/ui-shadcn";
+import { Fragment as i, jsx as a, jsxs as o } from "react/jsx-runtime";
+// src/components.tsx
+var s = {
+	en: {
+		reportTitle: "Report player",
+		category: "Category",
+		note: "What happened?",
+		report: "Submit report",
+		cancel: "Cancel",
+		pending: "Request pending. Keep this draft for recovery.",
+		appealTitle: "Request a review",
+		appealText: "Why should this measure be reviewed?",
+		appeal: "Submit appeal",
+		expires: "Ends",
+		permanent: "No end date",
+		scopeLoading: "Waiting for this account’s observation.",
+		noActions: "No active measures in this observation.",
+		noticeTitle: "Account measures",
+		categories: {
+			cheating: "Cheating",
+			abuse: "Abuse",
+			name: "Player name",
+			spam: "Spam",
+			griefing: "Griefing",
+			rmt: "Real-money trading"
+		},
+		kinds: {
+			warn: "Warning",
+			mute: "Chat mute",
+			chatBan: "Chat restriction",
+			matchmakingBan: "Matchmaking restriction",
+			rankedBan: "Ranked restriction",
+			tradeBan: "Trading restriction",
+			ban: "Account restriction",
+			shadowBan: "Matchmaking measure",
+			nameReset: "Name review",
+			rollback: "Progress review"
+		}
+	},
+	de: {
+		reportTitle: "Spieler melden",
+		category: "Kategorie",
+		note: "Was ist passiert?",
+		report: "Meldung senden",
+		cancel: "Abbrechen",
+		pending: "Anfrage läuft. Entwurf zur Wiederaufnahme behalten.",
+		appealTitle: "Prüfung beantragen",
+		appealText: "Warum soll diese Maßnahme geprüft werden?",
+		appeal: "Einspruch senden",
+		expires: "Endet",
+		permanent: "Ohne Enddatum",
+		scopeLoading: "Beobachtung dieses Kontos wird geladen.",
+		noActions: "Keine aktiven Maßnahmen in dieser Beobachtung.",
+		noticeTitle: "Kontomaßnahmen",
+		categories: {
+			cheating: "Cheating",
+			abuse: "Beleidigung",
+			name: "Spielername",
+			spam: "Spam",
+			griefing: "Griefing",
+			rmt: "Echtgeldhandel"
+		},
+		kinds: {
+			warn: "Warnung",
+			mute: "Chat-Stummschaltung",
+			chatBan: "Chat-Einschränkung",
+			matchmakingBan: "Matchmaking-Einschränkung",
+			rankedBan: "Ranglisten-Einschränkung",
+			tradeBan: "Handels-Einschränkung",
+			ban: "Konto-Einschränkung",
+			shadowBan: "Matchmaking-Maßnahme",
+			nameReset: "Namensprüfung",
+			rollback: "Fortschrittsprüfung"
+		}
+	}
+}, c = ({ scopeKey: i, dataScopeKey: c, targetId: l, draft: u, pending: d = !1, error: f, labels: p = s.en, onChange: m, onSubmit: h, onCancel: g, maxNoteLength: _ = 4e3 }) => {
+	let v = t(), y = i === c, b = y && !d && l.trim().length > 0 && [...u.note].length <= _;
+	return /* @__PURE__ */ o("section", {
+		role: "dialog",
+		"aria-modal": "false",
+		"aria-labelledby": v + "-title",
+		className: "space-y-4 rounded-lg border p-4",
+		children: [/* @__PURE__ */ a("h2", {
+			id: v + "-title",
+			className: "text-lg font-semibold",
+			children: p.reportTitle
+		}), y ? /* @__PURE__ */ o("form", {
+			className: "space-y-4",
+			onSubmit: (e) => {
+				e.preventDefault(), b && h();
+			},
+			children: [
+				/* @__PURE__ */ o("div", {
+					className: "space-y-2",
+					children: [/* @__PURE__ */ a("label", {
+						htmlFor: v + "-category",
+						children: p.category
+					}), /* @__PURE__ */ a("select", {
+						id: v + "-category",
+						value: u.category,
+						disabled: d,
+						className: "w-full rounded-md border bg-background px-3 py-2",
+						onChange: (t) => {
+							!d && e.includes(t.target.value) && m({
+								...u,
+								category: t.target.value
+							});
+						},
+						children: e.map((e) => /* @__PURE__ */ a("option", {
+							value: e,
+							children: p.categories[e]
+						}, e))
+					})]
+				}),
+				/* @__PURE__ */ o("div", {
+					className: "space-y-2",
+					children: [/* @__PURE__ */ a("label", {
+						htmlFor: v + "-note",
+						children: p.note
+					}), /* @__PURE__ */ a(r, {
+						id: v + "-note",
+						value: u.note,
+						readOnly: d,
+						onChange: (e) => {
+							d || m({
+								...u,
+								note: e.target.value
+							});
+						},
+						"aria-describedby": d ? v + "-pending" : void 0
+					})]
+				}),
+				d ? /* @__PURE__ */ a("p", {
+					id: v + "-pending",
+					role: "status",
+					className: "text-sm text-muted-foreground",
+					children: p.pending
+				}) : null,
+				f ? /* @__PURE__ */ a("p", {
+					role: "alert",
+					className: "text-sm text-destructive",
+					children: f
+				}) : null,
+				/* @__PURE__ */ o("div", {
+					className: "flex flex-wrap gap-2",
+					children: [/* @__PURE__ */ a(n, {
+						type: "submit",
+						"aria-disabled": !b,
+						children: p.report
+					}), /* @__PURE__ */ a(n, {
+						type: "button",
+						variant: "outline",
+						"aria-disabled": d,
+						onClick: () => {
+							d || g();
+						},
+						children: p.cancel
+					})]
+				})
+			]
+		}) : /* @__PURE__ */ a("p", {
+			role: "status",
+			className: "text-sm text-muted-foreground",
+			children: p.scopeLoading
+		})]
+	});
+}, l = ({ scopeKey: e, dataScopeKey: t, actions: r, appeals: c = [], locale: l = "en", labels: u = s[l], onAppeal: d }) => {
+	let f = e === t;
+	return /* @__PURE__ */ a("section", {
+		className: "space-y-4",
+		"aria-label": u.noticeTitle,
+		children: f ? r.length === 0 ? /* @__PURE__ */ a("p", {
+			className: "text-sm text-muted-foreground",
+			children: u.noActions
+		}) : /* @__PURE__ */ a("ul", {
+			className: "space-y-3",
+			children: r.map((e) => /* @__PURE__ */ o("li", {
+				className: "space-y-2 rounded-lg border p-4",
+				children: [
+					/* @__PURE__ */ a("h3", {
+						className: "font-medium",
+						children: u.kinds[e.kind]
+					}),
+					/* @__PURE__ */ a("p", {
+						className: "whitespace-pre-wrap break-words text-sm",
+						children: e.publicReason
+					}),
+					/* @__PURE__ */ a("p", {
+						className: "text-sm text-muted-foreground",
+						children: e.until === null ? u.permanent : /* @__PURE__ */ o(i, { children: [
+							u.expires,
+							" ",
+							/* @__PURE__ */ a("time", {
+								dateTime: new Date(e.until).toISOString(),
+								children: new Date(e.until).toLocaleString(l)
+							})
+						] })
+					}),
+					e.appealable && d && !c.some((t) => t.actionId === e.id) ? /* @__PURE__ */ a(n, {
+						type: "button",
+						variant: "outline",
+						onClick: () => d(e.id),
+						children: u.appealTitle
+					}) : null
+				]
+			}, e.id))
+		}) : /* @__PURE__ */ a("p", {
+			role: "status",
+			children: u.scopeLoading
+		})
+	});
+}, u = ({ scopeKey: e, dataScopeKey: i, action: c, text: l, pending: u = !1, error: d, labels: f = s.en, onChange: p, onSubmit: m, onCancel: h, maxTextLength: g = 4e3 }) => {
+	let _ = t(), v = e === i, y = v && !u && c.appealable && l.trim().length > 0 && [...l].length <= g;
+	return /* @__PURE__ */ o("section", {
+		role: "dialog",
+		"aria-modal": "false",
+		"aria-labelledby": _ + "-title",
+		className: "space-y-4 rounded-lg border p-4",
+		children: [/* @__PURE__ */ a("h2", {
+			id: _ + "-title",
+			className: "text-lg font-semibold",
+			children: f.appealTitle
+		}), v ? /* @__PURE__ */ o("form", {
+			className: "space-y-4",
+			onSubmit: (e) => {
+				e.preventDefault(), y && m();
+			},
+			children: [
+				/* @__PURE__ */ a("p", {
+					className: "whitespace-pre-wrap break-words text-sm",
+					children: c.publicReason
+				}),
+				/* @__PURE__ */ a("label", {
+					htmlFor: _ + "-text",
+					className: "block",
+					children: f.appealText
+				}),
+				/* @__PURE__ */ a(r, {
+					id: _ + "-text",
+					value: l,
+					readOnly: u,
+					onChange: (e) => {
+						u || p(e.target.value);
+					}
+				}),
+				u ? /* @__PURE__ */ a("p", {
+					role: "status",
+					className: "text-sm text-muted-foreground",
+					children: f.pending
+				}) : null,
+				d ? /* @__PURE__ */ a("p", {
+					role: "alert",
+					className: "text-sm text-destructive",
+					children: d
+				}) : null,
+				/* @__PURE__ */ o("div", {
+					className: "flex flex-wrap gap-2",
+					children: [/* @__PURE__ */ a(n, {
+						type: "submit",
+						"aria-disabled": !y,
+						children: f.appeal
+					}), /* @__PURE__ */ a(n, {
+						type: "button",
+						variant: "outline",
+						"aria-disabled": u,
+						onClick: () => {
+							u || h();
+						},
+						children: f.cancel
+					})]
+				})
+			]
+		}) : /* @__PURE__ */ a("p", {
+			role: "status",
+			children: f.scopeLoading
+		})]
+	});
+};
+export { u as AppealDialog, c as ReportDialog, l as SanctionNotice, s as sanctionLabels };

package/dist/contract.js

@@ -0,0 +1,88 @@
+import { Schema as e } from "effect";
+// src/contract.ts
+var t = "_voltro_sanc_reports", n = "_voltro_sanc_cases", r = "_voltro_sanc_actions", i = "_voltro_sanc_appeals", a = "_voltro_sanc_strikes", o = "_voltro_sanc_device_hints", s = "_voltro_sanc_admissions", c = [
+	"warn",
+	"mute",
+	"chatBan",
+	"matchmakingBan",
+	"rankedBan",
+	"tradeBan",
+	"ban",
+	"shadowBan",
+	"nameReset",
+	"rollback"
+], l = [
+	"cheating",
+	"abuse",
+	"name",
+	"spam",
+	"griefing",
+	"rmt"
+], u = [
+	"chat",
+	"matchmaking",
+	"trade",
+	"ranked",
+	"login"
+], d = e.Number.pipe(e.check(e.isInt()), e.check(e.isGreaterThanOrEqualTo(0))), f = e.Struct({
+	channels: e.Array(e.String),
+	queues: e.Array(e.String)
+}), p = e.Struct({
+	channelId: e.optional(e.String),
+	messageIds: e.optional(e.Array(e.String)),
+	roomId: e.optional(e.String),
+	matchId: e.optional(e.String),
+	replayRef: e.optional(e.String)
+}), m = e.Struct({
+	id: e.String,
+	kind: e.Literals(c),
+	scope: f,
+	from: d,
+	until: e.NullOr(d),
+	publicReason: e.String,
+	appealable: e.Boolean
+}), h = e.Struct({
+	id: e.String,
+	targetId: e.String,
+	category: e.Literals(l),
+	state: e.Literals([
+		"open",
+		"reviewing",
+		"actioned",
+		"dismissed"
+	]),
+	createdAt: d,
+	caseId: e.String
+}), g = e.Struct({
+	id: e.String,
+	actionId: e.String,
+	text: e.String,
+	state: e.Literals(["pending", "reviewed"]),
+	outcome: e.NullOr(e.Literals(["upheld", "revoked"])),
+	createdAt: d,
+	decidedAt: e.NullOr(d)
+}), _ = e.Struct({
+	id: e.String,
+	targetId: e.NullOr(e.String),
+	reports: d,
+	evidence: e.Array(e.Record(e.String, e.Unknown)),
+	trustScore: e.Number.pipe(e.check(e.isBetween({
+		minimum: 0,
+		maximum: 100
+	}))),
+	state: e.Literals([
+		"open",
+		"reviewing",
+		"actioned",
+		"dismissed"
+	]),
+	decidedBy: e.NullOr(e.String),
+	decidedAt: e.NullOr(d),
+	version: d
+});
+e.Struct({
+	allowed: e.Boolean,
+	actionIds: e.Array(e.String),
+	shadow: e.Boolean
+});
+export { r as ACTIONS_TABLE, c as ACTION_KINDS, s as ADMISSIONS_TABLE, i as APPEALS_TABLE, g as AppealSchema, n as CASES_TABLE, l as CATEGORIES, _ as CaseSchema, o as DEVICE_HINTS_TABLE, u as POINTS, t as REPORTS_TABLE, p as ReportContextSchema, h as ReportSchema, a as STRIKES_TABLE, m as SanctionSchema, f as SanctionScopeSchema };

package/dist/entities.js

@@ -0,0 +1,101 @@
+import { ACTIONS_TABLE as e, ACTION_KINDS as t, ADMISSIONS_TABLE as n, APPEALS_TABLE as r, CASES_TABLE as i, CATEGORIES as a, DEVICE_HINTS_TABLE as o, REPORTS_TABLE as s, STRIKES_TABLE as c } from "./contract.js";
+import { boolean as l, id as u, integer as d, json as f, table as p, text as m, timestamp as h } from "@voltro/database";
+// src/entities.ts
+var g = () => m().maxLength(256).externalId().sensitive("pii"), _ = () => m().maxLength(256).externalId().sensitive("pii"), v = () => m().maxLength(64).safe(), y = p(s, {
+	id: u({ prefix: "srep" }),
+	tenantId: g(),
+	reporterId: _().nullable(),
+	targetId: _().nullable(),
+	category: m().oneOf(a).safe(),
+	context: f().sensitive("pii"),
+	note: m().sensitive("pii"),
+	state: m().oneOf([
+		"open",
+		"reviewing",
+		"actioned",
+		"dismissed"
+	]).safe(),
+	assignee: _().nullable(),
+	createdAt: h().safe(),
+	caseId: v(),
+	requestKey: m().maxLength(64).serverOnly(),
+	source: m().oneOf(["human", "system"]).serverOnly(),
+	metadata: f().sensitive("pii")
+}).index(["tenantId", "targetId"]).index(["tenantId", "reporterId"]), b = p(i, {
+	id: u({ prefix: "scase" }),
+	tenantId: g(),
+	targetId: _().nullable(),
+	reports: d().safe(),
+	evidence: f().sensitive("pii"),
+	trustScore: d().safe(),
+	state: m().oneOf([
+		"open",
+		"reviewing",
+		"actioned",
+		"dismissed"
+	]).safe(),
+	decidedBy: _().nullable(),
+	decidedAt: h().nullable().safe(),
+	version: d().safe(),
+	metadata: f().sensitive("pii")
+}).index(["tenantId", "targetId"]).index(["tenantId", "state"]), x = p(e, {
+	id: u({ prefix: "sact" }),
+	tenantId: g(),
+	targetId: _().nullable(),
+	kind: m().oneOf(t).safe(),
+	scope: f().safe(),
+	from: h().safe(),
+	until: h().nullable().safe(),
+	reason: m().sensitive("pii").serverOnly(),
+	publicReason: m().sensitive("pii"),
+	issuedBy: _().nullable(),
+	evidenceCaseId: v().nullable(),
+	appealable: l().safe(),
+	revokedAt: h().nullable().safe(),
+	requestKey: m().maxLength(64).serverOnly(),
+	metadata: f().sensitive("pii")
+}).index(["tenantId", "targetId"]), S = p(r, {
+	id: u({ prefix: "sappeal" }),
+	tenantId: g(),
+	actionId: v(),
+	subjectId: _().nullable(),
+	text: m().sensitive("pii"),
+	state: m().oneOf(["pending", "reviewed"]).safe(),
+	decidedBy: _().nullable(),
+	decidedAt: h().nullable().safe(),
+	outcome: m().oneOf(["upheld", "revoked"]).nullable().safe(),
+	createdAt: h().safe(),
+	metadata: f().sensitive("pii")
+}).unique(["actionId"]).index(["tenantId", "subjectId"]), C = p(c, {
+	id: u({ prefix: "sstrike" }),
+	tenantId: g(),
+	targetId: _().nullable(),
+	category: m().oneOf(a).safe(),
+	count: d().safe(),
+	lastAt: h().safe(),
+	decayAt: h().safe(),
+	metadata: f().sensitive("pii")
+}).index(["tenantId", "targetId"]), w = p(o, {
+	id: u({ prefix: "sdhint" }),
+	tenantId: g(),
+	subjectId: _().nullable(),
+	deviceHash: m().maxLength(64).sensitive("pii"),
+	firstSeen: h().safe(),
+	metadata: f().sensitive("pii")
+}).index(["tenantId", "subjectId"]), T = p(n, {
+	id: u({ prefix: "sadmit" }),
+	tenantId: g(),
+	subjectId: _().nullable(),
+	admission: d().serverOnly(),
+	erased: l().serverOnly(),
+	metadata: f().sensitive("pii")
+}).index(["tenantId", "subjectId"]), E = [
+	y,
+	b,
+	x,
+	S,
+	C,
+	w,
+	T
+];
+export { x as sanctionActionsTable, T as sanctionAdmissionsTable, S as sanctionAppealsTable, b as sanctionCasesTable, w as sanctionDeviceHintsTable, y as sanctionReportsTable, C as sanctionStrikesTable, E as sanctionTables };

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare class SanctionsError extends SanctionsError_base {
+}
+
+export declare const sanctionsError: (code: SanctionsError["code"]) => SanctionsError;
+
+declare const SanctionsError_base: Schema.Class<SanctionsError, Schema.TaggedStruct<"SanctionsError", {
+    readonly code: Schema.Literals<readonly ["identity_required", "invalid_input", "forbidden", "not_found", "conflict", "rate_limited", "sanctioned", "unavailable", "export_limit"]>;
+}>, YieldableError>;
+
+export { }

package/dist/errors.js

@@ -0,0 +1,14 @@
+import { Schema as e } from "effect";
+// src/errors.ts
+var t = class extends e.TaggedError()("SanctionsError", { code: e.Literals([
+	"identity_required",
+	"invalid_input",
+	"forbidden",
+	"not_found",
+	"conflict",
+	"rate_limited",
+	"sanctioned",
+	"unavailable",
+	"export_limit"
+]) }) {}, n = (e) => new t({ code: e });
+export { t as SanctionsError, n as sanctionsError };

package/dist/eventProducer.d.ts

@@ -0,0 +1,8 @@
+import { ChangeEvent } from '@voltro/database';
+import { SubscribeContext } from '@voltro/runtime';
+
+export declare const publishSanctionChange: (event: ChangeEvent, ctx: SubscribeContext) => Promise<void>;
+
+export declare const sanctionEventTenant: (event: ChangeEvent) => string;
+
+export { }

package/dist/eventProducer.js

@@ -0,0 +1,19 @@
+import "./contract.js";
+import { sanctionsChanged as e } from "./events.js";
+// src/eventProducer.ts
+var t = (e) => {
+	if (e.table !== "_voltro_sanc_actions") throw Error("Sanction events require the owned actions table");
+	let t = (e.op === "delete" ? e.old : e.new)?.tenantId;
+	if (typeof t != "string" || !t.trim() || t.length > 256 || t.includes("\0") || t === "~" || e.op === "update" && e.old?.tenantId !== t) throw Error("Sanction events require stable committed tenant evidence");
+	return t;
+}, n = async (n, r) => {
+	t(n);
+	let i = n.op === "delete" ? n.old : n.new;
+	if (i?.targetId !== null) {
+		if (!i || typeof i.targetId != "string" || !i.targetId.trim() || i.targetId.length > 256 || typeof i.id != "string" || !i.id || i.id.length > 64) throw Error("Sanction events require committed action identity");
+		if (n.op === "update" && n.old?.targetId !== i.targetId) throw Error("Sanction events cannot transfer an action target");
+		if (!r.publish) throw Error("Sanction event publisher is unavailable");
+		await r.publish(e, { subjectId: i.targetId }, { actionId: i.id });
+	}
+};
+export { n as publishSanctionChange, t as sanctionEventTenant };

package/dist/events.d.ts

@@ -0,0 +1,14 @@
+import { DeclaredAccess } from '@voltro/protocol';
+import { EventDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+
+/** Operator metadata. Players receive their own public measures via Live Queries. */
+export declare const sanctionsChanged: EventDescriptor<"sanctions.changed", Schema.Struct<{
+    readonly subjectId: Schema.String;
+}>, Schema.Struct<{
+    readonly actionId: Schema.String;
+}>, DeclaredAccess<{
+    readonly subjectId: string;
+}>>;
+
+export { }

package/dist/events.js

@@ -0,0 +1,10 @@
+import { defineEvent as e } from "@voltro/protocol";
+import { Schema as t } from "effect";
+// src/events.ts
+var n = e({
+	name: "sanctions.changed",
+	key: t.Struct({ subjectId: t.String }),
+	payload: t.Struct({ actionId: t.String }),
+	guards: [{ scope: "sanctions:events:read" }]
+});
+export { n as sanctionsChanged };