@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/transform.js

@@ -0,0 +1,217 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { RoomFieldId as t, RoomInterpolation as n, RoomPrecision as r, RoomQuantization as i, RoomTransform as a, dequantize as o, fieldId as s, interpolate as c, precision as l, quantizationStep as u, quantize as d, quantized as f } from "./room.js";
+import { captureTransformRules as p, captureTransformRules2D as m, validateTransformRules2D as h } from "./transformRules.js";
+import { decodeQuaternionSmallestThree as g, encodeQuaternionSmallestThree as _, quaternionByteLength as v } from "./quaternion.js";
+import { SpatialGrid2D as y, SpatialInterest2D as b, spatialGrid as x } from "./spatial.js";
+import { collide as S, collisionWorld as C, tileCollisionWorld2D as w } from "./collision.js";
+import { Transform2D as T, Transform3D as E } from "./transformSchemas.js";
+import { AttachedTransform2D as D, BallisticProjectile2D as O, attachTransform2D as k, detachTransform2D as A, resolveAttachedTransforms2D as j, sampleBallisticProjectile2D as M, setTransformOwner2D as N } from "./movementSpecials.js";
+import { TransformHistory3D as P, interpolateTransform3D as F } from "./transform3d.js";
+import { TransformRenderPrediction3D as I } from "./transformPrediction3d.js";
+import { RoomTransformCollection2D as L } from "./transformCollection.js";
+import { RoomTransformCollection3D as R } from "./transformCollection3d.js";
+import { RoomAnimationFrameLoop as z, RoomTransformFrameLoop2D as B, RoomTransformFrameLoop3D as V, browserRoomAnimationFrames as H } from "./transformFrames.js";
+//#region src/transform.ts
+function U(t) {
+	throw new e({
+		room: "transform",
+		detail: t
+	});
+}
+var W = (e, t) => Number.isFinite(e) ? e : U(`${t} must be finite`), G = (e, t) => W(e, t) > 0 ? e : U(`${t} must be positive`), K = (e) => {
+	let t = p(e);
+	return (e) => e.annotate({ [a]: t });
+}, q = (e) => {
+	for (let t of [
+		e.x,
+		e.y,
+		e.rot,
+		e.vx ?? 0,
+		e.vy ?? 0
+	]) W(t, "transform component");
+}, J = (e) => (e % 360 + 360) % 360, Y = (e, t) => (J(t) - J(e) + 540) % 360 - 180, X = (e, t, n, r) => {
+	h(r), q(e), G(n, "dt"), W(t.dx, "dx"), W(t.dy, "dy");
+	let i = Math.hypot(t.dx, t.dy), a = Math.max(1, i), o = t.dx / a * r.maxSpeed, s = t.dy / a * r.maxSpeed, c = Math.hypot(e.vx ?? 0, e.vy ?? 0), l = c > r.maxSpeed ? r.maxSpeed / c : 1, u = (e.vx ?? 0) * l, d = (e.vy ?? 0) * l, f = o - u, p = s - d, m = Math.hypot(f, p), g = m === 0 ? 0 : Math.min(1, r.maxAccel * n / m), _ = u + f * g, v = d + p * g, y = e.x + _ * n, b = e.y + v * n, x = Math.max(r.bounds.min[0], Math.min(r.bounds.max[0], y)), S = Math.max(r.bounds.min[1], Math.min(r.bounds.max[1], b));
+	return x !== y && (_ = 0), S !== b && (v = 0), {
+		x,
+		y: S,
+		rot: J(e.rot),
+		vx: _,
+		vy: v
+	};
+}, Z = (e, t, n, r, i, a = !0) => {
+	q(e), q(t), W(n, "fraction"), G(r, "durationSeconds"), (![
+		"linear",
+		"hermite",
+		"none"
+	].includes(i) || typeof a != "boolean") && U("Invalid interpolation mode or velocity policy");
+	let o = Math.max(0, Math.min(1, n));
+	if (i === "none") return { ...o < 1 ? e : t };
+	let s = (e, t, n, a) => {
+		if (i === "linear") return e + (t - e) * o;
+		let s = o * o, c = s * o;
+		return (2 * c - 3 * s + 1) * e + (c - 2 * s + o) * n * r + (-2 * c + 3 * s) * t + (c - s) * a * r;
+	}, c = a ? (t.x - e.x) / r : 0, l = a ? (t.y - e.y) / r : 0;
+	return {
+		x: s(e.x, t.x, e.vx ?? c, t.vx ?? c),
+		y: s(e.y, t.y, e.vy ?? l, t.vy ?? l),
+		rot: J(e.rot + Y(e.rot, t.rot) * o),
+		vx: (e.vx ?? c) + ((t.vx ?? c) - (e.vx ?? c)) * o,
+		vy: (e.vy ?? l) + ((t.vy ?? l) - (e.vy ?? l)) * o
+	};
+}, Q = class e {
+	capacity;
+	snapshots = [];
+	rules;
+	constructor(e, t) {
+		this.capacity = e, (!Number.isSafeInteger(e) || e < 2 || e > 16384) && U("History capacity must be between two and its admitted maximum"), this.rules = m(t);
+	}
+	copy() {
+		let t = new e(this.capacity, this.rules);
+		for (let e of this.snapshots) t.push(e);
+		return t;
+	}
+	push(e) {
+		if ((!Number.isSafeInteger(e.tick) || e.tick < 0 || W(e.timeMs, "timeMs") < 0) && U("Invalid snapshot time or tick"), q(e.transform), typeof e.teleport != "boolean" && U("Snapshot teleport must be an explicit boolean"), this.snapshots.some((t) => t.tick === e.tick)) return !1;
+		let t = this.snapshots[0];
+		if (this.snapshots.length === this.capacity && t && e.tick < t.tick) return !1;
+		let n = this.rules.velocity === "derive" || this.rules.velocity === "none" ? {
+			x: e.transform.x,
+			y: e.transform.y,
+			rot: e.transform.rot
+		} : { ...e.transform }, r = [...this.snapshots, {
+			...e,
+			transform: n
+		}].sort((e, t) => e.tick - t.tick);
+		for (let e = 1; e < r.length; e++) {
+			let t = r[e - 1], n = r[e];
+			t && n && n.timeMs <= t.timeMs && U("Snapshot times must increase with their ticks");
+		}
+		return this.snapshots.splice(0, this.snapshots.length, ...r.slice(-this.capacity)), !0;
+	}
+	at(e) {
+		W(e, "timeMs");
+		let t = this.snapshots[0], n = this.snapshots[this.snapshots.length - 1];
+		if (!t || !n) return null;
+		if (e <= t.timeMs) return {
+			...t.transform,
+			stale: e < t.timeMs
+		};
+		for (let t = 1; t < this.snapshots.length; t++) {
+			let n = this.snapshots[t - 1], r = this.snapshots[t];
+			if (!(!n || !r || e > r.timeMs)) return r.teleport || Math.hypot(r.transform.x - n.transform.x, r.transform.y - n.transform.y) > this.rules.teleportThreshold ? {
+				...e < r.timeMs ? n.transform : r.transform,
+				stale: !1
+			} : {
+				...Z(n.transform, r.transform, (e - n.timeMs) / (r.timeMs - n.timeMs), (r.timeMs - n.timeMs) / 1e3, this.rules.interpolation, this.rules.velocity !== "none"),
+				stale: !1
+			};
+		}
+		let r = e - n.timeMs, i = Math.min(this.rules.extrapolateMs, r) / 1e3, a = this.snapshots[this.snapshots.length - 2], o = a ? (n.timeMs - a.timeMs) / 1e3 : 0, s = n.transform.vx ?? (this.rules.velocity !== "none" && a && o > 0 ? (n.transform.x - a.transform.x) / o : 0), c = n.transform.vy ?? (this.rules.velocity !== "none" && a && o > 0 ? (n.transform.y - a.transform.y) / o : 0);
+		return {
+			...n.transform,
+			x: n.transform.x + s * i,
+			y: n.transform.y + c * i,
+			vx: s,
+			vy: c,
+			stale: r > this.rules.extrapolateMs
+		};
+	}
+}, $ = class {
+	step;
+	capacity;
+	pending = [];
+	predicted;
+	lastSeq = -1;
+	lastAck = -1;
+	rules;
+	constructor(e, t, n, r) {
+		this.step = n, this.capacity = r, q(e), (!Number.isSafeInteger(r) || r < 1 || r > 16384) && U("Prediction capacity must be positive and bounded");
+		try {
+			this.rules = structuredClone(t);
+		} catch {
+			U("Prediction rules must be detached data");
+		}
+		this.predicted = { ...e };
+	}
+	send(e, t, n) {
+		(!Number.isSafeInteger(e) || e <= this.lastSeq) && U("Prediction sequences must increase"), G(n, "dt"), this.pending.length >= this.capacity && U("Prediction input history is full");
+		let r = structuredClone(t), i = this.step({ ...this.predicted }, structuredClone(r), n, structuredClone(this.rules));
+		return q(i), this.pending.push({
+			seq: e,
+			input: r,
+			dt: n
+		}), this.lastSeq = e, this.predicted = { ...i }, this.state();
+	}
+	reconcile(e, t) {
+		if ((!Number.isSafeInteger(e) || e < 0 || e > this.lastSeq) && U("Input acknowledgement is outside submitted history"), e < this.lastAck) return this.state();
+		q(t);
+		let n = this.pending.filter((t) => t.seq > e), r = { ...t };
+		for (let e of n) r = this.step(r, structuredClone(e.input), e.dt, structuredClone(this.rules)), q(r);
+		return this.pending.splice(0, this.pending.length, ...n), this.lastAck = e, this.predicted = { ...r }, this.state();
+	}
+	state() {
+		return { ...this.predicted };
+	}
+	queued() {
+		return this.pending.length;
+	}
+}, ee = class {
+	prediction;
+	now;
+	threshold;
+	blendMs;
+	lastTime;
+	lastAck = -1;
+	correctionAt = 0;
+	offset = {
+		x: 0,
+		y: 0,
+		rot: 0
+	};
+	constructor(e, t, n, r) {
+		this.threshold = G(r.teleportThreshold, "teleportThreshold"), this.blendMs = W(r.correctionBlendMs ?? 80, "correctionBlendMs"), this.blendMs < 0 && U("correctionBlendMs must be nonnegative"), (!r.clock || typeof r.clock.now != "function") && U("A render clock is required"), this.now = r.clock.now.bind(r.clock), this.lastTime = W(this.now(), "render clock"), this.lastTime < 0 && U("Render clock must be nonnegative"), this.prediction = new $(e, t, n, r.capacity);
+	}
+	time() {
+		let e = W(this.now(), "render clock");
+		return e < this.lastTime && U("Render clock must not move backwards"), this.lastTime = e, e;
+	}
+	at(e) {
+		let t = this.prediction.state(), n = this.blendMs === 0 ? 0 : Math.max(0, 1 - (e - this.correctionAt) / this.blendMs), r = {
+			...t,
+			x: t.x + this.offset.x * n,
+			y: t.y + this.offset.y * n,
+			rot: J(J(t.rot) + this.offset.rot * n)
+		};
+		return q(r), r;
+	}
+	send(e, t, n) {
+		return this.time(), this.prediction.send(e, t, n);
+	}
+	reconcile(e, t, n = !1) {
+		typeof n != "boolean" && U("Teleport must be an explicit boolean");
+		let r = this.time(), i = this.at(r), a = this.prediction.state(), o = this.prediction.reconcile(e, t);
+		if (e < this.lastAck || (this.lastAck = e, a.x === o.x && a.y === o.y && J(a.rot) === J(o.rot) && a.vx === o.vx && a.vy === o.vy && !n)) return o;
+		let s = {
+			x: i.x - o.x,
+			y: i.y - o.y,
+			rot: Y(o.rot, i.rot)
+		}, c = Math.hypot(a.x - o.x, a.y - o.y);
+		return this.offset = n || c > this.threshold || this.blendMs === 0 || !Number.isFinite(s.x) || !Number.isFinite(s.y) ? {
+			x: 0,
+			y: 0,
+			rot: 0
+		} : s, this.correctionAt = r, o;
+	}
+	state() {
+		return this.prediction.state();
+	}
+	render() {
+		return this.at(this.time());
+	}
+	queued() {
+		return this.prediction.queued();
+	}
+};
+//#endregion
+export { D as AttachedTransform2D, O as BallisticProjectile2D, z as RoomAnimationFrameLoop, t as RoomFieldId, n as RoomInterpolation, r as RoomPrecision, i as RoomQuantization, a as RoomTransform, L as RoomTransformCollection2D, R as RoomTransformCollection3D, B as RoomTransformFrameLoop2D, V as RoomTransformFrameLoop3D, y as SpatialGrid2D, b as SpatialInterest2D, T as Transform2D, E as Transform3D, Q as TransformHistory2D, P as TransformHistory3D, $ as TransformPrediction2D, ee as TransformRenderPrediction2D, I as TransformRenderPrediction3D, k as attachTransform2D, H as browserRoomAnimationFrames, S as collide, C as collisionWorld, g as decodeQuaternionSmallestThree, o as dequantize, A as detachTransform2D, _ as encodeQuaternionSmallestThree, s as fieldId, c as interpolate, Z as interpolateTransform2D, F as interpolateTransform3D, l as precision, u as quantizationStep, d as quantize, f as quantized, v as quaternionByteLength, j as resolveAttachedTransforms2D, M as sampleBallisticProjectile2D, N as setTransformOwner2D, x as spatialGrid, X as stepTransform2D, w as tileCollisionWorld2D, K as transform };

package/dist/transform3d.js

@@ -0,0 +1,118 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { captureTransformRules3D as t } from "./transformRules.js";
+//#region src/transform3d.ts
+function n(t) {
+	throw new e({
+		room: "transform3d",
+		detail: t
+	});
+}
+var r = (e) => Number.isFinite(e) ? e : n("Transform components and times must be finite"), i = (e) => {
+	let { x: t, y: i, z: a, qx: o, qy: s, qz: c, qw: l } = e;
+	for (let e of [
+		t,
+		i,
+		a,
+		o,
+		s,
+		c,
+		l
+	]) r(e);
+	let u = Math.max(Math.abs(o), Math.abs(s), Math.abs(c), Math.abs(l));
+	u === 0 && n("A zero quaternion has no rotation");
+	let d = Math.hypot(o / u, s / u, c / u, l / u);
+	return {
+		x: t,
+		y: i,
+		z: a,
+		qx: o / u / d,
+		qy: s / u / d,
+		qz: c / u / d,
+		qw: l / u / d
+	};
+}, a = (e, t, a, o, s, c, l) => {
+	let u = i(e), d = i(t), f = Math.max(0, Math.min(1, r(a)));
+	(r(o) <= 0 || ![
+		"linear",
+		"hermite",
+		"none"
+	].includes(s)) && n("Interpolation requires positive duration and a declared mode");
+	for (let e of [c, l]) if (e !== void 0) for (let t of [
+		e.x,
+		e.y,
+		e.z
+	]) r(t);
+	if (s === "none") return f < 1 ? u : d;
+	let p = (e) => {
+		if (s === "linear") return u[e] + (d[e] - u[e]) * f;
+		let t = (d[e] - u[e]) / o, n = c?.[e] ?? t, r = l?.[e] ?? t, i = f * f, a = i * f;
+		return (2 * a - 3 * i + 1) * u[e] + (a - 2 * i + f) * n * o + (-2 * a + 3 * i) * d[e] + (a - i) * r * o;
+	}, m = u.qx * d.qx + u.qy * d.qy + u.qz * d.qz + u.qw * d.qw, h = m < 0 ? -1 : 1;
+	m = Math.min(1, Math.max(0, m * h));
+	let g = Math.acos(m), _ = Math.sin(g), v = m > .9995, y = v ? 1 - f : Math.sin((1 - f) * g) / _, b = v ? f : Math.sin(f * g) / _;
+	return i({
+		x: p("x"),
+		y: p("y"),
+		z: p("z"),
+		qx: u.qx * y + d.qx * h * b,
+		qy: u.qy * y + d.qy * h * b,
+		qz: u.qz * y + d.qz * h * b,
+		qw: u.qw * y + d.qw * h * b
+	});
+}, o = class e {
+	capacity;
+	snapshots = [];
+	rules;
+	constructor(e, r) {
+		this.capacity = e, (!Number.isSafeInteger(e) || e < 2 || e > 16384) && n("History capacity must be between two and its admitted maximum"), this.rules = t(r);
+	}
+	copy() {
+		let t = new e(this.capacity, this.rules);
+		for (let e of this.snapshots) t.snapshots.push({
+			...e,
+			transform: { ...e.transform }
+		});
+		return t;
+	}
+	push(e) {
+		(!Number.isSafeInteger(e.tick) || e.tick < 0 || r(e.timeMs) < 0 || typeof e.teleport != "boolean") && n("Snapshot identity and teleport must be explicit");
+		let t = i(e.transform);
+		if (this.snapshots.some((t) => t.tick === e.tick) || this.snapshots.length === this.capacity && e.tick < this.snapshots[0].tick) return !1;
+		let a = this.snapshots.findIndex((t) => t.tick > e.tick), o = a < 0 ? this.snapshots.length : a, s = this.snapshots[o - 1], c = this.snapshots[o];
+		return (s && e.timeMs <= s.timeMs || c && e.timeMs >= c.timeMs) && n("Snapshot times must increase with ticks"), this.snapshots.splice(o, 0, {
+			tick: e.tick,
+			timeMs: e.timeMs,
+			teleport: e.teleport,
+			transform: t
+		}), this.snapshots.length > this.capacity && this.snapshots.shift(), !0;
+	}
+	at(e) {
+		r(e);
+		let t = this.snapshots[0], n = this.snapshots.at(-1);
+		if (!t || !n) return null;
+		if (e <= t.timeMs) return {
+			...t.transform,
+			stale: e < t.timeMs
+		};
+		for (let t = 1; t < this.snapshots.length; t++) {
+			let n = this.snapshots[t - 1], r = this.snapshots[t];
+			if (!(e > r.timeMs)) return r.teleport || Math.hypot(r.transform.x - n.transform.x, r.transform.y - n.transform.y, r.transform.z - n.transform.z) > this.rules.teleportThreshold ? {
+				...e < r.timeMs ? n.transform : r.transform,
+				stale: !1
+			} : {
+				...a(n.transform, r.transform, (e - n.timeMs) / (r.timeMs - n.timeMs), (r.timeMs - n.timeMs) / 1e3, this.rules.interpolation),
+				stale: !1
+			};
+		}
+		let i = this.snapshots.at(-2), o = i ? (n.timeMs - i.timeMs) / 1e3 : 0, s = e - n.timeMs, c = Math.min(this.rules.extrapolateMs, s) / 1e3, l = (e) => r(n.transform[e] + (i && o > 0 ? (n.transform[e] - i.transform[e]) / o : 0) * c);
+		return {
+			...n.transform,
+			x: l("x"),
+			y: l("y"),
+			z: l("z"),
+			stale: s > this.rules.extrapolateMs
+		};
+	}
+};
+//#endregion
+export { o as TransformHistory3D, a as interpolateTransform3D, i as normalizeTransform3D };

package/dist/transformCollection.js

@@ -0,0 +1,24 @@
+import { captureTransformRules2D as e } from "./transformRules.js";
+import { RoomTransformCollectionCore as t } from "./transformCollectionCore.js";
+import { TransformHistory2D as n } from "./transform.js";
+//#region src/transformCollection.ts
+var r = (e) => ({
+	copy: () => r(e.copy()),
+	push: (t) => e.push(t),
+	at: (t) => {
+		let n = e.at(t);
+		if (n === null) return null;
+		let { stale: r, ...i } = n;
+		return {
+			transform: i,
+			stale: r
+		};
+	}
+}), i = class extends t {
+	constructor(t, i) {
+		let a = e(i.rules);
+		super(t, i, (e) => r(new n(e, a)));
+	}
+};
+//#endregion
+export { i as RoomTransformCollection2D };

package/dist/transformCollection3d.js

@@ -0,0 +1,24 @@
+import { captureTransformRules3D as e } from "./transformRules.js";
+import { TransformHistory3D as t } from "./transform3d.js";
+import { RoomTransformCollectionCore as n } from "./transformCollectionCore.js";
+//#region src/transformCollection3d.ts
+var r = (e) => ({
+	copy: () => r(e.copy()),
+	push: (t) => e.push(t),
+	at: (t) => {
+		let n = e.at(t);
+		if (n === null) return null;
+		let { stale: r, ...i } = n;
+		return {
+			transform: i,
+			stale: r
+		};
+	}
+}), i = class extends n {
+	constructor(n, i) {
+		let a = e(i.rules);
+		super(n, i, (e) => r(new t(e, a)));
+	}
+};
+//#endregion
+export { i as RoomTransformCollection3D };

package/dist/transformCollectionCore.js

@@ -0,0 +1,156 @@
+import { BudgetExceeded as e, RoomAuthoringError as t } from "./errors.js";
+//#region src/transformCollectionCore.ts
+function n(e) {
+	throw new t({
+		room: "transform-collection",
+		detail: e
+	});
+}
+var r = (e, t) => Number.isFinite(e) ? e : n(`${t} must be finite`), i = (e) => typeof e == "string" && e.trim() && e.length <= 191 ? e : n("Transform identity must be nonempty and bounded"), a = (e, t, r) => Number.isSafeInteger(e) && e >= t && e <= r ? e : n("Transform collection capacity must fit its admitted bound"), o = class {
+	entries = /* @__PURE__ */ new Map();
+	epoch = -1;
+	tick = -1;
+	previous = null;
+	jitter = [];
+	currentError = null;
+	closing = !1;
+	closed = !1;
+	closeTask = null;
+	read;
+	serverTime;
+	release;
+	select;
+	timeAtTick;
+	makeHistory;
+	capacity;
+	maxEntities;
+	minDelay;
+	maxDelay;
+	interval;
+	maxLossIntervals;
+	loss;
+	jitterWindow;
+	jitterMultiplier;
+	constructor(t, i, o) {
+		this.makeHistory = o, this.capacity = a(i.capacity, 2, 16384), this.maxEntities = a(i.maxEntities, 1, 16384);
+		let s = a(i.maxRetainedSnapshots, 2, 1048576);
+		if (this.capacity * this.maxEntities > s) throw new e({
+			budget: "transformSnapshots",
+			limit: s
+		});
+		let c = r(i.sendIntervalMs, "sendIntervalMs");
+		c <= 0 && n("sendIntervalMs must be positive"), this.minDelay = r(i.minDelayMs ?? c * 2, "minDelayMs"), this.maxDelay = r(i.maxDelayMs ?? Math.max(1e3, this.minDelay), "maxDelayMs"), this.jitterWindow = a(i.jitterWindow ?? 32, 2, 256), this.jitterMultiplier = r(i.jitterMultiplier ?? 2, "jitterMultiplier"), this.interval = c, this.maxLossIntervals = a(i.maxLossIntervals ?? 2, 0, 16), this.loss = () => {
+			let e = t.lossRate;
+			return typeof e == "number" && e >= 0 && e <= 1 ? e : 0;
+		}, (this.minDelay < 0 || this.maxDelay < this.minDelay || this.jitterMultiplier < 0) && n("Render delay budgets must be ordered and nonnegative"), (typeof i.select != "function" || typeof i.timeAtTick != "function" || typeof t.deliveredSnapshot != "function" || typeof t.serverNow != "function" || typeof t.subscribe != "function") && n("Transform projection, server timeline and subscribed source are required"), this.select = i.select, this.timeAtTick = i.timeAtTick, this.read = t.deliveredSnapshot.bind(t), this.serverTime = t.serverNow.bind(t);
+		let l = t.subscribe.bind(t);
+		this.observe(), this.release = l(() => this.observe()), typeof this.release != "function" && n("Transform source must return its subscription release");
+	}
+	reset() {
+		this.entries.clear(), this.epoch = -1, this.tick = -1, this.previous = null, this.jitter = [];
+	}
+	observe() {
+		if (!this.closing) try {
+			let t = this.read();
+			if (t === null) {
+				this.reset(), this.currentError = null;
+				return;
+			}
+			if ((!Number.isSafeInteger(t.epoch) || t.epoch < 0 || !Number.isSafeInteger(t.tick) || t.tick < 0 || r(t.receivedAt, "receivedAt") < 0) && n("Delivered epoch, tick or observation is invalid"), t.epoch < this.epoch) return;
+			if (t.epoch !== this.epoch) this.reset(), this.epoch = t.epoch;
+			else if (t.tick <= this.tick) return;
+			let a = r(this.timeAtTick(t.epoch, t.tick), "server snapshot time");
+			(a < 0 || this.previous && (a <= this.previous.timeMs || t.receivedAt < this.previous.receivedAt)) && n("Server snapshot timeline must increase and local observation must not regress");
+			let o = this.select(structuredClone(t.state));
+			if (Array.isArray(o) || n("Transform projection must return a dense entity array"), o.length > this.maxEntities) throw new e({
+				budget: "transformEntities",
+				limit: this.maxEntities
+			});
+			let s = /* @__PURE__ */ new Map();
+			for (let e = 0; e < o.length; e++) {
+				let r = o[e];
+				(!Object.hasOwn(o, e) || !r || typeof r != "object") && n("Transform projection cannot contain holes");
+				let c = i(r.id);
+				s.has(c) && n("Transform projection identities must be unique");
+				let l = r.teleport ?? !1;
+				typeof l != "boolean" && n("Server teleport must be an explicit boolean");
+				let u = this.entries.get(c), d = u?.history.copy() ?? this.makeHistory(this.capacity);
+				d.push({
+					tick: t.tick,
+					timeMs: a,
+					transform: r.transform,
+					teleport: l
+				});
+				let f = {
+					tick: t.tick,
+					timeMs: a,
+					...r.data === void 0 ? {} : { data: structuredClone(r.data) }
+				};
+				s.set(c, {
+					history: d,
+					samples: [...u?.samples ?? [], f].slice(-this.capacity)
+				});
+			}
+			let c = this.previous ? [...this.jitter, Math.abs(t.receivedAt - this.previous.receivedAt - (a - this.previous.timeMs))].slice(-this.jitterWindow) : [];
+			this.entries = s, this.epoch = t.epoch, this.tick = t.tick, this.previous = {
+				timeMs: a,
+				receivedAt: t.receivedAt
+			}, this.jitter = c, this.currentError = null;
+		} catch (e) {
+			this.currentError = e;
+		}
+	}
+	get error() {
+		return this.currentError;
+	}
+	delayMs() {
+		let e = [...this.jitter].sort((e, t) => e - t), t = e[Math.max(0, Math.ceil(e.length * .95) - 1)] ?? 0, n = Math.min(this.maxLossIntervals, Math.round(this.loss() * 10));
+		return Math.min(this.maxDelay, this.minDelay + t * this.jitterMultiplier + n * this.interval);
+	}
+	ids() {
+		return this.closing ? [] : [...this.entries.keys()].sort();
+	}
+	renderTime() {
+		if (this.closing) return null;
+		let e = this.serverTime();
+		return e === null ? null : r(e, "server render clock") - this.delayMs();
+	}
+	at(e, t) {
+		if (i(e), this.closing) return null;
+		let n = this.entries.get(e);
+		if (!n) return null;
+		let a = t === void 0 ? this.renderTime() : t;
+		if (a === null) return null;
+		let o = r(a, "render time"), s = n.history.at(o), c = n.samples[0];
+		for (let e of n.samples) {
+			if (e.timeMs > o) break;
+			c = e;
+		}
+		if (!s || !c) return null;
+		let { stale: l, transform: u } = s;
+		return {
+			epoch: this.epoch,
+			tick: c.tick,
+			transform: u,
+			stale: l,
+			...c.data === void 0 ? {} : { data: structuredClone(c.data) }
+		};
+	}
+	close() {
+		if (this.closed) return Promise.resolve();
+		if (this.closeTask) return this.closeTask;
+		this.closing = !0;
+		let e = Promise.resolve().then(() => this.release()).then(() => {
+			this.reset(), this.closed = !0;
+		}, (e) => {
+			throw this.currentError = e, e;
+		});
+		return this.closeTask = e, e.then(() => {
+			this.closeTask = null;
+		}, () => {
+			this.closeTask = null;
+		}), e;
+	}
+};
+//#endregion
+export { o as RoomTransformCollectionCore };

package/dist/transformFrames.js

@@ -0,0 +1,121 @@
+import { RoomAuthoringError as e } from "./errors.js";
+//#region src/transformFrames.ts
+function t(t) {
+	throw new e({
+		room: "transform-frames",
+		detail: t
+	});
+}
+var n = () => {
+	let e = globalThis;
+	return typeof e.requestAnimationFrame != "function" || typeof e.cancelAnimationFrame != "function" ? t("Native animation frames are unavailable in this runtime") : Object.freeze({
+		request: e.requestAnimationFrame.bind(globalThis),
+		cancel: e.cancelAnimationFrame.bind(globalThis)
+	});
+}, r = class {
+	request;
+	cancel;
+	onFrame;
+	ticket = null;
+	callbackTask = null;
+	closingTask = null;
+	running = !1;
+	closing = !1;
+	closed = !1;
+	currentError = null;
+	constructor(e, r = n()) {
+		(typeof r.request != "function" || typeof r.cancel != "function" || typeof e != "function") && t("A frame callback and animation-frame port are required"), this.request = r.request.bind(r), this.cancel = r.cancel.bind(r), this.onFrame = e;
+	}
+	get error() {
+		return this.currentError;
+	}
+	get status() {
+		return this.closed ? "closed" : this.closing ? "closing" : this.currentError === null ? this.running ? "running" : "idle" : "failed";
+	}
+	start() {
+		if (this.closing && t("A closing frame loop cannot restart"), this.currentError !== null) throw this.currentError;
+		this.running || (this.running = !0, this.schedule());
+	}
+	schedule() {
+		if (!this.running || this.closing) return;
+		let n = !1, r = { id: null };
+		this.ticket = r;
+		try {
+			let i = this.request((i) => {
+				if (!n) {
+					this.currentError = new e({
+						room: "transform-frames",
+						detail: "Animation-frame port called synchronously"
+					}), this.running = !1;
+					return;
+				}
+				if (this.ticket !== r || (this.ticket = null, !this.running || this.closing)) return;
+				let a = Promise.resolve().then(async () => {
+					(!Number.isFinite(i) || i < 0) && t("Local frame observation must be finite and nonnegative"), await this.onFrame(i);
+				}).then(() => {
+					this.callbackTask === a && (this.callbackTask = null);
+					try {
+						this.schedule();
+					} catch (e) {
+						this.currentError = e, this.running = !1;
+					}
+				}, (e) => {
+					this.currentError = e, this.running = !1, this.callbackTask === a && (this.callbackTask = null);
+				});
+				this.callbackTask = a;
+			});
+			if (n = !0, (!Number.isSafeInteger(i) || i < 0) && t("Animation-frame identifier must be a nonnegative safe integer"), r.id = i, this.currentError !== null) {
+				let e = this.currentError;
+				try {
+					this.cancel(i);
+				} catch (t) {
+					throw AggregateError([e, t], "Frame admission and cleanup failed");
+				}
+				throw this.ticket = null, e;
+			}
+		} catch (e) {
+			throw this.running = !1, this.currentError = e, r.id === null && (this.ticket = null), e;
+		}
+	}
+	close() {
+		if (this.closed) return Promise.resolve();
+		if (this.closingTask) return this.closingTask;
+		this.closing = !0, this.running = !1;
+		let e = Promise.resolve().then(async () => {
+			let e = this.ticket;
+			e !== null && e.id !== null && (this.cancel(e.id), this.ticket === e && (this.ticket = null)), await this.callbackTask, this.closed = !0;
+		});
+		return this.closingTask = e, e.then(() => {
+			this.closingTask = null;
+		}, (e) => {
+			this.currentError ??= e, this.closingTask = null;
+		}), e;
+	}
+}, i = (e, n) => {
+	(typeof e.ids != "function" || typeof e.renderTime != "function" || typeof e.at != "function" || typeof n != "function") && t("A transform view and frame callback are required");
+	let r = e.ids.bind(e), i = e.renderTime.bind(e), a = e.at.bind(e);
+	return async (e) => {
+		let o = i();
+		o !== null && !Number.isFinite(o) && t("Server render time must be finite"), await n({
+			localTimeMs: e,
+			serverTimeMs: o,
+			entities: o === null ? [] : r().flatMap((e) => {
+				let t = a(e, o);
+				return t === null ? [] : [{
+					id: e,
+					sample: structuredClone(t)
+				}];
+			})
+		});
+	};
+}, a = class extends r {
+	constructor(e, t, r = n()) {
+		super(i(e, t), r);
+	}
+}, o = class extends r {
+	constructor(e, t, r = n()) {
+		super(i(e, t), r);
+	}
+};
+//#endregion
+export { r as RoomAnimationFrameLoop, a as RoomTransformFrameLoop2D, o as RoomTransformFrameLoop3D, n as browserRoomAnimationFrames };