@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryRollbackStore.js

@@ -0,0 +1,197 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { verifyGeometryArtifact as r } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as i, captureGeometryOwner as a, captureGeometryPersistenceScope as o, captureGeometryReceipt as s, captureGeometrySubject as c, geometryPersistenceInteger as l } from "./geometryPersistenceData.js";
+import { decodeGeometryPatch as u } from "./geometryPatch.js";
+import { assertRoomSubjectAdmission as d } from "./subjectAdmission.js";
+import { captureRoomSnapshotEffectRunner as f } from "./snapshotBlobIndex.js";
+import { captureGeometryStoredVersion as p, geometryPersistenceDigest as m, geometryPersistenceScopeKey as h, geometryPersistenceVersionKey as g } from "./geometryPersistenceCapture.js";
+import { assertGeometrySqlOwner as _ } from "./geometrySqlOwner.js";
+import { makeGeometryJournalPatchReader as v } from "./geometryJournalPatch.js";
+import { GEO_JOURNAL_TABLE as y, GEO_VERSIONS_TABLE as b } from "./geometryPersistence.js";
+import { prepareGeometryRollback as x } from "./geometryRollback.js";
+import { and as S, eq as C } from "@voltro/database";
+import { Context as w, Effect as T, Layer as E } from "effect";
+// src/geometryRollbackStore.ts
+var D = class extends w.Service()("@voltro/GeometryRollbackPreparationPort") {};
+function O() {
+	throw new t({ detail: "Geometry SQL rollback journal remains unconfirmed" });
+}
+var k = (e, t) => JSON.stringify(e) === JSON.stringify(t), A = (e) => E.succeed(D, e), j = (w, E) => {
+	let D = n(E, [
+		"persistence",
+		"staticSource",
+		"authorize",
+		"preparation",
+		"maxEntries",
+		"maxJournalBytes",
+		"maxManifestChunks",
+		"maxManifestBytes",
+		"journalArchiveIndex"
+	], [
+		"persistence",
+		"staticSource",
+		"authorize"
+	]), A = n(D.persistence, [
+		"publish",
+		"observe",
+		"commit",
+		"exportSubject",
+		"eraseSubject"
+	]), j = n(D.staticSource, ["load"]), M = A.observe, N = j.load, P = D.authorize, F = n(D.preparation ?? {}, [
+		"maxEntries",
+		"maxJournalBytes",
+		"maxCells",
+		"maxComparedCells",
+		"codecLimits",
+		"strategies"
+	], []), I = (e, t, n) => Object.hasOwn(D, e) ? l(D[e], 1, n) : t, L = I("maxEntries", 4096, 65536), R = I("maxJournalBytes", 16777216, 268435456), z = I("maxManifestChunks", 256, 4096), B = I("maxManifestBytes", 262144, 16777216);
+	if (typeof M != "function" || typeof N != "function" || typeof P != "function") return O();
+	let V = M, H = N, U = P, W = Object.hasOwn(F, "codecLimits") ? Object.freeze({ ...n(F.codecLimits, [
+		"maxSide",
+		"maxCells",
+		"maxPalette",
+		"maxRuns",
+		"maxBytes",
+		"maxSamples",
+		"maxShapes",
+		"maxVoxels",
+		"maxSections",
+		"maxRunsPerSection"
+	], []) }) : void 0, G = Object.hasOwn(F, "strategies") ? Object.freeze({ ...n(F.strategies, ["rebaseHeight"], []) }) : void 0, K = Object.freeze({
+		...F,
+		...W ? { codecLimits: W } : {},
+		...G ? { strategies: G } : {}
+	}), q = v({ ...Object.hasOwn(D, "journalArchiveIndex") ? { archive: D.journalArchiveIndex } : {} }), J = Object.freeze({
+		maxEntries: 65536,
+		maxJournalBytes: 268435456,
+		maxCells: 1048576,
+		maxComparedCells: 1073741824
+	});
+	for (let [e, t] of Object.entries(J)) Object.hasOwn(F, e) && l(F[e], 1, t);
+	if (G && Object.hasOwn(G, "rebaseHeight") && typeof G.rebaseHeight != "function") return O();
+	let Y = Object.hasOwn(F, "maxEntries") ? l(F.maxEntries, 1, 65536) : L, X = Object.hasOwn(F, "maxJournalBytes") ? l(F.maxJournalBytes, 1, 268435456) : R;
+	return Object.freeze({ prepare: (l) => {
+		let v;
+		try {
+			let e = n(l, [
+				"scope",
+				"owner",
+				"subject",
+				"target"
+			]);
+			v = Object.freeze({
+				scope: o(e.scope),
+				owner: a(e.owner),
+				subject: c(e.subject),
+				target: e.target === null ? null : c(e.target)
+			});
+		} catch {
+			return T.fail(new t({ detail: "Geometry rollback request could not be captured" }));
+		}
+		return T.flatMap(T.context(), (n) => T.uninterruptible(T.tryPromise({
+			try: async () => {
+				let t = f(n), o = async (e) => T.isEffect(e) ? t(e) : O(), { scope: l, owner: E, subject: D } = v;
+				if (await o(U(v)) !== void 0) return O();
+				let A = await w.transactional(async (t) => {
+					let n = await t.query({
+						table: b,
+						predicate: S(C("tenantId", l.tenantId), C("versionKey", g(l))),
+						order: [{
+							column: "id",
+							direction: "asc"
+						}],
+						take: 2,
+						skip: void 0,
+						projection: void 0,
+						lock: "update"
+					});
+					if (n.length !== 1) return O();
+					await _(t, l, E), await d(t, {
+						tenantId: l.tenantId,
+						subjectId: D.id
+					}), v.target !== null && await d(t, {
+						tenantId: l.tenantId,
+						subjectId: v.target.id
+					});
+					let r = await t.query({
+						table: y,
+						predicate: S(C("tenantId", l.tenantId), C("scopeKey", h(l))),
+						order: [{
+							column: "id",
+							direction: "asc"
+						}],
+						take: L + 1,
+						skip: void 0,
+						projection: void 0,
+						lock: "update"
+					});
+					if (r.length > L) throw new e({
+						budget: "geometryRollbackJournalEntries",
+						limit: L
+					});
+					return {
+						versions: n,
+						rows: r
+					};
+				}), j = await (async () => {
+					let { versions: t, rows: n } = A, r = 0, i = [];
+					for (let t of n) {
+						let n = s(t.receipt), d = c({
+							id: t.subjectId,
+							kind: t.subjectKind
+						}), f = a(t.owner), p = u(await o(q(t))), g = p.bytes(), _ = p.metadata;
+						if (r += g.length + new TextEncoder().encode(JSON.stringify(n)).length, r > R) throw new e({
+							budget: "geometryRollbackJournalBytes",
+							limit: R
+						});
+						if (t.tenantId !== l.tenantId || t.scopeKey !== h(l) || !k(n.scope, l) || t.requestKey !== m(JSON.stringify([l.tenantId, n.requestId])) || t.requestDigest !== m(JSON.stringify([
+							l,
+							f,
+							d,
+							n.requestId,
+							m(g)
+						])) || _.kind !== l.kind || _.worldId !== l.worldId || _.layerSetId !== l.layerSetId || _.version !== l.version || _.cx !== l.cx || _.cy !== l.cy || _.cz !== l.cz || _.baseRevision !== n.baseRevision || _.revision !== n.revision || _.changed !== n.changed || _.blobSha256 !== n.blobSha256 || _.contentSha256 !== n.contentSha256) return O();
+						i.push({
+							subject: d,
+							patch: g,
+							baseRevision: n.baseRevision,
+							changed: n.changed
+						});
+					}
+					return i.sort((e, t) => e.baseRevision - t.baseRevision || Number(e.changed) - Number(t.changed)), {
+						manifest: p(t[0], l, z, B),
+						entries: i.map((e) => Object.freeze({
+							subject: e.subject,
+							patch: e.patch
+						}))
+					};
+				})(), M = j.manifest.chunks.find((e) => h(e) === h(l));
+				if (!M) return O();
+				let N = await r(l.kind, await o(H(M)), M.blobSha256, K.codecLimits ?? {});
+				if (i(N, l), N.contentSha256 !== M.contentSha256) return O();
+				let P = await o(V(l));
+				if (!k(P.scope, l)) return O();
+				let F = await x(N, 0, P.artifact, P.revision, j.entries, v.target, {
+					...K,
+					maxEntries: Y,
+					maxJournalBytes: X
+				});
+				if (await o(U(v)) !== void 0) return O();
+				await w.transactional(async (e) => {
+					await _(e, l, E), await d(e, {
+						tenantId: l.tenantId,
+						subjectId: D.id
+					}), v.target !== null && await d(e, {
+						tenantId: l.tenantId,
+						subjectId: v.target.id
+					});
+				});
+				let I = await o(V(l));
+				return !k(I.scope, l) || I.revision !== P.revision || I.artifact.blobSha256 !== P.artifact.blobSha256 || I.artifact.contentSha256 !== P.artifact.contentSha256 ? O() : F;
+			},
+			catch: (n) => n instanceof e || n instanceof t ? n : new t({ detail: "Geometry SQL rollback journal remains unconfirmed" })
+		})));
+	} });
+};
+export { D as GeometryRollbackPreparationPort, j as dataStoreGeometryRollbackPreparation, A as geometryRollbackPreparationLayer };

package/dist/geometrySchemas.js

@@ -0,0 +1,26 @@
+import { fieldId as e } from "./room.js";
+import { Schema as t } from "effect";
+// src/geometrySchemas.ts
+var n = t.Struct({
+	worldId: t.String.pipe(e(1)),
+	layerSetId: t.String.pipe(e(2)),
+	cx: t.Int.pipe(e(3)),
+	cy: t.Int.pipe(e(4))
+}), r = t.Struct({
+	key: t.String.pipe(e(1)),
+	solid: t.Boolean.pipe(e(2))
+}), i = t.Struct({
+	paletteIndex: t.Int.pipe(e(1)),
+	length: t.Int.pipe(e(2))
+}), a = t.Struct({
+	kind: t.Literal("2d-tiles").pipe(e(1)),
+	formatVersion: t.Literal(1).pipe(e(2)),
+	address: n.pipe(e(3)),
+	version: t.String.pipe(e(4)),
+	width: t.Int.pipe(e(5)),
+	height: t.Int.pipe(e(6)),
+	tileSizeRaw: t.Int.pipe(e(7)),
+	palette: t.Array(r).pipe(e(8)),
+	runs: t.Array(i).pipe(e(9))
+});
+export { n as GeometryChunkAddressSchema, a as GeometryTileChunkSchema, r as GeometryTileMaterialSchema, i as GeometryTileRunSchema };