@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/replaySchema.js

@@ -0,0 +1,156 @@
+import { ProtocolError as e } from "./errors.js";
+import { RoomTransform as t, fieldId as n, precision as r, quantized as i } from "./room.js";
+import { captureTransformRules as a } from "./transformRules.js";
+import { RoomStateCodec as o } from "./stateCodec.js";
+import { definedOnly as s } from "./resolvedOptions.js";
+import { Result as c, Schema as l } from "effect";
+// src/replaySchema.ts
+function u() {
+	throw new e({ detail: "Invalid or unsupported archived binary schema" });
+}
+var d = (e) => {
+	if (typeof e != "object" || !e || Array.isArray(e) || ![Object.prototype, null].includes(Object.getPrototypeOf(e))) return u();
+	let t = Object.create(null);
+	for (let n of Reflect.ownKeys(e)) {
+		let r = Object.getOwnPropertyDescriptor(e, n);
+		if (typeof n != "string" || !r || !r.enumerable || !Object.hasOwn(r, "value")) return u();
+		t[n] = r.value;
+	}
+	return t;
+}, f = (e, t) => {
+	try {
+		return l.decodeUnknownSync(e)(t, { onExcessProperty: "error" });
+	} catch {
+		return u();
+	}
+}, p = (e, t, n) => {
+	let r = e === void 0 ? t : e;
+	return typeof r == "number" && Number.isSafeInteger(r) && r > 0 && r <= n ? r : u();
+}, m = l.Struct({
+	min: l.Number,
+	max: l.Number,
+	step: l.optional(l.Number),
+	bits: l.optional(l.Int)
+}), h = l.Struct({
+	kind: l.Literal("number"),
+	integer: l.Boolean,
+	precision: l.Literals(["f32", "f64"]),
+	q: l.optional(m),
+	wrap: l.optional(l.Int)
+}), g = l.Struct({
+	name: l.String,
+	id: l.Int,
+	optional: l.Boolean,
+	node: l.Unknown,
+	omit: l.optional(l.Literal(!0))
+}), _ = l.Struct({
+	kind: l.Literals(["struct", "transform3d"]),
+	fields: l.Array(g),
+	transform: l.optional(l.Unknown)
+}), v = l.Struct({
+	maxBytes: l.optional(l.Int),
+	maxCollectionLength: l.optional(l.Int),
+	maxFieldId: l.optional(l.Int)
+}), y = {
+	maxSpeed: l.Number,
+	maxAccel: l.Number,
+	precision: l.Number,
+	rotation: l.optional(l.Struct({ bits: l.Int })),
+	interpolation: l.Literals([
+		"linear",
+		"hermite",
+		"none"
+	]),
+	extrapolateMs: l.Number,
+	teleportThreshold: l.Number
+}, b = l.Struct({
+	...y,
+	bounds: l.Struct({
+		min: l.Tuple([l.Number, l.Number]),
+		max: l.Tuple([l.Number, l.Number])
+	}),
+	velocity: l.optional(l.Literals([
+		"send",
+		"derive",
+		"none"
+	]))
+}), x = l.Struct({
+	...y,
+	bounds: l.Struct({
+		min: l.Tuple([
+			l.Number,
+			l.Number,
+			l.Number
+		]),
+		max: l.Tuple([
+			l.Number,
+			l.Number,
+			l.Number
+		])
+	})
+}), S = (g, y = {}) => {
+	try {
+		let e = d(y);
+		for (let t of Object.keys(e)) [
+			"maxDescriptionBytes",
+			"maxSchemaNodes",
+			"maxSchemaDepth",
+			"codecLimits"
+		].includes(t) || u();
+		let S = p(e.maxDescriptionBytes, 262144, 1048576), C = p(e.maxSchemaNodes, 16384, 65536), w = p(e.maxSchemaDepth, 32, 64), T = e.codecLimits === void 0 ? {} : f(v, d(e.codecLimits));
+		(typeof g != "string" || g.length === 0 || g.length > S || !g.isWellFormed() || new TextEncoder().encode(g).length > S) && u();
+		let E = JSON.parse(g), D = 0, O = (e, o, s = !1) => {
+			(++D > C || o > w) && u();
+			let c = d(e), p = c.kind;
+			if (s && p !== "number" && u(), p === "number") {
+				let e = f(h, c);
+				if (s) return e.integer && u(), l.Number;
+				e.wrap !== void 0 && u();
+				let t = e.integer ? l.Int : l.Number;
+				if (t = t.pipe(r(e.precision)), e.q) {
+					let e = c.q;
+					if (!l.is(m)(e)) return u();
+					t = t.pipe(i(e));
+				}
+				return t;
+			}
+			if (p === "string" || p === "boolean") return f(l.Struct({ kind: l.Literals(["string", "boolean"]) }), c), p === "string" ? l.String : l.Boolean;
+			if (p === "literal") {
+				let e = f(l.Struct({
+					kind: l.Literal("literal"),
+					values: l.Array(l.Union([
+						l.String,
+						l.Number,
+						l.Boolean,
+						l.Null
+					]))
+				}), c);
+				return (e.values.length < 1 || e.values.length > 256) && u(), l.Union(e.values.map((e) => e === null ? l.Null : l.Literal(e)));
+			}
+			if (p === "array" || p === "record") {
+				let e = f(l.Struct({
+					kind: l.Literals(["array", "record"]),
+					element: l.Unknown
+				}), c), t = O(e.element, o + 1);
+				return p === "array" ? l.Array(t) : l.Record(l.String, t);
+			}
+			if (p === "struct" || p === "transform3d") {
+				let e = f(_, c);
+				e.fields.length > C - D && u();
+				let r = e.transform === void 0 ? void 0 : a(f(l.Union([b, x]), e.transform));
+				(p === "transform3d" && (r === void 0 || r.bounds.min.length !== 3) || p === "struct" && r !== void 0 && r.bounds.min.length !== 2) && u();
+				let i = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), d = e.fields.map((e) => {
+					(!e.name.isWellFormed() || i.has(e.name) || s.has(e.id)) && u(), i.add(e.name), s.add(e.id);
+					let t = O(e.node, o + 1, r !== void 0).pipe(n(e.id));
+					return [e.name, e.optional ? l.optional(t) : t];
+				}), m = l.Struct(Object.fromEntries(d));
+				return r === void 0 ? m : m.annotate({ [t]: r });
+			}
+			return u();
+		}, k = l.make(O(E, 0).ast), A = new o(k, T === void 0 ? {} : s(T));
+		return A.schemaDescription() !== g && u(), c.succeed(A);
+	} catch (t) {
+		return c.fail(t instanceof e ? t : new e({ detail: "Invalid or unsupported archived binary schema" }));
+	}
+};
+export { S as restoreReplayCodec };

package/dist/replayStorage.d.ts

@@ -0,0 +1,149 @@
+import { Context } from 'effect';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { Layer } from 'effect';
+import { PluginPrivacyRequest } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { StorageObjectMetadata } from '@voltro/plugin-storage';
+import { StorageServiceShape } from '@voltro/plugin-storage';
+import { TableLike } from '@voltro/database';
+import { YieldableError } from 'effect/Cause';
+
+/** Shared exact own-data admission for a durable publication or host recording.
+ * No bytes, resource acquisition, authorization or write happens here. */
+export declare const captureRoomReplayMetadata: (input: unknown, maxParticipants?: number) => RoomReplayPublicationMetadata;
+
+/** SQL index/journal is truth; borrowed StorageService owns provider operations
+ * and claims. Every remote effect runs outside a SQL transaction and the tick.
+ * Explicit all-node authority is required; this does not invent a default. */
+export declare const dataStoreRoomReplays: (store: DataStore, options: RoomReplayStoreOptions) => Context.Service.Shape<typeof RoomReplayPort>;
+
+declare class ProtocolError extends ProtocolError_base {
+    get message(): string;
+}
+
+declare const ProtocolError_base: Schema.Class<ProtocolError, Schema.TaggedStruct<"ProtocolError", {
+    readonly detail: Schema.String;
+}>, YieldableError>;
+
+declare interface ReplaySchemaOptions {
+    readonly maxDescriptionBytes?: number | undefined;
+    readonly maxSchemaNodes?: number | undefined;
+    readonly maxSchemaDepth?: number | undefined;
+    readonly codecLimits?: Partial<RoomCodecLimits> | undefined;
+}
+
+export declare const ROOM_REPLAYS_TABLE = "_voltro_replays";
+
+declare interface RoomCodecLimits {
+    readonly maxBytes: number;
+    readonly maxCollectionLength: number;
+    readonly maxFieldId: number;
+}
+
+export declare interface RoomReplayAuthority {
+    authorize(scope: RoomReplayScope, operation: 'publish' | 'load' | 'erase'): Effect.Effect<void, unknown>;
+    /** Fence and await every publisher/reader of this replay on all nodes. */
+    withdraw(scope: RoomReplayScope, requestId: string): Effect.Effect<void, unknown>;
+    authorizeSubject(request: PluginPrivacyRequest, operation: 'rooms' | 'export'): Effect.Effect<void, unknown>;
+    /** Permanent subject association fence + await accepted work, not a flag. */
+    withdrawSubject(request: PluginPrivacyRequest): Effect.Effect<void, unknown>;
+}
+
+export declare const roomReplayLayer: (store: DataStore, options: RoomReplayStoreOptions) => Layer.Layer<RoomReplayPort>;
+
+declare interface RoomReplayLimits {
+    readonly maxBytes: number;
+    readonly maxFrameBytes: number;
+    readonly maxFrames: number;
+    readonly maxHighlights: number;
+    readonly maxSchemaBytes: number;
+    readonly maxDurationMs: number;
+    readonly checkpointEveryMs: number;
+}
+
+/** Browser-safe trusted server contract. No player mutation or storage adapter
+ * is imported at value level; replacement services use this exact Tag. */
+export declare class RoomReplayPort extends RoomReplayPort_base {
+}
+
+declare const RoomReplayPort_base: Context.ServiceClass<RoomReplayPort, "@voltro/RoomReplayPort", {
+    publish(input: RoomReplayPublish): Effect.Effect<RoomStoredReplay, ProtocolError>;
+    load(scope: RoomReplayScope): Effect.Effect<Uint8Array, ProtocolError>;
+    erase(scope: RoomReplayScope, requestId: string): Effect.Effect<void, ProtocolError>;
+    expire(scope: RoomReplayScope, requestId: string): Effect.Effect<void, ProtocolError>;
+    subjectRooms(request: PluginPrivacyRequest): Effect.Effect<ReadonlyArray<string>, ProtocolError>;
+    eraseSubject(request: PluginPrivacyRequest): Effect.Effect<void, ProtocolError>;
+    exportSubject(request: PluginPrivacyRequest, roomId?: string): Effect.Effect<ReadonlyArray<RoomStoredReplay>, ProtocolError>;
+}>;
+
+export declare type RoomReplayPublicationMetadata = Omit<RoomReplayPublish, 'bytes'>;
+
+export declare interface RoomReplayPublish extends RoomReplayScope {
+    readonly roomId: string;
+    readonly roomName: string;
+    readonly matchId: string;
+    readonly participants: ReadonlyArray<string>;
+    readonly visibility: 'private' | 'unlisted' | 'public';
+    readonly expiresAtMs: number | null;
+    readonly bytes: Uint8Array;
+}
+
+export declare interface RoomReplayScope {
+    readonly tenantId: string;
+    readonly replayId: string;
+}
+
+export declare interface RoomReplayStoreOptions {
+    readonly storage: Pick<StorageServiceShape, 'put' | 'head' | 'getStream' | 'delete'>;
+    readonly operations: {
+        readonly bucket: string;
+        readonly metadata: Pick<StorageObjectMetadata, 'lookup'>;
+    };
+    readonly authority: RoomReplayAuthority;
+    readonly epochNow: () => number;
+    readonly maxTenantReplays?: number;
+    readonly maxParticipants?: number;
+    readonly replayLimits?: Partial<RoomReplayLimits>;
+    readonly schemaOptions?: ReplaySchemaOptions;
+}
+
+/** Explicit application schema contribution; not automatically installed by
+ * roomsPlugin until its normal privacy/binding/panel integration is supplied. */
+export declare const roomReplayTable: TableLike;
+
+export declare interface RoomStoredReplay {
+    readonly replayId: string;
+    readonly roomId: string;
+    readonly roomName: string;
+    readonly matchId: string;
+    readonly visibility: RoomReplayPublish['visibility'];
+    readonly expiresAtMs: number | null;
+    readonly durationMs: number;
+    readonly size: number;
+    readonly schemaHash: number;
+}
+
+declare interface RoomSubjectDataPolicy {
+    /** Permanently fence this Subject on every writer, await accepted work and
+     * persist that authority before returning. Idempotent by trusted requestId. */
+    withdraw(request: PluginPrivacyRequest): Effect.Effect<void, unknown>;
+    /** After the permanent SQL fence, before Room selection/destruction.
+     * Durable/idempotent by requestId; join/erase dependent geometry writers. */
+    readonly afterFence?: (request: PluginPrivacyRequest) => Effect.Effect<void, unknown>;
+    /** Complete app-owned room associations beyond SQL seats, including state,
+     * replay and command references. Never truncate or infer them from payloads. */
+    rooms(request: PluginPrivacyRequest): Effect.Effect<ReadonlyArray<string>, unknown>;
+    /** Remove app-owned references only after every selected room is erased.
+     * Must survive lost replies under the same trusted request identity. */
+    eraseAssociations(request: PluginPrivacyRequest): Effect.Effect<void, unknown>;
+    /** Explicit lossless JSON projection for this target; never export a shared
+     * room's raw state/commands or other players by default. */
+    exportRoom(roomId: string, request: PluginPrivacyRequest): Effect.Effect<unknown, unknown>;
+}
+
+/** Compose into the actual supplied Rooms Subject policy. The base still owns
+ * distributed withdrawal and shared-room projection; no successful fake policy. */
+export declare const withRoomReplayPrivacy: (policy: RoomSubjectDataPolicy, port: Context.Service.Shape<typeof RoomReplayPort>) => RoomSubjectDataPolicy;
+
+export { }