@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryCatalogueDigest.js

@@ -0,0 +1,110 @@
+import { geometryTileRefusal as e } from "./geometryTileCodec.js";
+// src/geometryCatalogueDigest.ts
+var t = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]), n = (e, t) => e >>> t | e << 32 - t, r = (r) => {
+	if (typeof r != "string" || r.length > 16777216) return e();
+	let i = new TextEncoder().encode(r);
+	if (i.length > 16777216) return e();
+	let a = Math.ceil((i.length + 9) / 64) * 64, o = i.length * 8, s = new Uint32Array([
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	]), c = /* @__PURE__ */ new Uint32Array(64), l = (e) => e < i.length ? i[e] : e === i.length ? 128 : e >= a - 4 ? o >>> (a - 1 - e) * 8 & 255 : 0;
+	for (let e = 0; e < a; e += 64) {
+		for (let t = 0; t < 16; t++) {
+			let n = e + t * 4;
+			c[t] = (l(n) << 24 | l(n + 1) << 16 | l(n + 2) << 8 | l(n + 3)) >>> 0;
+		}
+		for (let e = 16; e < 64; e++) {
+			let t = c[e - 15], r = c[e - 2], i = n(t, 7) ^ n(t, 18) ^ t >>> 3, a = n(r, 17) ^ n(r, 19) ^ r >>> 10;
+			c[e] = c[e - 16] + i + c[e - 7] + a >>> 0;
+		}
+		let r = s[0], i = s[1], a = s[2], o = s[3], u = s[4], d = s[5], f = s[6], p = s[7];
+		for (let e = 0; e < 64; e++) {
+			let s = p + (n(u, 6) ^ n(u, 11) ^ n(u, 25)) + (u & d ^ ~u & f) + t[e] + c[e] >>> 0, l = (n(r, 2) ^ n(r, 13) ^ n(r, 22)) + (r & i ^ r & a ^ i & a) >>> 0;
+			p = f, f = d, d = u, u = o + s >>> 0, o = a, a = i, i = r, r = s + l >>> 0;
+		}
+		let m = [
+			r,
+			i,
+			a,
+			o,
+			u,
+			d,
+			f,
+			p
+		];
+		for (let e = 0; e < 8; e++) s[e] = s[e] + m[e] >>> 0;
+	}
+	return c.fill(0), i.fill(0), Array.from(s, (e) => e.toString(16).padStart(8, "0")).join("");
+};
+export { r as geometryCatalogueDigest };

package/dist/geometryCellCoverage.js

@@ -0,0 +1,84 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { geometryPersistenceInteger as r } from "./geometryPersistenceData.js";
+import { captureGeometryPreparedScope as i } from "./geometryPrepared.js";
+import { captureWorldCatalog as a, worldCellAt as o, worldZoneAt as s } from "./world.js";
+// src/geometryCellCoverage.ts
+function c() {
+	throw new t({ detail: "World cell geometry needs exact complete declared coverage and chunk ownership" });
+}
+var l = (e) => {
+	let t = e * 65536;
+	return Number.isSafeInteger(t) ? t === 0 ? 0 : t : c();
+}, u = (e) => typeof e == "number" && Number.isSafeInteger(e) ? e === 0 ? 0 : e : c(), d = (e, t, n) => e >= t ? c() : {
+	minimum: r(Math.floor(e / n), -2147483648),
+	maximum: r(Math.ceil(t / n) - 1, -2147483648)
+}, f = (e, t) => {
+	let n = a([e])[0], i = n.geometry;
+	if (!i) return c();
+	let o = i.chunkSizeRaw;
+	return p(n, o, r(t.cx, -2147483648), r(t.cy, -2147483648), l(n.map.bounds[0][0]), l(n.map.bounds[0][1]), l(n.map.bounds[1][0]), l(n.map.bounds[1][1]));
+}, p = (e, t, n, r, i, a, c, l) => {
+	let d = u(Math.max(i, Math.min(c - 1, n * t + Math.floor(t / 2)))), f = u(Math.max(a, Math.min(l - 1, r * t + Math.floor(t / 2)))), p = [d / 65536, f / 65536];
+	return o(e, {
+		zone: s(e, p).id,
+		at: p
+	});
+}, m = (t, i = {}) => {
+	let o = a([t])[0], s = o.geometry, f = n(i, ["maxChunks", "vertical"], []);
+	if (!s) return c();
+	let p = s.kind === "3d-shapes" || s.kind === "3d-voxel", m = s.chunkSizeRaw, h = Object.hasOwn(f, "maxChunks") ? r(f.maxChunks, 1, 65536) : 4096, g = d(l(o.map.bounds[0][0]), l(o.map.bounds[1][0]), m), _ = d(l(o.map.bounds[0][1]), l(o.map.bounds[1][1]), m);
+	if (Object.hasOwn(f, "vertical") !== p) return c();
+	let v = 0, y = 0;
+	if (p) {
+		let e = n(f.vertical, ["minimumRaw", "maximumRaw"]), t = d(u(e.minimumRaw), u(e.maximumRaw), m);
+		v = t.minimum, y = t.maximum;
+	}
+	let b = (g.maximum - g.minimum + 1) * (_.maximum - _.minimum + 1) * (y - v + 1);
+	if (!Number.isSafeInteger(b) || b > h) throw new e({
+		budget: "geometryMapChunks",
+		limit: h
+	});
+	let x = [];
+	for (let e = v; e <= y; e++) for (let t = _.minimum; t <= _.maximum; t++) for (let n = g.minimum; n <= g.maximum; n++) x.push(Object.freeze({
+		cx: n,
+		cy: t,
+		...p ? { cz: e } : {}
+	}));
+	return Object.freeze(x);
+}, h = (t, s, f, m = {}) => {
+	let h = a([t])[0], g = h.geometry, _ = i(s), v = n(m, ["maxChunks", "vertical"], []), y = o(h, f);
+	if (!g || _.worldId !== h.name || _.kind !== g.kind) return c();
+	let b = Object.hasOwn(v, "maxChunks") ? r(v.maxChunks, 1, g.budgets.maxPreparedChunks) : g.budgets.maxPreparedChunks, x = _.kind === "3d-shapes" || _.kind === "3d-voxel", S = g.chunkSizeRaw, C = g.streaming.cell.marginChunks, w = l(h.map.bounds[0][0]), T = l(h.map.bounds[0][1]), E = l(h.map.bounds[1][0]), D = l(h.map.bounds[1][1]), O = d(w, E, S), k = d(T, D, S), A = d(l(y.bounds[0][0]), l(y.bounds[1][0]), S), j = d(l(y.bounds[0][1]), l(y.bounds[1][1]), S), M = Math.max(O.minimum, A.minimum - C), N = Math.min(O.maximum, A.maximum + C), P = Math.max(k.minimum, j.minimum - C), F = Math.min(k.maximum, j.maximum + C);
+	if (Object.hasOwn(v, "vertical") !== x) return c();
+	let I = 0, L = 0;
+	if (x) {
+		let e = n(v.vertical, ["minimumRaw", "maximumRaw"]), t = d(u(e.minimumRaw), u(e.maximumRaw), S);
+		I = t.minimum, L = t.maximum;
+	}
+	let R = (N - M + 1) * (F - P + 1) * (L - I + 1);
+	if (!Number.isSafeInteger(R) || R < 1 || R > b) throw new e({
+		budget: "geometryCellPreparedChunks",
+		limit: b
+	});
+	let z = [];
+	for (let e = I; e <= L; e++) for (let t = P; t <= F; t++) for (let n = M; n <= N; n++) {
+		let r = p(h, S, n, t, w, T, E, D), i = Object.freeze({
+			cx: n,
+			cy: t,
+			...x ? { cz: e } : {}
+		});
+		z.push(Object.freeze({
+			coordinate: i,
+			ownerCellId: r.id,
+			writable: r.id === y.id
+		}));
+	}
+	return Object.freeze({
+		scope: _,
+		cell: y,
+		marginChunks: C,
+		chunks: Object.freeze(z)
+	});
+};
+export { h as worldCellGeometryCoverage, f as worldGeometryChunkOwner, m as worldGeometryMapCoordinates };

package/dist/geometryCellLoader.js

@@ -0,0 +1,27 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { worldCellGeometryCoverage as r } from "./geometryCellCoverage.js";
+import { loadPreparedWorldGeometry as i } from "./geometryLoader.js";
+import { Effect as a } from "effect";
+// src/geometryCellLoader.ts
+var o = (o, s, c, l = {}) => {
+	try {
+		let e = n(l, [
+			"maxChunks",
+			"maxAccountedBytes",
+			"codecLimits",
+			"maxConcurrent",
+			"vertical"
+		], []), t = r(o, s, c, {
+			...Object.hasOwn(e, "maxChunks") ? { maxChunks: e.maxChunks } : {},
+			...Object.hasOwn(e, "vertical") ? { vertical: e.vertical } : {}
+		}), u = Object.fromEntries(Object.entries(e).filter(([e]) => e !== "vertical"));
+		return i(o, s, t.chunks.map((e) => e.coordinate), u).pipe(a.map((e) => Object.freeze({
+			coverage: t,
+			inventory: e
+		})));
+	} catch (n) {
+		return a.fail(n instanceof e ? n : new t({ detail: "Complete World cell geometry configuration could not be captured" }));
+	}
+};
+export { o as loadPreparedWorldCellGeometry };

package/dist/geometryChannel.js

@@ -0,0 +1,133 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { captureSimulationBytes as n } from "./simulationBytes.js";
+import { geometryOwnData as r } from "./geometryTileCodec.js";
+import { captureGeometryDense as i, captureGeometryPersistenceScope as a, captureGeometryReceipt as o, geometryPersistenceId as s, geometryPersistenceInteger as c } from "./geometryPersistenceData.js";
+import { decodeGeometryPatch as l } from "./geometryPatch.js";
+import { Schema as u } from "effect";
+// src/geometryChannel.ts
+var d = u.Struct({
+	tenantId: u.String,
+	kind: u.Literals([
+		"2d-tiles",
+		"2d-heightfield",
+		"3d-shapes",
+		"3d-voxel"
+	]),
+	worldId: u.String,
+	version: u.String,
+	layerSetId: u.String,
+	cx: u.Int,
+	cy: u.Int,
+	cz: u.optional(u.Int)
+}), f = u.Struct({
+	scope: d,
+	requestId: u.String,
+	baseRevision: u.Int,
+	revision: u.Int,
+	changed: u.Boolean,
+	blobSha256: u.String,
+	contentSha256: u.String
+}), p = u.Struct({
+	type: u.Literal("GeoDeltaFragment"),
+	receipt: f,
+	totalBytes: u.Int,
+	offset: u.Int,
+	bytes: u.Array(u.Int)
+}), m = Object.freeze({
+	schema: p,
+	direction: "server",
+	reliable: !0
+}), h = 8192;
+function g() {
+	throw new t({ detail: "Geometry reliable fragment escaped its exact bounded operation" });
+}
+var _ = (e) => {
+	let t = r(e, ["maxPatchBytes"], []);
+	return Object.hasOwn(t, "maxPatchBytes") ? c(t.maxPatchBytes, 512, 16777216) : 262144;
+}, v = (e, t = {}) => {
+	let n = _(t), a = r(e, [
+		"type",
+		"receipt",
+		"totalBytes",
+		"offset",
+		"bytes"
+	]), s = o(a.receipt), l = c(a.totalBytes, 16, n), u = c(a.offset, 0, l - 1), d = i(a.bytes, h, (e) => c(e, 0, 255));
+	return a.type !== "GeoDeltaFragment" || u % 8192 || d.length !== Math.min(8192, l - u) ? g() : Object.freeze({
+		type: "GeoDeltaFragment",
+		receipt: s,
+		totalBytes: l,
+		offset: u,
+		bytes: d
+	});
+}, y = (e, t, n) => {
+	let r = l(t, {
+		maxBytes: n,
+		maxMetadataBytes: Math.min(4096, n - 16)
+	}).metadata, i = e.scope;
+	if (r.kind !== i.kind || r.worldId !== i.worldId || r.layerSetId !== i.layerSetId || r.version !== i.version || r.cx !== i.cx || r.cy !== i.cy || r.cz !== i.cz || r.baseRevision !== e.baseRevision || r.revision !== e.revision || r.changed !== e.changed || r.blobSha256 !== e.blobSha256 || r.contentSha256 !== e.contentSha256) return g();
+}, b = (e, t, r = {}) => {
+	let i = _(r), a = o(e), s = n(t, i, "geometryReliablePatchBytes");
+	y(a, s, i);
+	let c = [];
+	for (let e = 0; e < s.length; e += h) c.push(Object.freeze({
+		type: "GeoDeltaFragment",
+		receipt: a,
+		totalBytes: s.length,
+		offset: e,
+		bytes: Object.freeze(Array.from(s.subarray(e, e + h)))
+	}));
+	return Object.freeze(c);
+}, x = (t = {}) => {
+	let n = r(t, [
+		"maxPending",
+		"maxPatchBytes",
+		"maxPendingBytes"
+	], []), i = Object.hasOwn(n, "maxPending") ? c(n.maxPending, 1, 256) : 4, o = _(Object.hasOwn(n, "maxPatchBytes") ? { maxPatchBytes: n.maxPatchBytes } : {}), l = Object.hasOwn(n, "maxPendingBytes") ? c(n.maxPendingBytes, 512, 67108864) : 1048576, u = /* @__PURE__ */ new Map(), d = () => [...u.values()].reduce((e, t) => e + t.bytes.length + t.seen.length, 0), f = (e) => JSON.stringify([e.scope, e.requestId]);
+	return Object.freeze({
+		receive: (t) => {
+			let n = v(t, { maxPatchBytes: o }), r = f(n.receipt), a = JSON.stringify([n.receipt, n.totalBytes]), s = Math.ceil(n.totalBytes / h), c = n.offset / h, p = u.get(r);
+			if (p && p.fingerprint !== a) return g();
+			if (!p) {
+				if (u.size >= i) throw new e({
+					budget: "geometryReliablePendingTransfers",
+					limit: i
+				});
+				if (d() + n.totalBytes + s > l) throw new e({
+					budget: "geometryReliablePendingBytes",
+					limit: l
+				});
+				p = {
+					fingerprint: a,
+					receipt: n.receipt,
+					bytes: new Uint8Array(n.totalBytes),
+					seen: new Uint8Array(s),
+					count: 0
+				}, u.set(r, p);
+			}
+			if (p.seen[c]) {
+				if (n.bytes.some((e, t) => e !== p.bytes[n.offset + t])) return g();
+			} else p.bytes.set(n.bytes, n.offset), p.seen[c] = 1, p.count++;
+			if (p.count !== s) return Object.freeze({
+				_tag: "pending",
+				receivedFragments: p.count,
+				totalFragments: s
+			});
+			y(p.receipt, p.bytes, o);
+			let m = new Uint8Array(p.bytes);
+			return u.delete(r), Object.freeze({
+				_tag: "complete",
+				receipt: p.receipt,
+				patch: m
+			});
+		},
+		drop: (e, t) => u.delete(JSON.stringify([a(e), s(t)])),
+		reset: () => {
+			u.clear();
+		},
+		observation: () => Object.freeze({
+			pending: u.size,
+			accountedBytes: d()
+		})
+	});
+};
+export { p as GeometryDeltaFragmentSchema, v as captureGeometryDeltaFragment, b as createGeometryDeltaFragments, h as geometryDeltaFragmentBytes, m as geometryReliableChannel, x as makeGeometryDeltaReceiver };

package/dist/geometryChunkHttp.js

@@ -0,0 +1,53 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryArtifact as r } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as i, captureGeometryPersistenceScope as a, geometryPersistenceInteger as o } from "./geometryPersistenceData.js";
+// src/geometryChunkHttp.ts
+var s = Object.freeze({
+	scope: "x-voltro-geometry-scope",
+	revision: "x-voltro-geometry-revision",
+	contentSha256: "x-voltro-geometry-content-sha256"
+}), c = (t, c = {}) => {
+	let l = n(t, [
+		"scope",
+		"revision",
+		"artifact"
+	]), u = a(l.scope), d = o(l.revision), f = r(l.artifact), p = n(c, ["maxBytes"], []), m = Object.hasOwn(p, "maxBytes") ? o(p.maxBytes, 512, 16777216) : 16777216;
+	i(f, u);
+	let h = f.bytes();
+	if (h.length > m) throw new e({
+		budget: "geometryHttpChunkBytes",
+		limit: m
+	});
+	return Object.freeze({
+		status: 200,
+		headers: Object.freeze({
+			"content-type": "application/octet-stream",
+			"content-length": String(h.length),
+			"cache-control": "private, no-store, no-transform",
+			"access-control-expose-headers": ["etag", ...Object.values(s)].join(", "),
+			etag: `"${f.blobSha256}"`,
+			[s.scope]: encodeURIComponent(JSON.stringify(u)),
+			[s.revision]: String(d),
+			[s.contentSha256]: f.contentSha256
+		}),
+		body: h
+	});
+}, l = (e) => {
+	if (e === null || e.length > 8192) throw new t({ detail: "Geometry HTTP scope metadata is missing or exceeds its parsing budget" });
+	try {
+		return a(JSON.parse(decodeURIComponent(e)));
+	} catch {
+		throw new t({ detail: "Geometry HTTP scope metadata could not be captured" });
+	}
+}, u = (e) => {
+	let t = a(e), n = new URLSearchParams({
+		worldId: t.worldId,
+		layerSetId: t.layerSetId,
+		version: t.version,
+		cx: String(t.cx),
+		cy: String(t.cy)
+	});
+	return t.cz !== void 0 && n.set("cz", String(t.cz)), n.toString();
+};
+export { l as decodeGeometryChunkHttpScope, s as geometryChunkHttpHeaders, u as geometryChunkHttpQuery, c as geometryChunkHttpResponse };

package/dist/geometryChunkLeases.js

@@ -0,0 +1,21 @@
+import { captureGeometryPersistenceScope as e, geometryPersistenceRefusal as t } from "./geometryPersistenceData.js";
+import { geometryPersistenceDigest as n } from "./geometryPersistenceCapture.js";
+import { bindWorldTransitionLeases as r, makeWorldTransitionLeases as i } from "./worldLeases.js";
+// src/geometryChunkLeases.ts
+var a = (r) => Object.freeze({
+	tenantId: r.tenantId,
+	acquire: (i) => {
+		let a = e(i);
+		if (a.tenantId !== r.tenantId) return t();
+		let o = "geometry:" + n(JSON.stringify([
+			a.tenantId,
+			a.worldId,
+			a.layerSetId,
+			a.cx,
+			a.cy,
+			a.cz ?? null
+		]));
+		return r.acquire(o);
+	}
+}), o = (e, t) => a(i(e, t)), s = async (e, t) => a(await r(e, t));
+export { s as bindGeometryChunkLeases, o as makeGeometryChunkLeases };