@voltro/plugin-sanctions 0.0.0-stage → 0.88.0

package/dist/index.js

@@ -0,0 +1,179 @@
+import { sanctionActionsTable as e, sanctionAdmissionsTable as t, sanctionAppealsTable as n, sanctionCasesTable as r, sanctionDeviceHintsTable as i, sanctionReportsTable as a, sanctionStrikesTable as o, sanctionTables as s } from "./entities.js";
+import { SanctionsError as c, sanctionsError as l } from "./errors.js";
+import { captureSanctionsAdmission as u, captureSanctionsAdmissionBatch as d } from "./admission.server.js";
+import { dataStoreSanctions as f } from "./service.js";
+import { SanctionsPort as p } from "./port.js";
+import { defaultSanctionsStrategies as m, resolveSanctionsOptions as h } from "./strategies.js";
+import { BASE_NAME as g, sanctionsRpcClientImports as _ } from "./rpc.js";
+import { sanctionsRpcRoutes as v } from "./rpcRoutes.js";
+import { sanctionsStatus as y } from "./inspect.js";
+import { sanctionsChanged as b } from "./events.js";
+import { Effect as x, Layer as S } from "effect";
+import { prepareSqlMutation as C, prepareSqlMutationGroup as w } from "@voltro/database/sql";
+import { defineLicensedGamePlugin as T } from "@voltro/plugin-licensing/gate";
+import { fileURLToPath as E } from "node:url";
+import { replicaEvidence as D } from "@voltro/protocol/identity";
+import { redisStore as O } from "@voltro/plugin-ratelimit";
+// src/index.ts
+var k = {
+	slots: {
+		escalationLadder: {
+			defaultExport: "abuseEscalationLadder",
+			fixtureExport: "sanctionsEscalationFixture"
+		},
+		trustScore: {
+			defaultExport: "conservativeTrustScore",
+			fixtureExport: "sanctionsTrustFixture"
+		},
+		evidenceCollector: {
+			defaultExport: "noCollectedSanctionEvidence",
+			fixtureExport: "sanctionsEvidenceFixture"
+		},
+		enforcementPoints: {
+			defaultExport: "defaultSanctionEnforcement",
+			fixtureExport: "sanctionsEnforcementFixture"
+		}
+	},
+	ports: { sanctions: {
+		tagExport: "SanctionsPort",
+		fakeLayerExport: "sanctionsFakeLayer",
+		fixtureExport: "sanctionsPortFixture"
+	} },
+	events: [b.name]
+}, A = (e = {}) => {
+	let t = h(e), n = O(t.rateLimit), r, i, a = !1, o = (e) => x.suspend(() => i === void 0 ? x.fail(l("unavailable")) : e(i)), m = {
+		report: (e, t) => o((n) => n.api.report(e, t)),
+		reportsMine: (e) => o((t) => t.api.reportsMine(e)),
+		mine: (e) => o((t) => t.api.mine(e)),
+		appeal: (e, t) => o((n) => n.api.appeal(e, t)),
+		appealsMine: (e) => o((t) => t.api.appealsMine(e)),
+		cases: (e) => o((t) => t.api.cases(e)),
+		reviewCase: (e, t) => o((n) => n.api.reviewCase(e, t)),
+		issue: (e, t) => o((n) => n.api.issue(e, t)),
+		revoke: (e, t) => o((n) => n.api.revoke(e, t)),
+		appealsQueue: (e) => o((t) => t.api.appealsQueue(e)),
+		reviewAppeal: (e, t) => o((n) => n.api.reviewAppeal(e, t))
+	}, b = {
+		issue: (e, t) => o((n) => n.operator.issue(e, t)),
+		revoke: (e, t) => o((n) => n.operator.revoke(e, t))
+	}, k = {
+		check: (e, t, n) => o((r) => r.port.check(e, t, n)),
+		active: (e) => o((t) => t.port.active(e)),
+		trust: (e) => o((t) => t.port.trust(e)),
+		recordSignal: (e, t) => o((n) => n.port.recordSignal(e, t))
+	}, A = (e, t) => x.try({
+		try: () => {
+			let n = r;
+			if (!n) throw l("unavailable");
+			let a = C(n, async () => {
+				if (i !== e || r !== n) throw l("unavailable");
+			});
+			return w(n, [a, t], async () => {});
+		},
+		catch: () => l("unavailable")
+	}), j = {
+		read: (e, t) => {
+			try {
+				let n = structuredClone(e), r = u(t, !1), i = {
+					point: r.point,
+					at: r.at,
+					context: r.context
+				};
+				return o((e) => e.admission.read(n, i));
+			} catch (e) {
+				return x.fail(e instanceof c ? e : l("invalid_input"));
+			}
+		},
+		prepare: (e, t) => {
+			try {
+				let n = structuredClone(e), r = u(t, !0);
+				if (!r.expected) throw l("invalid_input");
+				let i = {
+					point: r.point,
+					at: r.at,
+					context: r.context,
+					expected: r.expected
+				};
+				return o((e) => e.admission.prepare(n, i).pipe(x.flatMap((t) => A(e, t))));
+			} catch (e) {
+				return x.fail(e instanceof c ? e : l("invalid_input"));
+			}
+		},
+		prepareMany: (e) => {
+			try {
+				let t = d(e);
+				return o((e) => e.admission.prepareMany(t).pipe(x.flatMap((t) => A(e, t))));
+			} catch (e) {
+				return x.fail(e instanceof c ? e : l("invalid_input"));
+			}
+		}
+	};
+	return {
+		sanctions: {
+			admission: () => j,
+			operator: () => b
+		},
+		...T({
+			name: g,
+			description: "SQL-authoritative sanctions, human review and replaceable enforcement.",
+			permissions: ["store:write", "inspect:read"],
+			services: S.succeed(p, k),
+			routes: v(m),
+			rpcClientDescriptors: _,
+			errorSchemas: [{
+				schema: c,
+				import: {
+					module: "@voltro/plugin-sanctions/errors",
+					name: "SanctionsError"
+				}
+			}],
+			sources: E(new URL("./sanctions-app", "" + import.meta.url)),
+			extendSchema: { tables: s },
+			subjectPrivacy: {
+				tables: s.map((e) => e.tableName),
+				kinds: ["user", "guest"]
+			},
+			inspectEndpoints: [{
+				method: "GET",
+				path: "/status",
+				scope: "process",
+				description: "Declared sanctions configuration and binding; no case or evidence enumeration.",
+				handler: () => x.try({
+					try: () => ({
+						kind: "json",
+						data: y(t, i !== void 0, a)
+					}),
+					catch: () => l("unavailable")
+				})
+			}],
+			bindDataStore: (e) => {
+				if (r !== void 0 && r !== e) throw Error("Sanctions plugin instance cannot cross app stores");
+				r = e, i = f(e, t, n);
+			},
+			onActivate: (e) => x.tryPromise({
+				try: async () => {
+					if (t.rateLimit?.hotStore !== void 0 && D(e.env) !== null) throw l("unavailable");
+					await n.activate(e.env, e.connectionRegistry), a = !0;
+				},
+				catch: () => l("unavailable")
+			}),
+			onExport: (e, t) => o((n) => n.exportSubject({
+				subjectId: e,
+				tenantId: t.tenantId,
+				kind: t.kind
+			})),
+			onErase: (e, t) => o((n) => n.eraseSubject({
+				subjectId: e,
+				tenantId: t.tenantId,
+				kind: t.kind
+			})),
+			onDeactivate: () => x.tryPromise({
+				try: async () => {
+					i = void 0, r = void 0, a = !1, await n.deactivate();
+				},
+				catch: () => l("unavailable")
+			})
+		})
+	};
+};
+export { c as SanctionsError, p as SanctionsPort, f as dataStoreSanctions, m as defaultSanctionsStrategies, h as resolveSanctionsOptions, e as sanctionActionsTable, t as sanctionAdmissionsTable, n as sanctionAppealsTable, r as sanctionCasesTable, i as sanctionDeviceHintsTable, a as sanctionReportsTable, o as sanctionStrikesTable, s as sanctionTables, A as sanctionsPlugin, k as sanctionsSystemContract };

package/dist/inspect.js

@@ -0,0 +1,23 @@
+import { sanctionTables as e } from "./entities.js";
+import { defaultSanctionsStrategies as t } from "./strategies.js";
+// src/inspect.ts
+var n = (n, r, i) => ({
+	observedAt: n.now(),
+	bound: r,
+	rateActive: i,
+	atomicAdmissionInstalled: !0,
+	maxActiveActions: n.maxActiveActions,
+	maxReportsPerCase: n.maxReportsPerCase,
+	maxEvidenceRefs: n.maxEvidenceRefs,
+	maxContextMessageIds: n.maxContextMessageIds,
+	maxTextLength: n.maxTextLength,
+	pageSize: n.pageSize,
+	maxExportRows: n.maxExportRows,
+	reportLimit: n.reportLimit,
+	reportWindowMs: n.reportWindowMs,
+	strikeDecayMs: n.strikeDecayMs,
+	minimumSignalConfidence: n.minimumSignalConfidence,
+	slots: Object.fromEntries(Object.keys(t).map((e) => [e, n.strategies[e] === t[e] ? "default" : "custom"])),
+	tables: e.map((e) => e.tableName)
+});
+export { n as sanctionsStatus };

package/dist/port.d.ts

@@ -0,0 +1,82 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+declare const CATEGORIES: readonly ["cheating", "abuse", "name", "spam", "griefing", "rmt"];
+
+declare const DecisionSchema: Schema.Struct<{
+    readonly allowed: Schema.Boolean;
+    readonly actionIds: Schema.$Array<Schema.String>;
+    readonly shadow: Schema.Boolean;
+}>;
+
+declare const POINTS: readonly ["chat", "matchmaking", "trade", "ranked", "login"];
+
+declare type ReportContext = typeof ReportContextSchema.Type;
+
+declare const ReportContextSchema: Schema.Struct<{
+    readonly channelId: Schema.optional<Schema.String>;
+    readonly messageIds: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly roomId: Schema.optional<Schema.String>;
+    readonly matchId: Schema.optional<Schema.String>;
+    readonly replayRef: Schema.optional<Schema.String>;
+}>;
+
+declare type Sanction = typeof SanctionSchema.Type;
+
+declare type SanctionCategory = typeof CATEGORIES[number];
+
+declare interface SanctionCheckContext {
+    readonly channelId?: string;
+    readonly queueId?: string;
+}
+
+declare type SanctionDecision = typeof DecisionSchema.Type;
+
+declare type SanctionPoint = typeof POINTS[number];
+
+declare const SanctionSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["warn", "mute", "chatBan", "matchmakingBan", "rankedBan", "tradeBan", "ban", "shadowBan", "nameReset", "rollback"]>;
+    readonly scope: Schema.Struct<{
+        readonly channels: Schema.$Array<Schema.String>;
+        readonly queues: Schema.$Array<Schema.String>;
+    }>;
+    readonly from: Schema.Number;
+    readonly until: Schema.NullOr<Schema.Number>;
+    readonly publicReason: Schema.String;
+    readonly appealable: Schema.Boolean;
+}>;
+
+declare class SanctionsError extends SanctionsError_base {
+}
+
+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>;
+
+/** Other systems consult this small port rather than sanction SQL or an app-local enforcement map. */
+export declare class SanctionsPort extends SanctionsPort_base {
+}
+
+declare const SanctionsPort_base: Context.ServiceClass<SanctionsPort, "@voltro/SanctionsPort", SanctionsService>;
+
+export declare interface SanctionsService {
+    readonly check: (subject: Subject, point: SanctionPoint, context?: SanctionCheckContext) => Effect.Effect<SanctionDecision, SanctionsError>;
+    readonly active: (subject: Subject) => Effect.Effect<ReadonlyArray<Sanction>, SanctionsError>;
+    readonly trust: (subject: Subject) => Effect.Effect<number, SanctionsError>;
+    readonly recordSignal: (subject: Subject, input: TrustedSanctionSignal) => Effect.Effect<void, SanctionsError>;
+}
+
+declare interface TrustedSanctionSignal {
+    readonly tenantId: string;
+    readonly targetId: string;
+    readonly requestId: string;
+    readonly category: SanctionCategory;
+    readonly confidence: number;
+    readonly context?: ReportContext;
+}
+
+export { }

package/dist/port.js

@@ -0,0 +1,4 @@
+import { Context as e } from "effect";
+// src/port.ts
+var t = class extends e.Service()("@voltro/SanctionsPort") {};
+export { t as SanctionsPort };

package/dist/rpc.d.ts

@@ -0,0 +1,165 @@
+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 appealDescriptor: ActionProcedureDescriptor<"sanctions.appeal", Schema.Struct<{
+    readonly actionId: Schema.NonEmptyString;
+    readonly text: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly actionId: Schema.String;
+    readonly text: Schema.String;
+    readonly state: Schema.Literals<readonly ["pending", "reviewed"]>;
+    readonly outcome: Schema.NullOr<Schema.Literals<readonly ["upheld", "revoked"]>>;
+    readonly createdAt: Schema.Number;
+    readonly decidedAt: Schema.NullOr<Schema.Number>;
+}>, typeof SanctionsError>;
+
+export declare const appealsMineDescriptor: QueryProcedureDescriptor<"sanctions.appealsMine", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly actionId: Schema.String;
+    readonly text: Schema.String;
+    readonly state: Schema.Literals<readonly ["pending", "reviewed"]>;
+    readonly outcome: Schema.NullOr<Schema.Literals<readonly ["upheld", "revoked"]>>;
+    readonly createdAt: Schema.Number;
+    readonly decidedAt: Schema.NullOr<Schema.Number>;
+}>>, typeof SanctionsError>;
+
+export declare const appealsQueueDescriptor: QueryProcedureDescriptor<"sanctions.appealsQueue", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly actionId: Schema.String;
+    readonly text: Schema.String;
+    readonly state: Schema.Literals<readonly ["pending", "reviewed"]>;
+    readonly outcome: Schema.NullOr<Schema.Literals<readonly ["upheld", "revoked"]>>;
+    readonly createdAt: Schema.Number;
+    readonly decidedAt: Schema.NullOr<Schema.Number>;
+}>>, typeof SanctionsError>;
+
+export declare const BASE_NAME = "@voltro/plugin-sanctions";
+
+export declare const casesDescriptor: QueryProcedureDescriptor<"sanctions.cases", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly targetId: Schema.NullOr<Schema.String>;
+    readonly reports: Schema.Number;
+    readonly evidence: Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly trustScore: Schema.Number;
+    readonly state: Schema.Literals<readonly ["open", "reviewing", "actioned", "dismissed"]>;
+    readonly decidedBy: Schema.NullOr<Schema.String>;
+    readonly decidedAt: Schema.NullOr<Schema.Number>;
+    readonly version: Schema.Number;
+}>>, typeof SanctionsError>;
+
+export declare const issueDescriptor: ActionProcedureDescriptor<"sanctions.issue", Schema.Struct<{
+    readonly requestId: Schema.NonEmptyString;
+    readonly targetId: Schema.NonEmptyString;
+    readonly kind: Schema.Literals<readonly ["warn", "mute", "chatBan", "matchmakingBan", "rankedBan", "tradeBan", "ban", "shadowBan", "nameReset", "rollback"]>;
+    readonly scope: Schema.optional<Schema.Struct<{
+        readonly channels: Schema.$Array<Schema.String>;
+        readonly queues: Schema.$Array<Schema.String>;
+    }>>;
+    readonly durationMs: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly reason: Schema.NonEmptyString;
+    readonly publicReason: Schema.NonEmptyString;
+    readonly evidenceCaseId: Schema.optional<Schema.NonEmptyString>;
+    readonly appealable: Schema.optional<Schema.Boolean>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["warn", "mute", "chatBan", "matchmakingBan", "rankedBan", "tradeBan", "ban", "shadowBan", "nameReset", "rollback"]>;
+    readonly scope: Schema.Struct<{
+        readonly channels: Schema.$Array<Schema.String>;
+        readonly queues: Schema.$Array<Schema.String>;
+    }>;
+    readonly from: Schema.Number;
+    readonly until: Schema.NullOr<Schema.Number>;
+    readonly publicReason: Schema.String;
+    readonly appealable: Schema.Boolean;
+}>, typeof SanctionsError>;
+
+export declare const mineDescriptor: QueryProcedureDescriptor<"sanctions.mine", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["warn", "mute", "chatBan", "matchmakingBan", "rankedBan", "tradeBan", "ban", "shadowBan", "nameReset", "rollback"]>;
+    readonly scope: Schema.Struct<{
+        readonly channels: Schema.$Array<Schema.String>;
+        readonly queues: Schema.$Array<Schema.String>;
+    }>;
+    readonly from: Schema.Number;
+    readonly until: Schema.NullOr<Schema.Number>;
+    readonly publicReason: Schema.String;
+    readonly appealable: Schema.Boolean;
+}>>, typeof SanctionsError>;
+
+export declare const reportDescriptor: ActionProcedureDescriptor<"sanctions.report", Schema.Struct<{
+    readonly requestId: Schema.NonEmptyString;
+    readonly targetId: Schema.NonEmptyString;
+    readonly category: Schema.Literals<readonly ["cheating", "abuse", "name", "spam", "griefing", "rmt"]>;
+    readonly context: Schema.optional<Schema.Struct<{
+        readonly channelId: Schema.optional<Schema.String>;
+        readonly messageIds: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly roomId: Schema.optional<Schema.String>;
+        readonly matchId: Schema.optional<Schema.String>;
+        readonly replayRef: Schema.optional<Schema.String>;
+    }>>;
+    readonly note: Schema.optional<Schema.String>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly targetId: Schema.String;
+    readonly category: Schema.Literals<readonly ["cheating", "abuse", "name", "spam", "griefing", "rmt"]>;
+    readonly state: Schema.Literals<readonly ["open", "reviewing", "actioned", "dismissed"]>;
+    readonly createdAt: Schema.Number;
+    readonly caseId: Schema.String;
+}>, typeof SanctionsError>;
+
+export declare const reportsMineDescriptor: QueryProcedureDescriptor<"sanctions.reportsMine", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly targetId: Schema.String;
+    readonly category: Schema.Literals<readonly ["cheating", "abuse", "name", "spam", "griefing", "rmt"]>;
+    readonly state: Schema.Literals<readonly ["open", "reviewing", "actioned", "dismissed"]>;
+    readonly createdAt: Schema.Number;
+    readonly caseId: Schema.String;
+}>>, typeof SanctionsError>;
+
+export declare const reviewAppealDescriptor: ActionProcedureDescriptor<"sanctions.reviewAppeal", Schema.Struct<{
+    readonly appealId: Schema.NonEmptyString;
+    readonly outcome: Schema.Literals<readonly ["upheld", "revoked"]>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly actionId: Schema.String;
+    readonly text: Schema.String;
+    readonly state: Schema.Literals<readonly ["pending", "reviewed"]>;
+    readonly outcome: Schema.NullOr<Schema.Literals<readonly ["upheld", "revoked"]>>;
+    readonly createdAt: Schema.Number;
+    readonly decidedAt: Schema.NullOr<Schema.Number>;
+}>, typeof SanctionsError>;
+
+export declare const reviewCaseDescriptor: ActionProcedureDescriptor<"sanctions.reviewCase", Schema.Struct<{
+    readonly caseId: Schema.NonEmptyString;
+    readonly baseVersion: Schema.Number;
+    readonly state: Schema.Literals<readonly ["open", "reviewing", "actioned", "dismissed"]>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly targetId: Schema.NullOr<Schema.String>;
+    readonly reports: Schema.Number;
+    readonly evidence: Schema.$Array<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly trustScore: Schema.Number;
+    readonly state: Schema.Literals<readonly ["open", "reviewing", "actioned", "dismissed"]>;
+    readonly decidedBy: Schema.NullOr<Schema.String>;
+    readonly decidedAt: Schema.NullOr<Schema.Number>;
+    readonly version: Schema.Number;
+}>, typeof SanctionsError>;
+
+export declare const revokeDescriptor: ActionProcedureDescriptor<"sanctions.revoke", Schema.Struct<{
+    readonly actionId: Schema.NonEmptyString;
+}>, Schema.Void, typeof SanctionsError>;
+
+declare class SanctionsError extends SanctionsError_base {
+}
+
+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 declare const sanctionsRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export { }

package/dist/rpc.js

@@ -0,0 +1,146 @@
+import { ACTIONS_TABLE as e, ACTION_KINDS as t, ADMISSIONS_TABLE as n, APPEALS_TABLE as r, AppealSchema as i, CASES_TABLE as a, CATEGORIES as o, CaseSchema as s, REPORTS_TABLE as c, ReportContextSchema as l, ReportSchema as u, SanctionSchema as d, SanctionScopeSchema as f } from "./contract.js";
+import { SanctionsError as p } from "./errors.js";
+import { defineAction as m, defineQuery as h } from "@voltro/protocol";
+import { Schema as g } from "effect";
+// src/rpc.ts
+var _ = "@voltro/plugin-sanctions", v = g.NonEmptyString, y = g.Number.pipe(g.check(g.isInt()), g.check(g.isGreaterThanOrEqualTo(0))), b = "Trusted human or guest identity and exact tenant are required. Operator actions require sanctions:manage or admin:full; the server owns all sanction decisions.", x = g.Struct({}), S = [
+	c,
+	a,
+	e,
+	r,
+	n
+], C = m({
+	name: "sanctions.report",
+	input: g.Struct({
+		requestId: v,
+		targetId: v,
+		category: g.Literals(o),
+		context: g.optional(l),
+		note: g.optional(g.String)
+	}),
+	output: u,
+	error: p,
+	openAccess: b
+}), w = h({
+	name: "sanctions.reportsMine",
+	input: x,
+	output: g.Array(u),
+	source: S,
+	error: p,
+	openAccess: b
+}), T = h({
+	name: "sanctions.mine",
+	input: x,
+	output: g.Array(d),
+	source: [e, n],
+	error: p,
+	openAccess: b
+}), E = m({
+	name: "sanctions.appeal",
+	input: g.Struct({
+		actionId: v,
+		text: v
+	}),
+	output: i,
+	error: p,
+	openAccess: b
+}), D = h({
+	name: "sanctions.appealsMine",
+	input: x,
+	output: g.Array(i),
+	source: [
+		r,
+		e,
+		n
+	],
+	error: p,
+	openAccess: b
+}), O = h({
+	name: "sanctions.cases",
+	input: x,
+	output: g.Array(s),
+	source: S,
+	error: p,
+	openAccess: b
+}), k = m({
+	name: "sanctions.reviewCase",
+	input: g.Struct({
+		caseId: v,
+		baseVersion: y,
+		state: g.Literals([
+			"open",
+			"reviewing",
+			"actioned",
+			"dismissed"
+		])
+	}),
+	output: s,
+	error: p,
+	openAccess: b
+}), A = m({
+	name: "sanctions.issue",
+	input: g.Struct({
+		requestId: v,
+		targetId: v,
+		kind: g.Literals(t),
+		scope: g.optional(f),
+		durationMs: g.optional(g.NullOr(y)),
+		reason: v,
+		publicReason: v,
+		evidenceCaseId: g.optional(v),
+		appealable: g.optional(g.Boolean)
+	}),
+	output: d,
+	error: p,
+	openAccess: b
+}), j = m({
+	name: "sanctions.revoke",
+	input: g.Struct({ actionId: v }),
+	output: g.Void,
+	error: p,
+	openAccess: b
+}), M = h({
+	name: "sanctions.appealsQueue",
+	input: x,
+	output: g.Array(i),
+	source: [r, e],
+	error: p,
+	openAccess: b
+}), N = m({
+	name: "sanctions.reviewAppeal",
+	input: g.Struct({
+		appealId: v,
+		outcome: g.Literals(["upheld", "revoked"])
+	}),
+	output: i,
+	error: p,
+	openAccess: b
+}), P = [...[
+	"report",
+	"appeal",
+	"reviewCase",
+	"issue",
+	"revoke",
+	"reviewAppeal"
+].map((e) => ({
+	tag: "sanctions." + e,
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-sanctions/rpc",
+		name: e + "Descriptor"
+	}
+})), ...[
+	"reportsMine",
+	"mine",
+	"appealsMine",
+	"cases",
+	"appealsQueue"
+].map((e) => ({
+	tag: "sanctions." + e,
+	kind: "query",
+	import: {
+		module: "@voltro/plugin-sanctions/rpc",
+		name: e + "Descriptor"
+	}
+}))];
+export { _ as BASE_NAME, E as appealDescriptor, D as appealsMineDescriptor, M as appealsQueueDescriptor, O as casesDescriptor, A as issueDescriptor, T as mineDescriptor, C as reportDescriptor, w as reportsMineDescriptor, N as reviewAppealDescriptor, k as reviewCaseDescriptor, j as revokeDescriptor, P as sanctionsRpcClientImports };

package/dist/rpcRoutes.js

@@ -0,0 +1,49 @@
+import { appealDescriptor as e, appealsMineDescriptor as t, appealsQueueDescriptor as n, casesDescriptor as r, issueDescriptor as i, mineDescriptor as a, reportDescriptor as o, reportsMineDescriptor as s, reviewAppealDescriptor as c, reviewCaseDescriptor as l, revokeDescriptor as u } from "./rpc.js";
+// src/rpcRoutes.ts
+var d = (d) => [
+	{
+		...o,
+		execute: (e, t) => d.report(t.request.subject, e)
+	},
+	{
+		...s,
+		execute: (e, t) => d.reportsMine(t.request.subject)
+	},
+	{
+		...a,
+		execute: (e, t) => d.mine(t.request.subject)
+	},
+	{
+		...e,
+		execute: (e, t) => d.appeal(t.request.subject, e)
+	},
+	{
+		...t,
+		execute: (e, t) => d.appealsMine(t.request.subject)
+	},
+	{
+		...r,
+		execute: (e, t) => d.cases(t.request.subject)
+	},
+	{
+		...l,
+		execute: (e, t) => d.reviewCase(t.request.subject, e)
+	},
+	{
+		...i,
+		execute: (e, t) => d.issue(t.request.subject, e)
+	},
+	{
+		...u,
+		execute: (e, t) => d.revoke(t.request.subject, e.actionId)
+	},
+	{
+		...n,
+		execute: (e, t) => d.appealsQueue(t.request.subject)
+	},
+	{
+		...c,
+		execute: (e, t) => d.reviewAppeal(t.request.subject, e)
+	}
+];
+export { d as sanctionsRpcRoutes };

package/dist/sanctions-app/events/sanctions.changed.event.ts

@@ -0,0 +1 @@
+export { sanctionsChanged as default } from '@voltro/plugin-sanctions/events'

package/dist/sanctions-app/subscribers/sanctions.actions.subscribe.ts

@@ -0,0 +1,3 @@
+import { defineSubscriber } from '@voltro/runtime'
+import { sanctionEventTenant,publishSanctionChange } from '@voltro/plugin-sanctions/events/server'
+export default defineSubscriber({table:'_voltro_sanc_actions',on:['insert','update','delete'],once:true,eventTenant:sanctionEventTenant,handler:publishSanctionChange})