@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/fixed.d.ts

@@ -0,0 +1,284 @@
+export declare interface AabbFx {
+    readonly min: Vec2Fx;
+    readonly max: Vec2Fx;
+}
+
+export declare interface AabbFx32 {
+    readonly min: Vec2Fx32;
+    readonly max: Vec2Fx32;
+}
+
+/** Inclusive boundary/tangent predicates over exact raw integers. */
+export declare const aabbIntersectsFx: (offeredA: AabbFx, offeredB: AabbFx) => boolean;
+
+/** Inclusive predicates over exact captured signed64 raw coordinates. */
+export declare const aabbIntersectsFx32: (offeredA: AabbFx32, offeredB: AabbFx32) => boolean;
+
+export declare interface AabbSweepFx {
+    readonly entry: SweepFractionFx;
+    readonly exit: SweepFractionFx;
+}
+
+export declare interface AabbSweepFx32 {
+    readonly entry: SweepFractionFx32;
+    readonly exit: SweepFractionFx32;
+}
+
+/** First table ray enclosing the positive quadrant vector, then exact quadrant
+ * reflection; bounded binary search, unsigned-word products, result [0,1) turn.
+ * No floating ratio or native atan decides the angle. Zero vector refuses. */
+export declare const atan2Fx: (offeredY: Fx, offeredX: Fx) => Fx;
+
+/** Bounded enclosing table-ray search. Compare complete positive wide products,
+ * including MIN's 2^63 magnitude; no rounded float ratio/native atan in runtime. */
+export declare const atan2Fx32: (offeredY: Fx32, offeredX: Fx32) => Fx32;
+
+export declare const circleAabbIntersectsFx: (offeredCircle: CircleFx, offeredBox: AabbFx) => boolean;
+
+export declare const circleAabbIntersectsFx32: (offeredCircle: CircleFx32, offeredBox: AabbFx32) => boolean;
+
+export declare const circleContainsFx: (offered: CircleFx, offeredPoint: Vec2Fx) => boolean;
+
+export declare const circleContainsFx32: (offered: CircleFx32, offeredPoint: Vec2Fx32) => boolean;
+
+export declare interface CircleFx {
+    readonly center: Vec2Fx;
+    readonly radius: Fx;
+}
+
+export declare interface CircleFx32 {
+    readonly center: Vec2Fx32;
+    readonly radius: Fx32;
+}
+
+export declare const circlesIntersectFx: (offeredA: CircleFx, offeredB: CircleFx) => boolean;
+
+export declare const circlesIntersectFx32: (offeredA: CircleFx32, offeredB: CircleFx32) => boolean;
+
+export declare const cosFx: (angle: Fx) => Fx;
+
+export declare const cosFx32: (angle: Fx32) => Fx32;
+
+/** No floating trig, BigInt, randomness, clock, store or mutable global state. */
+export declare const createFixed: (offered?: FixedMathOptions) => FixedMath;
+
+/** Pure scalar Q32.32 core with shared pinned table trig. Vector/collision32 remains open;
+ * no BigInt, floating transcendentals, clock, store or global entropy here. */
+export declare const createFixed32: (offered?: FixedMathOptions) => Fixed32Math;
+
+/** Component operations retain the selected Q32.32 overflow/truncation policy.
+ * Dot/cross/length enforce every intermediate; cancellation does not bypass it. */
+export declare const createFixed32Vectors: (options?: FixedMathOptions) => Fixed32Vectors;
+
+/** Component operations retain the selected Q16.16 overflow/truncation policy.
+ * Dot/cross/length enforce every intermediate; cancellation does not bypass it. */
+export declare const createFixedVectors: (options?: FixedMathOptions) => FixedVectors;
+
+declare const fixed32Brand: unique symbol;
+
+export declare interface Fixed32Math {
+    readonly format: '32.32';
+    readonly fractionalBits: 32;
+    readonly overflowChecks: boolean;
+    raw(value: Uint64Words): Fx32;
+    fromInt(value: number): Fx32;
+    fromRatio(numerator: number, denominator: number): Fx32;
+    toNumber(value: Fx32): number;
+    compare(a: Fx32, b: Fx32): number;
+    add(a: Fx32, b: Fx32): Fx32;
+    sub(a: Fx32, b: Fx32): Fx32;
+    mul(a: Fx32, b: Fx32): Fx32;
+    div(a: Fx32, b: Fx32): Fx32;
+    sin(angle: Fx32): Fx32;
+    cos(angle: Fx32): Fx32;
+    atan2(y: Fx32, x: Fx32): Fx32;
+    sqrt(value: Fx32): Fx32;
+    abs(value: Fx32): Fx32;
+    floor(value: Fx32): Fx32;
+    round(value: Fx32): Fx32;
+    clamp(value: Fx32, min: Fx32, max: Fx32): Fx32;
+    lerp(a: Fx32, b: Fx32, fraction: Fx32): Fx32;
+}
+
+export declare interface Fixed32Vectors {
+    readonly math: Fixed32Math;
+    vec2(x: Fx32, y: Fx32): Vec2Fx32;
+    vec3(x: Fx32, y: Fx32, z: Fx32): Vec3Fx32;
+    add2(a: Vec2Fx32, b: Vec2Fx32): Vec2Fx32;
+    sub2(a: Vec2Fx32, b: Vec2Fx32): Vec2Fx32;
+    scale2(a: Vec2Fx32, scale: Fx32): Vec2Fx32;
+    dot2(a: Vec2Fx32, b: Vec2Fx32): Fx32;
+    cross2(a: Vec2Fx32, b: Vec2Fx32): Fx32;
+    length2(a: Vec2Fx32): Fx32;
+    normalize2(a: Vec2Fx32): Vec2Fx32;
+    lerp2(a: Vec2Fx32, b: Vec2Fx32, fraction: Fx32): Vec2Fx32;
+    add3(a: Vec3Fx32, b: Vec3Fx32): Vec3Fx32;
+    sub3(a: Vec3Fx32, b: Vec3Fx32): Vec3Fx32;
+    scale3(a: Vec3Fx32, scale: Fx32): Vec3Fx32;
+    dot3(a: Vec3Fx32, b: Vec3Fx32): Fx32;
+    cross3(a: Vec3Fx32, b: Vec3Fx32): Vec3Fx32;
+    length3(a: Vec3Fx32): Fx32;
+    normalize3(a: Vec3Fx32): Vec3Fx32;
+    lerp3(a: Vec3Fx32, b: Vec3Fx32, fraction: Fx32): Vec3Fx32;
+}
+
+export declare interface FixedMath {
+    readonly format: '16.16';
+    readonly fractionalBits: 16;
+    readonly scale: 65536;
+    readonly overflowChecks: boolean;
+    raw(value: number): Fx;
+    fromInt(value: number): Fx;
+    fromRatio(numerator: number, denominator: number): Fx;
+    toNumber(value: Fx): number;
+    add(a: Fx, b: Fx): Fx;
+    sub(a: Fx, b: Fx): Fx;
+    mul(a: Fx, b: Fx): Fx;
+    div(a: Fx, b: Fx): Fx;
+    sin(angle: Fx): Fx;
+    cos(angle: Fx): Fx;
+    atan2(y: Fx, x: Fx): Fx;
+    sqrt(value: Fx): Fx;
+    abs(value: Fx): Fx;
+    floor(value: Fx): Fx;
+    round(value: Fx): Fx;
+    clamp(value: Fx, min: Fx, max: Fx): Fx;
+    lerp(a: Fx, b: Fx, fraction: Fx): Fx;
+}
+
+export declare interface FixedMathOptions {
+    readonly overflowChecks?: boolean;
+}
+
+export declare interface FixedVectors {
+    readonly math: FixedMath;
+    vec2(x: Fx, y: Fx): Vec2Fx;
+    vec3(x: Fx, y: Fx, z: Fx): Vec3Fx;
+    add2(a: Vec2Fx, b: Vec2Fx): Vec2Fx;
+    sub2(a: Vec2Fx, b: Vec2Fx): Vec2Fx;
+    scale2(a: Vec2Fx, scale: Fx): Vec2Fx;
+    dot2(a: Vec2Fx, b: Vec2Fx): Fx;
+    cross2(a: Vec2Fx, b: Vec2Fx): Fx;
+    length2(a: Vec2Fx): Fx;
+    normalize2(a: Vec2Fx): Vec2Fx;
+    lerp2(a: Vec2Fx, b: Vec2Fx, fraction: Fx): Vec2Fx;
+    add3(a: Vec3Fx, b: Vec3Fx): Vec3Fx;
+    sub3(a: Vec3Fx, b: Vec3Fx): Vec3Fx;
+    scale3(a: Vec3Fx, scale: Fx): Vec3Fx;
+    dot3(a: Vec3Fx, b: Vec3Fx): Fx;
+    cross3(a: Vec3Fx, b: Vec3Fx): Vec3Fx;
+    length3(a: Vec3Fx): Fx;
+    normalize3(a: Vec3Fx): Vec3Fx;
+    lerp3(a: Vec3Fx, b: Vec3Fx, fraction: Fx): Vec3Fx;
+}
+
+/** Signed Q16.16 raw integer; convert to ordinary numbers only for rendering. */
+export declare type Fx = number & {
+    readonly [fxBrand]: 'Q16.16';
+};
+
+/** Signed Q32.32 two's-complement raw value, never a lossy 64-bit JS number. */
+export declare type Fx32 = Uint64Words & {
+    readonly [fixed32Brand]: 'Q32.32';
+};
+
+declare const fxBrand: unique symbol;
+
+/** PCG-XSH-RR 64/32. Numeric seeds are unsigned 32-bit; word seeds retain 64 bits.
+ * Algorithm reference: https://www.pcg-random.org/using-pcg-c-basic.html
+ * No global generator, BigInt, native dependency or implicit time/entropy seed. */
+export declare class Pcg32 {
+    #private;
+    constructor(seed: Pcg32Seed, stream?: Pcg32Seed, maxRejectionAttempts?: number);
+    get maxRejectionAttempts(): number;
+    nextU32(): number;
+    /** Rejection removes modulo bias. Exhaustion consumes exactly the bounded
+     * draws and fails; it never returns a biased fallback or substitutes entropy. */
+    bounded(bound: number): number;
+    snapshot(): Pcg32Snapshot;
+    restore(offered: Pcg32Snapshot): void;
+    clone(): Pcg32;
+    /** Exact skip-ahead modulo 2^64; at most 32 iterations for this delta API. */
+    advance(delta: number): void;
+}
+
+export declare type Pcg32Seed = number | Uint64Words;
+
+export declare interface Pcg32Snapshot {
+    readonly stateHi: number;
+    readonly stateLo: number;
+    readonly incrementHi: number;
+    readonly incrementLo: number;
+}
+
+export declare interface SegmentFx {
+    readonly start: Vec2Fx;
+    readonly end: Vec2Fx;
+}
+
+export declare interface SegmentFx32 {
+    readonly start: Vec2Fx32;
+    readonly end: Vec2Fx32;
+}
+
+export declare const segmentsIntersectFx: (offeredA: SegmentFx, offeredB: SegmentFx) => boolean;
+
+export declare const segmentsIntersectFx32: (offeredA: SegmentFx32, offeredB: SegmentFx32) => boolean;
+
+/** Table-interpolated deterministic approximation. Angle unit: turns, not radians. */
+export declare const sinFx: (angle: Fx) => Fx;
+
+/** Angles are turns; the low word is the exact wrapped fractional turn. */
+export declare const sinFx32: (angle: Fx32) => Fx32;
+
+/** Swept moving AABB against a stationary AABB over one captured displacement.
+ * Slab clipping compares exact 64-bit integer products; no float division or
+ * Q16 truncation decides contact. Entry/exit remain exact clipped fractions. */
+export declare const sweepAabbFx: (offeredMoving: AabbFx, offeredDisplacement: Vec2Fx, offeredStationary: AabbFx) => AabbSweepFx | null;
+
+/** Exact slab clipping over one displacement. No intermediate endpoint update,
+ * rounded division or scalar overflow policy decides contact. */
+export declare const sweepAabbFx32: (offeredMoving: AabbFx32, offeredDisplacement: Vec2Fx32, offeredStationary: AabbFx32) => AabbSweepFx32 | null;
+
+/** Exact clipped time ratio. Both unsigned values, denominator nonzero, in [0,1]. */
+export declare interface SweepFractionFx {
+    readonly numerator: number;
+    readonly denominator: number;
+}
+
+/** Exact unsigned raw-integer ratio in [0,1], not a rounded Q32.32 value.
+ * Numerator/denominator are magnitudes; denominator is nonzero. */
+export declare interface SweepFractionFx32 {
+    readonly numerator: Uint64Words;
+    readonly denominator: Uint64Words;
+}
+
+/** Exact unsigned 64-bit integer as independent 32-bit words. */
+export declare interface Uint64Words {
+    readonly hi: number;
+    readonly lo: number;
+}
+
+export declare interface Vec2Fx {
+    readonly x: Fx;
+    readonly y: Fx;
+}
+
+export declare interface Vec2Fx32 {
+    readonly x: Fx32;
+    readonly y: Fx32;
+}
+
+export declare interface Vec3Fx {
+    readonly x: Fx;
+    readonly y: Fx;
+    readonly z: Fx;
+}
+
+export declare interface Vec3Fx32 {
+    readonly x: Fx32;
+    readonly y: Fx32;
+    readonly z: Fx32;
+}
+
+export { }

package/dist/fixed.js

@@ -0,0 +1,10 @@
+import { atan2Fx as e, cosFx as t, sinFx as n } from "./fixedTrig.js";
+import { createFixed as r } from "./fixedMath.js";
+import { Pcg32 as i } from "./pcg32.js";
+import { createFixedVectors as a } from "./fixedVectors.js";
+import { aabbIntersectsFx as o, circleAabbIntersectsFx as s, circleContainsFx as c, circlesIntersectFx as l, segmentsIntersectFx as u, sweepAabbFx as d } from "./fixedCollision.js";
+import { atan2Fx32 as f, cosFx32 as p, sinFx32 as m } from "./fixedTrig32.js";
+import { createFixed32 as h } from "./fixed32.js";
+import { createFixed32Vectors as g } from "./fixedVectors32.js";
+import { aabbIntersectsFx32 as _, circleAabbIntersectsFx32 as v, circleContainsFx32 as y, circlesIntersectFx32 as b, segmentsIntersectFx32 as x, sweepAabbFx32 as S } from "./fixedCollision32.js";
+export { i as Pcg32, o as aabbIntersectsFx, _ as aabbIntersectsFx32, e as atan2Fx, f as atan2Fx32, s as circleAabbIntersectsFx, v as circleAabbIntersectsFx32, c as circleContainsFx, y as circleContainsFx32, l as circlesIntersectFx, b as circlesIntersectFx32, t as cosFx, p as cosFx32, r as createFixed, h as createFixed32, g as createFixed32Vectors, a as createFixedVectors, u as segmentsIntersectFx, x as segmentsIntersectFx32, n as sinFx, m as sinFx32, d as sweepAabbFx, S as sweepAabbFx32 };

package/dist/fixed32.js

@@ -0,0 +1,133 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { addUint64 as t, captureUint64Words as n, compareUint64 as r } from "./fixedWords.js";
+import { fixedRawInteger as i } from "./fixedRaw.js";
+import { simulationOwnData as a } from "./simulationAuthoring.js";
+import { compare as o, compareWide as s, invert as c, limbs as l, magnitude as u, negative as d, product as f, subtract as p, words as m } from "./fixedWide.js";
+import { atan2Fx32 as h, cosFx32 as g, sinFx32 as _ } from "./fixedTrig32.js";
+// src/fixed32.ts
+function v(t) {
+	throw new e({
+		room: "fixed",
+		detail: t
+	});
+}
+var y = (e, t) => {
+	if (!t.hi && !t.lo) return v("Fixed division by zero");
+	let n = [
+		0,
+		0,
+		...l(e)
+	], i = [
+		,
+		,
+		,
+		,
+		,
+		,
+	].fill(0), a = {
+		hi: 0,
+		lo: 0
+	};
+	for (let e = 95; e >= 0; e--) {
+		let o = a.hi >>> 31, s = n[Math.floor(e / 16)] >>> e % 16 & 1;
+		a = {
+			hi: (a.hi << 1 | a.lo >>> 31) >>> 0,
+			lo: (a.lo << 1 | s) >>> 0
+		}, (o || r(a, t) >= 0) && (a = p(a, t), i[Math.floor(e / 16)] += 2 ** (e % 16));
+	}
+	return i;
+}, b = (e = {}) => {
+	let r = a(e, ["overflowChecks"], []), b = !Object.hasOwn(r, "overflowChecks") || r.overflowChecks;
+	if (typeof b != "boolean") return v("Fixed overflowChecks must be boolean");
+	let x = (e) => n(e), S = (e, t) => {
+		let n = m(e);
+		return b && (e.slice(4).some((e) => e !== 0) || !t && n.hi >= 2147483648 || t && (n.hi > 2147483648 || n.hi === 2147483648 && n.lo !== 0)) ? v("Fixed Q32.32 overflow") : x(t ? c(n) : n);
+	}, C = (e, n) => {
+		let r = t(e, n);
+		return b && d(e) === d(n) && d(r) !== d(e) ? v("Fixed Q32.32 overflow") : x(r);
+	}, w = (e, t) => S(y(u(e), u(t)), d(e) !== d(t));
+	return Object.freeze({
+		format: "32.32",
+		fractionalBits: 32,
+		overflowChecks: b,
+		raw: x,
+		fromInt: (e) => x({
+			hi: i(e) >>> 0,
+			lo: 0
+		}),
+		fromRatio: (e, t) => w({
+			hi: i(e) >>> 0,
+			lo: 0
+		}, {
+			hi: i(t) >>> 0,
+			lo: 0
+		}),
+		toNumber: (e) => {
+			let t = x(e);
+			return (t.hi | 0) + t.lo / 4294967296;
+		},
+		compare: (e, t) => o(x(e), x(t)),
+		add: (e, t) => C(x(e), x(t)),
+		sub: (e, t) => {
+			let n = x(e), r = x(t), i = p(n, r);
+			return b && d(n) !== d(r) && d(i) !== d(n) ? v("Fixed Q32.32 overflow") : x(i);
+		},
+		mul: (e, t) => {
+			let n = x(e), r = x(t);
+			return S(f(u(n), u(r)).slice(2), d(n) !== d(r));
+		},
+		div: (e, t) => w(x(e), x(t)),
+		sin: _,
+		cos: g,
+		atan2: h,
+		sqrt: (e) => {
+			let t = x(e);
+			if (d(t)) return v("Fixed square root requires a nonnegative value");
+			let n = [
+				0,
+				0,
+				...l(t)
+			], r = 0, i = 281474976710656;
+			for (; r + 1 < i;) {
+				let e = Math.floor((r + i) / 2), t = {
+					hi: Math.floor(e / 4294967296),
+					lo: e >>> 0
+				};
+				s(f(t, t), n) <= 0 ? r = e : i = e;
+			}
+			return x({
+				hi: Math.floor(r / 4294967296),
+				lo: r >>> 0
+			});
+		},
+		abs: (e) => {
+			let t = x(e);
+			return S(l(u(t)), !1);
+		},
+		floor: (e) => {
+			let t = x(e);
+			return x({
+				hi: t.hi,
+				lo: 0
+			});
+		},
+		round: (e) => {
+			let t = x(e), n = (t.hi | 0) + +(t.lo >= 2147483648);
+			return b && n > 2147483647 ? v("Fixed Q32.32 overflow") : x({
+				hi: n >>> 0,
+				lo: 0
+			});
+		},
+		clamp: (e, t, n) => {
+			let r = x(e), i = x(t), a = x(n);
+			return o(i, a) > 0 ? v("Fixed clamp requires ordered bounds") : o(r, i) < 0 ? i : o(r, a) > 0 ? a : r;
+		},
+		lerp: (e, n, r) => {
+			let i = x(e), a = x(n), s = x(r);
+			if (d(s) || s.hi > 1 || s.hi === 1 && s.lo !== 0) return v("Fixed interpolation fraction must lie in [0, 1]");
+			let l = o(a, i) < 0, u = l ? p(i, a) : p(a, i), h = m(f(u, s).slice(2));
+			return x(t(i, l ? c(h) : h));
+		}
+	});
+};
+export { b as createFixed32 };

package/dist/fixedCollision.js

@@ -0,0 +1,59 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { compareUint64 as t, multiplyWords as n, signedProductDifferenceSign as r } from "./fixedWords.js";
+import { createFixed as i } from "./fixedMath.js";
+import { captureVec2 as a, fixedOwnData as o } from "./fixedVectors.js";
+import { clipFixedBoxSlabs as s } from "./fixedSlabs.js";
+// src/fixedCollision.ts
+var c = i();
+function l(t) {
+	throw new e({
+		room: "fixed-collision",
+		detail: t
+	});
+}
+var u = (e) => {
+	let t = o(e, ["min", "max"]), n = a(t.min), r = a(t.max);
+	return n.x > r.x || n.y > r.y ? l("AABB bounds must be ordered") : {
+		min: n,
+		max: r
+	};
+}, d = (e) => {
+	let t = o(e, ["center", "radius"]), n = a(t.center), r = c.raw(t.radius);
+	return r < 0 ? l("Circle radius must be nonnegative") : {
+		center: n,
+		radius: r
+	};
+}, f = (e) => {
+	let t = o(e, ["start", "end"]);
+	return {
+		start: a(t.start),
+		end: a(t.end)
+	};
+}, p = (e, r, i) => {
+	let a = Math.abs(e), o = Math.abs(r);
+	if (a > i || o > i) return !1;
+	let s = n(a, a), c = n(o, o), l = n(i, i), u = s.lo + c.lo, d = s.hi + c.hi + +(u >= 4294967296);
+	return d <= 4294967295 && t({
+		hi: d,
+		lo: u >>> 0
+	}, l) <= 0;
+}, m = (e, t) => {
+	let n = u(e), r = u(t);
+	return n.min.x <= r.max.x && n.max.x >= r.min.x && n.min.y <= r.max.y && n.max.y >= r.min.y;
+}, h = (e, t) => {
+	let n = d(e), r = a(t);
+	return p(r.x - n.center.x, r.y - n.center.y, n.radius);
+}, g = (e, t) => {
+	let n = d(e), r = d(t);
+	return p(n.center.x - r.center.x, n.center.y - r.center.y, n.radius + r.radius);
+}, _ = (e, t) => {
+	let n = d(e), r = u(t), i = Math.min(r.max.x, Math.max(r.min.x, n.center.x)), a = Math.min(r.max.y, Math.max(r.min.y, n.center.y));
+	return p(n.center.x - i, n.center.y - a, n.radius);
+}, v = (e, t, n) => r(t.x - e.x, n.y - e.y, t.y - e.y, n.x - e.x), y = (e, t, n) => n.x >= Math.min(e.x, t.x) && n.x <= Math.max(e.x, t.x) && n.y >= Math.min(e.y, t.y) && n.y <= Math.max(e.y, t.y), b = (e, t) => {
+	let n = f(e), r = f(t), i = v(n.start, n.end, r.start), a = v(n.start, n.end, r.end), o = v(r.start, r.end, n.start), s = v(r.start, r.end, n.end);
+	return i * a < 0 && o * s < 0 || i === 0 && y(n.start, n.end, r.start) || a === 0 && y(n.start, n.end, r.end) || o === 0 && y(r.start, r.end, n.start) || s === 0 && y(r.start, r.end, n.end);
+}, x = (e, t, n) => {
+	let r = u(e), i = u(n), o = a(t);
+	return s([r.min.x, r.min.y], [r.max.x, r.max.y], [o.x, o.y], [i.min.x, i.min.y], [i.max.x, i.max.y], !1);
+};
+export { m as aabbIntersectsFx, _ as circleAabbIntersectsFx, h as circleContainsFx, g as circlesIntersectFx, b as segmentsIntersectFx, x as sweepAabbFx };

package/dist/fixedCollision32.js

@@ -0,0 +1,108 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { addUint64 as t, compareUint64 as n } from "./fixedWords.js";
+import { fixedOwnData as r } from "./fixedVectors.js";
+import { addWide as i, compare as a, compareWide as o, magnitude as s, negative as c, product as l, subtract as u } from "./fixedWide.js";
+import { createFixed32 as d } from "./fixed32.js";
+import { captureVec2Fx32 as f } from "./fixedVectors32.js";
+// src/fixedCollision32.ts
+var p = d(), m = {
+	hi: 0,
+	lo: 0
+}, h = {
+	hi: 0,
+	lo: 1
+};
+function g(t) {
+	throw new e({
+		room: "fixed-collision32",
+		detail: t
+	});
+}
+var _ = (e) => e.hi === 0 && e.lo === 0, v = (e, t) => a(e, t) < 0 ? {
+	negative: !0,
+	words: u(t, e)
+} : {
+	negative: !1,
+	words: u(e, t)
+}, y = (e, t, n, r) => {
+	let i = !_(e.words) && !_(t.words) && e.negative !== t.negative;
+	if (i !== (!_(n.words) && !_(r.words) && n.negative !== r.negative)) return i ? -1 : 1;
+	let a = o(l(e.words, t.words), l(n.words, r.words));
+	return i ? -a : a;
+}, b = (e) => {
+	let t = r(e, ["min", "max"]), n = f(t.min), i = f(t.max);
+	return a(n.x, i.x) > 0 || a(n.y, i.y) > 0 ? g("AABB bounds must be ordered") : {
+		min: n,
+		max: i
+	};
+}, x = (e) => {
+	let t = r(e, ["center", "radius"]), n = f(t.center), i = p.raw(t.radius);
+	return c(i) ? g("Circle radius must be nonnegative") : {
+		center: n,
+		radius: i
+	};
+}, S = (e) => {
+	let t = r(e, ["start", "end"]);
+	return {
+		start: f(t.start),
+		end: f(t.end)
+	};
+}, C = (e, t, r) => n(e, r) > 0 || n(t, r) > 0 ? !1 : o(i(l(e, e), l(t, t)), l(r, r)) <= 0, w = (e, t) => {
+	let n = b(e), r = b(t);
+	return a(n.min.x, r.max.x) <= 0 && a(n.max.x, r.min.x) >= 0 && a(n.min.y, r.max.y) <= 0 && a(n.max.y, r.min.y) >= 0;
+}, T = (e, t) => {
+	let n = x(e), r = f(t);
+	return C(v(r.x, n.center.x).words, v(r.y, n.center.y).words, n.radius);
+}, E = (e, n) => {
+	let r = x(e), i = x(n);
+	return C(v(r.center.x, i.center.x).words, v(r.center.y, i.center.y).words, t(r.radius, i.radius));
+}, D = (e, t, n) => a(e, t) < 0 ? t : a(e, n) > 0 ? n : e, O = (e, t) => {
+	let n = x(e), r = b(t), i = D(n.center.x, r.min.x, r.max.x), a = D(n.center.y, r.min.y, r.max.y);
+	return C(v(n.center.x, i).words, v(n.center.y, a).words, n.radius);
+}, k = (e, t, n) => y(v(t.x, e.x), v(n.y, e.y), v(t.y, e.y), v(n.x, e.x)), A = (e, t, n) => a(e, t) <= 0 ? a(n, e) >= 0 && a(n, t) <= 0 : a(n, t) >= 0 && a(n, e) <= 0, j = (e, t, n) => A(e.x, t.x, n.x) && A(e.y, t.y, n.y), M = (e, t) => {
+	let n = S(e), r = S(t), i = k(n.start, n.end, r.start), a = k(n.start, n.end, r.end), o = k(r.start, r.end, n.start), s = k(r.start, r.end, n.end);
+	return i * a < 0 && o * s < 0 || i === 0 && j(n.start, n.end, r.start) || a === 0 && j(n.start, n.end, r.end) || o === 0 && j(r.start, r.end, n.start) || s === 0 && j(r.start, r.end, n.end);
+}, N = (e, t) => y(e.numerator, {
+	negative: !1,
+	words: t.denominator
+}, t.numerator, {
+	negative: !1,
+	words: e.denominator
+}), P = (e) => Object.freeze({
+	numerator: Object.freeze({ ...e.numerator.words }),
+	denominator: Object.freeze({ ...e.denominator })
+}), F = (e, t, n) => {
+	let r = b(e), i = b(n), o = f(t), l = {
+		numerator: {
+			negative: !1,
+			words: m
+		},
+		denominator: h
+	}, u = {
+		numerator: {
+			negative: !1,
+			words: h
+		},
+		denominator: h
+	};
+	for (let e of ["x", "y"]) {
+		let t = o[e];
+		if (_(t)) {
+			if (a(r.max[e], i.min[e]) < 0 || a(r.min[e], i.max[e]) > 0) return null;
+			continue;
+		}
+		let n = s(t), d = {
+			numerator: c(t) ? v(r.min[e], i.max[e]) : v(i.min[e], r.max[e]),
+			denominator: n
+		}, f = {
+			numerator: c(t) ? v(r.max[e], i.min[e]) : v(i.max[e], r.min[e]),
+			denominator: n
+		};
+		if (N(d, l) > 0 && (l = d), N(f, u) < 0 && (u = f), N(l, u) > 0) return null;
+	}
+	return Object.freeze({
+		entry: P(l),
+		exit: P(u)
+	});
+};
+export { w as aabbIntersectsFx32, O as circleAabbIntersectsFx32, T as circleContainsFx32, E as circlesIntersectFx32, M as segmentsIntersectFx32, F as sweepAabbFx32 };

package/dist/fixedMath.js

@@ -0,0 +1,55 @@
+import { RoomAuthoringError as e } from "./errors.js";
+import { multiplyWords as t } from "./fixedWords.js";
+import { fixedRawInteger as n } from "./fixedRaw.js";
+import { atan2Fx as r, cosFx as i, sinFx as a } from "./fixedTrig.js";
+// src/fixedMath.ts
+function o(t) {
+	throw new e({
+		room: "fixed",
+		detail: t
+	});
+}
+var s = (e, n) => {
+	let r = t(Math.abs(e), Math.abs(n)), i = r.hi * 65536 + (r.lo >>> 16);
+	return e < 0 == n < 0 ? i : -i;
+}, c = (e = {}) => {
+	if (!e || Object.getPrototypeOf(e) !== Object.prototype || Reflect.ownKeys(e).some((t) => {
+		let n = Object.getOwnPropertyDescriptor(e, t);
+		return t !== "overflowChecks" || !n?.enumerable || !("value" in n);
+	})) return o("Fixed configuration requires exact own data");
+	let t = !Object.hasOwn(e, "overflowChecks") || e.overflowChecks;
+	if (typeof t != "boolean") return o("Fixed overflowChecks must be boolean");
+	let c = (e) => !Number.isInteger(e) || !Number.isSafeInteger(e) ? o("Fixed arithmetic exceeded exact integer precision") : t && (e < -2147483648 || e > 2147483647) ? o("Fixed Q16.16 overflow") : e | 0;
+	return Object.freeze({
+		format: "16.16",
+		fractionalBits: 16,
+		scale: 65536,
+		overflowChecks: t,
+		raw: (e) => n(e) | 0,
+		fromInt: (e) => c(n(e) * 65536),
+		fromRatio: (e, t) => (n(e), n(t), t === 0 ? o("Fixed division by zero") : c(Math.trunc(e * 65536 / t))),
+		toNumber: (e) => n(e) / 65536,
+		add: (e, t) => c(n(e) + n(t)),
+		sub: (e, t) => c(n(e) - n(t)),
+		mul: (e, t) => c(s(n(e), n(t))),
+		div: (e, t) => (n(e), n(t), t === 0 ? o("Fixed division by zero") : c(Math.trunc(e * 65536 / t))),
+		sin: a,
+		cos: i,
+		atan2: r,
+		sqrt: (e) => {
+			if (n(e), e < 0) return o("Fixed square root requires a nonnegative value");
+			let t = e * 65536, r = 0, i = 16777216;
+			for (; r + 1 < i;) {
+				let e = Math.floor((r + i) / 2);
+				e * e <= t ? r = e : i = e;
+			}
+			return c(r);
+		},
+		abs: (e) => c(Math.abs(n(e))),
+		floor: (e) => c(Math.floor(n(e) / 65536) * 65536),
+		round: (e) => c(Math.floor((n(e) + 32768) / 65536) * 65536),
+		clamp: (e, t, r) => (n(e), n(t), n(r), t > r ? o("Fixed clamp requires ordered bounds") : c(Math.min(r, Math.max(t, e)))),
+		lerp: (e, t, r) => (n(e), n(t), n(r), r < 0 || r > 65536 ? o("Fixed interpolation fraction must lie in [0, 1]") : c(e + s(t - e, r)))
+	});
+};
+export { c as createFixed };

package/dist/fixedRaw.js

@@ -0,0 +1,10 @@
+import { RoomAuthoringError as e } from "./errors.js";
+// src/fixedRaw.ts
+var t = (t) => {
+	if (!Number.isInteger(t) || t < -2147483648 || t > 2147483647) throw new e({
+		room: "fixed",
+		detail: "Fixed raw values must be signed 32-bit integers"
+	});
+	return t === 0 ? 0 : t;
+};
+export { t as fixedRawInteger };