@voltro/plugin-saves 0.0.0-stage → 0.87.0

package/dist/plugin.js

@@ -0,0 +1,336 @@
+import { SaveConflict as e, SavesError as t, savesError as n } from "./errors.js";
+import { captureSavePut as r, saveData as i, saveId as a, saveInteger as o, saveOwner as s } from "./contract.js";
+import { SavesPort as c, captureSavesService as l } from "./port.js";
+import { defaultSaveValidator as u, resolveSavesOptions as d } from "./strategies.js";
+import { savesTables as f } from "./tables.entity.js";
+import { dataStoreSaves as p } from "./service.server.js";
+import { savesGetDescriptor as m, savesHistoryDescriptor as h, savesListDescriptor as g, savesPutDescriptor as _, savesRemoveDescriptor as v, savesRollbackDescriptor as y, savesRpcClientImports as b } from "./rpc.js";
+import { defineLicensedGamePlugin as x } from "@voltro/plugin-licensing/gate";
+import { replicaEvidence as S } from "@voltro/protocol/identity";
+import { ConnectionRegistry as C } from "@voltro/kv/connection";
+import { HotStore as w, layerRoutedHotRedis as T } from "@voltro/kv/hot";
+import { Effect as E, Layer as D, ManagedRuntime as O } from "effect";
+//#region src/plugin.ts
+var k = Object.freeze({
+	slots: { validator: {
+		defaultExport: "defaultSaveValidator",
+		fixtureExport: "saveValidatorSystemFixture"
+	} },
+	ports: { saves: {
+		tagExport: "SavesPort",
+		fakeLayerExport: "savesFakeLayer",
+		fixtureExport: "savesPortSystemFixture"
+	} },
+	events: []
+}), A = (k) => {
+	let A = [
+		"service",
+		"querySources",
+		"connection",
+		"hotStore"
+	], j = i(k, [
+		"gameId",
+		"slots",
+		"maxBytes",
+		"historyVersions",
+		"maxRequests",
+		"deleteGraceMs",
+		"version",
+		"validator",
+		"schema",
+		"schemaVersion",
+		"now",
+		...A
+	]), M = Object.fromEntries(Object.entries(j).filter(([e]) => !A.includes(e))), N = d(M), P = j.service === void 0 ? void 0 : l(j.service);
+	if (P && (N.version === "default.v1" || [
+		"maxBytes",
+		"historyVersions",
+		"maxRequests",
+		"deleteGraceMs",
+		"validator",
+		"schema",
+		"schemaVersion",
+		"now",
+		"connection",
+		"hotStore"
+	].some((e) => j[e] !== void 0)) || !P && j.querySources !== void 0) throw n("invalid_input");
+	let F;
+	if (P) {
+		let e = j.querySources;
+		if (!Array.isArray(e) || e.length < 1 || e.length > 32 || Reflect.ownKeys(e).length !== e.length + 1) throw n("invalid_input");
+		let t = [];
+		for (let r = 0; r < e.length; r++) {
+			let i = Object.getOwnPropertyDescriptor(e, String(r));
+			if (!i || !("value" in i) || typeof i.value != "string" || !/^[A-Za-z_][A-Za-z0-9_]{0,119}$/.test(i.value)) throw n("invalid_input");
+			t.push(i.value);
+		}
+		if (new Set(t).size !== t.length) throw n("invalid_input");
+		F = Object.freeze(t);
+	}
+	if (j.connection !== void 0 && (typeof j.connection != "string" || !/^redis:[A-Za-z][A-Za-z0-9_-]*$/.test(j.connection)) || j.hotStore !== void 0 && j.connection !== void 0) throw n("invalid_input");
+	let I = j.hotStore;
+	if (I !== void 0 && typeof I.rateLimit != "function") throw n("invalid_input");
+	let L, R, z = !1, B = !1, V = 0, H, U, W, G, K = () => E.fail(n("unavailable")), q = (e) => {
+		let t = P ?? R, n = V;
+		return E.suspend(() => z && B && n === V && t && t === (P ?? R) ? e(t).pipe(E.flatMap((e) => z && B && n === V && t === (P ?? R) ? E.succeed(e) : K())) : K()).pipe(E.catchDefect(() => K()));
+	}, J = (r) => {
+		try {
+			return r();
+		} catch (r) {
+			return E.fail(r instanceof t || r instanceof e ? r : n("invalid_input"));
+		}
+	}, Y = (e) => {
+		let t = a(e);
+		if (!N.slots.includes(t)) throw n("not_found");
+		return t;
+	}, X = (e) => {
+		let t = i(e, [
+			"tenantId",
+			"subjectId",
+			"kind"
+		]);
+		if (t.kind !== "guest" && t.kind !== "user") throw n("invalid_input");
+		return Object.freeze({
+			tenantId: a(t.tenantId),
+			subjectId: a(t.subjectId),
+			kind: t.kind
+		});
+	}, Z = Object.freeze({
+		get: (e, t) => J(() => {
+			s(e);
+			let n = structuredClone(e), r = Y(t);
+			return q((e) => e.get(n, r));
+		}),
+		list: (e) => J(() => {
+			s(e);
+			let t = structuredClone(e);
+			return q((e) => e.list(t));
+		}),
+		history: (e, t) => J(() => {
+			s(e);
+			let n = structuredClone(e), r = Y(t);
+			return q((e) => e.history(n, r));
+		}),
+		put: (e, t) => J(() => {
+			s(e);
+			let n = structuredClone(e), i = r(t, N.maxBytes);
+			return Y(i.slot), q((e) => e.put(n, i));
+		}),
+		rollback: (e, t) => J(() => {
+			s(e);
+			let n = structuredClone(e), r = i(t, [
+				"slot",
+				"requestId",
+				"baseVersion",
+				"version"
+			]), c = Object.freeze({
+				slot: Y(r.slot),
+				requestId: a(r.requestId),
+				baseVersion: o(r.baseVersion),
+				version: o(r.version, 1)
+			});
+			return q((e) => e.rollback(n, c));
+		}),
+		remove: (e, t) => J(() => {
+			s(e);
+			let n = structuredClone(e), r = i(t, [
+				"slot",
+				"requestId",
+				"baseVersion"
+			]), c = Object.freeze({
+				slot: Y(r.slot),
+				requestId: a(r.requestId),
+				baseVersion: o(r.baseVersion)
+			});
+			return q((e) => e.remove(n, c));
+		}),
+		exportSubject: (e) => J(() => {
+			let t = X(e);
+			return q((e) => e.exportSubject(t));
+		}),
+		eraseSubject: (e) => J(() => {
+			let t = X(e);
+			return q((e) => e.eraseSubject(t));
+		})
+	}), Q = P ? [] : [...f], $ = (e) => F ? {
+		...e,
+		source: F
+	} : e;
+	return {
+		saves: () => Z,
+		...x({
+			name: "@voltro/plugin-saves",
+			description: "Owner-scoped opaque saves with SQL versions, original-intent replay, history and privacy.",
+			permissions: ["store:write", "inspect:read"],
+			services: D.succeed(c, Z),
+			...!P && !I ? {
+				needs: {
+					hot: "local",
+					connections: [{
+						kind: "redis",
+						role: "hot",
+						onUnavailable: "fail"
+					}]
+				},
+				...j.connection === void 0 ? {} : { connectionBindings: { hot: j.connection } }
+			} : {},
+			routes: [
+				{
+					...$(m),
+					execute: (e, t) => Z.get(t.request.subject, e.slot)
+				},
+				{
+					...$(g),
+					execute: (e, t) => Z.list(t.request.subject)
+				},
+				{
+					...$(h),
+					execute: (e, t) => Z.history(t.request.subject, e.slot)
+				},
+				{
+					..._,
+					execute: (e, t) => Z.put(t.request.subject, e)
+				},
+				{
+					...y,
+					execute: (e, t) => Z.rollback(t.request.subject, e)
+				},
+				{
+					...v,
+					execute: (e, t) => Z.remove(t.request.subject, e)
+				}
+			],
+			rpcClientDescriptors: b,
+			errorSchemas: [{
+				schema: t,
+				import: {
+					module: "@voltro/plugin-saves/errors",
+					name: "SavesError"
+				}
+			}, {
+				schema: e,
+				import: {
+					module: "@voltro/plugin-saves/errors",
+					name: "SaveConflict"
+				}
+			}],
+			extendSchema: { tables: Q },
+			subjectPrivacy: {
+				tables: Q.map((e) => e.tableName),
+				kinds: ["user", "guest"]
+			},
+			bindDataStore: (e) => {
+				if (z && B || W || G) throw n("unavailable");
+				if (L && L !== e) throw Error("Saves plugin instance cannot cross app stores");
+				B = !1, L = e, V++;
+				let t = V;
+				P || (R = p(e, {
+					...N,
+					schemaVersion: N.schemaVersion ?? void 0,
+					admitWrite: (e, t) => E.suspend(() => !z || !B || !H ? K() : H.rateLimit(e, {
+						limit: 10,
+						windowMs: 6e4,
+						burst: 10,
+						algorithm: "fixed-window"
+					}, t).pipe(E.mapError(() => n("unavailable")), E.flatMap((e) => e.allowed ? E.void : E.fail(n("rate_limited")))))
+				}, () => {
+					if (!z || !B || !L || V !== t) throw n("unavailable");
+				})), B = !0;
+			},
+			onActivate: (e) => E.tryPromise({
+				try: () => {
+					if (G) throw n("unavailable");
+					if (z) return Promise.resolve();
+					if (W || L && !B) throw n("unavailable");
+					let t = V, r = (async () => {
+						let r, i;
+						try {
+							if (!P) {
+								if (I) {
+									if (S(e.env) !== null) throw n("unavailable");
+									i = I;
+								} else {
+									if (!e.connectionRegistry) throw n("unavailable");
+									let t = e.connectionReference?.("hot", "redis") ?? j.connection;
+									if (r = O.make(T({
+										consumer: "@voltro/plugin-saves",
+										namespace: "voltro:saves",
+										...t ? { connection: t } : {}
+									}).pipe(D.provide(D.succeed(C, e.connectionRegistry)))), i = await r.runPromise(w), S(e.env) !== null && !i.capabilities.crossNode) throw n("unavailable");
+								}
+							}
+							if (t !== V || G) throw n("unavailable");
+							H = i, U = r, r = void 0, z = !0;
+						} finally {
+							await r?.dispose();
+						}
+					})();
+					return W = r, r.finally(() => {
+						W === r && (W = void 0);
+					});
+				},
+				catch: () => n("unavailable")
+			}),
+			onDeactivate: () => E.tryPromise({
+				try: () => {
+					if (G) return G;
+					z = !1, B = !1, V++, R = void 0, H = void 0;
+					let e = (async () => {
+						await W?.catch(() => {});
+						let e = U;
+						await e?.dispose(), U === e && (U = void 0);
+					})();
+					return G = e, e.then(() => {
+						G === e && (G = void 0);
+					});
+				},
+				catch: () => n("unavailable")
+			}),
+			onExport: (e, t) => Z.exportSubject({
+				subjectId: e,
+				tenantId: t.tenantId,
+				kind: t.kind
+			}),
+			onErase: (e, t) => Z.eraseSubject({
+				subjectId: e,
+				tenantId: t.tenantId,
+				kind: t.kind
+			}),
+			inspectEndpoints: [{
+				method: "GET",
+				path: "/status",
+				scope: "process",
+				description: "Configured save ownership, bounds and binding; no save, owner or device data.",
+				handler: () => E.sync(() => ({
+					kind: "json",
+					data: {
+						observedAt: Date.now(),
+						bound: z && B,
+						backend: P ? "custom" : "sql",
+						gameId: N.gameId,
+						version: N.version,
+						slots: N.slots,
+						validator: P ? "app-owned" : N.validator === u ? "default" : "custom",
+						budgets: P ? null : {
+							maxBytes: N.maxBytes,
+							historyVersions: N.historyVersions,
+							maxRequests: N.maxRequests,
+							deleteGraceMs: N.deleteGraceMs,
+							writesPerMinute: 10
+						},
+						schemaVersion: P ? null : N.schemaVersion,
+						rateActive: !P && z && B && H !== void 0,
+						tables: Q.map((e) => e.tableName),
+						offlineInstalled: !1,
+						signaturesInstalled: !1,
+						externalStorageInstalled: !1,
+						purgeInstalled: !1,
+						gmRollbackInstalled: !1
+					}
+				}))
+			}]
+		})
+	};
+};
+//#endregion
+export { A as savesPlugin, k as savesSystemContract };

package/dist/port.d.ts

@@ -0,0 +1,103 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare const captureSavesService: (input: SavesService) => SavesService;
+
+declare class SaveConflict extends SaveConflict_base {
+}
+
+declare const SaveConflict_base: Schema.Class<SaveConflict, Schema.TaggedStruct<"SaveConflict", {
+    readonly serverVersion: Schema.Number;
+    readonly server: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+    readonly client: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+}>, YieldableError>;
+
+declare interface SaveDeleteIntent {
+    readonly slot: string;
+    readonly requestId: string;
+    readonly baseVersion: number;
+}
+
+declare type SaveDocument = typeof SaveDocumentSchema.Type;
+
+declare const SaveDocumentSchema: Schema.Struct<{
+    readonly bytes: Schema.Uint8ArrayFromBase64;
+    readonly slot: Schema.String;
+    readonly version: Schema.Number;
+    readonly schemaVersion: Schema.Number;
+    readonly byteLength: Schema.Number;
+    readonly checksum: Schema.String;
+    readonly deviceId: Schema.String;
+    readonly clientVersion: Schema.String;
+    readonly savedAt: Schema.Number;
+    readonly summary: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+    readonly deletedUntil: Schema.NullOr<Schema.Number>;
+}>;
+
+declare type SaveError = SavesError | SaveConflict;
+
+declare type SaveHeader = typeof SaveHeaderSchema.Type;
+
+declare const SaveHeaderSchema: Schema.Struct<{
+    readonly slot: Schema.String;
+    readonly version: Schema.Number;
+    readonly schemaVersion: Schema.Number;
+    readonly byteLength: Schema.Number;
+    readonly checksum: Schema.String;
+    readonly deviceId: Schema.String;
+    readonly clientVersion: Schema.String;
+    readonly savedAt: Schema.Number;
+    readonly summary: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+    readonly deletedUntil: Schema.NullOr<Schema.Number>;
+}>;
+
+declare interface SavePutIntent {
+    readonly slot: string;
+    readonly requestId: string;
+    readonly baseVersion: number;
+    readonly schemaVersion: number;
+    readonly bytes: Uint8Array;
+    readonly deviceId: string;
+    readonly clientVersion: string;
+    readonly summary: SaveSummary;
+}
+
+declare interface SaveRollbackIntent {
+    readonly slot: string;
+    readonly requestId: string;
+    readonly baseVersion: number;
+    readonly version: number;
+}
+
+declare class SavesError extends SavesError_base {
+}
+
+declare const SavesError_base: Schema.Class<SavesError, Schema.TaggedStruct<"SavesError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "forbidden", "not_found", "erased", "limit_exceeded", "invalid_save", "rate_limited", "unavailable", "request_conflict"]>;
+}>, YieldableError>;
+
+export declare class SavesPort extends SavesPort_base {
+}
+
+declare const SavesPort_base: Context.ServiceClass<SavesPort, "@voltro/SavesPort", SavesService>;
+
+export declare interface SavesService {
+    readonly get: (subject: Subject, slot: string) => Effect.Effect<SaveDocument | null, SaveError>;
+    readonly list: (subject: Subject) => Effect.Effect<readonly SaveHeader[], SaveError>;
+    readonly history: (subject: Subject, slot: string) => Effect.Effect<readonly SaveHeader[], SaveError>;
+    readonly put: (subject: Subject, intent: SavePutIntent) => Effect.Effect<SaveHeader, SaveError>;
+    readonly rollback: (subject: Subject, intent: SaveRollbackIntent) => Effect.Effect<SaveHeader, SaveError>;
+    readonly remove: (subject: Subject, intent: SaveDeleteIntent) => Effect.Effect<SaveHeader, SaveError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, SaveError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, SaveError>;
+}
+
+declare type SaveSummary = typeof SaveSummarySchema.Type;
+
+declare const SaveSummarySchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+
+export { }

package/dist/port.js

@@ -0,0 +1,34 @@
+import { savesError as e } from "./errors.js";
+import { Context as t } from "effect";
+//#region src/port.ts
+var n = class extends t.Service()("@voltro/SavesPort") {}, r = (t) => {
+	if (typeof t != "object" || !t || Array.isArray(t)) throw e("invalid_input");
+	let n = Object.create(null);
+	for (let r of [
+		"get",
+		"list",
+		"history",
+		"put",
+		"rollback",
+		"remove",
+		"exportSubject",
+		"eraseSubject"
+	]) {
+		let i = t, a = !1;
+		for (let o = 0; i && o < 8; o++, i = Object.getPrototypeOf(i)) {
+			let o = Object.getOwnPropertyDescriptor(i, r);
+			if (o) {
+				if (!("value" in o) || typeof o.value != "function") throw e("invalid_input");
+				Object.defineProperty(n, r, {
+					value: o.value.bind(t),
+					enumerable: !0
+				}), a = !0;
+				break;
+			}
+		}
+		if (!a) throw e("invalid_input");
+	}
+	return Object.freeze(n);
+};
+//#endregion
+export { n as SavesPort, r as captureSavesService };

package/dist/rpc.d.ts

@@ -0,0 +1,128 @@
+import { ActionProcedureDescriptor } from '@voltro/protocol';
+import { PluginRpcClientDescriptor } from '@voltro/protocol';
+import { QueryProcedureDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+declare class SaveConflict extends SaveConflict_base {
+}
+
+declare const SaveConflict_base: Schema.Class<SaveConflict, Schema.TaggedStruct<"SaveConflict", {
+    readonly serverVersion: Schema.Number;
+    readonly server: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+    readonly client: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+}>, YieldableError>;
+
+declare class SavesError extends SavesError_base {
+}
+
+declare const SavesError_base: Schema.Class<SavesError, Schema.TaggedStruct<"SavesError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "forbidden", "not_found", "erased", "limit_exceeded", "invalid_save", "rate_limited", "unavailable", "request_conflict"]>;
+}>, YieldableError>;
+
+export declare const savesGetDescriptor: QueryProcedureDescriptor<"saves.get", Schema.Struct<{
+    readonly slot: Schema.NonEmptyString;
+}>, Schema.NullOr<Schema.Struct<{
+    readonly bytes: Schema.Uint8ArrayFromBase64;
+    readonly slot: Schema.String;
+    readonly version: Schema.Number;
+    readonly schemaVersion: Schema.Number;
+    readonly byteLength: Schema.Number;
+    readonly checksum: Schema.String;
+    readonly deviceId: Schema.String;
+    readonly clientVersion: Schema.String;
+    readonly savedAt: Schema.Number;
+    readonly summary: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+    readonly deletedUntil: Schema.NullOr<Schema.Number>;
+}>>, Schema.Union<readonly [typeof SavesError, typeof SaveConflict]>>;
+
+export declare const savesHistoryDescriptor: QueryProcedureDescriptor<"saves.history", Schema.Struct<{
+    readonly slot: Schema.NonEmptyString;
+}>, Schema.$Array<Schema.Struct<{
+    readonly slot: Schema.String;
+    readonly version: Schema.Number;
+    readonly schemaVersion: Schema.Number;
+    readonly byteLength: Schema.Number;
+    readonly checksum: Schema.String;
+    readonly deviceId: Schema.String;
+    readonly clientVersion: Schema.String;
+    readonly savedAt: Schema.Number;
+    readonly summary: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+    readonly deletedUntil: Schema.NullOr<Schema.Number>;
+}>>, Schema.Union<readonly [typeof SavesError, typeof SaveConflict]>>;
+
+export declare const savesListDescriptor: QueryProcedureDescriptor<"saves.list", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly slot: Schema.String;
+    readonly version: Schema.Number;
+    readonly schemaVersion: Schema.Number;
+    readonly byteLength: Schema.Number;
+    readonly checksum: Schema.String;
+    readonly deviceId: Schema.String;
+    readonly clientVersion: Schema.String;
+    readonly savedAt: Schema.Number;
+    readonly summary: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+    readonly deletedUntil: Schema.NullOr<Schema.Number>;
+}>>, Schema.Union<readonly [typeof SavesError, typeof SaveConflict]>>;
+
+export declare const savesPutDescriptor: ActionProcedureDescriptor<"saves.put", Schema.Struct<{
+    readonly schemaVersion: Schema.Number;
+    readonly bytes: Schema.Uint8ArrayFromBase64;
+    readonly deviceId: Schema.NonEmptyString;
+    readonly clientVersion: Schema.NonEmptyString;
+    readonly summary: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+    readonly slot: Schema.NonEmptyString;
+    readonly requestId: Schema.NonEmptyString;
+    readonly baseVersion: Schema.Number;
+}>, Schema.Struct<{
+    readonly slot: Schema.String;
+    readonly version: Schema.Number;
+    readonly schemaVersion: Schema.Number;
+    readonly byteLength: Schema.Number;
+    readonly checksum: Schema.String;
+    readonly deviceId: Schema.String;
+    readonly clientVersion: Schema.String;
+    readonly savedAt: Schema.Number;
+    readonly summary: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+    readonly deletedUntil: Schema.NullOr<Schema.Number>;
+}>, Schema.Union<readonly [typeof SavesError, typeof SaveConflict]>>;
+
+export declare const savesRemoveDescriptor: ActionProcedureDescriptor<"saves.remove", Schema.Struct<{
+    slot: Schema.NonEmptyString;
+    requestId: Schema.NonEmptyString;
+    baseVersion: Schema.Number;
+}>, Schema.Struct<{
+    readonly slot: Schema.String;
+    readonly version: Schema.Number;
+    readonly schemaVersion: Schema.Number;
+    readonly byteLength: Schema.Number;
+    readonly checksum: Schema.String;
+    readonly deviceId: Schema.String;
+    readonly clientVersion: Schema.String;
+    readonly savedAt: Schema.Number;
+    readonly summary: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+    readonly deletedUntil: Schema.NullOr<Schema.Number>;
+}>, Schema.Union<readonly [typeof SavesError, typeof SaveConflict]>>;
+
+export declare const savesRequestSource = "_voltro_saves_requests";
+
+export declare const savesRollbackDescriptor: ActionProcedureDescriptor<"saves.rollback", Schema.Struct<{
+    readonly version: Schema.Number;
+    readonly slot: Schema.NonEmptyString;
+    readonly requestId: Schema.NonEmptyString;
+    readonly baseVersion: Schema.Number;
+}>, Schema.Struct<{
+    readonly slot: Schema.String;
+    readonly version: Schema.Number;
+    readonly schemaVersion: Schema.Number;
+    readonly byteLength: Schema.Number;
+    readonly checksum: Schema.String;
+    readonly deviceId: Schema.String;
+    readonly clientVersion: Schema.String;
+    readonly savedAt: Schema.Number;
+    readonly summary: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>>;
+    readonly deletedUntil: Schema.NullOr<Schema.Number>;
+}>, Schema.Union<readonly [typeof SavesError, typeof SaveConflict]>>;
+
+export declare const savesRpcClientImports: readonly PluginRpcClientDescriptor[];
+
+export { }

package/dist/rpc.js

@@ -0,0 +1,86 @@
+import { SaveConflict as e, SaveSummarySchema as t, SavesError as n } from "./errors.js";
+import { SAVE_HISTORY_TABLE as r, SAVE_REQUEST_TABLE as i, SAVE_SUBJECT_TABLE as a, SAVE_TABLE as o, SaveDocumentSchema as s, SaveHeaderSchema as c } from "./contract.js";
+import { Schema as l } from "effect";
+import { defineAction as u, defineQuery as d } from "@voltro/protocol";
+//#region src/rpc.ts
+var f = "Only the authenticated owner in the configured game and exact tenant may read or change opaque saves. Saves never grant server-owned values.", p = l.NonEmptyString, m = l.Number.pipe(l.check(l.isInt()), l.check(l.isBetween({
+	minimum: 0,
+	maximum: 2147483647
+}))), h = l.Union([n, e]), g = [o, a], _ = l.Struct({ slot: p }), v = {
+	slot: p,
+	requestId: p,
+	baseVersion: m
+}, y = d({
+	name: "saves.get",
+	input: _,
+	output: l.NullOr(s),
+	source: g,
+	error: h,
+	openAccess: f
+}), b = d({
+	name: "saves.list",
+	input: l.Struct({}),
+	output: l.Array(c),
+	source: g,
+	error: h,
+	openAccess: f
+}), x = d({
+	name: "saves.history",
+	input: _,
+	output: l.Array(c),
+	source: [r, a],
+	error: h,
+	openAccess: f
+}), S = u({
+	name: "saves.put",
+	input: l.Struct({
+		...v,
+		schemaVersion: m,
+		bytes: l.Uint8ArrayFromBase64,
+		deviceId: p,
+		clientVersion: p,
+		summary: t
+	}),
+	output: c,
+	error: h,
+	openAccess: f
+}), C = u({
+	name: "saves.rollback",
+	input: l.Struct({
+		...v,
+		version: m
+	}),
+	output: c,
+	error: h,
+	openAccess: f
+}), w = u({
+	name: "saves.remove",
+	input: l.Struct(v),
+	output: c,
+	error: h,
+	openAccess: f
+}), T = i, E = [...[
+	"Get",
+	"List",
+	"History"
+].map((e) => ({
+	tag: "saves." + e.toLowerCase(),
+	kind: "query",
+	import: {
+		module: "@voltro/plugin-saves/rpc",
+		name: "saves" + e + "Descriptor"
+	}
+})), ...[
+	"Put",
+	"Rollback",
+	"Remove"
+].map((e) => ({
+	tag: "saves." + e.toLowerCase(),
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-saves/rpc",
+		name: "saves" + e + "Descriptor"
+	}
+}))];
+//#endregion
+export { y as savesGetDescriptor, x as savesHistoryDescriptor, b as savesListDescriptor, S as savesPutDescriptor, w as savesRemoveDescriptor, T as savesRequestSource, C as savesRollbackDescriptor, E as savesRpcClientImports };