@voltro/plugin-gm 0.0.0-stage → 0.87.0

package/dist/index.d.ts

@@ -0,0 +1,498 @@
+import { ColumnBuilder } from '@voltro/database';
+import { DataStore } from '@voltro/database';
+import { EconomyService } from '@voltro/plugin-economy';
+import { Effect } from 'effect';
+import { FieldDefinitions } from '@voltro/database';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { RoomModerationService } from '@voltro/plugin-rooms';
+import { SanctionsOperatorService } from '@voltro/plugin-sanctions';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { systemSubject } from '@voltro/protocol';
+import { Table } from '@voltro/database';
+import { VoltroPlugin } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare const ACTION_RISKS: readonly ["routine", "sensitive"];
+
+declare namespace C {
+    export {
+        REQUESTS_TABLE,
+        REQUEST_STATES,
+        GmRequestState,
+        ACTION_RISKS,
+        GmActionRisk,
+        GmRequestSchema,
+        GmRequest,
+        GmActionInfoSchema,
+        GmActionInfo,
+        GmExecuteInput
+    }
+}
+
+/** Sets a Remote Config value for everyone. The value is JSON text (a form field), checked
+ * against the key's schema and bounds; durable and audited with the requester. Sensitive by default. */
+export declare const configSet: (source: GmConfigSource, options?: GmConfigActionOptions) => GmAction;
+
+/** Borrowed SQL owner. The request row is the idempotency and approval record; the action itself
+ * stays idempotent on its request id, so a crash between action and bookkeeping is retried safely. */
+export declare const dataStoreGm: (store: DataStore, options: ResolvedGmOptions) => {
+    api: GmApi;
+    exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<{
+        readonly id: string;
+        readonly actionId: string;
+        readonly state: "rejected" | "pending" | "approved" | "executed";
+        readonly targetId: string | null;
+        readonly input: unknown;
+        readonly output: unknown;
+        readonly reason: string;
+        readonly ticket: string | null;
+        readonly requesterId: string | null;
+        readonly approverId: string | null;
+        readonly createdAt: number;
+        readonly decidedAt: number | null;
+        readonly executedAt: number | null;
+    }[], GmError, never>;
+    /** Redacts what the request said about the player, unlinks staff ids and withdraws open requests that lost their subject. */
+    eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, GmError, never>;
+};
+
+/** Default approval rule: actions marked `sensitive` wait for a second person. */
+export declare const defaultGmApprovalWhen: ({ action }: {
+    readonly action: GmActionSummary;
+}) => boolean;
+
+export declare const defaultGmAuthorize: (actor: GmActor, action: GmActionSummary) => boolean;
+
+export declare const defineGmAction: <I, IE, O, OE>(definition: GmActionDefinition<I, IE, O, OE>) => GmAction;
+
+/** Pays currency from a system account into a player's wallet. */
+export declare const economyGrant: (source: GmEconomySource, options: GmEconomyActionOptions) => GmAction;
+
+/** A compensating transfer back to the system account; ledger history is never deleted. */
+export declare const economyRevoke: (source: GmEconomySource, options: GmEconomyActionOptions) => GmAction;
+
+/** Flips a feature's kill switch (a flag's `enabled`): live at once, durable and audited with the
+ * requesting staff member on the postgres tier. Sensitive: needs a second person by default. */
+export declare const flagsToggle: (source: GmFlagsSource, options?: GmFlagsActionOptions) => GmAction;
+
+/** Chunk reset: undoes every player's geometry edits in one chunk of a live Room, back to its
+ * built-in (static) version. Same path and policy as `geometryRollback`, with no target player;
+ * the history stays in the journal. Sensitive by default. */
+export declare const geometryReset: (source: GmGeometrySource, overrides?: GmActionOverrides) => GmAction;
+
+/** Griefing rollback: undoes one player's geometry edits in one chunk of a live Room. Runs as the
+ * requesting staff member; the Room's Host asks the app's rollback policy. The GM request is the
+ * rollback request ID, so a retried approval rolls back once. Sensitive by default. */
+export declare const geometryRollback: (source: GmGeometrySource, overrides?: GmActionOverrides) => GmAction;
+
+/** The erased shape the plugin stores; build one with `defineGmAction`. */
+export declare interface GmAction {
+    readonly id: string;
+    readonly title: string;
+    readonly input: Schema.Codec<unknown, unknown>;
+    readonly output: Schema.Codec<unknown, unknown>;
+    readonly risk: GmActionRisk;
+    readonly target?: ((input: never) => string | null) | undefined;
+    readonly execute: (input: never, ctx: GmActionContext) => Effect.Effect<unknown, unknown>;
+}
+
+/** What an action receives besides its decoded input. `requestId` is stable for the request
+ * (`[A-Za-z0-9-]`, at most 64 characters): pass it to the owning plugin as its idempotency key. */
+export declare interface GmActionContext {
+    readonly tenantId: string;
+    readonly requestId: string;
+    readonly requesterId: string;
+    readonly approverId: string | null;
+    readonly reason: string;
+    readonly ticket: string | null;
+}
+
+export declare interface GmActionDefinition<I, IE, O, OE> {
+    /** Stable, namespaced id (`economy.grant`); the default scope is `gm:<id>`. */
+    readonly id: string;
+    readonly title: string;
+    /** Decoded server-side; its encoded form must be a JSON object and is stored with the request. */
+    readonly input: Schema.Codec<I, IE>;
+    readonly output: Schema.Codec<O, OE>;
+    /** `sensitive` requests need a second person when the plugin's `approval` is configured. */
+    readonly risk: GmActionRisk;
+    /** The player the request acts on: indexed for history and redacted with that player. */
+    readonly target?: (input: I) => string | null;
+    /** Must be idempotent on `requestId`: a retried request or a second approval runs it again. */
+    readonly execute: (input: I, ctx: GmActionContext) => Effect.Effect<O, unknown>;
+}
+
+export declare type GmActionInfo = typeof GmActionInfoSchema.Type;
+
+/** One action the caller may run; `input` is the JSON Schema of the encoded input a console renders its form from. */
+declare const GmActionInfoSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly title: Schema.String;
+    readonly risk: Schema.Literals<readonly ["routine", "sensitive"]>;
+    readonly input: Schema.Unknown;
+}>;
+
+export declare interface GmActionOverrides {
+    readonly id?: string;
+    readonly title?: string;
+    readonly risk?: GmActionRisk;
+}
+
+export declare type GmActionRisk = typeof ACTION_RISKS[number];
+
+export declare interface GmActionSummary {
+    readonly id: string;
+    readonly title: string;
+    readonly risk: C.GmActionRisk;
+}
+
+/** The staff caller as the policies see it: resolved scopes, never a credential claim. */
+export declare interface GmActor {
+    readonly type: 'user' | 'serviceAccount';
+    readonly id: string;
+    readonly tenantId: string;
+    readonly scopes: ReadonlyArray<string>;
+}
+
+export declare interface GmApi {
+    readonly actions: (subject: Subject) => Effect.Effect<ReadonlyArray<C.GmActionInfo>, GmError>;
+    readonly requests: (subject: Subject, input: {
+        readonly state?: C.GmRequestState | undefined;
+    }) => Effect.Effect<ReadonlyArray<C.GmRequest>, GmError>;
+    readonly execute: (subject: Subject, input: C.GmExecuteInput) => Effect.Effect<C.GmRequest, GmError>;
+    readonly approve: (subject: Subject, id: string) => Effect.Effect<C.GmRequest, GmError>;
+    readonly reject: (subject: Subject, id: string) => Effect.Effect<C.GmRequest, GmError>;
+}
+
+export declare interface GmApprovalPolicy {
+    /** Which requests wait for a second person. Default: actions whose risk is `sensitive`. */
+    readonly when?: (request: {
+        readonly action: GmActionSummary;
+        readonly input: unknown;
+        readonly actor: GmActor;
+    }) => boolean;
+    /** Scope an approver holds (`admin:full` also approves). Default `gm:approve`. */
+    readonly approverScope?: string;
+}
+
+export declare interface GmConfigActionOptions extends GmActionOverrides {
+    /** Config keys the console offers; omitted, any declared key. */
+    readonly keys?: readonly [string, ...string[]];
+}
+
+/** The installed flags plugin with a Config catalogue (`flagsPlugin({ config })`). */
+export declare interface GmConfigSource {
+    readonly setConfig?: (input: {
+        readonly key: string;
+        readonly value: unknown;
+        readonly actor?: string | null;
+    }) => Effect.Effect<{
+        readonly key: string;
+        readonly value: unknown;
+    }, unknown>;
+}
+
+export declare interface GmEconomyActionOptions extends GmActionOverrides {
+    /** The system account a grant is paid from and a revoke is paid into. */
+    readonly systemAccount: string;
+    /** Currencies the console offers; omitted, any declared economy currency. */
+    readonly currencies?: readonly [string, ...string[]];
+}
+
+/** The installed economy plugin (`economyPlugin(...)`) or anything with its trusted transfer service. */
+export declare interface GmEconomySource {
+    readonly economy: {
+        readonly service: () => Pick<EconomyService, 'transfer'>;
+    };
+}
+
+/** `action_failed` carries the owning plugin's own error code (`insufficient_funds`, `conflict`, …) in `actionCode`. */
+export declare class GmError extends GmError_base {
+}
+
+declare const GmError_base: Schema.Class<GmError, Schema.TaggedStruct<"GmError", {
+    readonly code: Schema.Literals<readonly ["identity_required", "invalid_input", "forbidden", "not_found", "conflict", "unavailable", "action_failed"]>;
+    readonly actionCode: Schema.optional<Schema.String>;
+}>, YieldableError>;
+
+export declare interface GmExecuteInput {
+    readonly requestId: string;
+    readonly actionId: string;
+    readonly input: unknown;
+    readonly reason: string;
+    readonly ticket?: string | undefined;
+}
+
+export declare interface GmFlagsActionOptions extends GmActionOverrides {
+    /** Kill switches the console offers (flag keys); omitted, any non-Config flag. */
+    readonly keys?: readonly [string, ...string[]];
+}
+
+/** The installed flags plugin (`flagsPlugin(...)`) or anything with its audited kill-switch flip. */
+export declare interface GmFlagsSource {
+    readonly toggle: (input: {
+        readonly key: string;
+        readonly enabled: boolean;
+        readonly actor?: string | null;
+    }) => Effect.Effect<{
+        readonly key: string;
+        readonly enabled: boolean;
+        readonly previous: boolean;
+    }, unknown>;
+}
+
+export declare interface GmGeometrySource {
+    readonly moderation: Pick<RoomModerationService, 'rollbackGeometry'>;
+}
+
+export declare interface GmLeaguesSource {
+    readonly leaderboards: {
+        readonly service: () => {
+            readonly assignLeague: (subject: ReturnType<typeof systemSubject>, input: {
+                readonly tenantId: string;
+                readonly league: string;
+                readonly ownerId: string;
+                readonly division: string;
+            }) => Effect.Effect<{
+                readonly league: string;
+                readonly division: string;
+            }, unknown>;
+        };
+    };
+}
+
+/** The installed liveops plugin with maintenance (`liveOpsPlugin({ maintenance })`). */
+export declare interface GmMaintenanceSource {
+    readonly maintenance?: () => {
+        readonly schedule: (subject: ReturnType<typeof systemSubject>, tenantId: string, intent: {
+            readonly requestId: string;
+            readonly from: number;
+            readonly until: number;
+            readonly drainBy: number;
+            readonly messageKey: string;
+        }) => Effect.Effect<{
+            readonly id: string;
+            readonly from: number;
+            readonly until: number;
+            readonly drainBy: number;
+            readonly state: string;
+        }, unknown>;
+        readonly cancel: (subject: ReturnType<typeof systemSubject>, tenantId: string, intent: {
+            readonly requestId: string;
+            readonly windowId: string;
+        }) => Effect.Effect<{
+            readonly id: string;
+            readonly state: string;
+        }, unknown>;
+    };
+}
+
+export declare interface GmOptions {
+    readonly actions: ReadonlyArray<GmAction>;
+    /** Replaces the default rule: `gm:<id>`, `gm:<namespace>.*`, `gm:*` or `admin:full`. */
+    readonly authorize?: (actor: GmActor, action: GmActionSummary) => boolean;
+    /** Omitted: every authorized request runs at once. */
+    readonly approval?: GmApprovalPolicy;
+    readonly now?: () => number;
+    readonly pageSize?: number;
+    readonly maxExportRows?: number;
+}
+
+export declare interface GmPlugin extends VoltroPlugin {
+    readonly gm: {
+        readonly api: () => GmApi;
+    };
+}
+
+/** Game-master actions: each request names its action, input and reason, runs once per
+ * request id, and optionally waits for a second person. RPC calls are audited by plugin-audit. */
+export declare const gmPlugin: (input: GmOptions) => GmPlugin;
+
+export declare type GmRequest = typeof GmRequestSchema.Type;
+
+declare const GmRequestSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly actionId: Schema.String;
+    readonly state: Schema.Literals<readonly ["pending", "approved", "executed", "rejected"]>;
+    readonly targetId: Schema.NullOr<Schema.String>;
+    readonly input: Schema.Unknown;
+    readonly output: Schema.NullOr<Schema.Unknown>;
+    readonly reason: Schema.String;
+    readonly ticket: Schema.NullOr<Schema.String>;
+    readonly requesterId: Schema.NullOr<Schema.String>;
+    readonly approverId: Schema.NullOr<Schema.String>;
+    readonly createdAt: Schema.Number;
+    readonly decidedAt: Schema.NullOr<Schema.Number>;
+    readonly executedAt: Schema.NullOr<Schema.Number>;
+}>;
+
+export declare const gmRequestsTable: Table<"_voltro_gm_requests", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly actionId: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"rejected" | "pending" | "approved" | "executed", "text", boolean>;
+    readonly targetId: ColumnBuilder<string | null, "text", boolean>;
+    readonly input: ColumnBuilder<unknown, "json", boolean>;
+    readonly output: ColumnBuilder<unknown, "json", boolean>;
+    readonly reason: ColumnBuilder<string, "text", boolean>;
+    readonly ticket: ColumnBuilder<string | null, "text", boolean>;
+    readonly requesterId: ColumnBuilder<string | null, "text", boolean>;
+    readonly approverId: ColumnBuilder<string | null, "text", boolean>;
+    readonly digest: ColumnBuilder<string, "text", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly decidedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly executedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>;
+
+export declare type GmRequestState = typeof REQUEST_STATES[number];
+
+/** The installed rooms plugin (`roomsPlugin(...)`) or anything that can drain a tenant's Rooms. */
+export declare interface GmRoomsDrainSource {
+    readonly moderation: Pick<RoomModerationService, 'closeAll'>;
+}
+
+/** The installed rooms plugin (`roomsPlugin(...)`) or anything with its operator moderation. */
+export declare interface GmRoomsSource {
+    readonly moderation: Pick<RoomModerationService, 'kick'>;
+}
+
+/** The installed sanctions plugin (`sanctionsPlugin(...)`) or anything with its operator service. */
+export declare interface GmSanctionsSource {
+    readonly sanctions: {
+        readonly operator: () => Pick<SanctionsOperatorService, 'issue'>;
+    };
+}
+
+/** Declared GM configuration for operators: actions, rule slots and budgets. No request, reason or staff enumeration. */
+export declare const gmStatus: (options: ResolvedGmOptions, bound: boolean) => {
+    observedAt: number;
+    bound: boolean;
+    actions: {
+        id: string;
+        title: string;
+        risk: "sensitive" | "routine";
+    }[];
+    authorize: "custom" | "default";
+    approval: {
+        when: "custom" | "default";
+        approverScope: string;
+    } | null;
+    pageSize: number;
+    maxExportRows: number;
+    tables: "_voltro_gm_requests"[];
+};
+
+/** System21 inventory: the two policy slots; GM owns no port or event. */
+export declare const gmSystemContract: {
+    readonly slots: {
+        readonly authorize: {
+            readonly defaultExport: "defaultGmAuthorize";
+            readonly fixtureExport: "gmAuthorizeSlotFixture";
+        };
+        readonly 'approval.when': {
+            readonly defaultExport: "defaultGmApprovalWhen";
+            readonly fixtureExport: "gmApprovalSlotFixture";
+        };
+    };
+    readonly ports: {};
+    readonly events: readonly [];
+};
+
+export declare const gmTables: Table<"_voltro_gm_requests", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly actionId: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"rejected" | "pending" | "approved" | "executed", "text", boolean>;
+    readonly targetId: ColumnBuilder<string | null, "text", boolean>;
+    readonly input: ColumnBuilder<unknown, "json", boolean>;
+    readonly output: ColumnBuilder<unknown, "json", boolean>;
+    readonly reason: ColumnBuilder<string, "text", boolean>;
+    readonly ticket: ColumnBuilder<string | null, "text", boolean>;
+    readonly requesterId: ColumnBuilder<string | null, "text", boolean>;
+    readonly approverId: ColumnBuilder<string | null, "text", boolean>;
+    readonly digest: ColumnBuilder<string, "text", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly decidedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly executedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>[];
+
+/** The installed leaderboards plugin with tournament coordination (`leaderboardsPlugin({ tournamentCoordination })`). */
+export declare interface GmTournamentsSource {
+    readonly leaderboards: {
+        readonly tournaments: () => {
+            readonly resolve: (subject: ReturnType<typeof systemSubject>, scope: {
+                readonly tenantId: string;
+                readonly tournamentId: string;
+            }, intent: {
+                readonly disputeId: string;
+                readonly resolutionId: string;
+                readonly winnerId: string;
+            }) => Effect.Effect<{
+                readonly phase: string;
+                readonly champion: string | null;
+                readonly unresolvedDisputes: number;
+            }, unknown>;
+        };
+    };
+}
+
+/** Places a player in a league division (a correction or a placement). Takes effect at once;
+ * the next league close moves the player from there. Sensitive by default. */
+export declare const leaguesAssign: (source: GmLeaguesSource, overrides?: GmActionOverrides) => GmAction;
+
+/** Cancels a planned or running maintenance window of the staff member's tenant. */
+export declare const maintenanceCancel: (source: GmMaintenanceSource, overrides?: GmActionOverrides) => GmAction;
+
+/** Plans a maintenance window for the staff member's tenant (epoch ms). New Room reservations
+ * close and running Rooms drain where the app wires that up. Sensitive by default. */
+export declare const maintenanceSchedule: (source: GmMaintenanceSource, overrides?: GmActionOverrides) => GmAction;
+
+/** pending: waits for a second person. approved: may run (retries re-run the idempotent action). executed and rejected are terminal. */
+export declare const REQUEST_STATES: readonly ["pending", "approved", "executed", "rejected"];
+
+export declare const REQUESTS_TABLE = "_voltro_gm_requests";
+
+declare interface ResolvedAction {
+    readonly action: GmAction;
+    readonly summary: GmActionSummary;
+    readonly schema: unknown;
+}
+
+export declare interface ResolvedGmOptions {
+    readonly actions: ReadonlyMap<string, ResolvedAction>;
+    readonly authorize: (actor: GmActor, action: GmActionSummary) => boolean;
+    readonly approval: {
+        readonly when: NonNullable<GmApprovalPolicy['when']>;
+        readonly approverScope: string;
+    } | null;
+    readonly now: () => number;
+    readonly pageSize: number;
+    readonly maxExportRows: number;
+}
+
+/** Validates the configured actions once at construction; a bad definition refuses the plugin, not a request. */
+export declare const resolveGmOptions: (input: GmOptions) => ResolvedGmOptions;
+
+/** Maintenance drain: kicks every session in every live Room of the tenant (seats released, no
+ * reconnect). Close new reservations first (Rooms `admission`), or players join again. Sensitive:
+ * needs a second person by default. */
+export declare const roomsCloseAll: (source: GmRoomsDrainSource, overrides?: GmActionOverrides) => GmAction;
+
+/** Closes the player's sessions in one Room with a Kick frame and releases their seats; the
+ * owning Host is found through the Rooms directory. Pair with a ban to keep them out. */
+export declare const roomsKick: (source: GmRoomsSource, overrides?: GmActionOverrides) => GmAction;
+
+/** Account ban through the sanctions plugin; permanent when `durationMs` is omitted. */
+export declare const sanctionsBan: (source: GmSanctionsSource, overrides?: GmActionOverrides) => GmAction;
+
+/** Chat mute through the sanctions plugin. */
+export declare const sanctionsMute: (source: GmSanctionsSource, overrides?: GmActionOverrides) => GmAction;
+
+export declare const staffActor: (subject: Subject) => GmActor;
+
+/** Decides a disputed tournament match for the named winner; the bracket resumes when no dispute
+ * is left. The GM request is the resolution ID, so a retried approval resolves once. Sensitive by default. */
+export declare const tournamentsResolve: (source: GmTournamentsSource, overrides?: GmActionOverrides) => GmAction;
+
+export { }

package/dist/index.js

@@ -0,0 +1,108 @@
+import { GmError as e, gmError as t } from "./errors.js";
+import { ACTION_RISKS as n, REQUESTS_TABLE as r, REQUEST_STATES as i } from "./contract.js";
+import { gmRequestsTable as a, gmTables as o } from "./entities.js";
+import { dataStoreGm as s, defaultGmApprovalWhen as c, defaultGmAuthorize as l, resolveGmOptions as u, staffActor as d } from "./service.js";
+import { gmStatus as f } from "./inspect.js";
+import { BASE_NAME as p, actionsDescriptor as m, approveDescriptor as h, executeDescriptor as g, gmRpcClientImports as _, rejectDescriptor as v, requestsDescriptor as y } from "./rpc.js";
+import { defineGmAction as b } from "./action.js";
+import { configSet as x, economyGrant as S, economyRevoke as C, flagsToggle as w, geometryReset as T, geometryRollback as E, leaguesAssign as D, maintenanceCancel as O, maintenanceSchedule as k, roomsCloseAll as A, roomsKick as j, sanctionsBan as M, sanctionsMute as N, tournamentsResolve as P } from "./builtins.js";
+import { defineLicensedGamePlugin as F } from "@voltro/plugin-licensing/gate";
+import { Effect as I } from "effect";
+//#region src/index.ts
+var L = {
+	slots: {
+		authorize: {
+			defaultExport: "defaultGmAuthorize",
+			fixtureExport: "gmAuthorizeSlotFixture"
+		},
+		"approval.when": {
+			defaultExport: "defaultGmApprovalWhen",
+			fixtureExport: "gmApprovalSlotFixture"
+		}
+	},
+	ports: {},
+	events: []
+}, R = (n) => {
+	let r = u(n), i, a, c = (e) => I.suspend(() => a === void 0 ? I.fail(t("unavailable")) : e(a)), l = {
+		actions: (e) => c((t) => t.api.actions(e)),
+		requests: (e, t) => c((n) => n.api.requests(e, t)),
+		execute: (e, t) => c((n) => n.api.execute(e, t)),
+		approve: (e, t) => c((n) => n.api.approve(e, t)),
+		reject: (e, t) => c((n) => n.api.reject(e, t))
+	}, d = [
+		{
+			...m,
+			execute: (e, t) => l.actions(t.request.subject)
+		},
+		{
+			...y,
+			execute: (e, t) => l.requests(t.request.subject, e)
+		},
+		{
+			...g,
+			execute: (e, t) => l.execute(t.request.subject, e)
+		},
+		{
+			...h,
+			execute: (e, t) => l.approve(t.request.subject, e.id)
+		},
+		{
+			...v,
+			execute: (e, t) => l.reject(t.request.subject, e.id)
+		}
+	];
+	return {
+		gm: { api: () => l },
+		...F({
+			name: p,
+			description: "Configurable game-master actions with reasons, idempotent requests and optional second-person approval.",
+			permissions: ["store:write", "inspect:read"],
+			routes: d,
+			inspectEndpoints: [{
+				method: "GET",
+				path: "/status",
+				scope: "process",
+				description: "Declared GM actions, rule slots and budgets; no request, reason or staff enumeration.",
+				handler: () => I.try({
+					try: () => ({
+						kind: "json",
+						data: f(r, a !== void 0)
+					}),
+					catch: () => t("unavailable")
+				})
+			}],
+			rpcClientDescriptors: _,
+			errorSchemas: [{
+				schema: e,
+				import: {
+					module: "@voltro/plugin-gm/errors",
+					name: "GmError"
+				}
+			}],
+			extendSchema: { tables: o },
+			subjectPrivacy: {
+				tables: o.map((e) => e.tableName),
+				kinds: ["user", "guest"]
+			},
+			bindDataStore: (e) => {
+				if (i !== void 0 && i !== e) throw Error("GM plugin instance cannot cross app stores");
+				i = e, a = s(e, r);
+			},
+			onExport: (e, t) => c((n) => n.exportSubject({
+				subjectId: e,
+				tenantId: t.tenantId,
+				kind: t.kind
+			})),
+			onErase: (e, t) => c((n) => n.eraseSubject({
+				subjectId: e,
+				tenantId: t.tenantId,
+				kind: t.kind
+			})),
+			onDeactivate: () => I.sync(() => {
+				a = void 0, i = void 0;
+			})
+		})
+	};
+};
+//#endregion
+export { n as ACTION_RISKS, e as GmError, r as REQUESTS_TABLE, i as REQUEST_STATES, x as configSet, s as dataStoreGm, c as defaultGmApprovalWhen, l as defaultGmAuthorize, b as defineGmAction, S as economyGrant, C as economyRevoke, w as flagsToggle, T as geometryReset, E as geometryRollback, R as gmPlugin, a as gmRequestsTable, f as gmStatus, L as gmSystemContract, o as gmTables, D as leaguesAssign, O as maintenanceCancel, k as maintenanceSchedule, u as resolveGmOptions, A as roomsCloseAll, j as roomsKick, M as sanctionsBan, N as sanctionsMute, d as staffActor, P as tournamentsResolve };

package/dist/inspect.js

@@ -0,0 +1,22 @@
+import { gmTables as e } from "./entities.js";
+import { defaultGmApprovalWhen as t, defaultGmAuthorize as n } from "./service.js";
+//#region src/inspect.ts
+var r = (r, i) => ({
+	observedAt: r.now(),
+	bound: i,
+	actions: [...r.actions.values()].map(({ summary: e }) => ({
+		id: e.id,
+		title: e.title,
+		risk: e.risk
+	})),
+	authorize: r.authorize === n ? "default" : "custom",
+	approval: r.approval === null ? null : {
+		when: r.approval.when === t ? "default" : "custom",
+		approverScope: r.approval.approverScope
+	},
+	pageSize: r.pageSize,
+	maxExportRows: r.maxExportRows,
+	tables: e.map((e) => e.tableName)
+});
+//#endregion
+export { r as gmStatus };