rayzee 9.4.2 → 9.5.0

package/dist/RayzeeRenderer-BQxnzCTD.js

@@ -0,0 +1,3542 @@
+import { dt as e } from "./SolarLimb-ken-JbDK.js";
+import { Mt as t, Nt as n, St as r, _t as i, ct as a, ft as o, gt as s, n as c, ot as l, st as u, vt as d, xt as f, yt as ee } from "./PathTracer-Ccl9KOuF.js";
+import { n as p, t as m } from "./EngineEvents-Ci8dVWCP.js";
+import { _ as h, d as te, f as ne, g, l as re, m as ie, o as ae, p as _, r as oe, u as se } from "./sceneCachePolicy-BmwYOYDu.js";
+import { A as ce, P as le, k as ue, l as de, o as fe, p as v, q as pe, v as me, y, z as he } from "./EngineDefaults-DH3bI5t-.js";
+import { i as b, r as ge } from "./Logger-BnHghprG.js";
+import { i as _e, n as x, t as ve } from "./EngineIssues-CIZnXHsF.js";
+import { n as ye, r as be } from "./shared-BGBcSxBQ.js";
+import { a as xe } from "./WorkingMatrix-C6y233hT.js";
+import { i as S, r as Se, t as C } from "./ActiveColor-YvuQq44O.js";
+import { n as w, r as Ce } from "./AssetConfig-DSEntE65.js";
+import { c as we, f as Te, l as T, p as Ee, u as De } from "./ViewTransforms-D0rTLBsX.js";
+import { n as Oe, r as E } from "./identity-DrQsGT2o.js";
+import { t as ke } from "./ToneMapGPU-BHi5JzIq.js";
+import { n as Ae } from "./archiveFormats-BZw7TiDp.js";
+import { LinearSRGBColorSpace as je, MeshBasicNodeMaterial as Me, NodeMaterial as Ne, QuadMesh as D, RectAreaLightNode as Pe, SRGBColorSpace as Fe, TextureNode as Ie, WebGPURenderer as Le } from "three/webgpu";
+import { Fn as Re, If as ze, cubeTexture as Be, dot as Ve, float as O, int as k, ivec2 as He, mix as A, screenCoordinate as Ue, select as j, storage as We, texture as Ge, uint as Ke, uniform as M, uv as N, vec3 as P, vec4 as qe } from "three/tsl";
+import { Box3 as Je, BufferGeometry as Ye, CircleGeometry as Xe, Color as Ze, DataTexture as Qe, DirectionalLight as $e, DirectionalLightHelper as et, EquirectangularReflectionMapping as tt, EventDispatcher as F, FloatType as nt, LinearFilter as rt, LinearSRGBColorSpace as it, LoaderUtils as I, LoadingManager as at, MathUtils as L, Mesh as ot, MeshPhysicalMaterial as st, NearestFilter as ct, NoBlending as lt, NoToneMapping as ut, Object3D as R, OrthographicCamera as dt, PerspectiveCamera as ft, PointLight as pt, PointLightHelper as mt, REVISION as ht, RGBAFormat as gt, RectAreaLight as z, RenderTarget as _t, SRGBColorSpace as B, Scene as vt, SpotLight as yt, SpotLightHelper as bt, TextureLoader as xt, UnsignedByteType as St, Vector2 as Ct, Vector3 as V } from "three";
+import { RectAreaLightTexturesLib as wt } from "three/addons/lights/RectAreaLightTexturesLib.js";
+import { RectAreaLightHelper as Tt } from "three/addons/helpers/RectAreaLightHelper.js";
+import { GLTFLoader as Et } from "three/addons/loaders/GLTFLoader.js";
+import { HDRLoader as Dt } from "three/addons/loaders/HDRLoader.js";
+import { createMeshesFromMultiMaterialMesh as Ot } from "three/addons/utils/SceneUtils.js";
+import { clone as kt } from "three/addons/utils/SkeletonUtils.js";
+//#region src/SceneHelpers.js
+var At = class {
+	constructor() {
+		this.scene = new vt(), this._helpers = /* @__PURE__ */ new Map(), this.visible = !1;
+	}
+	add(e) {
+		if (this._helpers.has(e.uuid)) return this._helpers.get(e.uuid);
+		let t = this._createHelper(e);
+		return t ? (this._helpers.set(e.uuid, t), this.scene.add(t), t) : null;
+	}
+	remove(e) {
+		let t = this._helpers.get(e.uuid);
+		t && (t.dispose(), this.scene.remove(t), this._helpers.delete(e.uuid));
+	}
+	has(e) {
+		return this._helpers.has(e.uuid);
+	}
+	get isDrawing() {
+		return this.visible && this._helpers.size > 0;
+	}
+	update() {
+		for (let e of this._helpers.values()) e.update?.();
+	}
+	sync(e) {
+		let t = new Set(e.map((e) => e.uuid));
+		for (let [e, n] of this._helpers) t.has(e) || (n.dispose(), this.scene.remove(n), this._helpers.delete(e));
+		for (let t of e) this.add(t);
+	}
+	clear() {
+		for (let e of this._helpers.values()) e.dispose(), this.scene.remove(e);
+		this._helpers.clear();
+	}
+	render(e, t) {
+		if (!this.isDrawing) return;
+		let n = e.autoClear;
+		e.autoClear = !1, e.clearDepth(), e.setRenderTarget(null), e.render(this.scene, t), e.autoClear = n;
+	}
+	dispose() {
+		this.clear();
+	}
+	_createHelper(e) {
+		return e.isRectAreaLight ? new Tt(e) : e.isPointLight ? new mt(e, .5) : e.isSpotLight ? new bt(e) : e.isDirectionalLight ? new et(e, .5) : null;
+	}
+}, jt = class extends t {
+	constructor(t, r = {}) {
+		super("Compositor", {
+			...r,
+			executionMode: n.ALWAYS
+		}), this.renderer = t, this._lightSources = [...r.displaySources ?? [], "pathtracer:color"], this.saturation = M(r.saturation ?? 1), this._transparentBackground = M(0, "int"), this._pathTracer = r.pathTracer ?? null, this._convergenceOverlay = !1, this._debugMaterial = null, this._debugQuad = null, this._debugTexNode = null, this._debugM2Attr = null, this._debugMaskAttr = null, this._debugExposureComp = M(1), this._sourceTexNode = new Ie();
+		let i = this._sourceTexNode.sample(N()), a = A(P(Ve(i.xyz, e)), i.xyz, this.saturation), o = j(this._transparentBackground, i.w, 1);
+		this.compositorMaterial = new Me(), this.compositorMaterial.colorNode = qe(a, o), this.compositorMaterial.blending = lt, this.compositorQuad = new D(this.compositorMaterial);
+	}
+	resolveLightTexture(e) {
+		return this.resolveLightSource(e)?.texture ?? null;
+	}
+	resolveLightSource(e) {
+		for (let t of this._lightSources) {
+			let n = e.getTexture(t);
+			if (n) return {
+				key: t,
+				texture: n
+			};
+		}
+		return null;
+	}
+	_ensureDebugMaterial() {
+		let t = this._pathTracer?.getConvergenceDebugSource?.();
+		if (!t) return !1;
+		if (this._debugMaterial && this._debugM2Attr === t.m2 && this._debugMaskAttr === t.frozenMask) return !0;
+		this._debugMaterial?.dispose(), this._debugTexNode?.dispose(), this._debugM2Attr = t.m2, this._debugMaskAttr = t.frozenMask, this._debugTexNode = new Ie();
+		let n = Re(() => {
+			let n = Ve(this._debugTexNode.sample(N()).toVar().xyz, e).toVar(), r = t.renderWidth, i = t.renderHeight, a = k(N().x.mul(O(r))).min(r.sub(k(1))).max(k(0)), o = Ke(k(N().y.mul(O(i))).min(i.sub(k(1))).max(k(0)).mul(r).add(a)).toVar(), s = We(t.m2, "float").toReadOnly().element(o).toVar(), c = We(t.frozenMask, "uint").toReadOnly().element(o).toVar(), l = s.sub(n.mul(n)).max(O(0)).div(O(t.frame).add(1)).sqrt().toVar(), u = t.usePixelFreeze.greaterThan(k(0)), d = j(n.lessThan(O(1)), n.sqrt(), n).toVar(), f = j(u, l.div(n.add(O(1e-4))), l.div(d.add(O(1e-4)))).toVar(), ee = j(u, t.pixelFreezeThreshold, t.noiseThreshold).toVar(), p = f.div(ee.max(O(1e-6))).toVar(), m = P(n.div(n.add(O(1))).sqrt().mul(.55)).toVar(), h = m.toVar(), te = O(t.frame).greaterThanEqual(O(t.adaptiveMinSamples));
+			return ze(p.greaterThanEqual(O(1)).or(te.not()), () => {
+				let e = A(P(1, .8, .1), P(1, .1, .05), p.sub(1).div(3).clamp(0, 1));
+				h.assign(A(m, e, .85));
+			}), ze(c.equal(Ke(1)).and(u), () => {
+				h.assign(A(m, P(.1, .45, 1), .55));
+			}), h;
+		});
+		return this._debugMaterial = new Me(), this._debugMaterial.colorNode = qe(n().pow(2.2).mul(this._debugExposureComp), 1), this._debugMaterial.blending = lt, this._debugQuad = new D(this._debugMaterial), !0;
+	}
+	render(e) {
+		if (!this.enabled) return;
+		if (this._convergenceOverlay && this._ensureDebugMaterial()) {
+			let t = e.getTexture("pathtracer:color");
+			if (t) {
+				this._debugTexNode.value = t;
+				let e = this.renderer.toneMapping !== ut;
+				this._debugExposureComp.value = e ? 1 / Math.max(this.renderer.toneMappingExposure, 1e-4) : 1, this.renderer.setRenderTarget(null), this._debugQuad.render(this.renderer);
+				return;
+			}
+		}
+		let t = this.resolveLightTexture(e);
+		t && (this._sourceTexNode.value = t, this.renderer.setRenderTarget(null), this.compositorQuad.render(this.renderer));
+	}
+	setConvergenceOverlay(e) {
+		this._convergenceOverlay = !!e;
+	}
+	setSaturation(e) {
+		this.saturation.value = e;
+	}
+	setTransparentBackground(e) {
+		this._transparentBackground.value = +!!e;
+	}
+	dispose() {
+		this._sourceTexNode?.dispose(), this.compositorMaterial?.dispose(), this._debugTexNode?.dispose(), this._debugMaterial?.dispose(), this.compositorQuad = null, this._debugQuad = null, this._debugMaterial = null, this._debugTexNode = null, this._pathTracer = null;
+	}
+}, Mt = class {
+	constructor() {
+		this.textures = /* @__PURE__ */ new Map(), this.renderTargets = /* @__PURE__ */ new Map(), this.uniforms = /* @__PURE__ */ new Map(), this.state = {
+			frame: 0,
+			accumulatedFrames: 0,
+			renderMode: 0,
+			interactionMode: !1,
+			isComplete: !1,
+			tileInfo: null,
+			currentTile: 0,
+			totalTiles: 0,
+			cameraChanged: !1,
+			cameraMoving: !1,
+			width: 0,
+			height: 0,
+			time: 0,
+			deltaTime: 0
+		}, this._stateChangeCallbacks = /* @__PURE__ */ new Map();
+	}
+	setTexture(e, t) {
+		this.textures.set(e, t);
+	}
+	getTexture(e) {
+		return this.textures.get(e);
+	}
+	hasTexture(e) {
+		return this.textures.has(e);
+	}
+	removeTexture(e) {
+		this.textures.delete(e);
+	}
+	getTextureNames() {
+		return Array.from(this.textures.keys());
+	}
+	clearTextures() {
+		this.textures.clear();
+	}
+	setRenderTarget(e, t) {
+		this.renderTargets.set(e, t);
+	}
+	getRenderTarget(e) {
+		return this.renderTargets.get(e);
+	}
+	hasRenderTarget(e) {
+		return this.renderTargets.has(e);
+	}
+	removeRenderTarget(e) {
+		this.renderTargets.delete(e);
+	}
+	getRenderTargetNames() {
+		return Array.from(this.renderTargets.keys());
+	}
+	clearRenderTargets() {
+		this.renderTargets.clear();
+	}
+	setUniform(e, t) {
+		this.uniforms.has(e) ? this.uniforms.get(e).value = t : this.uniforms.set(e, { value: t });
+	}
+	getUniform(e) {
+		return this.uniforms.get(e);
+	}
+	getUniformValue(e) {
+		return this.uniforms.get(e)?.value;
+	}
+	hasUniform(e) {
+		return this.uniforms.has(e);
+	}
+	removeUniform(e) {
+		this.uniforms.delete(e);
+	}
+	getUniformNames() {
+		return Array.from(this.uniforms.keys());
+	}
+	clearUniforms() {
+		this.uniforms.clear();
+	}
+	setState(e, t) {
+		let n = this.state[e], r = n !== t;
+		return r && (this.state[e] = t, this._notifyStateChange(e, t, n)), r;
+	}
+	getState(e) {
+		return this.state[e];
+	}
+	getAllState() {
+		return this.state;
+	}
+	setStates(e) {
+		let t = [];
+		for (let [n, r] of Object.entries(e)) this.setState(n, r) && t.push(n);
+		return t;
+	}
+	hasState(e) {
+		return e in this.state;
+	}
+	watchState(e, t) {
+		this._stateChangeCallbacks.has(e) || this._stateChangeCallbacks.set(e, []), this._stateChangeCallbacks.get(e).push(t);
+	}
+	unwatchState(e, t) {
+		if (!this._stateChangeCallbacks.has(e)) return;
+		let n = this._stateChangeCallbacks.get(e), r = n.indexOf(t);
+		r > -1 && n.splice(r, 1);
+	}
+	_notifyStateChange(e, t, n) {
+		if (!this._stateChangeCallbacks.has(e)) return;
+		let r = this._stateChangeCallbacks.get(e);
+		for (let i of r) try {
+			i(t, n);
+		} catch (t) {
+			console.error(`Error in state change callback for '${e}':`, t);
+		}
+	}
+	reset() {
+		this.state.frame = 0, this.state.accumulatedFrames = 0, this.state.isComplete = !1, this.state.cameraChanged = !0, this.state.currentTile = 0;
+	}
+	incrementFrame() {
+		return this.state.frame++, this.state.accumulatedFrames++, this.state.frame;
+	}
+	dispose() {
+		this.textures.clear(), this.renderTargets.clear(), this.uniforms.clear(), this._stateChangeCallbacks.clear(), this.state = {};
+	}
+}, Nt = class extends F {
+	constructor() {
+		super(), this._onceCallbacks = /* @__PURE__ */ new Map();
+	}
+	on(e, t) {
+		this.addEventListener(e, t);
+	}
+	once(e, t) {
+		let n = (r) => {
+			t(r), this.off(e, n), this._onceCallbacks.delete(t);
+		};
+		this._onceCallbacks.set(t, n), this.on(e, n);
+	}
+	off(e, t) {
+		let n = this._onceCallbacks.get(t);
+		n ? (this.removeEventListener(e, n), this._onceCallbacks.delete(t)) : this.removeEventListener(e, t);
+	}
+	emit(e, t) {
+		t && typeof t == "object" && t.type ? this.dispatchEvent(t) : this.dispatchEvent({
+			type: e,
+			...t
+		});
+	}
+	removeAllListeners(e) {
+		if (e) {
+			for (let [t, n] of this._onceCallbacks.entries()) this.hasEventListener(e, n) && (this.removeEventListener(e, n), this._onceCallbacks.delete(t));
+			this._listeners && this._listeners[e] && delete this._listeners[e];
+		} else this._onceCallbacks.clear(), this._listeners &&= {};
+	}
+	listenerCount(e) {
+		return !this._listeners || !this._listeners[e] ? 0 : this._listeners[e].length;
+	}
+	clear() {
+		this.removeAllListeners();
+	}
+	eventNames() {
+		return this._listeners ? Object.keys(this._listeners) : [];
+	}
+}, Pt = !1, H = [], Ft = /* @__PURE__ */ new WeakMap();
+function It(e) {
+	Pt = !!e;
+}
+function Lt() {
+	return H.slice();
+}
+function Rt() {
+	H.length = 0;
+}
+function zt(e) {
+	let t = [];
+	for (let n of Object.keys(e)) e[n]?.isTextureNode === !0 && t.push(n);
+	return t;
+}
+var Bt = (e) => !e || !e.image || !(e.image.width > 0);
+function Vt(e, t, n) {
+	if (!Pt) {
+		n();
+		return;
+	}
+	let r = Ft.get(e);
+	if (r || (r = {
+		phase: "pending",
+		unboundAtCompile: []
+	}, Ft.set(e, r)), r.phase !== "pending") {
+		n(), r.phase === "watch" && Ht(e, r);
+		return;
+	}
+	let i = Object.prototype.hasOwnProperty.call(t, "compute"), a = t.compute;
+	t.compute = function(...t) {
+		return r.phase === "pending" && (r.unboundAtCompile = zt(e).filter((t) => Bt(e[t].value)), r.phase = r.unboundAtCompile.length < 2 ? "done" : "watch"), a.apply(this, t);
+	};
+	try {
+		n();
+	} finally {
+		i ? t.compute = a : delete t.compute;
+	}
+}
+function Ht(e, t) {
+	let n = [];
+	for (let r of t.unboundAtCompile) {
+		let t = e[r]?.value;
+		if (Bt(t)) return;
+		t.isStorageTexture !== !0 && n.push(r);
+	}
+	t.phase = "done", n.length !== 0 && H.push({
+		stage: e.name,
+		nodes: n,
+		unboundAtCompile: t.unboundAtCompile.slice(),
+		message: `${e.name}: ${n.join(", ")} ${n.length === 1 ? "was" : "were"} still holding EmptyTexture when the stage first dispatched, alongside ${t.unboundAtCompile.length - n.length} other unbound node(s), and later received a non-storage texture. Two nodes unbound at compile time can share one GPU binding and then both resolve to whichever is assigned last. Assign these before the first dispatch.`
+	});
+}
+//#endregion
+//#region src/Pipeline/RenderPipeline.js
+var Ut = class {
+	_reportStageFailure(e, t, n) {
+		console.error(`[Pipeline] Error in stage '${e}' (${t}):`, n);
+		let r = `${e}:${t}`;
+		this._reportedStageFailures.has(r) || (this._reportedStageFailures.add(r), this._issues?.record(x.STAGE_RENDER_FAILED, `stage "${e}" threw during ${t} — the frame is incomplete`, {
+			stage: e,
+			phase: t,
+			cause: String(n?.message ?? n)
+		}));
+	}
+	constructor(e, t, n, { issues: r = null } = {}) {
+		this.renderer = e, this._issues = r, this._reportedStageFailures = /* @__PURE__ */ new Set(), this.width = t, this.height = n, this.stages = [], this.context = new Mt(), this.eventBus = new Nt(), this.context.setState("width", t), this.context.setState("height", n), this.stats = {
+			enabled: !1,
+			logSkipped: !1,
+			timings: /* @__PURE__ */ new Map(),
+			frameCount: 0
+		};
+	}
+	addStage(e) {
+		this.stages.push(e), e.initialize(this.context, this.eventBus), this.stats.enabled && console.log(`[Pipeline] Added stage: ${e.name}`);
+	}
+	getStage(e) {
+		return this.stages.find((t) => t.name === e);
+	}
+	removeStage(e) {
+		let t = this.stages.findIndex((t) => t.name === e);
+		if (t > -1) {
+			let e = this.stages[t];
+			return this.stages.splice(t, 1), e.dispose && e.dispose(), this.stats.timings.delete(e.name), !0;
+		}
+		return !1;
+	}
+	setStageEnabled(e, t) {
+		let n = this.getStage(e);
+		n && (t ? n.enable() : n.disable());
+	}
+	render(e = null) {
+		let t = this.stats.enabled ? performance.now() : 0;
+		for (let t of this.stages) {
+			if (!t.shouldExecuteThisFrame(this.context)) {
+				this.stats.enabled && this.stats.logSkipped && console.log(`[Pipeline] Skipped stage '${t.name}' (executionMode: ${t.executionMode})`);
+				continue;
+			}
+			try {
+				let n = this.stats.enabled ? performance.now() : 0;
+				if (Vt(t, this.renderer, () => t.render(this.context, e)), this.stats.enabled) {
+					let e = performance.now() - n;
+					this.stats.timings.has(t.name) || this.stats.timings.set(t.name, []);
+					let r = this.stats.timings.get(t.name);
+					r.push(e), r.length > 60 && r.shift();
+				}
+			} catch (e) {
+				this._reportStageFailure(t.name, "render", e);
+			}
+		}
+		if (this.context.incrementFrame(), this.eventBus.emit("frame:complete", {
+			frame: this.context.getState("frame"),
+			accumulatedFrames: this.context.getState("accumulatedFrames")
+		}), this.stats.enabled) {
+			let e = performance.now() - t;
+			this.stats.timings.has("_total") || this.stats.timings.set("_total", []);
+			let n = this.stats.timings.get("_total");
+			n.push(e), n.length > 60 && n.shift(), this.stats.frameCount++;
+		}
+	}
+	reset() {
+		this.eventBus.emit("pipeline:reset");
+		for (let e of this.stages) if (e.reset) try {
+			e.reset();
+		} catch (t) {
+			this._reportStageFailure(e.name, "reset", t);
+		}
+		this.context.reset(), this.stats.enabled && (this.stats.timings.clear(), this.stats.frameCount = 0);
+	}
+	setSize(e, t) {
+		this.width = e, this.height = t, this.context.setState("width", e), this.context.setState("height", t), this.eventBus.emit("pipeline:resize", {
+			width: e,
+			height: t
+		});
+		for (let n of this.stages) if (n.setSize) try {
+			n.setSize(e, t);
+		} catch (e) {
+			console.error(`[Pipeline] Error resizing stage '${n.name}':`, e);
+		}
+	}
+	dispose() {
+		for (let e of this.stages) if (e.dispose) try {
+			e.dispose();
+		} catch (t) {
+			console.error(`[Pipeline] Error disposing stage '${e.name}':`, t);
+		}
+		this.stages = [], this.context.dispose(), this.eventBus.clear(), this.stats.timings.clear();
+	}
+	setStatsEnabled(e) {
+		this.stats.enabled = e, e || (this.stats.timings.clear(), this.stats.frameCount = 0);
+	}
+	getStats() {
+		if (!this.stats.enabled) return null;
+		let e = {
+			frameCount: this.stats.frameCount,
+			stages: {},
+			total: 0
+		};
+		for (let [t, n] of this.stats.timings.entries()) {
+			if (n.length === 0) continue;
+			let r = n.reduce((e, t) => e + t, 0) / n.length, i = Math.min(...n), a = Math.max(...n);
+			t === "_total" ? (e.total = r, e.totalMin = i, e.totalMax = a) : e.stages[t] = {
+				avg: r,
+				min: i,
+				max: a
+			};
+		}
+		return e;
+	}
+	logStats() {
+		let e = this.getStats();
+		if (!e) {
+			console.log("[Pipeline] Stats not enabled");
+			return;
+		}
+		console.group("[Pipeline] Performance Stats"), console.log(`Frames: ${e.frameCount}`), e.totalMin === void 0 ? console.log("Total: no frames recorded yet (pipeline.render() has not run since stats were enabled — the path tracer may have converged and stopped its animation loop)") : console.log(`Total: ${e.total.toFixed(2)}ms (min: ${e.totalMin.toFixed(2)}ms, max: ${e.totalMax.toFixed(2)}ms)`);
+		for (let [t, n] of Object.entries(e.stages)) console.log(`  ${t}: ${n.avg.toFixed(2)}ms (min: ${n.min.toFixed(2)}ms, max: ${n.max.toFixed(2)}ms)`);
+		console.groupEnd();
+	}
+	getInfo() {
+		return {
+			stageCount: this.stages.length,
+			enabledStages: this.stages.filter((e) => e.enabled).length,
+			stages: this.stages.map((e) => ({
+				name: e.name,
+				enabled: e.enabled
+			})),
+			contextState: this.context.getAllState(),
+			textures: this.context.getTextureNames(),
+			renderTargets: this.context.getRenderTargetNames(),
+			uniforms: this.context.getUniformNames(),
+			events: this.eventBus.eventNames()
+		};
+	}
+	logInfo() {
+		let e = this.getInfo();
+		console.group("[Pipeline] Info"), console.log("Stages:", e.stages), console.log("Context Textures:", e.textures), console.log("Context Render Targets:", e.renderTargets), console.log("Context Uniforms:", e.uniforms), console.log("Event Types:", e.events), console.log("State:", e.contextState), console.groupEnd();
+	}
+}, Wt = ge("engine"), Gt = class {
+	constructor() {
+		this.timeElapsed = 0, this.lastResetTime = performance.now(), this.renderCompleteDispatched = !1, this.budgetOverrun = !1, this._budgetHeldWarned = !1;
+	}
+	updateTime() {
+		this.timeElapsed = (performance.now() - this.lastResetTime) / 1e3;
+	}
+	isTimeLimitReached(e, t, n) {
+		return t !== "time" || !(n > 0) || this.timeElapsed < n ? !1 : e?.frameCount > 0 ? (this.budgetOverrun = !0, !0) : (this._budgetHeldWarned || (this._budgetHeldWarned = !0, Wt.warn(`render time limit (${n}s) expired before the first sample landed — holding the deadline open to avoid capturing an empty frame`)), !1);
+	}
+	isLimitReached(e, t, n) {
+		return e ? this.isTimeLimitReached(e, t, n) ? !0 : this.stopCondition(e) !== null : !1;
+	}
+	stopCondition(e) {
+		return this.budgetOverrun ? "timeLimit" : e ? e.frameCount >= e.completionThreshold ? "samples" : e._isConvergedComplete?.() ? "converged" : null : null;
+	}
+	markComplete() {
+		return this.renderCompleteDispatched ? !1 : (this.renderCompleteDispatched = !0, !0);
+	}
+	reset() {
+		this.timeElapsed = 0, this.lastResetTime = performance.now(), this.renderCompleteDispatched = !1, this.budgetOverrun = !1, this._budgetHeldWarned = !1;
+	}
+	resumeFromPause() {
+		this.renderCompleteDispatched = !1, this.lastResetTime = performance.now() - this.timeElapsed * 1e3;
+	}
+}, Kt = class {
+	constructor(e) {
+		this.renderer = e, this.target = null, this.material = new Ne(), this.material.name = "rayzee:texture-readback", this.quad = new D(this.material), this._node = null, this._source = null;
+	}
+	_ensureTarget(e, t) {
+		this.target && this.target.width === e && this.target.height === t || (this.target?.dispose(), this.target = new _t(e, t, {
+			type: nt,
+			format: gt,
+			depthBuffer: !1,
+			minFilter: ct,
+			magFilter: ct
+		}));
+	}
+	async read(e, t, n) {
+		try {
+			return await this.renderer.readRenderTargetPixelsAsync(this.draw(e, t, n), 0, 0, t, n);
+		} finally {
+			this.release();
+		}
+	}
+	draw(e, t, n) {
+		this._ensureTarget(t, n), this._source !== e && (this._node = Ge(e).load(He(Ue.xy)), this.material.outputNode = this._node, this.material.needsUpdate = !0, this._source = e);
+		let r = this.renderer.getRenderTarget();
+		return this.renderer.setRenderTarget(this.target), this.quad.render(this.renderer), this.renderer.setRenderTarget(r), this.target;
+	}
+	release() {
+		this.target?.dispose(), this.target = null;
+	}
+	dispose() {
+		this.target?.dispose(), this.material.dispose(), this.target = null, this._source = null, this._node = null;
+	}
+}, qt = 864e5, U = Object.freeze({
+	IMMUTABLE: "immutable",
+	REVALIDATE: "revalidate",
+	NETWORK: "network"
+}), W = (e, t) => ({
+	loaded: e,
+	total: t,
+	lengthComputable: t > 0 && e <= t
+}), G = (e, t) => e.headers?.get?.(t) ?? null, Jt = (e) => e.reason ?? new DOMException("aborted", "AbortError");
+function K(e) {
+	try {
+		let t = new URL(e, globalThis.location?.href ?? "http://localhost/").pathname;
+		return decodeURIComponent(t.split("/").pop()) || "download";
+	} catch {
+		return "download";
+	}
+}
+async function Yt(e, { onProgress: t, signal: n }) {
+	let r = Number(G(e, "content-length")) || 0, i = G(e, "content-type") ?? "";
+	if (!e.body) return new Blob([await e.arrayBuffer()], { type: i });
+	let a = e.body.getReader(), o = [], s = 0;
+	for (;;) {
+		if (n?.aborted) throw a.cancel().catch(() => {}), Jt(n);
+		let { done: e, value: i } = await a.read();
+		if (e) break;
+		o.push(i), s += i.length, t?.(W(s, r));
+	}
+	return new Blob(o, { type: i });
+}
+var q = (e, t, n) => new File([e], t, {
+	type: n || e.type,
+	lastModified: e.lastModified ?? Date.now()
+}), Xt = () => {}, J = class {
+	constructor(e) {
+		this._storage = e, this._revalidating = /* @__PURE__ */ new Set();
+	}
+	get _area() {
+		return this._storage?.area(be.DOWNLOADS) ?? null;
+	}
+	async fetch(e, { key: t = e, name: n = K(e), policy: r = U.REVALIDATE, maxAgeMs: i = qt, onProgress: a = null, signal: o = null, fetchOptions: s = {} } = {}) {
+		let c = this._area;
+		if (c && r !== U.NETWORK) {
+			let o = await c.open(t);
+			if (o) {
+				let c = await o.file("data");
+				if (c) return r === U.REVALIDATE && Date.now() - (o.extra.checkedAt ?? 0) >= i && this._revalidate(e, t, n, o.extra, s), a?.(W(c.size, c.size)), {
+					file: q(c, n, o.extra.contentType),
+					release: () => o.release(),
+					fromCache: !0
+				};
+				o.release();
+			}
+		}
+		return this._download(e, t, n, {
+			onProgress: a,
+			signal: o,
+			fetchOptions: s,
+			cache: !!c
+		});
+	}
+	async has(e) {
+		return await this._area?.has(e) === !0;
+	}
+	async _download(e, t, n, { onProgress: r, signal: i, fetchOptions: a, cache: o }) {
+		if (i?.aborted) throw Jt(i);
+		let s = await fetch(e, {
+			...a,
+			signal: i
+		});
+		if (!s.ok) throw Error(`HTTP ${s.status} fetching ${e}`);
+		let c = Number(G(s, "content-length")) || 0, l = {
+			url: e,
+			contentType: G(s, "content-type") ?? "",
+			lastModified: G(s, "last-modified"),
+			contentLength: c || null,
+			checkedAt: Date.now()
+		}, u = o && s.body ? await this._area.create(t, {
+			label: n,
+			expectedBytes: c
+		}) : null;
+		if (!u) return {
+			file: q(await Yt(s, {
+				onProgress: r,
+				signal: i
+			}), n, l.contentType),
+			release: Xt,
+			fromCache: !1
+		};
+		try {
+			await u.writeStream("data", s.body, {
+				signal: i,
+				onProgress: (e) => r?.(W(e, c))
+			}), await u.commit(l);
+		} catch (o) {
+			if (await u.abort(), o?.name !== "QuotaExceededError") throw o;
+			return this._download(e, t, n, {
+				onProgress: r,
+				signal: i,
+				fetchOptions: a,
+				cache: !1
+			});
+		}
+		let d = await this._area.open(t, { wait: !0 }), f = d && await d.file("data");
+		if (!f) throw d?.release(), Error(`storage: ${n} vanished right after it was saved`);
+		return {
+			file: q(f, n, l.contentType),
+			release: () => d.release(),
+			fromCache: !1
+		};
+	}
+	async _revalidate(e, t, n, r, i) {
+		if (this._revalidating.has(t)) return;
+		this._revalidating.add(t);
+		let a = !1;
+		try {
+			let t = new Headers(i?.headers);
+			t.set("Range", "bytes=0-0");
+			let n = await fetch(e, {
+				...i,
+				headers: t
+			});
+			if (n.body?.cancel().catch(() => {}), n.ok) {
+				let e = G(n, "last-modified"), t = n.status === 206 ? Number(G(n, "content-range")?.match(/\/(\d+)$/)?.[1]) || null : Number(G(n, "content-length")) || null;
+				a = !!(e && r.lastModified && e !== r.lastModified || t && r.contentLength && t !== r.contentLength);
+			}
+		} catch {}
+		try {
+			if (a) {
+				let { release: r } = await this._download(e, t, n, {
+					fetchOptions: i,
+					cache: !0
+				});
+				r();
+			} else await this._area.patchMeta(t, { extra: {
+				...r,
+				checkedAt: Date.now()
+			} });
+		} catch {} finally {
+			this._revalidating.delete(t);
+		}
+	}
+};
+function Zt(e, t, n) {
+	return new J(t).fetch(e, n);
+}
+function Qt() {
+	return new J(ye(w().cacheNamespace));
+}
+async function $t(e, { downloads: t = Qt(), ...n } = {}) {
+	if (!t._storage || !/^https?:/i.test(e)) return {
+		url: e,
+		release: Xt,
+		cached: !1
+	};
+	let { file: r, release: i } = await t.fetch(e, n), a = URL.createObjectURL(r);
+	return {
+		url: a,
+		cached: !0,
+		release: () => {
+			URL.revokeObjectURL(a), i();
+		}
+	};
+}
+//#endregion
+//#region src/RenderSettings.js
+var en = {
+	maxBounces: {
+		uniform: "maxBounces",
+		reset: !0
+	},
+	transmissiveBounces: {
+		uniform: "transmissiveBounces",
+		reset: !0
+	},
+	maxSubsurfaceSteps: {
+		uniform: "maxSubsurfaceSteps",
+		reset: !0
+	},
+	maxTransparentBounces: {
+		uniform: "maxTransparentBounces",
+		reset: !0
+	},
+	environmentIntensity: {
+		uniform: "environmentIntensity",
+		reset: !0
+	},
+	backgroundIntensity: {
+		uniform: "backgroundIntensity",
+		reset: !0
+	},
+	backgroundBlurriness: {
+		uniform: "backgroundBlurriness",
+		reset: !0
+	},
+	backgroundBlurSamples: {
+		uniform: "backgroundBlurSamples",
+		reset: !0
+	},
+	showBackground: {
+		uniform: "showBackground",
+		reset: !0
+	},
+	enableEnvironment: {
+		uniform: "enableEnvironment",
+		reset: !0
+	},
+	groundProjectionEnabled: {
+		uniform: "groundProjectionEnabled",
+		reset: !0
+	},
+	groundProjectionRadius: {
+		uniform: "groundProjectionRadius",
+		reset: !0
+	},
+	groundProjectionHeight: {
+		uniform: "groundProjectionHeight",
+		reset: !0
+	},
+	groundProjectionLevel: {
+		uniform: "groundProjectionLevel",
+		reset: !0
+	},
+	enableGroundCatcher: {
+		uniform: "enableGroundCatcher",
+		reset: !0
+	},
+	groundCatcherHeight: {
+		uniform: "groundCatcherHeight",
+		reset: !0
+	},
+	globalIlluminationIntensity: {
+		uniform: "globalIlluminationIntensity",
+		reset: !0
+	},
+	panoramaLevelHorizon: {
+		uniform: "panoLevelHorizon",
+		reset: !0
+	},
+	enableDOF: {
+		uniform: "enableDOF",
+		reset: !0
+	},
+	focusDistance: {
+		uniform: "focusDistance",
+		reset: !1
+	},
+	focalLength: {
+		uniform: "focalLength",
+		reset: !0
+	},
+	aperture: {
+		uniform: "aperture",
+		reset: !0
+	},
+	apertureScale: {
+		uniform: "apertureScale",
+		reset: !0
+	},
+	anamorphicRatio: {
+		uniform: "anamorphicRatio",
+		reset: !0
+	},
+	unitsPerMetre: {
+		uniform: "unitsPerMetre",
+		reset: !0
+	},
+	dofMode: {
+		handler: "handleDofMode",
+		reset: !0
+	},
+	dofBlur: {
+		uniform: "dofBlur",
+		reset: !0
+	},
+	samplingTechnique: {
+		uniform: "samplingTechnique",
+		reset: !0
+	},
+	fireflyThreshold: {
+		uniform: "fireflyThreshold",
+		reset: !0
+	},
+	shadowTerminatorOffset: {
+		uniform: "shadowTerminatorOffset",
+		reset: !0
+	},
+	enableAlphaShadows: {
+		uniform: "enableAlphaShadows",
+		reset: !0
+	},
+	useAdaptiveSampling: {
+		uniform: "useAdaptiveSampling",
+		reset: !0
+	},
+	noiseThreshold: {
+		uniform: "noiseThreshold",
+		reset: !0
+	},
+	adaptiveMinSamples: {
+		uniform: "adaptiveMinSamples",
+		reset: !0
+	},
+	adaptiveStopFraction: {
+		uniform: "adaptiveStopFraction",
+		reset: !0
+	},
+	usePixelFreeze: {
+		uniform: "usePixelFreeze",
+		reset: !0
+	},
+	pixelFreezeThreshold: {
+		uniform: "pixelFreezeThreshold",
+		reset: !0
+	},
+	pixelFreezeStability: {
+		uniform: "pixelFreezeStability",
+		reset: !0
+	},
+	convergenceOverlay: {
+		handler: "handleConvergenceOverlay",
+		reset: !1
+	},
+	enableEmissiveTriangleSampling: {
+		uniform: "enableEmissiveTriangleSampling",
+		reset: !0
+	},
+	emissiveBoost: {
+		uniform: "emissiveBoost",
+		reset: !0
+	},
+	visMode: {
+		uniform: "visMode",
+		reset: !0
+	},
+	debugVisScale: {
+		uniform: "debugVisScale",
+		reset: !0
+	},
+	cameraProjection: {
+		handler: "handleCameraProjection",
+		reset: !0
+	},
+	panoramaLonRange: {
+		handler: "handlePanoramaLonRange",
+		reset: !0
+	},
+	panoramaLatRange: {
+		handler: "handlePanoramaLatRange",
+		reset: !0
+	},
+	interactionModeEnabled: {
+		handler: "handleInteractionModeEnabled",
+		reset: !1
+	},
+	maxSamples: {
+		handler: "handleMaxSamples",
+		reset: !1
+	},
+	transparentBackground: { handler: "handleTransparentBackground" },
+	backgroundColor: {
+		handler: "handleBackgroundColor",
+		reset: !0
+	},
+	exposure: { handler: "handleExposure" },
+	saturation: { handler: "handleSaturation" },
+	renderLimitMode: { handler: "handleRenderLimitMode" },
+	renderTimeLimit: {
+		handler: "handleRenderTimeLimit",
+		reset: !1
+	},
+	renderMode: { handler: "handleRenderMode" },
+	integrator: {
+		handler: "handleIntegrator",
+		reset: !0
+	},
+	environmentRotation: { handler: "handleEnvironmentRotation" }
+}, Y = Object.freeze({
+	DEFAULT: "default",
+	HOST: "host",
+	SCENE_METADATA: "scene-metadata",
+	MODE_PRESET: "mode-preset"
+}), tn = {
+	bounces: "maxBounces",
+	debugMode: "visMode"
+}, nn = class extends F {
+	constructor(e = v, { issues: t = null } = {}) {
+		super(), this._issues = t, this._defaults = e, this._routes = new Map(Object.entries(en)), this._values = /* @__PURE__ */ new Map(), this._sources = /* @__PURE__ */ new Map(), this._pathTracer = null, this._resetCallback = null, this._handlers = {}, this._initDefaults(e);
+	}
+	bind(e) {
+		this._pathTracer = e.stages.pathTracer, this._resetCallback = e.resetCallback, this._handlers = this._buildHandlers(e);
+	}
+	define(e, { apply: t, reset: n = !0 }) {
+		if (this._routes.has(e)) throw Error(`setting "${e}" is already defined`);
+		this._routes.set(e, {
+			apply: t,
+			reset: n
+		}), !this._values.has(e) && e in this._defaults && (this._values.set(e, this._defaults[e]), this._sources.set(e, Y.DEFAULT));
+	}
+	_buildHandlers({ stages: e, resetCallback: t, reconcileCompletion: n, applyExposure: r, onCameraProjection: i }) {
+		let a = new Ct(), o = (t, n) => {
+			a.set(n?.[0] ?? 0, n?.[1] ?? 0).multiplyScalar(L.DEG2RAD), e.pathTracer?.setUniform(t, a);
+		};
+		return {
+			handleCameraProjection: (t) => {
+				e.pathTracer?.setUniform("cameraProjection", de[t] ?? de.perspective), i?.(t);
+			},
+			handleDofMode: (t) => e.pathTracer?.setUniform("dofMode", +(t === "look")),
+			handlePanoramaLonRange: (e) => o("panoLonRange", e),
+			handlePanoramaLatRange: (e) => o("panoLatRange", e),
+			handleTransparentBackground: (t) => {
+				e.pathTracer?.setUniform("transparentBackground", t), e.compositor?.setTransparentBackground(t);
+			},
+			handleBackgroundColor: (t) => {
+				let n = t?.isColor ? t : new Ze(t);
+				e.pathTracer?.setUniform("backgroundColor", n);
+			},
+			handleExposure: (e) => {
+				r?.(e);
+			},
+			handleSaturation: (t) => {
+				e.compositor?.setSaturation(t);
+			},
+			handleConvergenceOverlay: (n) => {
+				e.pathTracer?.setUniform("convergenceOverlay", n), e.compositor?.setConvergenceOverlay(n), n && !this.get("useAdaptiveSampling") && t?.();
+			},
+			handleRenderLimitMode: (t) => {
+				e.pathTracer?.setRenderLimitMode?.(t), n?.();
+			},
+			handleMaxSamples: (t) => {
+				e.pathTracer?.setUniform("maxSamples", t), e.pathTracer?.updateCompletionThreshold(), n?.();
+			},
+			handleRenderTimeLimit: () => {
+				n?.();
+			},
+			handleRenderMode: (t) => {
+				e.pathTracer?.setUniform("renderMode", parseInt(t));
+			},
+			handleIntegrator: (t) => {
+				e.pathTracer?.setIntegrator?.(t);
+			},
+			handleEnvironmentRotation: (t) => {
+				e.pathTracer?.environment.setEnvironmentRotation(t);
+			},
+			handleInteractionModeEnabled: (t) => {
+				e.pathTracer?.setInteractionModeEnabled(t);
+			}
+		};
+	}
+	set(e, t, { reset: n, silent: r, source: i = Y.HOST } = {}) {
+		let a = this._applyOne(e, t, i);
+		a?.route && ((n === void 0 ? a.route.reset ?? !0 : n) && this._resetCallback?.(), r || this.dispatchEvent({
+			type: m.SETTING_CHANGED,
+			key: e,
+			value: t,
+			prev: a.prev
+		}));
+	}
+	setMany(e, { silent: t, reset: n, source: r = Y.HOST } = {}) {
+		let i = !1;
+		for (let [n, a] of Object.entries(e)) {
+			let e = this._applyOne(n, a, r);
+			e?.route && ((e.route.reset ?? !0) && (i = !0), t || this.dispatchEvent({
+				type: m.SETTING_CHANGED,
+				key: n,
+				value: a,
+				prev: e.prev
+			}));
+		}
+		(n === void 0 ? i : n) && this._resetCallback?.();
+	}
+	_applyOne(e, t, n) {
+		let r = this._values.get(e);
+		if (r === t) return null;
+		this._values.set(e, t), this._sources.set(e, n);
+		let i = this._routes.get(e);
+		return i ? (this._applyRoute(i, t, r), {
+			route: i,
+			prev: r
+		}) : (this._reportUnknownKey(e), {
+			route: null,
+			prev: r
+		});
+	}
+	_reportUnknownKey(e) {
+		this._issues?.record(x.SETTING_UNKNOWN_KEY, `unknown setting "${e}" — stored but never applied to any stage`, { key: e });
+	}
+	get(e) {
+		return this._values.get(e);
+	}
+	getEffective() {
+		let e = {};
+		for (let [t, n] of this._values) e[t] = {
+			value: n,
+			source: this._sources.get(t) ?? Y.DEFAULT,
+			routed: this._routes.has(t)
+		};
+		return e;
+	}
+	getAll() {
+		return Object.fromEntries(this._values);
+	}
+	serialize() {
+		let e = {};
+		for (let [t, n] of this._values) {
+			if (this._sources.get(t) !== Y.HOST || !this._routes.has(t)) continue;
+			let i = r(n);
+			i !== void 0 && (e[t] = i);
+		}
+		return e;
+	}
+	restore(e) {
+		let t = {}, n = [];
+		for (let [r, i] of Object.entries(e ?? {})) this._routes.has(r) ? t[r] = f(i) : n.push(r);
+		return this.setMany(t), n;
+	}
+	applyAll() {
+		for (let [e, t] of this._values) {
+			let n = this._routes.get(e);
+			n && this._applyRoute(n, t, void 0);
+		}
+	}
+	_applyRoute(e, t, n) {
+		e.uniform ? this._pathTracer?.setUniform(e.uniform, t) : e.handler ? this._handlers[e.handler]?.(t, n) : e.apply(t, n);
+	}
+	_initDefaults(e) {
+		for (let t of Object.keys(en)) t in e && (this._values.set(t, e[t]), this._sources.set(t, Y.DEFAULT));
+		for (let [t, n] of Object.entries(tn)) t in e && (this._values.set(n, e[t]), this._sources.set(n, Y.DEFAULT));
+	}
+}, rn = class {
+	constructor({ issues: e = null } = {}) {
+		this._issues = e, this._renderer = null, this._offRegistry = Te(() => {
+			this._renderer && Ee(this._renderer);
+		});
+	}
+	get hasConfig() {
+		return !1;
+	}
+	get workingSpace() {
+		return C;
+	}
+	get workingSpaceAdopted() {
+		return !1;
+	}
+	get inputKey() {
+		return "-";
+	}
+	attachRenderer(e) {
+		this._renderer = e;
+		let t = Ee(e);
+		return e.outputColorSpace = B, t;
+	}
+	listViews() {
+		return De();
+	}
+	get activeView() {
+		return null;
+	}
+	setActiveView(e) {
+		let t = T(e);
+		if (!t) throw Error(`no view transform with id ${e}`);
+		if (t.outputEncoded) throw Error(`"${t.name}" returns display-encoded colour: it needs rayzee/addons/color`);
+		return this._renderer && (this._renderer.toneMapping = e), t;
+	}
+	_publishWorkingMatrix() {
+		xe(null, C);
+	}
+	loadConfig() {
+		let e = "colour configs need the OCIO pipeline: renderer.setColorManagement( ColorManagement ), from rayzee/addons/color";
+		return this._issues?.record(x.CAPABILITY_MISSING, e, { capability: "color" }), Promise.reject(Error(e));
+	}
+	unloadConfig() {}
+	setWorkingSpace() {}
+	exportPixels(e) {
+		return {
+			rgba: e,
+			colorSpace: C
+		};
+	}
+	status() {
+		let e = this._renderer ? T(this._renderer.toneMapping) : null;
+		return {
+			config: null,
+			workingSpace: C,
+			workingSpaceAdopted: !1,
+			activeTransform: e ? {
+				id: e.id,
+				name: e.name,
+				source: e.source
+			} : null,
+			activeView: null,
+			context: null,
+			exportSpace: null,
+			views: De(),
+			registryVersion: we(),
+			bakeError: e?.error ?? null
+		};
+	}
+	dispose() {
+		this._offRegistry?.(), this._renderer = null, this._issues = null, Se() === this && (xe(null), S(null));
+	}
+}, an = [
+	[/\.jpe?g(\?|#|$)/i, "image/jpeg"],
+	[/\.webp(\?|#|$)/i, "image/webp"],
+	[/\.avif(\?|#|$)/i, "image/avif"]
+];
+function on(e) {
+	return e.mimeType ? e.mimeType : e.uri?.startsWith("data:") ? e.uri.slice(5, e.uri.indexOf(";")) : an.find(([t]) => t.test(e.uri ?? ""))?.[1] ?? "image/png";
+}
+function sn(e) {
+	for (let t = 8; t + 12 <= e.length;) {
+		let n = (e[t] << 24 | e[t + 1] << 16 | e[t + 2] << 8 | e[t + 3]) >>> 0, r = t + 12 + n;
+		if (e[t + 4] === 73 && e[t + 5] === 69 && e[t + 6] === 78 && e[t + 7] === 68) return e.subarray(0, r);
+		t = r;
+	}
+	return e;
+}
+function cn({ data: e, width: t, height: n }, { shared: r = !1 } = {}) {
+	let i = new Uint8Array(e.buffer, e.byteOffset, t * n * 4), a = i;
+	r && typeof SharedArrayBuffer < "u" && !(i.buffer instanceof SharedArrayBuffer) && (a = new Uint8Array(new SharedArrayBuffer(i.byteLength)), a.set(i));
+	let o = new Qe(a, t, n, gt, St);
+	return o.needsUpdate = !0, o;
+}
+function ln(e, t) {
+	return s().decodeImage(t === "image/png" ? sn(e) : e, t);
+}
+async function un(e) {
+	let t = await fetch(e);
+	if (!t.ok) throw Error(`HTTP ${t.status}`);
+	return new Uint8Array(await t.arrayBuffer());
+}
+function dn(e, t) {
+	return t.bufferView === void 0 ? un(e.options.manager.resolveURL(I.resolveURL(t.uri, e.options.path))) : e.getDependency("bufferView", t.bufferView).then((e) => new Uint8Array(e));
+}
+var fn = (e, t) => !!t && t !== e.textureLoader && typeof t.parse == "function";
+function pn(e, t, n) {
+	if (e.sourceCache[t] !== void 0) return e.sourceCache[t].then((e) => e.clone());
+	let r = dn(e, e.json.images[t]).then((e) => new Promise((t, r) => {
+		n.parse(e.buffer.slice(e.byteOffset, e.byteOffset + e.byteLength), t, r);
+	}));
+	return e.sourceCache[t] = r, r;
+}
+async function mn(e, t = on({ uri: e })) {
+	let n = cn(await ln(await un(e), t));
+	return n.flipY = !0, n;
+}
+function hn(e, t = null) {
+	return e.loadImageSource = function(e, n) {
+		if (fn(this, n)) return pn(this, e, n);
+		let r = this.json.images[e], i = /* @__PURE__ */ Error("no image decoder in this runtime: configurePlatform( nodePlatform( { decodeImage } ) ) — see \"Running in Node\"");
+		return t?.(r.uri ?? `bufferView ${r.bufferView}`, i), Promise.reject(i);
+	}, { name: "RAYZEE_missing_image_decoder" };
+}
+function gn(e, t = null) {
+	return e.loadImageSource = function(e, n) {
+		if (fn(this, n)) return pn(this, e, n);
+		if (this.sourceCache[e] !== void 0) return this.sourceCache[e].then((e) => e.clone());
+		let r = this.json.images[e], i = on(r), a = r.uri ?? `bufferView ${r.bufferView}`, o = dn(this, r).then((e) => ln(e, i)).then((e) => {
+			let t = cn(e, { shared: !0 });
+			return r.extras && typeof r.extras == "object" && Object.assign(t.userData, r.extras), t.userData.mimeType = i, t;
+		}).catch((e) => {
+			throw t?.(a, e), e;
+		});
+		return this.sourceCache[e] = o, o;
+	}, { name: "RAYZEE_platform_images" };
+}
+//#endregion
+//#region src/Processor/GLTFDiffuseTransmission.js
+var _n = "KHR_materials_diffuse_transmission";
+function vn(e) {
+	let t = (t, n, r, i) => {
+		let a = {};
+		return e.assignTexture(a, n, r, i).then(() => {
+			a[n] && (t[n] = a[n]);
+		});
+	};
+	return {
+		name: _n,
+		afterRoot(n) {
+			let r = e.json.materials ?? [], i = /* @__PURE__ */ new Set(), a = [];
+			for (let o of n.scenes ?? []) o.traverse((n) => {
+				let o = Array.isArray(n.material) ? n.material : n.material ? [n.material] : [];
+				for (let n of o) {
+					if (i.has(n)) continue;
+					i.add(n);
+					let o = e.associations.get(n)?.materials, s = o === void 0 ? null : r[o]?.extensions?.[_n];
+					if (!s) continue;
+					n.diffuseTransmission = s.diffuseTransmissionFactor ?? 0;
+					let [c, l, u] = s.diffuseTransmissionColorFactor ?? [
+						1,
+						1,
+						1
+					];
+					n.diffuseTransmissionColor = new Ze().setRGB(c, l, u, it), s.diffuseTransmissionTexture && a.push(t(n, "diffuseTransmissionMap", s.diffuseTransmissionTexture)), s.diffuseTransmissionColorTexture && a.push(t(n, "diffuseTransmissionColorMap", s.diffuseTransmissionColorTexture, B));
+				}
+			});
+			return Promise.all(a);
+		}
+	};
+}
+//#endregion
+//#region src/Processor/GLTFDecoders.js
+var yn = "KHR_draco_mesh_compression", bn = "KHR_texture_basisu", xn = ["EXT_meshopt_compression", "KHR_meshopt_compression"], Sn = new TextDecoder();
+function Cn(e) {
+	if (typeof e == "string") return e;
+	if (!(e instanceof ArrayBuffer)) return JSON.stringify(e?.extensionsUsed ?? []);
+	let t = new DataView(e);
+	if (!(e.byteLength >= 20 && t.getUint32(0, !0) === 1179937895)) return Sn.decode(e);
+	let n = Math.min(t.getUint32(12, !0), e.byteLength - 20);
+	return Sn.decode(new Uint8Array(e, 20, n));
+}
+async function wn(e, t, n) {
+	let { dracoDecoderPath: r, ktx2TranscoderPath: i } = w(), [a, o, s] = await Promise.all([
+		t.includes(yn) && !e.dracoLoader ? import("three/addons/loaders/DRACOLoader.js") : null,
+		t.includes(bn) && !e.ktx2Loader ? import("three/addons/loaders/KTX2Loader.js") : null,
+		xn.some((e) => t.includes(e)) && !e.meshoptDecoder ? import("three/addons/libs/meshopt_decoder.module.js") : null
+	]);
+	if (a) {
+		let t = new a.DRACOLoader();
+		t.setDecoderConfig({ type: "js" }), t.setDecoderPath(r), e.setDRACOLoader(t);
+	}
+	if (o) {
+		let t = new o.KTX2Loader();
+		t.setTranscoderPath(i), n && (t.detectSupport(n), t.workerConfig = {
+			astcSupported: !1,
+			etc1Supported: !1,
+			etc2Supported: !1,
+			dxtSupported: !1,
+			bptcSupported: !1,
+			pvrtcSupported: !1
+		}), e.setKTX2Loader(t);
+	}
+	s && e.setMeshoptDecoder(s.MeshoptDecoder);
+}
+function Tn(e, t) {
+	let n = e.parse.bind(e);
+	return e.parse = (r, i, a, o) => {
+		wn(e, Cn(r), t).then(() => n(r, i, a, o), (e) => o?.(e));
+	}, e;
+}
+//#endregion
+//#region src/Processor/AssetLoader.js
+var En = {
+	glb: {
+		type: "model",
+		name: "GLB (GLTF Binary)"
+	},
+	gltf: {
+		type: "model",
+		name: "GLTF"
+	},
+	hdr: {
+		type: "environment",
+		name: "HDR (High Dynamic Range)"
+	},
+	png: {
+		type: "image",
+		name: "PNG"
+	},
+	jpg: {
+		type: "image",
+		name: "JPEG"
+	},
+	jpeg: {
+		type: "image",
+		name: "JPEG"
+	},
+	webp: {
+		type: "image",
+		name: "WebP"
+	}
+}, X = {
+	addOn: "rayzee/addons/archives",
+	install: "assetLoader.setArchiveImporter()"
+}, Z = {
+	addOn: "rayzee/addons/formats",
+	install: "assetLoader.registerFormat()"
+}, Dn = {
+	zip: X,
+	gz: X,
+	tgz: X,
+	tar: X,
+	fbx: Z,
+	obj: Z,
+	stl: Z,
+	ply: Z,
+	dae: Z,
+	"3mf": Z,
+	usd: Z,
+	usda: Z,
+	usdc: Z,
+	usdz: Z,
+	exr: Z
+};
+function On(e) {
+	let t = new Ye();
+	for (let n in e.attributes) t.setAttribute(n, e.attributes[n]);
+	e.index && t.setIndex(e.index);
+	for (let n of e.groups) t.addGroup(n.start, n.count, n.materialIndex);
+	return t;
+}
+var kn = 683;
+function An(e, t, n, r) {
+	if (!(r.normalize ?? !0)) return Math.PI;
+	let i = r.shape === "ellipse" || r.shape === "disk" ? Math.PI / 4 : 1, a = e.getWorldScale(new V()), o = Math.PI * i * Math.abs(t * a.x * n * a.y);
+	return Number.isFinite(o) ? o : Math.PI;
+}
+var jn = class e extends F {
+	constructor(e, t, n, { issues: r = null, profile: i = null } = {}) {
+		super(), this.scene = e, this.camera = t, this.controls = n, this.targetModel = null, this.floorPlane = null, this.sceneScale = 1, this.sceneSize = new V(1, 1, 1), this.loaderCache = {}, this.uploadedFileInfo = null, this.animations = [], this.renderer = null, this.sceneMetadata = null, this._loadingManager = new at(), this._loadCancelled = !1, this._urlAbort = null, this.storage = null, this._downloads = null, this._sourceKey = null, this._appended = !1, this.archives = null, this._archiveLoader = null, this._formats = /* @__PURE__ */ new Map(), this._issues = r, this._profile = i ?? he(), this._loadingManager.onError = (e) => {
+			this._loadCancelled || this._issues?.record(x.ASSET_UNREACHABLE, `asset "${e}" could not be fetched — anything depending on it renders without it`, { url: e });
+		};
+	}
+	cancelActiveLoad() {
+		this._loadCancelled = !0, this._loadingManager.abort(), this._urlAbort?.abort();
+	}
+	async _viaCache(t, n, r, { cacheKey: i = t, cachePolicy: a } = {}) {
+		if (!this.storage || !e._isNetworkUrl(t) || /\.gltf$/i.test(t.split(/[?#]/)[0])) return {
+			url: t,
+			release: () => {},
+			cached: !1
+		};
+		let o = new AbortController();
+		this._urlAbort = o;
+		try {
+			return await $t(t, {
+				downloads: this.downloads,
+				key: i,
+				policy: a,
+				name: K(t),
+				signal: o.signal,
+				onProgress: this._downloadProgress(n, r)
+			});
+		} catch (e) {
+			throw this._isCancellation(e) ? this._cancellationError() : e;
+		} finally {
+			this._urlAbort = null;
+		}
+	}
+	get sceneSourceKey() {
+		return this._appended ? null : this._sourceKey;
+	}
+	_keyed(e, t) {
+		return t ? `${e}:${this._profile?.name ?? ""}:${t}` : null;
+	}
+	get downloads() {
+		return this._downloads?._storage !== this.storage && (this._downloads = new J(this.storage)), this._downloads;
+	}
+	_isCancellation(e) {
+		return this._loadCancelled || e?.name === "AbortError" || e?.code === "LOAD_CANCELLED";
+	}
+	_cancellationError() {
+		let e = /* @__PURE__ */ Error("Load cancelled");
+		return e.code = "LOAD_CANCELLED", e;
+	}
+	_downloadProgress(e, t) {
+		return (n) => {
+			let r = n?.loaded || 0, i = n?.lengthComputable && n.total || 0;
+			g({
+				isLoading: !0,
+				status: e,
+				loadedBytes: r,
+				totalBytes: i,
+				canCancel: !!t,
+				progress: i ? Math.min(60, 2 + Math.round(r / i * 58)) : 2
+			});
+		};
+	}
+	_downloadComplete(e = "Processing Data...", t = 62) {
+		g({
+			status: e,
+			progress: t,
+			canCancel: !1,
+			loadedBytes: null,
+			totalBytes: null
+		});
+	}
+	static _isNetworkUrl(e) {
+		return typeof e == "string" && /^https?:/i.test(e);
+	}
+	_adoptExternalObject(e) {
+		let t;
+		try {
+			t = kt(e);
+		} catch (t) {
+			throw Error(`Cannot render "${e.name || e.type}": its userData must be JSON-serializable.`, { cause: t });
+		}
+		return t.userData.__rayzeeExternal = !0, this.scene?.children.some((t) => t.uuid === e.uuid) || (t.uuid = e.uuid), e.parent && (e.parent.updateWorldMatrix(!0, !1), t.applyMatrix4(e.parent.matrixWorld)), t;
+	}
+	releaseTargetModel() {
+		this.sceneMetadata = null, this._sourceKey = null, this._appended = !1, this.archives?.release(), this.targetModel && (this.removeModelRoot(this.targetModel), this.targetModel = null, this.animations = []);
+	}
+	setRenderer(e) {
+		this.renderer = e;
+	}
+	setArchiveImporter(e) {
+		this.archives = e;
+	}
+	setArchiveImporterLoader(e, t) {
+		this._archiveLoader = {
+			load: e,
+			formats: t,
+			pending: null
+		};
+	}
+	async _archiveImporter() {
+		return !this.archives && this._archiveLoader && (this.archives = await (this._archiveLoader.pending ??= this._archiveLoader.load())), this.archives;
+	}
+	get _archiveFormats() {
+		return this.archives?.constructor.FORMATS ?? this._archiveLoader?.formats ?? null;
+	}
+	registerFormat(...e) {
+		for (let t of e) for (let e of t.extensions) this._formats.set(e, t);
+		return this;
+	}
+	getFileFormat(e) {
+		let t = e.split(".").pop().toLowerCase();
+		return En[t] || this._formats.get(t) || this._archiveFormats?.[t] || null;
+	}
+	formatError(e) {
+		let t = Dn[e.split(".").pop().toLowerCase()];
+		return /* @__PURE__ */ Error(t ? `${e}: this format is read by ${t.addOn} — install it with ${t.install}` : `Unsupported file format: ${e}`);
+	}
+	async inspectArchive(e) {
+		let t = await this._archiveImporter();
+		if (!t) throw this.formatError(e.name ?? "archive.zip");
+		return await t.inspectArchive(e);
+	}
+	flushPendingGraph(e) {
+		this.archives?.flushPendingGraph(e);
+	}
+	readFileAsArrayBuffer(e) {
+		return e.arrayBuffer();
+	}
+	readFileAsText(e) {
+		return e.text();
+	}
+	async loadAssetFromFile(e, t = {}) {
+		let n = e.name, r = this.getFileFormat(n);
+		if (!r) throw this.formatError(n);
+		g({
+			isLoading: !0,
+			status: `Loading ${r.name}...`,
+			progress: 2
+		});
+		try {
+			let i;
+			switch (r.type) {
+				case "model":
+					i = await this.loadModelFromFile(e, n);
+					break;
+				case "environment":
+				case "image":
+					i = await this.loadEnvironmentFromFile(e, n);
+					break;
+				case "archive":
+					i = await (await this._archiveImporter()).loadArchiveFromFile(e, n, t);
+					break;
+				default: throw Error(`Unknown asset type: ${r.type}`);
+			}
+			return i;
+		} catch (e) {
+			throw this.dispatchEvent({
+				type: "error",
+				message: e.message,
+				filename: n
+			}), e;
+		}
+	}
+	async loadAssetFromUrl(t, n = {}) {
+		let { filename: r = K(t), cacheKey: i = t, cachePolicy: a, ...o } = n;
+		if (!this.getFileFormat(r)) throw this.formatError(r);
+		this._loadCancelled = !1;
+		let s = e._isNetworkUrl(t), c = `Downloading ${r}...`, l = new AbortController();
+		this._urlAbort = l, g({
+			isLoading: !0,
+			status: c,
+			progress: 2,
+			canCancel: s,
+			loadedBytes: 0,
+			totalBytes: 0
+		});
+		let u;
+		try {
+			u = await this.downloads.fetch(t, {
+				key: i,
+				name: r,
+				policy: a,
+				signal: l.signal,
+				onProgress: this._downloadProgress(c, s)
+			});
+		} catch (e) {
+			throw this._isCancellation(e) ? this._cancellationError() : e;
+		} finally {
+			this._urlAbort = null;
+		}
+		this._downloadComplete();
+		try {
+			return await this.loadAssetFromFile(u.file, o);
+		} catch (e) {
+			throw e?.code === "ARCHIVE_NEEDS_ELEMENT" && (e.file = u.file), e;
+		} finally {
+			u.release();
+		}
+	}
+	async loadModelFromFile(e, t) {
+		let n = this.storage ? this._keyed("file", E(await Oe(e))) : null, r = await this._loadModelFileByExtension(e, t);
+		return this._sourceKey = n, r;
+	}
+	async _loadModelFileByExtension(e, t) {
+		let n = t.split(".").pop().toLowerCase();
+		if (n === "glb" || n === "gltf") return await this.loadGLBFromArrayBuffer(await this.readFileAsArrayBuffer(e), t);
+		let r = this._formats.get(n);
+		if (r?.type !== "model") throw this.formatError(t);
+		return await this._loadModelWithFormat(r, e, t);
+	}
+	async _loadModelWithFormat(e, t, n) {
+		try {
+			g({
+				isLoading: !0,
+				status: `Processing ${e.label} Data...`,
+				progress: 5
+			}), await new Promise((e) => setTimeout(e, 0));
+			let { model: r, result: i = r } = await e.parse(t, {
+				filename: n,
+				cache: this.loaderCache
+			});
+			return this.releaseTargetModel(), this.targetModel = r, g({
+				isLoading: !0,
+				status: "Processing Data...",
+				progress: 10
+			}), await this.onModelLoad(this.targetModel), this.dispatchEvent({
+				type: "load",
+				model: r,
+				filename: n
+			}), i;
+		} catch (t) {
+			throw console.error(`Error loading ${e.label}:`, t), this.dispatchEvent({
+				type: "error",
+				message: t.message,
+				filename: n
+			}), t;
+		}
+	}
+	async loadEnvironmentFromFile(e, t) {
+		let n = URL.createObjectURL(e);
+		this.uploadedFileInfo = {
+			name: t,
+			type: e.type,
+			size: e.size
+		};
+		try {
+			let r = await this.loadEnvironment(n);
+			return ae(r, E(await Oe(e))), this.dispatchEvent({
+				type: "load",
+				texture: r,
+				filename: t
+			}), r;
+		} finally {
+			URL.revokeObjectURL(n);
+		}
+	}
+	async loadEnvironment(t) {
+		this._loadCancelled = !1;
+		try {
+			this.dispatchEvent({
+				type: "beforeEnvironmentLoad",
+				url: t
+			});
+			let n;
+			if (t.startsWith("blob:")) n = await this.loadEnvironmentFromBlob(t);
+			else {
+				let e = t.split(/[?#]/)[0].split(".").pop().toLowerCase();
+				n = await this.loadEnvironmentByExtension(t, e);
+			}
+			return n.generateMipmaps = !0, e._isNetworkUrl(t) && ae(n, t), this.applyEnvironmentToScene(n), this.dispatchEvent({
+				type: "load",
+				texture: n,
+				url: t,
+				filename: t.split(/[?#]/)[0].split("/").pop()
+			}), n;
+		} catch (e) {
+			throw this._isCancellation(e) ? this._cancellationError() : (console.error("Error loading environment:", e), this.dispatchEvent({
+				type: "error",
+				message: e.message,
+				filename: t
+			}), e);
+		}
+	}
+	async loadEnvironmentFromBlob(e) {
+		let t = await (await fetch(e)).blob(), n = this.determineEnvironmentExtension(t, e), r = URL.createObjectURL(t);
+		try {
+			return await this.loadEnvironmentByExtension(r, n);
+		} finally {
+			URL.revokeObjectURL(r);
+		}
+	}
+	determineEnvironmentExtension(e, t) {
+		let n;
+		if (e.type === "image/x-exr" || e.type.includes("exr")) n = "exr";
+		else if (e.type === "image/vnd.radiance" || e.type.includes("hdr")) n = "hdr";
+		else {
+			let e = t.split("/").pop();
+			if (e) {
+				let t = e.match(/\.([^.]+)$/);
+				t && (n = t[1].toLowerCase());
+			}
+		}
+		return !n && this.uploadedFileInfo && (n = this.uploadedFileInfo.name.split(".").pop().toLowerCase()), n;
+	}
+	async loadEnvironmentByExtension(t, n, { loader: r = null } = {}) {
+		let i = this._formats.get(n);
+		if (!r && i?.type === "environment" && (r = this.loaderCache[n] ??= await i.createLoader(this._loadingManager)), !r && n === "hdr" && (r = this.loaderCache.hdr ??= new Dt(this._loadingManager).setDataType(nt)), !r && Dn[n]) throw this.formatError(`environment.${n}`);
+		let a = e._isNetworkUrl(t), o = "Downloading Environment...", c = await this._viaCache(t, o, a), l = c.cached ? void 0 : this._downloadProgress(o, a), u;
+		try {
+			r ? u = await r.loadAsync(c.url, l) : s().decodeImage ? (u = await mn(c.url, `image/${n === "jpg" ? "jpeg" : n}`), u.colorSpace = B) : (this.loaderCache.texture || (this.loaderCache.texture = new xt(this._loadingManager)), u = await this.loaderCache.texture.loadAsync(c.url, l), u.colorSpace = B);
+		} finally {
+			c.release();
+		}
+		return this._downloadComplete("Processing Environment...", 62), u.mapping = tt, u.minFilter = rt, u.magFilter = rt, u;
+	}
+	applyEnvironmentToScene(e) {
+		this.scene.background = e, this.scene.environment = e;
+	}
+	async createGLTFLoader() {
+		let e = Tn(new Et(this._loadingManager), this.renderer), t = (e, t) => this._reportImageFailure(e, t);
+		return s().decodeImage ? e.register((e) => gn(e, t)) : i() || e.register((e) => hn(e, t)), e.register((e) => vn(e)), e;
+	}
+	_reportImageFailure(e, t) {
+		try {
+			this._issues?.record(x.TEXTURE_BUILD_FAILED, `image ${e} could not be decoded (${t?.message ?? t}) — the surfaces using it render untextured`, {
+				image: e,
+				cause: String(t?.message ?? t)
+			});
+		} catch (e) {
+			this._deferredError ??= e;
+		}
+	}
+	_throwDeferred() {
+		let e = this._deferredError;
+		if (this._deferredError = null, e) throw e;
+	}
+	_disposeGLTFLoader(e) {
+		e && (e.dracoLoader?.dispose(), e.ktx2Loader?.dispose());
+	}
+	async loadExampleModels(e, t) {
+		if (!t || !t[e]) throw Error(`No model file at index ${e}`);
+		let n = `${t[e].url}`;
+		return await this.loadModel(n);
+	}
+	async loadModel(t, n = {}) {
+		this._loadCancelled = !1;
+		let r = await this.createGLTFLoader(), i = e._isNetworkUrl(t), a = null;
+		try {
+			g({
+				isLoading: !0,
+				status: "Downloading Model...",
+				progress: 2,
+				canCancel: i,
+				loadedBytes: 0,
+				totalBytes: 0
+			}), a = await this._viaCache(t, "Downloading Model...", i, n), a.cached && r.setResourcePath(I.extractUrlBase(t));
+			let e = await d(() => r.loadAsync(a.url, a.cached ? void 0 : this._downloadProgress("Downloading Model...", i)));
+			return this._downloadComplete(), this._throwDeferred(), this.releaseTargetModel(), this._sourceKey = i ? this._keyed("url", n.cacheKey ?? t) : null, this.targetModel = e.scene, this.animations = e.animations || [], this.sceneMetadata = Ae(e), await this.onModelLoad(this.targetModel), this.dispatchEvent({
+				type: "load",
+				model: e.scene,
+				filename: t.split("/").pop()
+			}), e;
+		} catch (e) {
+			throw this._isCancellation(e) ? this._cancellationError() : (console.error("Error loading model:", e), this.dispatchEvent({
+				type: "error",
+				message: e.message,
+				filename: t
+			}), e);
+		} finally {
+			a?.release(), this._disposeGLTFLoader(r);
+		}
+	}
+	_processAndParent(e) {
+		this.processModelObjects(e), this.scene.add(e), e.updateMatrixWorld(!0);
+	}
+	async appendModel(t, n = {}) {
+		this._loadCancelled = !1;
+		let r = await this.createGLTFLoader(), i = e._isNetworkUrl(t), a = null;
+		try {
+			g({
+				isLoading: !0,
+				status: "Downloading Model...",
+				progress: 2,
+				canCancel: i,
+				loadedBytes: 0,
+				totalBytes: 0
+			}), a = await this._viaCache(t, "Downloading Model...", i, n), a.cached && r.setResourcePath(I.extractUrlBase(t));
+			let e = await d(() => r.loadAsync(a.url, a.cached ? void 0 : this._downloadProgress("Downloading Model...", i)));
+			return this._downloadComplete(), this._throwDeferred(), this._appended = !0, this._processAndParent(e.scene), {
+				root: e.scene,
+				animations: e.animations || []
+			};
+		} catch (e) {
+			throw this._isCancellation(e) ? this._cancellationError() : e;
+		} finally {
+			a?.release(), this._disposeGLTFLoader(r);
+		}
+	}
+	appendObject3D(e, t = "object3d") {
+		this._appended = !0;
+		let n = this._adoptExternalObject(e);
+		return n.name = e.name || t, this._processAndParent(n), { root: n };
+	}
+	removeModelRoot(e) {
+		e && (e.userData.__rayzeeExternal ? (re(e), e.parent?.remove(e)) : se(e));
+	}
+	async loadGLBFromArrayBuffer(e, t = "model.glb") {
+		let n = await this.createGLTFLoader();
+		try {
+			g({
+				isLoading: !0,
+				status: "Processing GLB Data...",
+				progress: 5
+			}), await new Promise((e) => setTimeout(e, 0));
+			let r = await d(() => n.parseAsync(e, ""));
+			return this._throwDeferred(), this.releaseTargetModel(), this.targetModel = r.scene, this.animations = r.animations || [], this.sceneMetadata = Ae(r), g({
+				isLoading: !0,
+				status: "Processing Data...",
+				progress: 10
+			}), await this.onModelLoad(this.targetModel), this.dispatchEvent({
+				type: "load",
+				model: r.scene,
+				filename: t
+			}), r;
+		} catch (e) {
+			throw console.error("Error loading GLB:", e), this.dispatchEvent({
+				type: "error",
+				message: e.message,
+				filename: t
+			}), e;
+		} finally {
+			this._disposeGLTFLoader(n);
+		}
+	}
+	async loadObject3D(e, t = "object3d") {
+		this.releaseTargetModel();
+		let n = this._adoptExternalObject(e);
+		return n.name = e.name || t, this.targetModel = n, g({
+			isLoading: !0,
+			status: "Processing Data...",
+			progress: 10
+		}), await this.onModelLoad(this.targetModel), this.dispatchEvent({
+			type: "load",
+			model: n,
+			filename: t
+		}), n;
+	}
+	async onModelLoad(e) {
+		let t = new u("onModelLoad");
+		t.start("Camera extraction");
+		let n = this.extractCamerasFromModel(e);
+		t.end("Camera extraction"), t.start("Camera setup");
+		let r = new Je().setFromObject(e), i = r.getCenter(new V()), a = r.getSize(new V());
+		this.controls?.target.copy(i);
+		let o = Math.max(a.x, a.y, a.z), s = this.camera.fov * (Math.PI / 180), c = Math.abs(o / Math.sin(s / 2) / 2), l = Math.PI / 6, d = new V(Math.cos(l) * c, c / Math.sqrt(2), Math.sin(l) * c);
+		if (this.camera.position.copy(d.add(i)), this.camera.lookAt(i), this.camera.near = o / 100, this.camera.far = o * 100, this.camera.updateProjectionMatrix(), this.controls && (this.controls.maxDistance = c * 10, this.controls.saveState(), this.controls.update()), t.end("Camera setup"), this.floorPlane) {
+			let e = r.min.y;
+			this.floorPlane.position.y = e, this.floorPlane.rotation.x = -Math.PI / 2, this.floorPlane.scale.setScalar(o * 5);
+		}
+		t.start("Process model objects"), this.processModelObjects(e), t.end("Process model objects"), t.start("Scene add"), this.scene.add(e), t.end("Scene add");
+		let f = o;
+		return this.sceneSize.copy(a), t.start("setupPathTracing"), await this.setupPathTracing(e, f), t.end("setupPathTracing"), t.print(), this.dispatchEvent({
+			type: "modelProcessed",
+			model: e,
+			cameras: n,
+			sceneData: {
+				center: i,
+				size: a,
+				maxDim: o,
+				sceneScale: f
+			}
+		}), this.dispatchEvent({ type: "SceneRebuild" }), {
+			center: i,
+			size: a,
+			maxDim: o,
+			sceneScale: f
+		};
+	}
+	extractCamerasFromModel(e) {
+		let t = [];
+		return e.updateWorldMatrix(!0, !0), e.traverse((e) => {
+			if (e.isCamera) {
+				let n = e.clone();
+				n.userData.__rayzeeSourceUuid = e.uuid, e.getWorldPosition(n.position), e.getWorldQuaternion(n.quaternion), e.getWorldScale(n.scale), n.scale.set(Math.sign(n.scale.x) || 1, Math.sign(n.scale.y) || 1, Math.sign(n.scale.z) || 1), (!n.name || n.name === "") && (n.name = `Model Camera ${t.length + 1}`), n.isPerspectiveCamera && (n.aspect = this.camera.aspect, n.updateProjectionMatrix()), t.push(n);
+			}
+		}), t;
+	}
+	processModelObjects(e) {
+		let t = [], n = [];
+		e.traverse((e) => {
+			let r = e.userData;
+			e.isRectAreaLight && !r.__radianceConverted && (e.intensity *= An(e, e.width, e.height, r), r.__radianceConverted = !0), (e.isPointLight || e.isSpotLight) && !r.__candelaConverted && (e.intensity *= 4 * Math.PI / kn, r.__candelaConverted = !0), e.isDirectionalLight && !r.__luxConverted && (e.intensity /= kn, r.__luxConverted = !0);
+			let i = e.name.startsWith("RectAreaLightPlaceholder");
+			if (i && !(r.name && r.type === "RectAreaLight") && !e.parent?.name?.startsWith("RectAreaLightPlaceholder") && n.push(e.name), i && r.name && r.type === "RectAreaLight") {
+				let t = r.normalize ?? !0, n = r.shape ?? "rectangle", i = r.intensity * An(e, r.width, r.height, r), a = new z(new Ze(...r.color), i * this._profile.areaLightIntensityScale, r.width, r.height);
+				a.userData.normalize = t, a.userData.spread = Number.isFinite(r.spread) ? r.spread : Math.PI, a.userData.shape = n, a.userData.__radianceConverted = !0, a.name = r.name, e.add(a);
+			}
+			e.isMesh && Array.isArray(e.material) && t.push(e);
+		}), n.length && this._issues?.record(x.LIGHT_PLACEHOLDER_SKIPPED, `${n.length} area-light placeholder(s) lack userData.name or userData.type 'RectAreaLight' — no light was made for them`, {
+			count: n.length,
+			names: n.slice(0, 10)
+		});
+		let r = e.userData.__rayzeeExternal === !0;
+		for (let e of t) {
+			if (!e.parent) continue;
+			console.log("Found multi-material mesh:", e.name), r && (e.geometry = On(e.geometry));
+			let t = Ot(e);
+			for (let e of t.children) e.geometry.userData.__rayzeeOwned = !0;
+			e.parent.add(t), e.parent.remove(e);
+		}
+	}
+	async setupPathTracing(e, t) {
+		this.sceneScale = t;
+	}
+	createFloorPlane() {
+		this.floorPlane = new ot(new Xe(), new st({
+			transparent: !1,
+			color: 3158064,
+			roughness: 1,
+			metalness: 0,
+			opacity: 0,
+			transmission: 0
+		})), this.floorPlane.name = "Ground", this.floorPlane.visible = !1, this.scene.add(this.floorPlane);
+	}
+	setFloorPlane(e) {
+		this.floorPlane = e;
+	}
+	getSceneScale() {
+		return this.sceneScale;
+	}
+	getSceneSize() {
+		return this.sceneSize.clone();
+	}
+	getTargetModel() {
+		return this.targetModel;
+	}
+	getSupportedFormats(e = null) {
+		let t = {
+			...En,
+			...this._archiveFormats
+		};
+		for (let [e, { type: n, name: r }] of this._formats) t[e] = {
+			type: n,
+			name: r
+		};
+		if (e) {
+			let n = {};
+			for (let [r, i] of Object.entries(t)) i.type === e && (n[r] = i);
+			return n;
+		}
+		return t;
+	}
+	dispose() {
+		for (let e in this.loaderCache) {
+			let t = this.loaderCache[e];
+			t && typeof t.dispose == "function" && t.dispose();
+		}
+		this.loaderCache = {}, this._listeners = void 0, this._loadingManager.onError = void 0, this._issues = null, this._urlAbort?.abort(), this._urlAbort = null, this.storage = null, this._downloads = null, this.archives?.release(), this.archives = null, this._archiveLoader = null, this.releaseTargetModel();
+	}
+	removeAllEventListeners() {
+		this._listeners = void 0;
+	}
+}, Mn = {
+	addEventListener() {},
+	removeEventListener() {},
+	dispatchEvent() {
+		return !0;
+	}
+}, Nn = class {
+	constructor(e) {
+		this.canvas = e, this._configuration = null, this._texture = null;
+	}
+	configure(e) {
+		this.unconfigure(), this._configuration = e;
+	}
+	unconfigure() {
+		this._texture?.destroy(), this._texture = null, this._configuration = null;
+	}
+	getConfiguration() {
+		return this._configuration;
+	}
+	getCurrentTexture() {
+		if (!this._configuration) throw Error("HeadlessGPUContext: getCurrentTexture() before configure()");
+		let e = Math.max(1, this.canvas.width), t = Math.max(1, this.canvas.height);
+		if (this._texture?.width !== e || this._texture?.height !== t) {
+			let { device: n, format: r, usage: i } = this._configuration;
+			this._texture?.destroy(), this._texture = n.createTexture({
+				label: "headless-canvas",
+				size: [e, t],
+				format: r,
+				usage: i
+			});
+		}
+		return this._texture;
+	}
+};
+function Pn(e = 1, t = 1) {
+	let n = {
+		...Mn,
+		defaultView: null
+	}, r = {
+		...Mn,
+		isHeadlessCanvas: !0,
+		width: e,
+		height: t,
+		clientWidth: 0,
+		clientHeight: 0,
+		style: {},
+		parentNode: null,
+		ownerDocument: n,
+		getRootNode: () => n,
+		getBoundingClientRect() {
+			return {
+				x: 0,
+				y: 0,
+				left: 0,
+				top: 0,
+				right: this.width,
+				bottom: this.height,
+				width: this.width,
+				height: this.height
+			};
+		},
+		setPointerCapture() {},
+		releasePointerCapture() {},
+		hasPointerCapture: () => !1,
+		focus() {},
+		getContext: (e) => e === "webgpu" ? i : null
+	}, i = new Nn(r);
+	return r;
+}
+//#endregion
+//#region src/managers/ViewCamera.js
+var Fn = class extends ft {
+	constructor(e, t, n, r) {
+		super(e, t, n, r), this.orthographic = !1, this.orthoHalfHeight = 1;
+	}
+	get isPerspectiveCamera() {
+		return !this.orthographic;
+	}
+	set isPerspectiveCamera(e) {}
+	get isOrthographicCamera() {
+		return this.orthographic;
+	}
+	get top() {
+		return this.orthoHalfHeight;
+	}
+	get bottom() {
+		return -this.orthoHalfHeight;
+	}
+	get right() {
+		return this.orthoHalfHeight * this.aspect;
+	}
+	get left() {
+		return -this.orthoHalfHeight * this.aspect;
+	}
+	updateProjectionMatrix() {
+		this.orthographic ? dt.prototype.updateProjectionMatrix.call(this) : super.updateProjectionMatrix();
+	}
+	copy(e, t) {
+		return super.copy(e, t), this.orthographic = e.orthographic === !0, this.orthoHalfHeight = e.orthoHalfHeight ?? this.orthoHalfHeight, this;
+	}
+}, In = "__rayzeeUserLight", Ln = {
+	DirectionalLight: $e,
+	PointLight: pt,
+	SpotLight: yt,
+	RectAreaLight: z
+}, Rn = class extends F {
+	constructor(e, t, n, r = {}) {
+		super(), this.scene = e, this.sceneHelpers = t, this.pathTracer = n, this._onReset = r.onReset || null, this._onLightRemoved = r.onLightRemoved || null;
+	}
+	addLight(e) {
+		let t = {
+			DirectionalLight: {
+				position: [
+					1,
+					1,
+					1
+				],
+				intensity: 1,
+				color: "#ffffff"
+			},
+			PointLight: {
+				position: [
+					0,
+					2,
+					0
+				],
+				intensity: 1e3,
+				color: "#ffffff"
+			},
+			SpotLight: {
+				position: [
+					0,
+					1,
+					0
+				],
+				intensity: 1e3,
+				color: "#ffffff",
+				angle: 15
+			},
+			RectAreaLight: {
+				position: [
+					0,
+					2,
+					0
+				],
+				intensity: 100,
+				color: "#ffffff",
+				width: 2,
+				height: 2
+			}
+		}[e];
+		if (!t) return null;
+		let n;
+		if (e === "DirectionalLight") n = new $e(t.color, t.intensity), n.position.fromArray(t.position);
+		else if (e === "PointLight") n = new pt(t.color, t.intensity), n.position.fromArray(t.position);
+		else if (e === "SpotLight") {
+			n = new yt(t.color, t.intensity), n.position.fromArray(t.position), n.angle = L.degToRad(t.angle);
+			let e = new R();
+			this.scene.add(e), n.target = e;
+		} else e === "RectAreaLight" && (n = new z(t.color, t.intensity, t.width, t.height), n.position.fromArray(t.position), n.lookAt(0, 0, 0), n.userData.normalize = !0, n.userData.spread = Math.PI, n.userData.shape = "rectangle");
+		n.userData[In] = !0, n.userData.temperature = 6500, n.userData.useTemperature = !1, n.userData.exposure = 0;
+		let r = this.scene.getObjectsByProperty("isLight", !0).length;
+		return n.name = `${e.replace("Light", "")} ${r + 1}`, this.scene.add(n), this.updateLights(), this._syncHelpers(), this._onReset?.(), this._buildDescriptor(n);
+	}
+	getLight(e) {
+		let t = this.scene.getObjectByProperty("uuid", e);
+		return t?.isLight ? t : null;
+	}
+	setIntensity(e, t) {
+		let n = this.getLight(e);
+		return n ? (n.intensity = t, this.updateLights(), this._onReset?.(), !0) : !1;
+	}
+	removeLight(e) {
+		let t = this.scene.getObjectByProperty("uuid", e);
+		return !t || !t.isLight ? !1 : (this._onLightRemoved?.(t), this.sceneHelpers.remove(t), t.target && t.target.removeFromParent(), t.removeFromParent(), this.updateLights(), this._onReset?.(), !0);
+	}
+	clearLights() {
+		this.sceneHelpers.clear(), this._removeAllLights(), this.updateLights(), this._onReset?.();
+	}
+	getLights() {
+		return this.scene.getObjectsByProperty("isLight", !0).map((e) => this._buildDescriptor(e));
+	}
+	updateLights() {
+		this.pathTracer?.updateLights(), this.sceneHelpers?.visible && this.sceneHelpers.update();
+	}
+	transferSceneLights(e, { keepUserLights: t = !1 } = {}) {
+		this._removeAllLights(t ? (e) => !e.userData?.[In] : void 0);
+		let n = e.getObjectsByProperty("isLight", !0);
+		if (!n || n.length === 0) {
+			this.updateLights();
+			return;
+		}
+		for (let e of n) {
+			let t = e.clone();
+			if (e.updateWorldMatrix(!0, !1), e.getWorldPosition(t.position), e.getWorldQuaternion(t.quaternion), e.getWorldScale(t.scale), t.isRectAreaLight && (t.width *= t.scale.x, t.height *= t.scale.y, t.scale.set(1, 1, 1)), (e.isSpotLight || e.isDirectionalLight) && e.target) {
+				let n = new R();
+				e.target.updateWorldMatrix(!0, !1), e.target.getWorldPosition(n.position), this.scene.add(n), t.target = n;
+			}
+			this.scene.add(t);
+		}
+		this.updateLights(), this._syncHelpers();
+	}
+	setShowLightHelper(e) {
+		this.sceneHelpers.visible = e, e ? this._syncHelpers() : this.sceneHelpers.clear();
+	}
+	serialize() {
+		return this.scene.getObjectsByProperty("isLight", !0).map((e) => {
+			let t = {
+				type: e.type,
+				name: e.name,
+				visible: e.visible,
+				color: [
+					e.color.r,
+					e.color.g,
+					e.color.b
+				],
+				intensity: e.intensity,
+				position: e.position.toArray(),
+				quaternion: e.quaternion.toArray(),
+				scale: e.scale.toArray(),
+				userData: r(e.userData) ?? {}
+			};
+			return e.isSpotLight && Object.assign(t, {
+				angle: e.angle,
+				penumbra: e.penumbra,
+				distance: e.distance,
+				decay: e.decay
+			}), e.isPointLight && Object.assign(t, {
+				distance: e.distance,
+				decay: e.decay
+			}), e.isRectAreaLight && Object.assign(t, {
+				width: e.width,
+				height: e.height
+			}), e.target && (e.isSpotLight || e.isDirectionalLight) && (t.target = e.target.position.toArray()), t;
+		});
+	}
+	restore(e) {
+		this.sceneHelpers?.clear(), this._removeAllLights();
+		let t = [];
+		for (let n of e ?? []) {
+			let e = Ln[n.type];
+			if (!e) continue;
+			let r = new e();
+			r.name = n.name ?? "", r.visible = n.visible !== !1, r.color.setRGB(...n.color), r.intensity = n.intensity, r.position.fromArray(n.position), r.quaternion.fromArray(n.quaternion), r.scale.fromArray(n.scale ?? [
+				1,
+				1,
+				1
+			]), r.userData = f(n.userData) ?? {};
+			for (let e of [
+				"angle",
+				"penumbra",
+				"distance",
+				"decay",
+				"width",
+				"height"
+			]) typeof n[e] == "number" && (r[e] = n[e]);
+			if (n.target) {
+				let e = new R();
+				e.position.fromArray(n.target), this.scene.add(e), r.target = e;
+			}
+			this.scene.add(r), t.push(r);
+		}
+		return this.updateLights(), this._syncHelpers(), this._onReset?.(), t;
+	}
+	add(e) {
+		return this.addLight(e);
+	}
+	remove(e) {
+		return this.removeLight(e);
+	}
+	clear() {
+		this.clearLights();
+	}
+	getAll() {
+		return this.getLights();
+	}
+	sync() {
+		this.updateLights();
+	}
+	showHelpers(e) {
+		this.setShowLightHelper(e);
+	}
+	dispose() {
+		this._disposed || (this._disposed = !0, this._onLightRemoved = null, this.sceneHelpers?.clear(), this._removeAllLights(), this._onReset = null, this.pathTracer = null, this.sceneHelpers = null, this.scene = null);
+	}
+	_removeAllLights(e) {
+		this.scene.getObjectsByProperty("isLight", !0).filter((t) => !e || e(t)).forEach((e) => {
+			this._onLightRemoved?.(e), e.target && this.scene.remove(e.target), this.scene.remove(e);
+		});
+	}
+	_syncHelpers() {
+		if (!this.sceneHelpers.visible) return;
+		let e = this.scene.getObjectsByProperty("isLight", !0);
+		this.sceneHelpers.sync(e);
+	}
+	_buildDescriptor(e) {
+		let t = 0;
+		e.type === "SpotLight" && e.angle !== void 0 ? t = L.radToDeg(e.angle) : e.type === "DirectionalLight" && (t = L.radToDeg(e.userData?.angle ?? 0));
+		let n = {
+			uuid: e.uuid,
+			name: e.name,
+			type: e.type,
+			visible: e.visible,
+			intensity: e.intensity,
+			color: `#${e.color.getHexString()}`,
+			position: [
+				e.position.x,
+				e.position.y,
+				e.position.z
+			],
+			angle: t,
+			temperature: e.userData?.temperature ?? 6500,
+			useTemperature: e.userData?.useTemperature ?? !1,
+			exposure: e.userData?.exposure ?? 0
+		};
+		if (e.type === "RectAreaLight") {
+			n.width = e.width, n.height = e.height, n.normalize = e.userData?.normalize ?? !0, n.spread = L.radToDeg(e.userData?.spread ?? Math.PI);
+			let t = e.userData?.shape;
+			n.shape = t === "square" || t === "rectangle" || t === "disk" || t === "ellipse" ? t : t === 1 ? "ellipse" : "rectangle";
+			let r = e.getWorldDirection(e.position.clone());
+			n.target = [
+				e.position.x + r.x,
+				e.position.y + r.y,
+				e.position.z + r.z
+			];
+		} else e.type === "SpotLight" && e.target ? (n.target = [
+			e.target.position.x,
+			e.target.position.y,
+			e.target.position.z
+		], n.distance = e.distance ?? 0, n.penumbra = e.penumbra ?? 0, n.decay = e.decay ?? 2) : e.type === "PointLight" && (n.distance = e.distance ?? 0, n.decay = e.decay ?? 2);
+		return (e.type === "SpotLight" || e.type === "DirectionalLight") && e.userData?.gobo && (n.gobo = e.userData.gobo.name, n.goboIntensity = e.userData.gobo.intensity, n.goboInverted = !!e.userData.gobo.inverted, e.type === "DirectionalLight" && (n.goboScale = e.userData.gobo.scale ?? 5)), e.type === "SpotLight" && e.userData?.ies && (n.ies = e.userData.ies.name, n.iesIntensity = e.userData.ies.intensity ?? 1, n.fixtureLumens = e.userData.ies.fixtureLumens ?? null), n;
+	}
+}, zn = ({ element: e, pbrtEntry: t } = {}) => ({
+	...e === void 0 ? {} : { element: e },
+	...t === void 0 ? {} : { pbrtEntry: t }
+}), Q = /* @__PURE__ */ new WeakMap(), Bn = new Set([...Object.values(m), ...Object.values(p)]), Vn = /* @__PURE__ */ new Set();
+async function Hn(e, t) {
+	if (!t || typeof self < "u") return e.init();
+	globalThis.self = {
+		requestAnimationFrame: () => 0,
+		cancelAnimationFrame: () => {}
+	};
+	try {
+		return await e.init();
+	} finally {
+		delete globalThis.self;
+	}
+}
+var $ = ge("engine");
+function Un() {
+	let e = new Float32Array(16);
+	return new Uint32Array(e.buffer)[3] = fe.TRIANGLE_LEAF, e;
+}
+function Wn(e, t) {
+	e.lost.then((e) => {
+		t.app && t.app._handleDeviceLost(e);
+	});
+}
+var Gn = /swiftshader|llvmpipe|lavapipe|basic render|microsoft basic|warp/i;
+function Kn(e) {
+	let t = e.info ?? {}, n = `${t.vendor ?? ""} ${t.architecture ?? ""} ${t.device ?? ""} ${t.description ?? ""}`;
+	return {
+		vendor: t.vendor ?? "",
+		architecture: t.architecture ?? "",
+		device: t.device ?? "",
+		description: t.description ?? "",
+		isSoftware: t.isFallbackAdapter === !0 || e.isFallbackAdapter === !0 || Gn.test(n)
+	};
+}
+var qn = class extends F {
+	constructor(e, t = {}) {
+		super(), this._headless = t.headless === !0 || !e, e ??= Pn();
+		try {
+			Q.get(e)?.dispose();
+		} catch (e) {
+			$.warn("prior canvas owner dispose failed", e);
+		}
+		Q.set(e, this), this.canvas = e, this._autoResize = !this._headless && t.autoResize !== !1, this._maxSceneBytes = t.maxSceneBytes, this._hostMemoryGB = t.hostMemoryGB, this._storageOption = t.storage, this._storageOpener = null, this._memorySpill = t.memorySpill === !0, this.storage = null, this._storageRelease = null, this._applySceneMetadataEnabled = t.applySceneMetadata !== !1, this._unlitRestore = null, this._applyingSceneMetadata = !1, this._profile = he(t.profile), this._profileName = t.profile ?? "viewer", this._issues = new _e({
+			strict: t.strict === !0,
+			onIssue: (e) => this.dispatchEvent({
+				type: m.ISSUE,
+				issue: e
+			})
+		}), this.color = new rn({ issues: this._issues }), S(this.color), this.settings = new nn({
+			...v,
+			environmentRotation: this._profile.environmentRotation,
+			saturation: this._profile.saturation,
+			dofMode: this._profile.dofMode
+		}, { issues: this._issues }), this.renderer = null, this.scene = null, this.meshScene = null, this._sceneHelpers = null, this.assetLoader = null, this._sdf = null, this._maxTextureSize = v.maxTextureSize, this.pipeline = null, this._pendingReservedRenderSize = null, this.stages = {}, this.camera = null, this.lightManager = null, this.environmentManager = null, this.isInitialized = !1, this.pauseRendering = !1, this._pathTracerEnabled = !0, this._rasterPrecompile = null, this.animationManagerId = null, this.needsReset = !1, this._loadingInProgress = !1, this._needsDisplayRefresh = !1, this._paused = !1, this._emissiveSamplingUserSet = !1, this.completion = new Gt(), this._resizeDebounceTimer = null, this._displayWidth = 0, this._displayHeight = 0, this._renderScale = 1, this._renderWidth = 0, this._renderHeight = 0, this._trackedListeners = [], this._disposed = !1, this._deviceLost = !1, this._gpuDevice = null, this._deviceLostHolder = null, this._deterministic = !1, this._dispatchPinned = !1, this._deterministicRestore = null, this.adapterInfo = null;
+	}
+	_addTrackedListener(e, t, n) {
+		e && (e.addEventListener(t, n), this._trackedListeners.push({
+			target: e,
+			type: t,
+			handler: n
+		}));
+	}
+	_removeTrackedListeners() {
+		for (let { target: e, type: t, handler: n } of this._trackedListeners) try {
+			e.removeEventListener(t, n);
+		} catch (e) {
+			$.warn("failed to remove listener", t, e);
+		}
+		this._trackedListeners.length = 0;
+	}
+	async init() {
+		let e = this._initStorage();
+		return await this._initRenderer(), this._applyPendingReservedRenderSize(), this.camera = this._createCamera(), this._initScenes(), this._initAssetPipeline(), this._initPipeline(), await this._initManagers(), this._wireEvents(), await e, this._attachStorage(), this.stages.pathTracer.setTriangleData(new Uint32Array(le.FLOATS_PER_TRIANGLE), 0), this.stages.pathTracer.setBVHData(Un()), this.stages.pathTracer.materialData.setMaterialData(new Float32Array(16)), this.stages.pathTracer.setupMaterial(), this.isInitialized = !0, $.debug("WebGPU path tracer app initialized"), this;
+	}
+	async setStorageOpener(e) {
+		this._storageOpener = e, !(!this.isInitialized || this.storage || this._disposed) && (await this._initStorage(), this._attachStorage());
+	}
+	async _initStorage() {
+		let e = this._storageOption ?? (this._issues.strict && !Ce("storage") ? !1 : w().storage);
+		if (e !== !1) {
+			if (e && typeof e == "object") this.storage = e;
+			else {
+				if (!this._storageOpener) {
+					(this._storageOption !== void 0 || Ce("storage")) && this._issues.warn(x.CAPABILITY_MISSING, "on-disk storage needs rayzee/addons/storage: setStorageOpener( acquireSharedStorage )");
+					return;
+				}
+				let { storage: e, reason: t, release: n } = await this._storageOpener(w().cacheNamespace);
+				if (this._disposed) {
+					n();
+					return;
+				}
+				if (!e) {
+					this._issues.warn(x.STORAGE_UNAVAILABLE, `on-disk storage is off: ${t}`, { reason: t });
+					return;
+				}
+				this.storage = e, this._storageRelease = n;
+			}
+			this._addTrackedListener(this.storage, "change", (e) => this.dispatchEvent({
+				type: m.STORAGE_CHANGED,
+				area: e.area
+			})), this._addTrackedListener(this.storage, "issue", (e) => this._issues.warn(e.code, e.message, e.detail));
+		}
+	}
+	_attachStorage() {
+		this.assetLoader && (this.assetLoader.storage = this.storage);
+	}
+	dispatchEvent(e) {
+		super.dispatchEvent(e);
+		let t = p[e.type];
+		t && super.dispatchEvent({
+			...e,
+			type: t
+		});
+	}
+	addEventListener(e, t) {
+		!Bn.has(e) && !Vn.has(e) && (Vn.add(e), $.warn(`no engine event is named "${e}", so this listener will never fire — see EngineEvents`)), super.addEventListener(e, t);
+	}
+	animate() {
+		if (this._headless) throw Error("a headless app has no render loop — drive it with renderFrames() or renderUntilComplete()");
+		if (this._deviceLost) return;
+		if (this.animationManagerId = requestAnimationFrame(() => this.animate()), this._loadingInProgress || this._sdf?.isProcessing) {
+			this.dispatchEvent({ type: m.FRAME });
+			return;
+		}
+		this._beginFrame();
+		let e = this.needsReset;
+		if (this.needsReset &&= (this.stages.pathTracer?.noteViewChanged(), this.reset(!0), !1), this.camera.updateMatrixWorld(), !this.pathTracerEnabled) {
+			this.renderer.render(this.meshScene, this.camera), this._renderHelperOverlay();
+			return;
+		}
+		if (!this.pauseRendering) {
+			if (this._beforeTrace(), this.stages.pathTracer?.isReady) {
+				if (this.stages.pathTracer.isComplete && this.completion.renderCompleteDispatched) {
+					this._needsDisplayRefresh && (this._needsDisplayRefresh = !1, this.stages.compositor.render(this.pipeline.context), this._renderHelperOverlay()), this.stopAnimation();
+					return;
+				}
+				if (this._holdTrace(e)) {
+					this._renderHelperOverlay(), this.dispatchEvent({ type: m.FRAME });
+					return;
+				}
+				if (this.stages.pathTracer.readbackWait()) {
+					this.dispatchEvent({ type: m.FRAME });
+					return;
+				}
+				this._traceFrame({ liveDenoise: !0 }), this.stages.pathTracer.isComplete && this.completion.markComplete() && (this._renderCompleted(), this.dispatchEvent({
+					type: m.RENDER_COMPLETE,
+					...this._completionInfo()
+				}));
+			}
+			this._renderHelperOverlay(), this.dispatchEvent({ type: m.FRAME });
+		}
+	}
+	_traceFrame({ liveDenoise: e = !1 } = {}) {
+		let t = this.stages.pathTracer;
+		this.pipeline.render(), this._afterTrace(t, e), t.isComplete || this.completion.updateTime(), this._ensureVRAMWiring();
+		let n = t.vramTracker, r = t.frameCount ?? 0;
+		n && (r <= 1 || r % 30 == 0) && n.measure(), h({
+			timeElapsed: this.completion.timeElapsed,
+			samples: ne(t),
+			memoryUsed: n?.current ?? 0,
+			memoryPeak: n?.peak ?? 0
+		}), this.completion.isTimeLimitReached(t, this.settings.get("renderLimitMode"), this.settings.get("renderTimeLimit")) && (t.isComplete = !0);
+	}
+	_completionInfo() {
+		return {
+			samples: this.stages.pathTracer.frameCount,
+			timeElapsed: this.completion.timeElapsed,
+			budgetOverrun: this.completion.budgetOverrun,
+			reason: this.completion.stopCondition(this.stages.pathTracer) ?? "samples"
+		};
+	}
+	stopAnimation() {
+		this.animationManagerId &&= (cancelAnimationFrame(this.animationManagerId), null);
+	}
+	_handleDeviceLost(e) {
+		this._deviceLost || (this._deviceLost = !0, $.error(`WebGPU device lost (${e?.reason || "unknown"}): ${e?.message || ""}`), this.stopAnimation(), this.dispatchEvent({
+			type: m.DEVICE_LOST,
+			reason: e?.reason,
+			message: e?.message
+		}));
+	}
+	wake() {
+		this._deviceLost || this._headless || !this.animationManagerId && this.isInitialized && !this._paused && this.animate();
+	}
+	pause() {
+		this._paused = !0, this.stopAnimation();
+	}
+	resume() {
+		this._paused = !1, !this.animationManagerId && !this._headless && this.animate();
+	}
+	reset(e = !1, { motion: t = !1 } = {}) {
+		t && this.stages.pathTracer?.noteViewChanged(), this._beforeReset(e || t), this.pipeline && (this.pipeline.reset(), e || this.pipeline.eventBus.emit("pipeline:historyReset")), this._afterReset(), this.completion.reset(), this.wake(), this.dispatchEvent({ type: m.RENDER_RESET });
+	}
+	dispose() {
+		if (!this._disposed) {
+			if (this._disposed = !0, this.dispatchEvent({ type: m.DISPOSE }), this.stopAnimation(), clearTimeout(this._resizeDebounceTimer), this._resizeDebounceTimer = null, this._removeTrackedListeners(), ie(null), this._storageRelease?.(), this._storageRelease = null, this.storage = null, this._sceneSource = this._sceneSourceFile = null, this._issues.detach(), this.color?.dispose(), this.color = null, this._textureReadback?.dispose(), this._textureReadback = null, this._readbackToneMapper?.dispose(), this._readbackToneMapper = null, this._disposeExtensions(), this.lightManager?.dispose(), this.pipeline?.dispose(), this._sdf?.dispose(), this._sdf = null, this.assetLoader?.dispose(), this.assetLoader = null, this.meshScene) {
+				this.meshScene.environment?.dispose(), this.meshScene.environment = null;
+				for (let e of [...this.meshScene.children]) se(e);
+				this.meshScene.clear(), this.meshScene = null;
+			}
+			this._sceneHelpers?.clear(), this._sceneHelpers = null, this.scene?.clear(), this.scene = null;
+			try {
+				let e = Ge().value, t = Be().value;
+				e?._listeners?.dispose && (e._listeners.dispose.length = 0), t?._listeners?.dispose && (t._listeners.dispose.length = 0);
+			} catch (e) {
+				$.warn("failed to clear TSL texture singleton listeners", e);
+			}
+			this.canvas && Q.get(this.canvas) === this && Q.delete(this.canvas), this._gpuDevice &&= (this._gpuDevice.onuncapturederror = null, null), this._deviceLostHolder &&= (this._deviceLostHolder.app = null, null), te(this.renderer), this.renderer = null, this.stages = {}, this.isInitialized = !1;
+		}
+	}
+	unloadScene() {
+		if (this.isInitialized) {
+			if (this._loadingInProgress) throw Error("PathTracerApp.unloadScene: cannot unload while a load is in progress");
+			this._disposed || (this._releaseSceneState(), this.assetLoader?.releaseTargetModel(), this._sceneSource = this._sceneSourceFile = null, this.lightManager?.clearLights?.(), this.stages.pathTracer && (this.stages.pathTracer.setTriangleData(new Uint32Array(le.FLOATS_PER_TRIANGLE), 0), this.stages.pathTracer.setBVHData(Un()), this.stages.pathTracer.materialData.setMaterialData(new Float32Array(16)), this.stages.pathTracer.setEmissiveTriangleData?.(new Float32Array(), 0, 0), this.stages.pathTracer.setupMaterial()), this._dropDisplay(), this.reset(), this.dispatchEvent({ type: m.SCENE_UNLOADED }));
+		}
+	}
+	async loadModel(e, t = {}) {
+		await this._loadWithSceneRebuild(() => this.assetLoader.loadModel(e, t), {
+			type: m.MODEL_LOADED,
+			url: e
+		}, {
+			kind: "url",
+			url: e,
+			cacheKey: t.cacheKey ?? null
+		});
+	}
+	async loadObject3D(e, t = "object3d") {
+		await this._loadWithSceneRebuild(() => this.assetLoader.loadObject3D(e, t), {
+			type: m.OBJECT3D_LOADED,
+			name: t
+		}, {
+			kind: "object3d",
+			name: t
+		});
+	}
+	_busyError(e) {
+		let t = /* @__PURE__ */ Error(`${e}: another load is already in progress`);
+		return t.code = "LOAD_IN_PROGRESS", t;
+	}
+	async loadEnvironment(e) {
+		if (this._loadingInProgress) throw this._busyError("PathTracerApp.loadEnvironment");
+		this._loadingInProgress = !0;
+		try {
+			await this.assetLoader.loadEnvironment(e);
+			let t = this.meshScene.environment;
+			t && this.stages.pathTracer && await this.stages.pathTracer.environment.setEnvironmentMap(t), this.pipeline?.eventBus.emit("pipeline:lightingChanged"), this.reset(), this.dispatchEvent({
+				type: m.ENVIRONMENT_LOADED,
+				url: e
+			});
+		} finally {
+			this._loadingInProgress = !1;
+		}
+	}
+	async inspectArchive(e) {
+		return await this.assetLoader.inspectArchive(e);
+	}
+	async loadFile(e, t = {}) {
+		if (t = this._sceneBudgets(t), typeof e == "string") {
+			let n = t.filename ?? K(e), r = this.assetLoader?.getFileFormat(n);
+			if (!r) throw this.assetLoader.formatError(n);
+			if (r.type === "environment" || r.type === "image") return this.loadEnvironment(e);
+			await this._loadWithSceneRebuild(() => this.assetLoader.loadAssetFromUrl(e, {
+				...t,
+				filename: n
+			}), {
+				type: m.MODEL_LOADED,
+				filename: n
+			}, {
+				kind: "url",
+				url: e,
+				filename: n,
+				cacheKey: t.cacheKey ?? null,
+				...zn(t)
+			});
+			return;
+		}
+		let n = this.assetLoader?.getFileFormat(e?.name || "");
+		if (!n) throw this.assetLoader.formatError(e?.name || "");
+		if (n.type !== "environment" && n.type !== "image") {
+			let n = Oe(e).catch(() => ({
+				name: e.name,
+				size: e.size,
+				lastModified: e.lastModified ?? 0,
+				sample: null
+			}));
+			await this._loadWithSceneRebuild(() => this.assetLoader.loadAssetFromFile(e, t), {
+				type: m.MODEL_LOADED,
+				filename: e.name
+			}, async () => {
+				let e = await n;
+				return {
+					kind: "local-file",
+					file: e,
+					key: e.sample ? E(e) : null,
+					...zn(t)
+				};
+			}), this._sceneSourceFile = e;
+			return;
+		}
+		if (this._loadingInProgress) throw this._busyError("PathTracerApp.loadFile");
+		this._loadingInProgress = !0;
+		try {
+			await this.assetLoader.loadAssetFromFile(e);
+			let t = this.meshScene.environment;
+			t && this.stages.pathTracer && await this.stages.pathTracer.environment.applyHDRI(t), this.pipeline?.eventBus.emit("pipeline:lightingChanged"), this.reset(), this.dispatchEvent({
+				type: m.ENVIRONMENT_LOADED,
+				filename: e.name
+			});
+		} finally {
+			this._loadingInProgress = !1;
+		}
+	}
+	async loadExampleModels(e, t) {
+		await this._loadWithSceneRebuild(() => this.assetLoader.loadExampleModels(e, t), {
+			type: m.MODEL_LOADED,
+			index: e
+		}, {
+			kind: "url",
+			url: t[e]?.url ?? null,
+			cacheKey: null
+		});
+	}
+	cancelLoad() {
+		this._loadingInProgress && this.assetLoader?.cancelActiveLoad();
+	}
+	async setMaxTextureSize(e, { reprocess: t = !0 } = {}) {
+		let n = this._maxTextureSize;
+		if (this._maxTextureSize = this._sdf?.setMaxTextureSize(e) ?? e, typeof this.stages?.pathTracer?.sdfs?.setMaxTextureSize == "function" && this.stages.pathTracer.sdfs.setMaxTextureSize(this._maxTextureSize), t && this._maxTextureSize !== n && this._sdf?.triangles && !this._loadingInProgress) {
+			this._loadingInProgress = !0;
+			try {
+				await this.loadSceneData(), this.reset(), this.dispatchEvent({
+					type: m.TEXTURES_REPROCESSED,
+					maxTextureSize: this._maxTextureSize
+				});
+			} finally {
+				this._loadingInProgress = !1;
+			}
+		}
+	}
+	get sceneSource() {
+		return this._sceneSource ?? null;
+	}
+	get sceneSourceFile() {
+		return this._sceneSourceFile ?? null;
+	}
+	async _loadWithSceneRebuild(e, t, n = null) {
+		if (this._loadingInProgress) throw this._busyError("PathTracerApp");
+		this._loadingInProgress = !0;
+		try {
+			await e(), this._sceneSource = typeof n == "function" ? await n() : n, this._sceneSourceFile = null, this._emissiveSamplingUserSet = !1, this._clearAppendedModels(), this._modelReplaced(), await this.loadSceneData({ pendingEnvironment: this._beginSceneMetadataEnvironment() }), this._maybeSpill(), this.pipeline?.eventBus.emit("pipeline:lightingChanged"), this._dropDisplay(), this.reset(), this.dispatchEvent(t), this._modelAnnounced();
+		} catch (e) {
+			throw (!e || e.code !== "LOAD_IN_PROGRESS") && this._discardFailedLoad(), e?.code === "ARCHIVE_NEEDS_ELEMENT" ? _() : e?.code !== "LOAD_IN_PROGRESS" && g({
+				status: `Error: ${e?.message ?? e}`,
+				failed: !0,
+				progress: 100
+			}), e;
+		} finally {
+			this._loadingInProgress = !1;
+		}
+	}
+	_discardFailedLoad() {
+		this._sceneSource = this._sceneSourceFile = null;
+		try {
+			this._clearAppendedModels(), this.assetLoader?.releaseTargetModel(), this._dropDisplay(), this.reset();
+		} catch (e) {
+			console.warn("PathTracerApp: could not clear the scene after a failed load", e);
+		}
+	}
+	get sceneMetadata() {
+		return this.assetLoader?.sceneMetadata ?? null;
+	}
+	_beginSceneMetadataEnvironment() {
+		this._restoreUnlitSettings();
+		let e = this.sceneMetadata?.environment;
+		return this._applySceneMetadataEnabled && e?.enabled === !1 ? (this._applyUnlitSettings(), null) : !this._applySceneMetadataEnabled || !e?.sourceFile || !this.stages.pathTracer ? null : (this.stages.pathTracer.environment.beginHDRI(), this._applyingSceneMetadata = !0, this.assetLoader.loadEnvironment(e.sourceFile).catch((t) => (this._issues.record(x.ENVIRONMENT_LOAD_FAILED, `authored environment "${e.sourceFile}" failed to load — lighting falls back to the previous environment`, {
+			sourceFile: e.sourceFile,
+			cause: String(t?.message ?? t)
+		}), null)).finally(() => {
+			this._applyingSceneMetadata = !1;
+		}));
+	}
+	_applySceneMetadataSettings(e) {
+		let t = this.sceneMetadata, n = t?.environment;
+		if (!n || n.enabled === !1) return;
+		let r = {
+			enableEnvironment: !0,
+			showBackground: !0,
+			transparentBackground: !1
+		};
+		n.intensity !== void 0 && (r.environmentIntensity = n.intensity, r.backgroundIntensity = n.intensity), n.rotation !== void 0 && (r.environmentRotation = n.rotation), this.settings.setMany(r, {
+			reset: !1,
+			source: Y.SCENE_METADATA
+		}), this.scene && (this.scene.background = e), this.dispatchEvent({
+			type: m.SCENE_METADATA_APPLIED,
+			metadata: t,
+			environment: { ...n }
+		});
+	}
+	_applyUnlitSettings() {
+		let e = this.settings.getEffective(), t = {
+			enableEnvironment: !1,
+			showBackground: !1
+		};
+		this._unlitRestore = Object.fromEntries(Object.keys(t).map((t) => [t, {
+			value: e[t].value,
+			source: e[t].source
+		}])), this.settings.setMany(t, {
+			reset: !1,
+			source: Y.SCENE_METADATA
+		}), this.dispatchEvent({
+			type: m.SCENE_METADATA_APPLIED,
+			metadata: this.sceneMetadata,
+			environment: { enabled: !1 }
+		});
+	}
+	_restoreUnlitSettings() {
+		let e = this._unlitRestore;
+		if (!e) return;
+		this._unlitRestore = null;
+		let t = this.settings.getEffective();
+		for (let [n, { value: r, source: i }] of Object.entries(e)) t[n]?.source === Y.SCENE_METADATA && this.settings.set(n, r, {
+			reset: !1,
+			source: i
+		});
+		this.dispatchEvent({
+			type: m.SCENE_METADATA_APPLIED,
+			metadata: this.sceneMetadata,
+			environment: { enabled: this.settings.get("enableEnvironment") }
+		});
+	}
+	async loadSceneData({ pendingEnvironment: e = null, keepUserLights: t = !1 } = {}) {
+		this._releaseSceneState({ keepSelection: !!this._preserveSelectionOnRebuild }), this._tagPrimarySceneObject();
+		let n = new u("", {
+			namespace: "scene",
+			level: "info"
+		}), r = () => this.stages.pathTracer.environment.envParams.mode === "hdri" ? this.meshScene.environment : null, i = r(), a = null;
+		if (e ? (n.start("Environment fetch + CDF (concurrent)"), a = e.then(async (e) => {
+			e && (await this.stages.pathTracer.environment.applyHDRI(e), this._applySceneMetadataSettings(e));
+		}).catch((e) => this._issues.record(x.ENVIRONMENT_LOAD_FAILED, "authored environment failed to install — the scene is lit by whatever was already loaded", { cause: String(e?.message ?? e) })).finally(() => n.end("Environment fetch + CDF (concurrent)"))) : i?.image?.data && (n.start("Environment CDF build (worker)"), this.stages.pathTracer.scene.environment = i, a = this.stages.pathTracer.environment.buildEnvironmentCDF().then(() => {
+			n.end("Environment CDF build (worker)"), this._applySceneMetadataEnabled && this._applySceneMetadataSettings(i);
+		})), n.start("BVH build (SceneProcessor)"), this._sdf.setMaxTextureSize(this._maxTextureSize), await this._sdf.buildBVH(this.meshScene, {
+			sceneKey: this.assetLoader?.sceneSourceKey ?? null,
+			progressive: this._progressiveSpill()
+		}), this.assetLoader?.flushPendingGraph(this._sdf.performanceMetrics.totalProcessingTime), n.end("BVH build (SceneProcessor)"), g({
+			status: "Transferring data to GPU...",
+			progress: 86
+		}), await new Promise((e) => setTimeout(e, 0)), n.start("GPU data transfer"), !this._sdf.uploadToPathTracer(this.stages.pathTracer, this.lightManager, this.meshScene, r(), { keepUserLights: t })) return !1;
+		this.stages.pathTracer._meshRefs = this.stages.pathTracer._collectMeshRefs(this.meshScene), this.stages.pathTracer.setMeshVisibilityData(this.stages.pathTracer._meshRefs), this._refreshEmissiveForVisibility(), n.end("GPU data transfer"), g({
+			status: "Compiling shaders...",
+			progress: 90
+		}), await new Promise((e) => setTimeout(e, 0)), n.start("Material setup (TSL compile)"), this.stages.pathTracer.setupMaterial(), n.end("Material setup (TSL compile)"), this._rasterPrecompile = null, this._pathTracerEnabled || (n.start("Pipeline precompile"), await this.precompileRaster(), n.end("Pipeline precompile")), a && (g({
+			status: "Finalizing environment map...",
+			progress: 95
+		}), await a, this.stages.pathTracer.environment.applyCDFResults());
+		let o = this.getSceneMinY();
+		if (this.settings.set("groundProjectionLevel", o, { reset: !1 }), this.settings.set("groundCatcherHeight", o, { reset: !1 }), !this._emissiveSamplingUserSet) {
+			let e = (this._sdf?.emissiveTriangleBuilder?.emissiveTriangles?.length ?? this._sdf?.emissiveTriangleCount ?? 0) > 0;
+			this.settings.set("enableEmissiveTriangleSampling", e, { reset: !1 });
+		}
+		return n.start("Apply settings"), this.settings.applyAll(), this.stages.compositor.setTransparentBackground(this.settings.get("transparentBackground")), n.end("Apply settings"), n.print(this._sceneSummaryParts()), _(), this._sceneRebuilt(), this.dispatchEvent({ type: m.SCENE_REBUILD }), !0;
+	}
+	_sceneSummaryParts() {
+		let e = this.stages.pathTracer, t = this._sdf?.instanceTable?.setCount ?? 0, n = this._sdf?.geometryExtractor?.maps?.length ?? 0;
+		return [
+			b.count(e.triangleCount, "tri"),
+			t ? b.count(t, "mesh", "meshes") : null,
+			b.count(e.materialData.materialCount, "material"),
+			n ? b.count(n, "map") : null,
+			b.count(e.bvhNodeCount, "BVH node")
+		];
+	}
+	_tagPrimarySceneObject() {
+		let e = this.sceneModel;
+		e && (e.userData.__rayzeeSceneObject = !0);
+	}
+	_clearAppendedModels() {
+		let e = this.meshScene;
+		if (!e) return;
+		let t = this.assetLoader?.floorPlane, n = this.sceneModel;
+		for (let r of [...e.children]) r === t || r === n || r.userData?.__rayzeeSceneObject && this.assetLoader.removeModelRoot(r);
+	}
+	async _finishRebuildNoReframe(e) {
+		await this.loadSceneData({ keepUserLights: !0 }), this._maybeSpill(), this._sceneBoundsChanged(), this.pipeline?.eventBus.emit("pipeline:lightingChanged"), this.reset(), e && this.dispatchEvent(e);
+	}
+	async addModel(e, { name: t, cacheKey: n } = {}) {
+		if (this._loadingInProgress) throw Error("PathTracerApp.addModel: another load is already in progress");
+		this._loadingInProgress = !0, this._preserveSelectionOnRebuild = !0;
+		try {
+			let { root: r } = await this.assetLoader.appendModel(e, { cacheKey: n });
+			return r.userData.__rayzeeSceneObject = !0, r.userData.__rayzeeSourceUrl = e, n && (r.userData.__rayzeeCacheKey = n), t && (r.userData.__rayzeeName = t), await this._finishRebuildNoReframe({
+				type: m.MODEL_ADDED,
+				url: e,
+				id: r.uuid
+			}), r.uuid;
+		} finally {
+			this._preserveSelectionOnRebuild = !1, this._loadingInProgress = !1;
+		}
+	}
+	async addModelFromObject3D(e, { name: t } = {}) {
+		if (this._loadingInProgress) throw Error("PathTracerApp.addModelFromObject3D: another load is already in progress");
+		this._loadingInProgress = !0, this._preserveSelectionOnRebuild = !0;
+		try {
+			let { root: n } = this.assetLoader.appendObject3D(e, t || "object3d");
+			return n.userData.__rayzeeSceneObject = !0, t && (n.userData.__rayzeeName = t), await this._finishRebuildNoReframe({
+				type: m.MODEL_ADDED,
+				id: n.uuid
+			}), n.uuid;
+		} finally {
+			this._preserveSelectionOnRebuild = !1, this._loadingInProgress = !1;
+		}
+	}
+	async removeSceneObject(e) {
+		if (!this.meshScene) return !1;
+		let t = this.assetLoader?.floorPlane;
+		if (t && t.uuid === e) return !1;
+		let n = this.getSceneObject(e);
+		if (!n) return !1;
+		if (this._loadingInProgress) throw Error("PathTracerApp.removeSceneObject: another load is already in progress");
+		this._loadingInProgress = !0;
+		try {
+			return this._releaseSceneState(), n === this.sceneModel ? this.assetLoader.releaseTargetModel() : this.assetLoader.removeModelRoot(n), await this._finishRebuildNoReframe({
+				type: m.SCENE_OBJECT_REMOVED,
+				id: e
+			}), !0;
+		} finally {
+			this._loadingInProgress = !1;
+		}
+	}
+	setSceneObjectVisibility(e, t) {
+		return this.setMeshVisibilityByUuid(e, t);
+	}
+	_sceneBudgets(e) {
+		return !this._memorySpill || !this.storage ? e : {
+			maxTriangles: ce,
+			maxPlacements: ue,
+			...e
+		};
+	}
+	_progressiveSpill() {
+		if (!this._memorySpill || !this.storage || (this.assetLoader?.animations?.length ?? 0) > 0) return null;
+		let e = this.stages.pathTracer;
+		return {
+			storage: this.storage,
+			uploader: (t, n) => n === "triangles" ? e.createTriangleChunkUploader(t) : e.createChunkUploader(t)
+		};
+	}
+	_maybeSpill() {
+		!this._memorySpill || !this.storage || (this.assetLoader?.animations?.length ?? 0) > 0 || this._sdf?.spillToDisk(this.storage).then((e) => e && this.dispatchEvent({
+			type: m.SCENE_SPILLED,
+			...e
+		})).catch((e) => this._issues.warn(x.STORAGE_WRITE_FAILED, `memory spill failed: ${e.message}`));
+	}
+	async ensureSceneResident() {
+		this._sdf?.spilled && await this._sdf.ensureResident();
+	}
+	get sceneMeshes() {
+		return this._sdf?.meshes ?? [];
+	}
+	get sceneModel() {
+		return this.assetLoader?.targetModel ?? null;
+	}
+	getSceneObject(e) {
+		let t = this.meshScene?.children.find((t) => t.uuid === e);
+		return t?.userData?.__rayzeeSceneObject ? t : null;
+	}
+	async refitBVH(e, t) {
+		await this.ensureSceneResident();
+		let { triRanges: n, bvhRanges: r, ...i } = await this._sdf.refitBVH(e, t);
+		return this.stages.pathTracer.updateTriangleData(this._sdf.triangles, n), this.stages.pathTracer.updateBVHData(this._sdf.bvh, r), this.reset(!1, { motion: !0 }), i;
+	}
+	refitBLASes(e, t, n) {
+		if (this._sdf?.spilled) throw Error("refitBLASes: the scene is spilled to disk — await app.ensureSceneResident() first");
+		let r = this._sdf.refitBLASes(e, t, n), { triRanges: i, bvhRanges: a } = this._sdf.computeBLASDirtyRanges(e);
+		return this.stages.pathTracer.updateBufferRanges(i, a), this.reset(!1, { motion: !0 }), this._sdf.scheduleBackgroundRebuild(e, (e) => {
+			let t = this._sdf.computeBLASDirtyRanges([e]);
+			this.stages.pathTracer.updateBufferRanges(t.triRanges, t.bvhRanges), this.reset(!1, { motion: !0 });
+		}), r;
+	}
+	updateMeshTransforms(e) {
+		this._notePlacementsMoving(e);
+		let t = this._sdf.updateMeshTransforms(e);
+		return this.stages.pathTracer.updateBufferRanges([], [this._sdf.computeTLASDirtyRange()]), this.reset(!1, { motion: !0 }), t;
+	}
+	setReservedRenderResolution(e, { allowLower: t = !1 } = {}) {
+		let n = t ? e : Math.max(e, y);
+		if (!this.renderer) return this._pendingReservedRenderSize = {
+			requestedPx: e,
+			allowLower: t
+		}, Math.max(256, Math.min(me, Math.floor(n) || 256));
+		let r = this.renderer.backend?.device?.limits?.maxStorageBufferBindingSize || 128 * 1024 * 1024, i = o(this._hostMemoryGB), a = i.gb >= 8 && r >= 1024 * 1024 * 1024 ? me : 2048, s = pe(Math.min(n, a));
+		if (s < Math.floor(e) && this._issues.warn(x.RENDER_RESERVE_CAPPED, `reserved render size ${b.n(e)}px was capped to ${b.n(s)}px by this device's limits — renders above ${b.n(s)}px will be declined` + (i.assumed && i.gb < 8 ? " (host memory unknown, 4 GB assumed: pass hostMemoryGB)" : ""), {
+			requested: e,
+			applied: s,
+			deviceMemoryGB: i.gb,
+			assumed: i.assumed,
+			maxStorageBufferBindingSize: r
+		}), (this.stages?.pathTracer?.storageTextures?.writeColor?.image?.width ?? s) !== s) {
+			let e = this.pauseRendering;
+			this.pauseRendering = !0;
+			try {
+				let e = this.renderer.domElement;
+				(e.width > s || e.height > s) && this.renderer.setSize(Math.min(e.width, s), Math.min(e.height, s), !1);
+				for (let e of Object.values(this.stages)) e?.reallocateReservedStorage?.();
+			} finally {
+				this.pauseRendering = e;
+			}
+			this.reset(), this.dispatchEvent({
+				type: m.RESERVED_RENDER_SIZE_CHANGED,
+				size: s
+			});
+		}
+		return s;
+	}
+	_applyPendingReservedRenderSize() {
+		let e = this._pendingReservedRenderSize;
+		if (!e) return;
+		this._pendingReservedRenderSize = null;
+		let t = this.setReservedRenderResolution(e.requestedPx, { allowLower: e.allowLower });
+		this.dispatchEvent({
+			type: m.RESERVED_RENDER_SIZE_CHANGED,
+			size: t
+		});
+	}
+	getReservedRenderResolution() {
+		return y;
+	}
+	_isRenderSizeSupported(e, t) {
+		return e > y || t > y ? (this._issues.record(x.RENDER_SIZE_DECLINED, `render resolution ${e}×${t} exceeds the ${y}px storage reserve — resize ignored, so output stays at the previous size. Raise it with setReservedRenderResolution( ${Math.max(e, t)} ) before init().`, {
+			width: e,
+			height: t,
+			reserve: y
+		}), !1) : !0;
+	}
+	onResize() {
+		let e = this.canvas.clientWidth, t = this.canvas.clientHeight;
+		e === 0 || t === 0 || this._isRenderSizeSupported(e, t) && (this.renderer.setPixelRatio(1), this._setDisplaySize(e, t), !(e === this._renderWidth && t === this._renderHeight) && (clearTimeout(this._resizeDebounceTimer), this._resizeDebounceTimer = setTimeout(() => {
+			this._applyRenderResize(e, t);
+		}, 300)));
+	}
+	_applyRenderResize(e, t) {
+		this._isRenderSizeSupported(e, t) && (this.pipeline?.setSize(this._scaled(e), this._scaled(t)), this._renderWidth = e, this._renderHeight = t, this._renderSizeChanged(e, t), this.needsReset = !0, this.dispatchEvent({
+			type: m.RESOLUTION_CHANGED,
+			width: e,
+			height: t
+		}));
+	}
+	setCanvasSize(e, t) {
+		return e === 0 || t === 0 || !this._isRenderSizeSupported(e, t) ? null : (this.renderer.setPixelRatio(1), this._setDisplaySize(e, t), clearTimeout(this._resizeDebounceTimer), this._applyRenderResize(e, t), {
+			width: e,
+			height: t
+		});
+	}
+	_scaled(e) {
+		return Math.max(1, Math.round(e * this._renderScale));
+	}
+	_setDisplaySize(e, t) {
+		this._displayWidth = e, this._displayHeight = t, this.renderer.setSize(this._scaled(e), this._scaled(t), !1), this.camera.aspect = e / t, this.camera.updateProjectionMatrix();
+	}
+	refreshFrame() {
+		this._needsDisplayRefresh = !0, this.wake();
+	}
+	setDeterministicMode(e = !0, { pinDispatch: t = !0 } = {}) {
+		let n = this.stages.pathTracer;
+		if (!n) return !1;
+		if (e) this._deterministicRestore ||= {
+			settings: {
+				useAdaptiveSampling: this.settings.get("useAdaptiveSampling"),
+				usePixelFreeze: this.settings.get("usePixelFreeze"),
+				interactionModeEnabled: this.settings.get("interactionModeEnabled"),
+				renderLimitMode: this.settings.get("renderLimitMode"),
+				renderTimeLimit: this.settings.get("renderTimeLimit")
+			},
+			bounceEarlyExit: n._bounceEarlyExitThreshold,
+			dynamicDispatch: n._useDynamicDispatch,
+			extras: this._deterministicSnapshot()
+		}, this.settings.setMany({
+			useAdaptiveSampling: !1,
+			usePixelFreeze: !1,
+			interactionModeEnabled: !1,
+			renderLimitMode: "frames",
+			renderTimeLimit: 0
+		}, { silent: !0 }), t ? (n._bounceEarlyExitThreshold = -1, n._useDynamicDispatch = !1) : (n._bounceEarlyExitThreshold = this._deterministicRestore.bounceEarlyExit, n._useDynamicDispatch = this._deterministicRestore.dynamicDispatch), this._setDeterministicExtras(!0, this._deterministicRestore.extras), n._pinSeedToFrame = !0, this._deterministic = !0, this._dispatchPinned = t;
+		else if (this._deterministicRestore) {
+			let e = this._deterministicRestore;
+			this.settings.setMany(e.settings, { silent: !0 }), n._bounceEarlyExitThreshold = e.bounceEarlyExit, n._useDynamicDispatch = e.dynamicDispatch, this._setDeterministicExtras(!1, e.extras), n._pinSeedToFrame = !1, this._deterministicRestore = null, this._deterministic = !1, this._dispatchPinned = !1;
+		}
+		return this.reset(), this.stopAnimation(), this._deterministic;
+	}
+	get issues() {
+		return this._issues.list;
+	}
+	get issueErrors() {
+		return this._issues.errors;
+	}
+	clearIssues() {
+		this._issues.clear();
+	}
+	get isDeterministic() {
+		return this._deterministic && this._dispatchPinned;
+	}
+	async renderFrames(e, { reset: t = !0, yieldEvery: n = 8, onProgress: r, allowEarlyRetire: i = !1 } = {}) {
+		let a = this.stages.pathTracer;
+		if (!a) throw Error("renderFrames: app is not initialized");
+		if (!(e > 0)) throw Error(`renderFrames: count must be positive, got ${e}`);
+		let o = (t ? 0 : a.frameCount) + e;
+		this.settings.get("maxSamples") < o && this.settings.set("maxSamples", o, {
+			silent: !0,
+			reset: !1
+		}), t && this.reset(), this.stopAnimation();
+		let s = e + 64, c = 0, l = !1;
+		for (; a.frameCount < o && c < s;) {
+			if (this._deviceLost) throw Error("renderFrames: WebGPU device lost");
+			if (!a.isReady) throw Error("renderFrames: path tracer stage is not ready");
+			let e = a.readbackWait();
+			if (e) {
+				await this._awaitReadback(e);
+				continue;
+			}
+			if (this.camera.updateMatrixWorld(), this.pipeline.render(), c++, a.isComplete && a.frameCount < o) {
+				l = !0;
+				break;
+			}
+			r?.(a.frameCount), n > 0 && c % n === 0 && await new Promise((e) => setTimeout(e, 0));
+		}
+		if (a.frameCount < o && !(l && i)) {
+			let e = l ? "adaptive sampling retired the frame at the convergence threshold — pass `allowEarlyRetire: true`, or disable it with setDeterministicMode()" : "something retired the render (maxSamples, a stray reset, or a canvas resize)";
+			throw Error(`renderFrames: stopped at ${a.frameCount}/${o} samples after ${c} passes — ${e}`);
+		}
+		return a.frameCount;
+	}
+	async renderUntilComplete({ reset: e = !0, denoise: t = !0, signal: n, drainEvery: r = 4, onProgress: i } = {}) {
+		let a = this.stages.pathTracer;
+		if (!a) throw Error("renderUntilComplete: app is not initialized");
+		if (this._loadingInProgress || this._sdf?.isProcessing) throw Error("renderUntilComplete: a scene is still loading");
+		let o = a.lockstepReadbacks;
+		a.setLockstepReadbacks(!0);
+		let s = this.settings.getEffective().interactionModeEnabled;
+		this.settings.set("interactionModeEnabled", !1, {
+			silent: !0,
+			reset: !1
+		});
+		try {
+			e && this.reset(), this.stopAnimation();
+			let o = this.renderer.backend.device?.queue, s = 0, c = null;
+			for (; !a.isComplete;) {
+				if (n?.throwIfAborted(), this._deviceLost) throw Error("renderUntilComplete: WebGPU device lost");
+				if (!a.isReady) throw Error("renderUntilComplete: path tracer stage is not ready");
+				let e = a.readbackWait();
+				if (e) {
+					await this._awaitReadback(e);
+					continue;
+				}
+				this.camera.updateMatrixWorld();
+				let t = a.frameCount;
+				if (this._traceFrame(), i?.(a.frameCount), a.frameCount === t && !a.isComplete && await new Promise((e) => setTimeout(e, 0)), o && r > 0 && ++s % r === 0) {
+					let e = o.onSubmittedWorkDone();
+					c && await c, c = e;
+				}
+			}
+			let l = this._completionInfo();
+			this.completion.markComplete() && this.dispatchEvent({
+				type: m.RENDER_COMPLETE,
+				...l
+			});
+			let u = t ? await this._finalDenoise() : !1, { reason: d, ...f } = l;
+			return {
+				...f,
+				retiredBy: d,
+				denoised: u
+			};
+		} finally {
+			a.setLockstepReadbacks(o), s && this.settings.set("interactionModeEnabled", s.value, {
+				silent: !0,
+				reset: !1,
+				source: s.source
+			});
+		}
+	}
+	getProvenance() {
+		let e = this.stages.pathTracer, t = this.color?.status();
+		return r({
+			engine: oe,
+			three: ht,
+			profile: {
+				name: this._profileName,
+				values: { ...this._profile }
+			},
+			adapter: this.adapterInfo ?? null,
+			mode: {
+				headless: this._headless,
+				strict: this._issues.strict,
+				deterministic: this.isDeterministic,
+				lockstep: !!e?.accumulationLockstep
+			},
+			render: e ? {
+				width: e.width,
+				height: e.height,
+				samples: e.frameCount,
+				complete: e.isComplete,
+				retiredBy: e.isComplete ? this.completion.stopCondition(e) ?? "samples" : null
+			} : null,
+			color: t ? {
+				config: t.config?.id ?? null,
+				workingSpace: t.workingSpace,
+				view: t.activeView ?? t.activeTransform?.id ?? null,
+				context: t.context
+			} : null,
+			scene: this.sceneSource,
+			settings: this.settings.getEffective(),
+			issues: this.issues.map(({ code: e, severity: t }) => ({
+				code: e,
+				severity: t
+			}))
+		});
+	}
+	setLockstepReadbacks(e = !0) {
+		this.stages.pathTracer?.setLockstepReadbacks(e);
+	}
+	async _awaitReadback(e) {
+		let t = this.renderer.backend.device?.lost, n = await (t ? Promise.race([e.then(() => null), t]) : e);
+		if (n) throw Error(`WebGPU device lost while awaiting a readback: ${n.message ?? n.reason}`);
+	}
+	async captureRenderCheckpoint() {
+		let e = this.stages.pathTracer;
+		if (!e) return null;
+		let t = await e.captureAccumulation();
+		return {
+			v: 1,
+			engine: oe,
+			savedAt: Date.now(),
+			samples: t.state.frameCount,
+			...t
+		};
+	}
+	restoreRenderCheckpoint(e) {
+		if (e?.v !== 1) throw Error(`render checkpoint version ${e?.v} is not 1`);
+		let t = this.stages.pathTracer;
+		if (!t) throw Error("restoreRenderCheckpoint: app is not initialized");
+		t.restoreAccumulation(e), this.needsReset = !1, this.dispatchEvent({
+			type: m.RENDER_RESET,
+			restored: e.samples
+		});
+	}
+	async renderToBuffer({ colorSpace: e = "srgb", preserveAlpha: t = !1, source: n = "accumulation" } = {}) {
+		if (e !== "linear" && e !== "srgb" && !this.color?.hasConfig) throw Error(`renderToBuffer: colorSpace must be 'linear' or 'srgb' without a colour config loaded, got "${e}"`);
+		let r = this.stages?.pathTracer, i = r?.storageTextures?.readTarget;
+		if (!i) throw Error("renderToBuffer: no render target — call init() and render at least one sample");
+		let { width: o, height: s } = r;
+		if (e === "srgb") {
+			let r = n === "display" ? this._displaySource(i) : null, c = {
+				exposure: this.renderer.toneMappingExposure,
+				toneMapping: this.renderer.toneMapping,
+				saturation: this.settings.get("saturation") ?? 1,
+				preserveAlpha: t
+			}, l = await this._toneMapOnGPU(r?.texture ?? null, i, o, s, c);
+			return {
+				data: l ?? a(r ? await this._readTexture(r.texture, o, s) : await this.renderer.readRenderTargetPixelsAsync(i, 0, 0, o, s, 0), c),
+				width: o,
+				height: s,
+				colorSpace: e,
+				source: r?.source ?? "accumulation",
+				toneMappedOn: l ? "gpu" : "cpu"
+			};
+		}
+		let { data: c, source: l } = n === "display" ? await this._readDisplaySource(i, o, s) : {
+			data: await this.renderer.readRenderTargetPixelsAsync(i, 0, 0, o, s, 0),
+			source: "accumulation"
+		};
+		if (e === "linear") return {
+			data: c,
+			width: o,
+			height: s,
+			colorSpace: e,
+			workingSpace: this.color?.workingSpace ?? null,
+			source: l
+		};
+		let { rgba: u, colorSpace: d } = this.color.exportPixels(c, e);
+		return {
+			data: u,
+			width: o,
+			height: s,
+			colorSpace: d,
+			source: l
+		};
+	}
+	async _toneMapOnGPU(e, t, n, r, i) {
+		let a = this.renderer?.backend;
+		if (!a?.device) return this._toneMapFallback("the renderer has no WebGPU device");
+		try {
+			let o = e ? this._readbackPass().draw(e, n, r).texture : t.textures[0], s = a.get(o).texture;
+			return s ? (this._readbackToneMapper ??= new ke(a.device, "rayzee:readback-tonemap", { input: "texture" }), this._readbackToneMapper.ensureSize(n, r), await this._readbackToneMapper.toRGBA8(s, i)) : this._toneMapFallback("the picture has no GPU texture yet");
+		} catch (e) {
+			if (e instanceof ve) throw e;
+			return this._toneMapFallback("the GPU pass threw", e);
+		} finally {
+			this._readbackToneMapper?.release(), e && this._textureReadback?.release();
+		}
+	}
+	_toneMapFallback(e, t = null) {
+		let n = t ? String(t?.message ?? t) : null, r = `renderToBuffer: tone mapped on the CPU — ${e}${n ? `: ${n}` : ""}`;
+		return $.warn(r), this._issues.warn(x.OUTPUT_TONEMAP_FALLBACK, r, {
+			reason: e,
+			cause: n
+		}), null;
+	}
+	enableGPUTiming(e = !0) {
+		let t = this.renderer?.backend;
+		return !t || e && t.hasFeature?.("timestamp-query") !== !0 ? !1 : (t.trackTimestamp = e, t.trackTimestamp === e);
+	}
+	async getGPUTimings() {
+		let e = this.renderer;
+		if (!e?.backend?.trackTimestamp) return null;
+		await e.resolveTimestampsAsync("compute"), await e.resolveTimestampsAsync("render");
+		let t = e.info.compute.timestamp || 0, n = e.info.render.timestamp || 0;
+		return {
+			compute: t,
+			render: n,
+			total: t + n
+		};
+	}
+	async getKernelGPUTimings() {
+		let e = this.renderer;
+		if (!e?.backend?.trackTimestamp) return null;
+		await e.resolveTimestampsAsync("compute");
+		let t = e.backend.timestampQueryPool?.compute?.timestamps;
+		if (!t || t.size === 0) return null;
+		let n = /* @__PURE__ */ new Map(), r = this.stages?.pathTracer?._kernelManager?.kernels;
+		if (r) for (let [e, t] of r) n.set(t.id, e);
+		let i = [], a = -1;
+		for (let [e, n] of t) {
+			let t = e.split(":");
+			if (t.length !== 4) continue;
+			let r = Number(t[3].slice(1));
+			Number.isFinite(r) && (i.push({
+				nodeId: Number(t[2]),
+				f: r,
+				ms: n
+			}), r > a && (a = r));
+		}
+		let o = {}, s = 0, c = 0;
+		for (let e of i) {
+			if (e.f !== a) continue;
+			s += e.ms;
+			let t = n.get(e.nodeId);
+			t === void 0 ? c += e.ms : o[t] = (o[t] ?? 0) + e.ms;
+		}
+		return {
+			kernels: o,
+			total: s,
+			unattributed: c,
+			frame: a
+		};
+	}
+	getCanvas() {
+		return this.renderer?.domElement ? this._displayCanvas() || (this.stages.compositor && this.pipeline?.context && this.stages.compositor.render(this.pipeline.context), this.renderer.domElement) : null;
+	}
+	screenshot({ type: e = "image/png", quality: t } = {}) {
+		let n = this.getCanvas();
+		return n ? new Promise((r) => n.toBlob(r, e, t)) : Promise.resolve(null);
+	}
+	getStatistics() {
+		try {
+			return this._sdf?.getStatistics?.() ?? null;
+		} catch {
+			return null;
+		}
+	}
+	get pathTracerEnabled() {
+		return this._pathTracerEnabled;
+	}
+	set pathTracerEnabled(e) {
+		this._pathTracerEnabled = e, e || this.precompileRaster();
+	}
+	precompileRaster() {
+		return !this.renderer || !this.meshScene ? Promise.resolve() : (this._rasterPrecompile ??= this.renderer.compileAsync(this.meshScene, this.camera).catch((e) => $.warn("raster fallback precompile failed", e)), this._rasterPrecompile);
+	}
+	get isLoading() {
+		return this._loadingInProgress;
+	}
+	isComplete() {
+		return this.stages.pathTracer?.isComplete ?? !1;
+	}
+	getFrameCount() {
+		return this.stages.pathTracer?.frameCount || 0;
+	}
+	getConvergenceStats() {
+		return this.stages.pathTracer?.getConvergenceStats?.() ?? null;
+	}
+	get vram() {
+		return this.stages.pathTracer?.vramTracker ?? null;
+	}
+	getMemoryInfo() {
+		return this._ensureVRAMWiring(), this.stages.pathTracer?.vramTracker?.measure() ?? {
+			current: 0,
+			peak: 0,
+			byCategory: {}
+		};
+	}
+	getHostMemoryInfo() {
+		let e = this._sdf;
+		return e?.memory ? {
+			preflight: e.memoryPreflight,
+			...e.memory.report
+		} : null;
+	}
+	_ensureVRAMWiring() {
+		if (this._vramWired) return;
+		let e = this.stages.pathTracer?.vramTracker;
+		if (!e) return;
+		e.register("stages", () => this._collectStageTextures()), this._registerVRAM(e), e.register("canvas", () => [
+			{ bytes: this.canvas.width * this.canvas.height * 4 },
+			...this.renderer?._frameBufferTargets?.values() ?? [],
+			...this._canvasResources()
+		]);
+		let t = () => e.measure();
+		this._addTrackedListener(this, m.SCENE_REBUILD, t), this._addTrackedListener(this, m.ENVIRONMENT_LOADED, t), this._addTrackedListener(this, m.RESOLUTION_CHANGED, t), this._vramWired = !0;
+	}
+	_collectStageTextures() {
+		let e = [], t = this.stages || {}, n = t.pathTracer;
+		for (let r in t) {
+			let i = t[r];
+			if (!(!i || i === n || typeof i != "object")) for (let t in i) {
+				let n = i[t];
+				n && (n.isTexture || n.isRenderTarget) && e.push(n);
+			}
+		}
+		return e;
+	}
+	getSceneMinY() {
+		if (!this.meshScene) return 0;
+		let e = new Je().setFromObject(this.meshScene);
+		return Number.isFinite(e.min.y) ? e.min.y : 0;
+	}
+	getMaterialProperty(e, t) {
+		return this.stages.pathTracer?.materialData.getMaterialProperty(e, t);
+	}
+	getMaterialPropertySource(e, t) {
+		return this.stages.pathTracer?.materialData.getMaterialPropertySource(e, t);
+	}
+	setMaterialProperty(e, t, n) {
+		if (this._sdf?.spilled && ee.has(t)) {
+			this.ensureSceneResident().then(() => this.setMaterialProperty(e, t, n));
+			return;
+		}
+		this.stages.pathTracer?.materialData.updateMaterialProperty(e, t, n), ["emissive", "emissiveIntensity"].includes(t) && this._sdf && this._uploadEmissivePayload(this._sdf.updateMaterialEmissive(e, t, n)), this.reset();
+	}
+	_uploadEmissivePayload(e) {
+		!e || !this.stages.pathTracer || (this.stages.pathTracer.setEmissiveTriangleData(e.rawData, e.emissiveCount, e.totalPower, e.bitTrailMap), e.lightBVHNodeData && this.stages.pathTracer.setLightBVHData(e.lightBVHNodeData, e.lightBVHNodeCount));
+	}
+	_refreshEmissiveForVisibility() {
+		let e = this._sdf?.instanceTable;
+		if (!e) return;
+		let t = /* @__PURE__ */ new Set();
+		for (let n = 0; n < e.count; n++) e.isSet[n] && !e.visible[n] && t.add(e.sourceMesh[n]);
+		this._uploadEmissivePayload(this._sdf.rebuildEmissiveForVisibility(t));
+	}
+	setEmissiveTriangleSampling(e) {
+		this._emissiveSamplingUserSet = !0, this.settings.set("enableEmissiveTriangleSampling", e);
+	}
+	hasEmissiveGeometry() {
+		return (this._sdf?.emissiveTriangleBuilder?.emissiveTriangles?.length ?? this._sdf?.emissiveTriangleCount ?? 0) > 0;
+	}
+	setMeshVisibility(e, t) {
+		this.stages.pathTracer?.updateMeshVisibility(e, t), this._refreshEmissiveForVisibility(), this.reset();
+	}
+	updateAllMeshVisibility() {
+		this.stages.pathTracer?.updateAllMeshVisibility(), this._refreshEmissiveForVisibility(), this.reset();
+	}
+	getScene() {
+		return this.meshScene || this.scene;
+	}
+	setMeshVisibilityByUuid(e, t) {
+		let n = this.getScene()?.getObjectByProperty("uuid", e);
+		if (!n) return null;
+		let r = typeof t == "function" ? !!t(n.visible) : !!t;
+		return n.visible = r, this.updateAllMeshVisibility(), r;
+	}
+	setTextureTransform(e, t, n) {
+		this.stages.pathTracer?.materialData.updateTextureTransform(e, t, n), this.reset();
+	}
+	_displaySource(e) {
+		let t = this.pipeline?.context, n = t && this.stages.compositor?.resolveLightSource(t);
+		return n && n.key !== "pathtracer:color" && n.texture !== e.texture ? {
+			texture: n.texture,
+			source: n.key.split(":")[0]
+		} : (this._denoiserInUse() && this._issues.record(x.OUTPUT_SOURCE_FALLBACK, "renderToBuffer: 'display' was asked for, but no denoiser has published a picture — returned the raw accumulation", {
+			requested: "display",
+			read: "accumulation"
+		}), null);
+	}
+	async _readDisplaySource(e, t, n) {
+		let r = this._displaySource(e);
+		return r ? {
+			data: await this._readTexture(r.texture, t, n),
+			source: r.source
+		} : {
+			data: await this.renderer.readRenderTargetPixelsAsync(e, 0, 0, t, n, 0),
+			source: "accumulation"
+		};
+	}
+	_readbackPass() {
+		return this._textureReadback ??= new Kt(this.renderer);
+	}
+	_readTexture(e, t, n) {
+		return this._readbackPass().read(e, t, n);
+	}
+	async setTextureColorSpace(e, t) {
+		if (!e?.isTexture) throw Error("setTextureColorSpace wants a three.js texture");
+		let n = e.userData ??= {};
+		n.__rayzeeOriginalColorSpace === void 0 && (n.__rayzeeOriginalColorSpace = e.colorSpace);
+		let r = n.__rayzeeOriginalColorSpace;
+		if (delete n.ocioColorSpace, delete n.__rayzeeColorSpaceChoice, t == null) e.colorSpace = r, delete n.__rayzeeOriginalColorSpace;
+		else if (t === "srgb" || t === "linear") e.colorSpace = t === "srgb" ? Fe : je, n.__rayzeeColorSpaceChoice = t;
+		else {
+			if (!this.color?.hasConfig) throw Error(`"${t}" needs a colour config loaded`);
+			n.ocioColorSpace = t, e.colorSpace = Fe;
+		}
+		e.needsUpdate = !0, this.stages.pathTracer?.sdfs && await this.rebuildMaterials();
+	}
+	setColorManagement(e) {
+		this.color?.dispose(), this.color = new e({ issues: this._issues }), S(this.color), this.renderer && this.color.attachRenderer(this.renderer);
+	}
+	async loadColorConfig(e = {}) {
+		await this._leaveColorWorkingSpace();
+		let t = T(this.renderer?.toneMapping), n = await this.color.loadConfig(e);
+		return this.color.workingSpaceAdopted && await this.applyColorWorkingSpace(), (!(t?.source === "ocio" && T(this.renderer?.toneMapping) === t) || this.color.workingSpaceAdopted) && this.reset(), n;
+	}
+	async unloadColorConfig() {
+		await this._leaveColorWorkingSpace(), this.color.unloadConfig(), this.reset();
+	}
+	async _leaveColorWorkingSpace() {
+		this.color?.workingSpaceAdopted && (this.color.setWorkingSpace(null), await this.applyColorWorkingSpace());
+	}
+	async applyColorWorkingSpace() {
+		let e = this.environmentManager?.getEnvironmentTexture?.(), t = !1;
+		if (e && this.color?.hasConfig) try {
+			t = this.color.convertTexturePixels(e);
+		} catch (e) {
+			$.warn(`environment colour conversion failed: ${e.message}`);
+		}
+		this.stages.pathTracer?.sdfs && (await this.rebuildMaterials(), this._uploadEmissivePayload(this._sdf?.rebuildEmissiveColors?.() ?? null)), t && await this.environmentManager?.buildEnvironmentCDF?.(), e?._isPhysicalSky && await this.environmentManager.generateProceduralSkyTexture(), this.environmentManager?.refreshSun?.(), this.reset();
+	}
+	async rebuildMaterials(e) {
+		await this.ensureSceneResident(), await this.stages.pathTracer?.rebuildMaterials(e || this.meshScene), this.reset();
+	}
+	async _initRenderer() {
+		if (ie((e) => this.dispatchEvent(e)), typeof navigator > "u" || !navigator.gpu) throw Error("WebGPU is not available — outside a browser, install one as navigator.gpu (for Node, the `webgpu` package)");
+		let e = await navigator.gpu.requestAdapter({ powerPreference: "high-performance" });
+		if (!e) throw Error("Failed to get WebGPU adapter");
+		this.adapterInfo = Kn(e), this.adapterInfo.isSoftware && (this._issues.warn(x.ADAPTER_SOFTWARE, `software GPU adapter "${this.adapterInfo.description || this.adapterInfo.vendor}" — renders are correct but orders of magnitude slower than hardware`, { ...this.adapterInfo }), $.warn(`software GPU adapter — check app.adapterInfo.isSoftware. ${this.adapterInfo.description}`));
+		let t = e.limits, n = { maxColorAttachmentBytesPerSample: 128 };
+		for (let e of [
+			"maxBufferSize",
+			"maxStorageBufferBindingSize",
+			"maxSampledTexturesPerShaderStage",
+			"maxStorageTexturesPerShaderStage",
+			"maxTextureArrayLayers",
+			"maxTextureDimension2D",
+			"maxComputeInvocationsPerWorkgroup",
+			"maxComputeWorkgroupStorageSize",
+			"maxComputeWorkgroupSizeX",
+			"maxComputeWorkgroupSizeY",
+			"maxComputeWorkgroupSizeZ"
+		]) {
+			let r = t[e];
+			r !== void 0 && (n[e] = r);
+		}
+		if (n.maxStorageBuffersPerShaderStage = Math.min(t.maxStorageBuffersPerShaderStage, 10), this.renderer = new Le({
+			canvas: this.canvas,
+			alpha: !0,
+			powerPreference: "high-performance",
+			requiredLimits: n
+		}), await Hn(this.renderer, this._headless), !this.renderer.backend?.isWebGPUBackend) throw Error("WebGPU backend unavailable — three.js fell back to WebGL2, which cannot run the path tracer's compute kernels. Check GPU process flags and driver support.");
+		let r = this.renderer.backend?.device;
+		r?.lost && (this._gpuDevice = r, this._deviceLostHolder = { app: this }, Wn(r, this._deviceLostHolder), r.onuncapturederror = (e) => $.error("WebGPU uncaptured error:", e.error)), Pe.setLTC(wt.init()), this.renderer.outputColorSpace = Fe, this.renderer.toneMapping = this._profile.toneMapping, this.renderer.toneMappingExposure = 1, this.renderer.setPixelRatio(1), this.color.attachRenderer(this.renderer);
+	}
+	_initScenes() {
+		this.scene = new vt(), this.meshScene = new vt(), this._sceneHelpers = new At();
+	}
+	_initAssetPipeline() {
+		this._sdf = new l({
+			issues: this._issues,
+			...this._maxSceneBytes === void 0 ? {} : { maxSceneBytes: this._maxSceneBytes }
+		}), this.assetLoader = new jn(this.meshScene, this.camera, null, {
+			issues: this._issues,
+			profile: this._profile
+		}), this.assetLoader.setRenderer(this.renderer), this.assetLoader.createFloorPlane();
+	}
+	_initPipeline() {
+		this._createStages();
+		let { clientWidth: e, clientHeight: t } = this.canvas;
+		this.pipeline = new Ut(this.renderer, e || 1, t || 1, { issues: this._issues }), this.pipeline.addStage(this.stages.pathTracer);
+		for (let e of this._extraStages) this.pipeline.addStage(e);
+		this.pipeline.addStage(this.stages.compositor);
+		let n = this.canvas.clientWidth || 1, r = this.canvas.clientHeight || 1;
+		this._displayWidth = n, this._displayHeight = r, this._renderWidth = n, this._renderHeight = r, this.pipeline.setSize(n, r);
+	}
+	async _initManagers() {
+		this.lightManager = new Rn(this.scene, this._sceneHelpers, this.stages.pathTracer, {
+			onReset: () => this.reset(),
+			onLightRemoved: (e) => this._lightRemoved(e)
+		}), this.environmentManager = this.stages.pathTracer.environment, this.environmentManager.issues = this._issues, this.stages.pathTracer.issues = this._issues, this.environmentManager.callbacks.onLightingChanged = () => this.pipeline.eventBus.emit("pipeline:lightingChanged"), this.environmentManager.callbacks.onReset = () => this.reset();
+	}
+	_wireEvents() {
+		this.settings.bind(this._settingsBindings()), this.renderer.toneMappingExposure = this.settings.get("exposure") ?? 1, this.onResize(), this.resizeHandler = () => this.onResize(), this._autoResize && this._addTrackedListener(window, "resize", this.resizeHandler), this._onAssetLoaded = async (e) => {
+			if (!this._loadingInProgress && !(this._applyingSceneMetadata && e.texture)) {
+				if (e.model) this._clearAppendedModels(), await this.loadSceneData({ pendingEnvironment: this._beginSceneMetadataEnvironment() });
+				else if (e.texture) {
+					let e = this.meshScene.environment;
+					e && this.stages.pathTracer && await this.stages.pathTracer.environment.setEnvironmentMap(e), _();
+				}
+				this.pauseRendering = !1, this.reset();
+			}
+		}, this._addTrackedListener(this.assetLoader, "load", this._onAssetLoaded), this.pipeline.eventBus.on("pathtracer:compiling", ({ compiling: e }) => this.dispatchEvent({
+			type: m.SHADERS_COMPILING,
+			compiling: e
+		}));
+	}
+	_createStages() {
+		this.stages.pathTracer = new c(this.renderer, this.scene, this.camera, { hostMemoryGB: this._hostMemoryGB }), this._extraStages = this._createExtraStages(), this.stages.compositor = new jt(this.renderer, {
+			saturation: this.settings.get("saturation") ?? v.saturation,
+			pathTracer: this.stages.pathTracer,
+			displaySources: this._displaySources()
+		});
+	}
+	_reconcileCompletion() {
+		let e = this.stages.pathTracer;
+		if (!e) return;
+		let t = this.completion.isLimitReached(e, this.settings.get("renderLimitMode"), this.settings.get("renderTimeLimit"));
+		t && !e.isComplete ? e.isComplete = !0 : !t && e.isComplete && (e.isComplete = !1, this.completion.resumeFromPause(), this._completionReopened(), this.dispatchEvent({ type: m.RENDER_RESET }), this.wake());
+	}
+	_forwardEvents(e, t) {
+		if (e) for (let n of t) this._addTrackedListener(e, n, (e) => this.dispatchEvent(e));
+	}
+	_createCamera() {
+		let e = new Fn(60, this.canvas.clientWidth / this.canvas.clientHeight || 1, .01, 1e3);
+		return e.position.set(0, 0, 5), e;
+	}
+	_createExtraStages() {
+		return [];
+	}
+	_displaySources() {
+		return [];
+	}
+	_settingsBindings() {
+		return {
+			stages: this.stages,
+			resetCallback: () => this.reset(),
+			reconcileCompletion: () => this._reconcileCompletion(),
+			applyExposure: (e) => {
+				this.renderer.toneMappingExposure = e;
+			}
+		};
+	}
+	_beginFrame() {}
+	_beforeTrace() {}
+	_holdTrace() {
+		return !1;
+	}
+	_afterTrace() {}
+	_renderCompleted() {}
+	_renderHelperOverlay() {
+		this.scene.updateMatrixWorld();
+	}
+	_beforeReset() {}
+	_afterReset() {}
+	_dropDisplay() {}
+	_releaseSceneState() {}
+	_modelReplaced() {}
+	_modelAnnounced() {}
+	_sceneRebuilt() {}
+	_sceneBoundsChanged() {}
+	_notePlacementsMoving() {}
+	_lightRemoved() {}
+	_renderSizeChanged() {}
+	_completionReopened() {}
+	async _finalDenoise() {
+		return !1;
+	}
+	_denoiserInUse() {
+		return !1;
+	}
+	_displayCanvas() {
+		return null;
+	}
+	_registerVRAM() {}
+	_canvasResources() {
+		return [];
+	}
+	_deterministicSnapshot() {
+		return null;
+	}
+	_setDeterministicExtras() {}
+	_disposeExtensions() {}
+};
+//#endregion
+export { Mt as _, nn as a, J as c, K as d, Qt as f, It as g, Lt as h, Fn as i, $t as l, Rt as m, Kn as n, Y as o, Ut as p, Rn as r, U as s, qn as t, Zt as u };