@kvyverse/world-runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,1707 @@
+import { t as RapierPhysics } from "./RapierPhysics-C_3b7QOn.js";
+import { n as getRadiusScale, t as getHalfheightRadiusScale } from "./get-scale-from-obj-QKv3Fig5.js";
+import * as THREE from "three/webgpu";
+import { BufferGeometryLoader, LoadingManager, TextureLoader } from "three/webgpu";
+import * as ThreeStartNS from "three-start";
+import { ContextModule, ThreeContextEvents, ThreeStart } from "three-start";
+import * as TSL from "three/tsl";
+import { emissive, mrt, output } from "three/tsl";
+import van from "vanjs-core";
+import EventEmitter from "eventemitter3";
+import { Howl, Howler } from "howler";
+import { mergeGeometries } from "three/examples/jsm/utils/BufferGeometryUtils.js";
+import { clone } from "three/examples/jsm/utils/SkeletonUtils.js";
+//#region packages/world-runtime/src/world-events.ts
+/**
+* World lifecycle events, emitted on `game.emitter` (`world.events` in scripts)
+* during classic-load. The entry script runs BEFORE them (step 9) — subscriptions
+* from `main.ts` catch all three. See `docs/scripting/game-runtime.md`.
+*/
+var WorldEvent = /* @__PURE__ */ function(WorldEvent) {
+	/** Scene parsed, values applied; objects are NOT yet added to `ctx.scene`. */
+	WorldEvent["BeforeSceneReady"] = "before-scene-ready";
+	/** Hierarchy added to `ctx.scene` — scene is ready; lifecycle not started yet. */
+	WorldEvent["SceneReady"] = "scene-ready";
+	/** `start()` called: behaviours woke up, the render loop is running. */
+	WorldEvent["Started"] = "started";
+	return WorldEvent;
+}({});
+//#endregion
+//#region packages/world-runtime/src/World.ts
+/**
+* A loaded world is a three-start app with the scene already assembled.
+* Mounting and starting are manual: `mount(container)` attaches the canvas and
+* runs the render loop, `start()` activates behaviours (idempotent — call it
+* after a user gesture if the world plays audio or captures the pointer).
+*/
+var World = class extends ThreeStart {
+	_runtime;
+	constructor(options, _runtime) {
+		super(options);
+		this._runtime = _runtime;
+	}
+	/** Asset URL by project path — same resolving as `getUrl` in scripts. */
+	getUrl = (path) => this._runtime.getUrl(path);
+	/** World lifecycle event bus — the same one as `world.events` in scripts. */
+	get events() {
+		return this._runtime.emitter;
+	}
+	start() {
+		const wasStarted = this.isStarted;
+		super.start();
+		if (!wasStarted) this._runtime.emitter.emit(WorldEvent.Started);
+		return this;
+	}
+	dispose() {
+		this._runtime.dispose();
+		super.dispose();
+	}
+};
+//#endregion
+//#region packages/world-runtime/src/utils/lazy.ts
+/** Lazy cached value: the factory is called once on the first `get()`. */
+function lazy(factory) {
+	let has = false;
+	let value;
+	return { get: () => {
+		if (!has) {
+			value = factory();
+			has = true;
+		}
+		return value;
+	} };
+}
+//#endregion
+//#region packages/world-runtime/src/resources/loaders.ts
+var LOADING_MANAGER = new LoadingManager();
+LOADING_MANAGER.onError = (url) => {
+	console.error(`Loading asset failed: ${url}`);
+};
+var options = { 
+/**
+* Draco decoder folder (file names inside are fixed, the folder is
+* versioned). Default — the public Google decoder: always available and
+* served with CORS, so an exported world works without our infrastructure.
+* The host may override it: the app serves its own copy from
+* `public/draco/<hash>/`, a self-hosted world — via `loadWorld({ dracoPath })`.
+*/
+dracoPath: "https://www.gstatic.com/draco/v1/decoders/" };
+/** Loader configuration. Called by the host before the first asset load. */
+function configureAssetLoaders(next) {
+	Object.assign(options, next);
+}
+var m = LOADING_MANAGER;
+/** Lazy three loaders: the chunk is pulled only on first use of the format. */
+var AssetLoaders = {
+	texture: lazy(() => {
+		const loader = new TextureLoader(m);
+		loader.setCrossOrigin("anonymous");
+		return loader;
+	}),
+	gltf: lazy(async () => {
+		const [{ DRACOLoader }, { GLTFLoader }] = await Promise.all([import("three/examples/jsm/loaders/DRACOLoader.js"), import("three/examples/jsm/loaders/GLTFLoader.js")]);
+		const gltfLoader = new GLTFLoader(m);
+		const dracoLoader = new DRACOLoader(m);
+		dracoLoader.setDecoderPath(options.dracoPath);
+		dracoLoader.setCrossOrigin("anonymous");
+		gltfLoader.setDRACOLoader(dracoLoader);
+		gltfLoader.setCrossOrigin("anonymous");
+		return gltfLoader;
+	}),
+	fbx: lazy(async () => {
+		const { FBXLoader } = await import("three/examples/jsm/loaders/FBXLoader.js");
+		const loader = new FBXLoader(m);
+		loader.setCrossOrigin("anonymous");
+		return loader;
+	}),
+	obj: lazy(async () => {
+		const { OBJLoader } = await import("three/examples/jsm/loaders/OBJLoader.js");
+		const loader = new OBJLoader(m);
+		loader.setCrossOrigin("anonymous");
+		return loader;
+	}),
+	rgbe: lazy(async () => {
+		const { RGBELoader } = await import("three/examples/jsm/loaders/RGBELoader.js");
+		const loader = new RGBELoader(m);
+		loader.setCrossOrigin("anonymous");
+		return loader;
+	}),
+	exr: lazy(async () => {
+		const { EXRLoader } = await import("three/examples/jsm/loaders/EXRLoader.js");
+		const loader = new EXRLoader(m);
+		loader.setCrossOrigin("anonymous");
+		return loader;
+	}),
+	bufferGeometry: lazy(() => {
+		const loader = new BufferGeometryLoader(m);
+		loader.setCrossOrigin("anonymous");
+		return loader;
+	}),
+	font: lazy(async () => {
+		const [{ TTFLoader }, { Font }] = await Promise.all([import("three/examples/jsm/loaders/TTFLoader.js"), import("three/examples/jsm/loaders/FontLoader.js")]);
+		return {
+			ttfLoader: new TTFLoader(m),
+			Font
+		};
+	})
+};
+//#endregion
+//#region packages/world-runtime/src/rendering/renderer-apply.ts
+var SHADOW_MAP_TYPES$1 = {
+	Basic: THREE.BasicShadowMap,
+	PCF: THREE.PCFShadowMap,
+	PCFSoft: THREE.PCFSoftShadowMap,
+	VSM: THREE.VSMShadowMap
+};
+var TONE_MAPPINGS = {
+	None: THREE.NoToneMapping,
+	Linear: THREE.LinearToneMapping,
+	Reinhard: THREE.ReinhardToneMapping,
+	Cineon: THREE.CineonToneMapping,
+	ACESFilmic: THREE.ACESFilmicToneMapping,
+	AgX: THREE.AgXToneMapping,
+	Neutral: THREE.NeutralToneMapping
+};
+/**
+* Applies the runtime part of `RendererConfig` to an already created WebGPURenderer
+* (shadowMap, toneMapping, pixelRatio). Used by game (once on load) and editor
+* (live, see `editor/rendering`). Defaults: PCFSoft shadows, Neutral tonemap,
+* pixelResolution=1. Construction params (`cfg.renderer`) are applied only in
+* the renderer constructor (see `createGameCtx`).
+*
+* The config is NOT schema-validated at runtime (raw JSON.parse), so bad values
+* (enum typo, non-number) fall back to defaults instead of producing an
+* `undefined` constant / `NaN` (silently broken rendering).
+*/
+function applyRendererConfig(renderer, cfg) {
+	renderer.shadowMap.enabled = cfg.shadowMap?.enabled ?? true;
+	renderer.shadowMap.type = SHADOW_MAP_TYPES$1[cfg.shadowMap?.type ?? "PCFSoft"] ?? THREE.PCFSoftShadowMap;
+	renderer.toneMapping = TONE_MAPPINGS[cfg.toneMapping ?? "Neutral"] ?? THREE.NeutralToneMapping;
+	const pr = cfg.pixelResolution;
+	const pixelResolution = typeof pr === "number" && Number.isFinite(pr) && pr > 0 ? pr : 1;
+	renderer.setPixelRatio(window.devicePixelRatio * pixelResolution);
+}
+//#endregion
+//#region packages/world-runtime/src/rendering/SceneBloom.ts
+/** BloomNode loads as a chunk only when bloom is enabled. */
+var lazyBloomModule = lazy(() => import("three/addons/tsl/display/BloomNode.js"));
+/**
+* Enables MRT `{ output, emissive }` on the scenePass. Idempotent. IMPORTANT:
+* MRT is part of the WebGPU pipelines' attachment state; enable it either before
+* the first frame (game), or sticky + material invalidation (editor). It must
+* NEVER be disabled at runtime — see `./README.md` → "MRT and attachment state".
+*/
+function enableSceneEmissiveMrt(scenePass) {
+	if (scenePass.getMRT()) return;
+	scenePass.setMRT(mrt({
+		output,
+		emissive
+	}));
+}
+/**
+* Bloom post-effect over the scenePass (editor + game). `mode=threshold` —
+* full-frame by brightness; `mode=emissive` — selective, via the emissive MRT
+* target (MRT must be enabled by the caller via `enableSceneEmissiveMrt` BEFORE
+* creation). SceneBloom does not own the MRT topology. Pipeline contracts — `./README.md`.
+*/
+var SceneBloom = class SceneBloom {
+	mode;
+	/** Bloom contribution (RGB) — for custom outputNode composition (editor). */
+	node;
+	/** `scenePassColor + bloom` — ready outputNode for the default pipeline (game). */
+	sceneWithBloom;
+	constructor(props) {
+		this.mode = props.mode;
+		this.node = props.node;
+		this.sceneWithBloom = props.scenePass.getTextureNode().add(props.node);
+	}
+	static async createAsync(props) {
+		const { bloom } = await lazyBloomModule.get();
+		const { scenePass, config } = props;
+		const mode = config.mode ?? "threshold";
+		let node;
+		if (mode === "emissive") {
+			if (!scenePass.getMRT()) throw new Error("SceneBloom: emissive mode requires MRT on scenePass — call enableSceneEmissiveMrt() first");
+			node = bloom(scenePass.getTextureNode("emissive"));
+		} else node = bloom(scenePass.getTextureNode());
+		const sceneBloom = new SceneBloom({
+			scenePass,
+			mode,
+			node
+		});
+		sceneBloom.updateParams(config);
+		return sceneBloom;
+	}
+	/** strength/radius/threshold are uniforms — applied on the fly without a rebuild. */
+	updateParams(cfg) {
+		this.strength = finiteOr(cfg.strength, 1);
+		this.radius = finiteOr(cfg.radius, 0);
+		this.threshold = this.mode === "emissive" ? 0 : finiteOr(cfg.threshold, 0);
+	}
+	get strength() {
+		return this.node.strength.value;
+	}
+	set strength(value) {
+		this.node.strength.value = value;
+	}
+	get radius() {
+		return this.node.radius.value;
+	}
+	set radius(value) {
+		this.node.radius.value = value;
+	}
+	get threshold() {
+		return this.node.threshold.value;
+	}
+	set threshold(value) {
+		this.node.threshold.value = value;
+	}
+	/** true — a mode change requires recreation (dispose + createAsync + new outputNode). */
+	needsRebuild(cfg) {
+		return (cfg.mode ?? "threshold") !== this.mode;
+	}
+	dispose() {
+		this.node.dispose();
+	}
+};
+function finiteOr(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+//#endregion
+//#region packages/world-runtime/src/modules/is-mobile-device.ts
+function isMobileDevice() {
+	if (typeof navigator === "undefined" || typeof window === "undefined") return false;
+	const ua = navigator.userAgent || navigator.vendor || window.opera;
+	if (/android/i.test(ua)) return true;
+	if (/iPhone|iPad|iPod/i.test(ua)) return true;
+	if (/Mobile|Opera Mini|IEMobile|WPDesktop/i.test(ua)) return true;
+	if (/Mobile|Mobi/i.test(ua)) return true;
+	return "ontouchstart" in window || navigator.maxTouchPoints && navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0;
+}
+//#endregion
+//#region packages/world-runtime/src/modules/EnvModule.ts
+var EnvModule = class extends ContextModule {
+	dev = true;
+	prod = true;
+	mode;
+	isMobile;
+	constructor(mode) {
+		super();
+		this.mode = mode;
+		this.dev = mode === "dev";
+		this.prod = mode === "prod";
+		this.isMobile = isMobileDevice();
+	}
+};
+//#endregion
+//#region packages/world-runtime/src/modules/HtmlHudModule.ts
+var { div } = van.tags;
+var HtmlHudModule = class extends ContextModule {
+	root;
+	crosshair;
+	constructor() {
+		super();
+		this.crosshair = div({
+			id: "kvyverse-game-gui-crosshair",
+			style: "position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);"
+		});
+		this.root = div({
+			id: "kvyverse-game-gui-root",
+			style: "position:fixed;inset:0;pointer-events:none;"
+		}, this.crosshair);
+	}
+	onAwake() {
+		const ctx = this.ctx;
+		if (ctx.canvasContainer) this.onMount(ctx.canvasContainer);
+		ctx.on(ThreeContextEvents.Mount, this.onMount);
+		ctx.on(ThreeContextEvents.Unmount, this.onUnmount);
+	}
+	append(...nodes) {
+		this.root.append(...nodes);
+	}
+	setCrosshair(innerHtml) {
+		this.crosshair.innerHTML = innerHtml;
+	}
+	/** three-start ContextModule has no onDestroy; teardown is explicit. */
+	dispose() {
+		this.ctx.off(ThreeContextEvents.Mount, this.onMount);
+		this.ctx.off(ThreeContextEvents.Unmount, this.onUnmount);
+	}
+	onMount = (container) => {
+		container.append(this.root);
+	};
+	onUnmount = () => {
+		this.root.remove();
+	};
+};
+//#endregion
+//#region packages/world-runtime/src/modules/InputSystemModule.ts
+var PlayerInput = class extends EventEmitter {
+	_forward = 0;
+	_lateral = 0;
+	_force = 1;
+	/**
+	* @default 0
+	*/
+	get forward() {
+		return this._forward;
+	}
+	/**
+	* @default 0
+	*/
+	get lateral() {
+		return this._lateral;
+	}
+	/**
+	* @default 1
+	*/
+	get force() {
+		return this._force;
+	}
+	setDir(forward, lateral) {
+		this._forward = forward;
+		this._lateral = lateral;
+		this.emit("dirchanged", forward, lateral);
+	}
+	setForce(force) {
+		this._force = force;
+		this.emit("forcechanged", force);
+	}
+	jump() {
+		this.emit("jump");
+	}
+	/**
+	* 0 is keyboard, 1 is joystick
+	* @default 0
+	*/
+	mode = 0;
+};
+var InputSystemModule = class extends ContextModule {
+	_dom;
+	_keys = /* @__PURE__ */ new Set();
+	_shift = false;
+	_alt = false;
+	_ctrl = false;
+	_meta = false;
+	_isDragging = false;
+	_pointerNdc = new THREE.Vector2();
+	_averageActivePointersCoords = {
+		x: 0,
+		y: 0
+	};
+	_pointerXStack = [0, 0];
+	_pointerYStack = [0, 0];
+	_domBoundingClientRect = null;
+	activePointers = /* @__PURE__ */ new Map();
+	get pointerDeltaX() {
+		return this._pointerXStack[1] - this._pointerXStack[0];
+	}
+	get pointerDeltaY() {
+		return this._pointerYStack[1] - this._pointerYStack[0];
+	}
+	get isDragging() {
+		return this._isDragging;
+	}
+	/** Pointer position {x,y} in normalized device coordinates (-1 to +1) */
+	get pointerNdc() {
+		return this._pointerNdc;
+	}
+	get shiftKey() {
+		return this._shift;
+	}
+	get altKey() {
+		return this._alt;
+	}
+	get ctrlKey() {
+		return this._ctrl;
+	}
+	get metaKey() {
+		return this._meta;
+	}
+	isKeyDown = (key) => {
+		return this._keys.has(key);
+	};
+	player = new PlayerInput();
+	onAwake() {
+		const ctx = this.ctx;
+		this._dom = ctx.renderer.domElement;
+		window.addEventListener("resize", this.onWindowResize);
+		window.addEventListener("scroll", this.onWindowScroll);
+		ctx.on(ThreeContextEvents.Resized, this.onDomResize);
+		const on = this._dom.addEventListener.bind(this._dom);
+		on("focus", this.onFocus);
+		on("blur", this.onBlur);
+		on("pointerenter", this.onPointerEnter);
+		on("pointerdown", this.onPointerDown);
+		on("pointermove", this.onPointerMove);
+		on("pointerup", this.onPointerUp);
+		on("pointerleave", this.onPointerLeave);
+		on("keydown", this.onKeyDown);
+		on("keyup", this.onKeyUp);
+	}
+	/** three-start `ContextModule` has no `onDestroy`; teardown is explicit. */
+	dispose() {
+		window.removeEventListener("resize", this.onWindowResize);
+		window.removeEventListener("scroll", this.onWindowScroll);
+		this.ctx.off(ThreeContextEvents.Resized, this.onDomResize);
+		const off = this._dom.removeEventListener.bind(this._dom);
+		off("focus", this.onFocus);
+		off("blur", this.onBlur);
+		off("pointerenter", this.onPointerEnter);
+		off("pointerdown", this.onPointerDown);
+		off("pointermove", this.onPointerMove);
+		off("pointerup", this.onPointerUp);
+		off("pointerleave", this.onPointerLeave);
+		off("keydown", this.onKeyDown);
+		off("keyup", this.onKeyUp);
+	}
+	onWindowResize = () => {
+		this.updateDomBoundingClientRect();
+	};
+	onWindowScroll = () => {
+		this.updateDomBoundingClientRect();
+	};
+	onDomResize = () => {
+		this.updateDomBoundingClientRect();
+	};
+	onFocus = () => {
+		this.resetKeys();
+		this.resetPointers();
+	};
+	onBlur = () => {
+		this.resetKeys();
+		this.resetPointers();
+	};
+	onKeyDown = (event) => {
+		this.updFnKeys(event);
+		this._keys.add(event.code);
+		this.emit("keyschanged");
+	};
+	onKeyUp = (event) => {
+		this.updFnKeys(event);
+		this._keys.delete(event.code);
+		this.emit("keyschanged");
+	};
+	onPointerEnter = (_) => {};
+	onPointerDown = (event) => {
+		this.activePointers.set(event.pointerId, event);
+		this.updateStackAndNdcByActivePointers(true);
+		this._isDragging = true;
+	};
+	onPointerMove = (event) => {
+		if (this.activePointers.size > 0) {
+			this.activePointers.has(event.pointerId) && this.activePointers.set(event.pointerId, event);
+			this.updateStackAndNdcByActivePointers();
+		} else this.updateStackAndNdcByPointer(event.clientX, event.clientY);
+	};
+	onPointerUp = (event) => {
+		this.activePointers.delete(event.pointerId);
+		this._isDragging = this.activePointers.size > 0;
+	};
+	onPointerLeave = () => {
+		this.resetKeys();
+		this.resetPointers();
+	};
+	resetKeys() {
+		this._shift = false;
+		this._alt = false;
+		this._ctrl = false;
+		this._meta = false;
+		this._keys.clear();
+	}
+	updFnKeys(event) {
+		this._shift = event.shiftKey;
+		this._alt = event.altKey;
+		this._ctrl = event.ctrlKey;
+		this._meta = event.metaKey;
+	}
+	updateAverageActivePointersCoords() {
+		let x = 0;
+		let y = 0;
+		const size = this.activePointers.size;
+		if (size === 1) {
+			const pointerEvent = this.activePointers.values().next().value;
+			if (pointerEvent) {
+				x = pointerEvent.clientX;
+				y = pointerEvent.clientY;
+			}
+		} else if (size > 1) {
+			let sumX = 0;
+			let sumY = 0;
+			this.activePointers.forEach((pointer) => {
+				sumX += pointer.clientX;
+				sumY += pointer.clientY;
+			});
+			x = sumX / size;
+			y = sumY / size;
+		}
+		this._averageActivePointersCoords.x = x;
+		this._averageActivePointersCoords.y = y;
+		return this._averageActivePointersCoords;
+	}
+	updateStackAndNdcByActivePointers = (fillStack) => {
+		const { x, y } = this.updateAverageActivePointersCoords();
+		this.updateStackAndNdcByPointer(x, y, fillStack);
+	};
+	updateStackAndNdcByPointer(x, y, fillStack) {
+		if (fillStack) this.fillPointerStack(x, y);
+		else this.pushPointerStack(x, y);
+		this.recalculatePointerNdc(x, y);
+	}
+	pushPointerStack(x, y) {
+		this._pointerXStack.shift();
+		this._pointerXStack.push(x);
+		this._pointerYStack.shift();
+		this._pointerYStack.push(y);
+	}
+	fillPointerStack(x, y) {
+		this._pointerXStack = [x, x];
+		this._pointerYStack = [y, y];
+	}
+	resetPointers() {
+		this._pointerXStack = [0, 0];
+		this._pointerYStack = [0, 0];
+		this.activePointers.clear();
+	}
+	recalculatePointerNdc(clientX, clientY) {
+		this._pointerNdc.x = clientX / this._dom.clientWidth * 2 - 1;
+		this._pointerNdc.y = -(clientY / this._dom.clientHeight) * 2 + 1;
+		const bounds = this._domBoundingClientRect ?? this.updateDomBoundingClientRect();
+		const fixedClientX = (clientX - bounds.left) / bounds.width;
+		const fixedClientY = (clientY - bounds.top) / bounds.height;
+		this._pointerNdc.x = fixedClientX * 2 - 1;
+		this._pointerNdc.y = -(fixedClientY * 2 - 1);
+	}
+	updateDomBoundingClientRect() {
+		this._domBoundingClientRect = this._dom.getBoundingClientRect();
+		return this._domBoundingClientRect;
+	}
+};
+//#endregion
+//#region packages/world-runtime/src/modules/SoundsModule.ts
+var SoundsModule = class extends ContextModule {
+	global = Howler;
+	/** three-start ContextModule has no onDestroy; teardown is explicit. */
+	dispose() {
+		Howler.stop();
+	}
+};
+//#endregion
+//#region packages/world-runtime/src/modules/UtilsModule.ts
+var UtilsModule = class extends ContextModule {
+	cloneObject3D;
+	mergeGeometries;
+	constructor() {
+		super();
+		this.cloneObject3D = clone;
+		this.mergeGeometries = mergeGeometries;
+	}
+};
+//#endregion
+//#region packages/world-runtime/src/modules/index.ts
+/** World ctx modules. Registered before `start()` — three-start forbids it later. */
+function createWorldModules(mode = "prod") {
+	return {
+		env: new EnvModule(mode),
+		html: new HtmlHudModule(),
+		input: new InputSystemModule(),
+		sounds: new SoundsModule(),
+		utils: new UtilsModule()
+	};
+}
+//#endregion
+//#region packages/world-runtime/src/behaviours/physics/_required-patch.ts
+/** rapier loads lazily: the wasm is pulled only in worlds with physics. */
+var lazyRapier = lazy(async () => {
+	const rapier = await import("@dimforge/rapier3d-compat");
+	await rapier.init();
+	return rapier;
+});
+var lazyRapierPhysicsModule = lazy(async () => (await import("./RapierPhysics-C_3b7QOn.js").then((n) => n.n)).default);
+var lazyRapierDebugModule = lazy(async () => (await import("./RapierDebugRenderer-sURZDLP4.js")).default);
+/**
+* Registers rapier modules before bootstrap: three-start forbids `addModules`
+* after `start()`. Idempotent — a repeated call sees the module in ctx and exits.
+*/
+async function applyRapierPhysicsPatch(starter) {
+	const RAPIER = await lazyRapier.get();
+	const RapierPhysicsModule = await lazyRapierPhysicsModule.get();
+	const RapierDebugRenderer = await lazyRapierDebugModule.get();
+	if (RapierPhysics.findInCtx(starter.ctx)) return;
+	starter.addModules({
+		rapier: new RapierPhysicsModule(RAPIER),
+		rapierDebug: new RapierDebugRenderer()
+	});
+}
+//#endregion
+//#region packages/world-runtime/src/behaviours/registry.ts
+var entries = [
+	{
+		uuid: "spinning",
+		name: "Spinning",
+		load: () => loadDefault(import("./Spinning-sgUhHld8.js"))
+	},
+	{
+		uuid: "scalingtofro",
+		name: "ScalingToFro",
+		load: () => loadDefault(import("./ScalingToFro-BD-E5-uR.js"))
+	},
+	{
+		uuid: "startanim",
+		name: "StartAnimation",
+		load: () => loadDefault(import("./StartAnimation-B9eomOS2.js"))
+	},
+	{
+		uuid: "pointerlockcameracontrols",
+		name: "PointerLockCameraController",
+		load: () => loadDefault(import("./PointerLockCameraControls-DYxxMeSw.js"))
+	},
+	{
+		uuid: "simplewasdmovement",
+		name: "SimpleWASDMovement",
+		load: () => loadDefault(import("./SimpleWASDMovement-C2m53YYH.js"))
+	},
+	{
+		uuid: "fpscameracontroller",
+		name: "FpsCameraController",
+		load: () => loadDefault(import("./FpsCameraController-BE2EirRj.js"))
+	},
+	{
+		uuid: "sightinteractablearea",
+		name: "SightInteractableArea",
+		load: () => loadDefault(import("./SightInteractableArea-DrqyB41W.js"))
+	},
+	{
+		uuid: "meshinstansing",
+		name: "MeshInstansing",
+		load: () => loadDefault(import("./MeshInstansing-Bxij0Yc9.js"))
+	},
+	{
+		uuid: "rrb",
+		name: "Rigidbody",
+		load: () => loadDefault(import("./Rigidbody-b7QNF4ev.js").then((n) => n.n)),
+		requiredPatch: applyRapierPhysicsPatch
+	},
+	{
+		uuid: "rapierballcol",
+		name: "BallCollider",
+		load: () => loadDefault(import("./BallCollider-8ZrxReEd.js")),
+		requiredPatch: applyRapierPhysicsPatch
+	},
+	{
+		uuid: "rapiercapscol",
+		name: "CapsuleCollider",
+		load: () => loadDefault(import("./CapsuleCollider-bynyf6Mc.js")),
+		requiredPatch: applyRapierPhysicsPatch
+	},
+	{
+		uuid: "rapierconecol",
+		name: "ConeCollider",
+		load: () => loadDefault(import("./ConeCollider-DtRZmgK8.js")),
+		requiredPatch: applyRapierPhysicsPatch
+	},
+	{
+		uuid: "rapierconvxcol",
+		name: "ConvexMeshCollider",
+		load: () => loadDefault(import("./ConvexMeshCollider-BSmDM4o3.js")),
+		requiredPatch: applyRapierPhysicsPatch
+	},
+	{
+		uuid: "rapiercubcol",
+		name: "CuboidCollider",
+		load: () => loadDefault(import("./CuboidCollider-CJvq7--s.js")),
+		requiredPatch: applyRapierPhysicsPatch
+	},
+	{
+		uuid: "rapiercylcol",
+		name: "CylinderCollider",
+		load: () => loadDefault(import("./CylinderCollider-CQPSh4tu.js")),
+		requiredPatch: applyRapierPhysicsPatch
+	},
+	{
+		uuid: "rapiertricol",
+		name: "TrimeshCollider",
+		load: () => loadDefault(import("./TrimeshCollider-7dIs_xtZ.js")),
+		requiredPatch: applyRapierPhysicsPatch
+	},
+	{
+		uuid: "rapierfpsplayercontroller",
+		name: "RapierFpsPlayerController",
+		load: () => loadDefault(import("./RapierFpsPlayerController-VsNfQl6v.js")),
+		requiredPatch: applyRapierPhysicsPatch
+	}
+];
+/** Registry of built-in behaviours by uuid — source of truth for both game and export. */
+var BUILTIN_BEHAVIOURS = Object.fromEntries(entries.map((entry) => [entry.uuid, entry]));
+var BUILTIN_BEHAVIOUR_LIST = entries;
+function getBuiltinBehaviour(uuid) {
+	return BUILTIN_BEHAVIOURS[uuid];
+}
+async function loadDefault(module) {
+	return (await module).default;
+}
+//#endregion
+//#region packages/world-runtime/src/resources/font.ts
+var FORMAT_BY_MIME = {
+	"font/ttf": "truetype",
+	"font/otf": "opentype",
+	"font/woff": "woff",
+	"font/woff2": "woff2"
+};
+/** CSS font format by mime (for `@font-face … format(...)`). */
+function fontFormatFromMime(mime) {
+	return FORMAT_BY_MIME[mime] ?? "truetype";
+}
+/**
+* Font source: the CSS side (`family` + `toFontFaceCss`) and the three side
+* (`getThreeFontAsync`, lazy TTFLoader/opentype chunk).
+*/
+var FontSource = class {
+	url;
+	format;
+	name = "";
+	uuid = crypto.randomUUID();
+	/** CSS font-family. Edited in the inspector, persisted in `values.src.family`. */
+	family;
+	_threeFontPromise = null;
+	constructor(url, family, format) {
+		this.url = url;
+		this.format = format;
+		this.family = family;
+	}
+	/** Ready-to-use `@font-face` rule for the game document. */
+	toFontFaceCss() {
+		return `@font-face { font-family: ${JSON.stringify(this.family)}; src: url("${this.url}") format("${this.format}"); }`;
+	}
+	/**
+	* three.js `Font` (for TextGeometry etc.). Lazy TTFLoader import
+	* (pulls opentype ~100kB gzip), the result is cached. woff2 is not
+	* supported by opentype — throws a clear error.
+	*/
+	getThreeFontAsync() {
+		if (this._threeFontPromise) return this._threeFontPromise;
+		this._threeFontPromise = this._parseThreeFontAsync();
+		this._threeFontPromise.catch(() => this._threeFontPromise = null);
+		return this._threeFontPromise;
+	}
+	dispose() {
+		this._threeFontPromise = null;
+		if (this.url.startsWith("blob:")) URL.revokeObjectURL(this.url);
+	}
+	async _parseThreeFontAsync() {
+		if (this.format === "woff2") throw new Error(`FontSource "${this.name}": woff2 is not supported by three TTFLoader (opentype.js). Use ttf/otf/woff for 3D text, or use this font via CSS font-family ${JSON.stringify(this.family)}.`);
+		const response = await fetch(this.url);
+		if (!response.ok) throw new Error(`Failed to load font "${this.url}": ${response.status}`);
+		const { ttfLoader, Font } = await AssetLoaders.font.get();
+		return new Font(ttfLoader.parse(await response.arrayBuffer()));
+	}
+};
+/** Font source from a URL. `mime` determines the CSS format of the `@font-face` rule. */
+function createFont(url, family, mime, name) {
+	const source = new FontSource(url, family, fontFormatFromMime(mime));
+	if (name !== void 0) source.name = name;
+	return source;
+}
+//#endregion
+//#region packages/world-runtime/src/settings/lib-registry.ts
+/**
+* Registry of built-in libraries enabled via `settings.addons.json → libs`.
+*
+* Separates two keys: `id` (short config key under `libs`) and `requireKey`
+* (what the user writes in `require(...)` in scripts). Single source for:
+*  - game: dynamic loading (`lib-loaders`),
+*  - editor: JSON schema (`libs` props) + require typings (`AddonsRequireTypings`).
+*
+* Adding a lib = add an entry here (+ loader in game, + d.ts loader in editor).
+*/
+var LibId = /* @__PURE__ */ function(LibId) {
+	LibId["Tween"] = "tween";
+	LibId["Anime"] = "anime";
+	return LibId;
+}({});
+var LIBS = {
+	["tween"]: {
+		id: "tween",
+		requireKey: "@tweenjs/tween.js",
+		label: "Tween.js"
+	},
+	["anime"]: {
+		id: "anime",
+		requireKey: "animejs/animation",
+		label: "Anime.js (animate)"
+	}
+};
+var LIB_IDS = Object.values(LibId);
+var LIB_DESCRIPTORS = LIB_IDS.map((id) => LIBS[id]);
+function libByRequireKey(requireKey) {
+	return LIB_DESCRIPTORS.find((l) => l.requireKey === requireKey);
+}
+//#endregion
+//#region packages/world-runtime/src/settings/lib-loaders.ts
+/**
+* Dynamic loaders of built-in libs (game-only). Key — `LibId` from the registry;
+* the value resolves for the user via `require("<requireKey>")`. Imports are lazy —
+* bundled only when the lib is enabled in `settings.addons.json`.
+*/
+var LIB_LOADERS = {
+	[LibId.Tween]: () => import("@tweenjs/tween.js"),
+	[LibId.Anime]: () => import("animejs/animation")
+};
+//#endregion
+//#region packages/world-runtime/src/settings/AddonsRuntime.ts
+/**
+* Runtime loading of addons (game-only): enabled built-in libs + external
+* scripts (externals). Exposes them to user scripts via `resolve(key)`
+* (used in `ScriptsRuntime.require`). Replaces the old
+* `GameLoader.loadExternalsAsync` / `getExternalLib`.
+*/
+var AddonsRuntime = class {
+	/** libs — by requireKey (`@tweenjs/tween.js`), externals — by accessor (`Tone`). */
+	_byKey = /* @__PURE__ */ new Map();
+	_scriptTags = [];
+	async load(addons) {
+		await this._loadLibs(addons.libs);
+		await this._loadExternals(addons.externals);
+	}
+	/** Resolves a require key: enabled lib or external accessor; undefined otherwise. */
+	resolve(key) {
+		return this._byKey.get(key);
+	}
+	async _loadLibs(libs) {
+		if (!libs) return;
+		for (const id of LIB_IDS) {
+			if (!libs[id]) continue;
+			try {
+				this._byKey.set(LIBS[id].requireKey, await LIB_LOADERS[id]());
+			} catch (e) {
+				console.error(`[addons] failed to load lib "${id}"`, e);
+			}
+		}
+	}
+	async _loadExternals(externals) {
+		if (!externals) return;
+		for (const ext of externals) try {
+			if (ext.type === "module") this._byKey.set(ext.accessor, await import(
+				/* @vite-ignore */
+				ext.src
+));
+			else {
+				await this._mountScript(ext.src);
+				this._byKey.set(ext.accessor, window[ext.accessor]);
+			}
+		} catch (e) {
+			console.error(`[addons] failed to load external "${ext.accessor}"`, e);
+		}
+	}
+	_mountScript(src) {
+		return new Promise((resolve, reject) => {
+			const script = document.createElement("script");
+			script.src = src;
+			script.onload = () => resolve();
+			script.onerror = () => reject(/* @__PURE__ */ new Error(`external script failed: ${src}`));
+			document.head.appendChild(script);
+			this._scriptTags.push(script);
+		});
+	}
+	dispose() {
+		for (const tag of this._scriptTags) tag.remove();
+		this._scriptTags.length = 0;
+		this._byKey.clear();
+	}
+};
+//#endregion
+//#region packages/world-runtime/src/settings/module-registry.ts
+/**
+* Registry of pluggable engine modules (`settings.addons.json → modules`).
+* These are three-start modules that must be registered before `start()`.
+* Feature toggles (chat/joystick/debugPerf) are NOT here — they live in
+* `settings.json` (see `../features/feature-registry`).
+*
+* The only module so far is physics.
+* Installation lives in game (`game/settings/module-installers`).
+*/
+var ModuleId = /* @__PURE__ */ function(ModuleId) {
+	ModuleId["Physics"] = "physics";
+	return ModuleId;
+}({});
+var PHYSICS_ENGINES = ["rapier"];
+var MODULE_IDS = Object.values(ModuleId);
+/** Normalizes the physics config to an object (or null if disabled). */
+function normalizePhysics(value) {
+	if (!value) return null;
+	if (typeof value === "string") return {
+		engine: value,
+		debug: false
+	};
+	return {
+		engine: value.engine,
+		debug: value.debug ?? false
+	};
+}
+//#endregion
+//#region packages/world-runtime/src/WorldRuntime.ts
+/**
+* Owner of the world's runtime state: assets, script execution, ctx access.
+* The only object the generated code receives.
+*/
+var WorldRuntime = class {
+	definition;
+	options;
+	/** World lifecycle event bus (`world.events` in scripts). */
+	emitter = new EventEmitter();
+	_addons = new AddonsRuntime();
+	_executedScripts = /* @__PURE__ */ new Map();
+	_builtins = /* @__PURE__ */ new Map();
+	_styleElements = [];
+	_resources = {};
+	_ctx = null;
+	_bloom = null;
+	_scriptContext = null;
+	constructor(definition, options) {
+		this.definition = definition;
+		this.options = options;
+	}
+	/** ctx appears at the 3d-context creation step; unavailable to scripts before that. */
+	get ctx() {
+		if (!this._ctx) throw new Error("World runtime: 3d context is not created yet");
+		return this._ctx;
+	}
+	/** @internal Set by bootstrap. */
+	setContext(ctx) {
+		this._ctx = ctx;
+	}
+	/** @internal World bloom, if enabled in the renderer config. */
+	setBloom(bloom) {
+		this._bloom = bloom;
+	}
+	/** @internal Built-in libs and external scripts from `settings.addons.json`. */
+	async loadAddons() {
+		const addons = this.definition.addons;
+		if (addons) await this._addons.load(addons);
+	}
+	/** @internal World resources by asset path — result of `loadAssets`. */
+	setResources(resources) {
+		this._resources = resources;
+	}
+	reportProgress(stage, details) {
+		const progress = {
+			stage,
+			details
+		};
+		this.options.onProgress?.(progress);
+	}
+	getUrl = (path) => {
+		const url = this.definition.assets[path];
+		if (url === void 0) throw new Error(`World runtime: unknown asset "${path}"`);
+		if (isAbsoluteUrl(url)) return url;
+		return `${this.options.assetsBaseUrl ?? ""}${url}`;
+	};
+	/**
+	* Built-in behaviour class by uuid. Classes are preloaded by bootstrap,
+	* so attaching in `buildScene` is synchronous.
+	*/
+	builtin = (uuid) => {
+		const Component = this._builtins.get(uuid);
+		if (!Component) throw new Error(`World runtime: built-in behaviour "${uuid}" is not loaded`);
+		return Component;
+	};
+	/** @internal Loads classes of the used built-in behaviours (before scene assembly). */
+	async loadBuiltins() {
+		const uuids = this.definition.usedBuiltins;
+		if (!uuids || uuids.length === 0) return;
+		await Promise.all(uuids.map(async (uuid) => {
+			const entry = getBuiltinBehaviour(uuid);
+			if (!entry) {
+				console.error(`World runtime: unknown built-in behaviour "${uuid}"`);
+				return;
+			}
+			this._builtins.set(uuid, await entry.load());
+		}));
+	}
+	/**
+	* @internal Registers ctx modules required by built-in behaviours (physics).
+	* Strictly before `start()` — three-start forbids `addModules` afterwards.
+	*/
+	async applyRequiredPatches(starter) {
+		for (const uuid of this.definition.usedBuiltins ?? []) {
+			const patch = getBuiltinBehaviour(uuid)?.requiredPatch;
+			if (!patch) continue;
+			try {
+				await patch(starter);
+			} catch (error) {
+				console.error(`Required patch of "${uuid}" failed`, error);
+			}
+		}
+		if (normalizePhysics(this.definition.addons?.modules?.physics)) try {
+			await applyRapierPhysicsPatch(starter);
+		} catch (error) {
+			console.error("Physics module patch failed", error);
+		}
+	}
+	/** Addon (built-in lib / external) → script by path → asset resource. Same
+	* resolve order as in play mode. */
+	require = (key) => {
+		const addon = this._addons.resolve(key);
+		if (addon !== void 0) return addon;
+		if (this.definition.scripts?.[key]) return this.executeScript(key);
+		const resource = this._resources[key];
+		if (resource !== void 0) return resource;
+		throw new Error(`World runtime: cannot resolve require("${key}")`);
+	};
+	/**
+	* Runtime spawn: a prefab (build-time factory) is assembled anew, a regular
+	* object is cloned. Returns a detached object — the caller adds it.
+	*/
+	instantiate = (source, options) => {
+		const object = typeof source === "function" ? source() : clone(source);
+		if (options?.position) setVec3(object.position, options.position);
+		if (options?.rotation) setVec3(object.rotation, options.rotation);
+		if (options?.scale !== void 0) if (typeof options.scale === "number") object.scale.setScalar(options.scale);
+		else setVec3(object.scale, options.scale);
+		return object;
+	};
+	/** Runs a script once and caches its `output`. The cache entry is set before
+	* execution — this breaks cyclic `require`. */
+	executeScript(path) {
+		if (this._executedScripts.has(path)) return this._executedScripts.get(path);
+		const script = this.definition.scripts?.[path];
+		if (!script) throw new Error(`World runtime: unknown script "${path}"`);
+		this._executedScripts.set(path, void 0);
+		try {
+			const output = script(this.scriptContext);
+			this._executedScripts.set(path, output);
+			return output;
+		} catch (error) {
+			console.error(`Script "${path}" failed`, error);
+			return;
+		}
+	}
+	/** World entry script (`main.ts`), once. */
+	executeEntryScript() {
+		const entry = this.definition.entryScript;
+		if (entry) this.executeScript(entry);
+	}
+	/** Mounts world css scripts into the document where the canvas actually renders. */
+	mountStyles() {
+		const styles = this.definition.styles;
+		if (!styles || styles.length === 0) return;
+		for (const css of styles) this.appendStyle(css);
+	}
+	/** `@font-face` of all world fonts in a single tag — before styles and entry script. */
+	mountFonts() {
+		const paths = this.definition.fontPaths;
+		if (!paths || paths.length === 0) return;
+		const rules = [];
+		for (const path of paths) {
+			const source = this._resources[path];
+			if (source instanceof FontSource) rules.push(source.toFontFaceCss());
+		}
+		if (rules.length === 0) return;
+		this.appendStyle(rules.join("\n")).setAttribute("data-kvy-fonts", "");
+	}
+	dispose() {
+		this._addons.dispose();
+		for (const element of this._styleElements) element.remove();
+		this._styleElements.length = 0;
+		this._executedScripts.clear();
+		this.emitter.removeAllListeners();
+	}
+	/** Narrow bloom facade for scripts: mode is read-only, params are live
+	* (uniforms, can be animated per frame). `null` — bloom is disabled. */
+	get bloomApi() {
+		const bloom = this._bloom;
+		if (!bloom) return null;
+		return {
+			mode: bloom.mode,
+			get strength() {
+				return bloom.strength;
+			},
+			set strength(value) {
+				bloom.strength = value;
+			},
+			get radius() {
+				return bloom.radius;
+			},
+			set radius(value) {
+				bloom.radius = value;
+			},
+			get threshold() {
+				return bloom.threshold;
+			},
+			set threshold(value) {
+				bloom.threshold = value;
+			}
+		};
+	}
+	/** Script-scope globals: all of three-start + `world`, `require`, libs.
+	* `ctx` is a getter: script components run before the 3d context is created. */
+	get scriptContext() {
+		if (this._scriptContext) return this._scriptContext;
+		const runtime = this;
+		this._scriptContext = {
+			...ThreeStartNS,
+			world: {
+				get ctx() {
+					return runtime.ctx;
+				},
+				events: this.emitter,
+				emitter: this.emitter,
+				rendering: { get bloom() {
+					return runtime.bloomApi;
+				} }
+			},
+			require: this.require,
+			instantiate: this.instantiate,
+			getUrl: this.getUrl,
+			THREE,
+			TSL,
+			van
+		};
+		return this._scriptContext;
+	}
+	appendStyle(css) {
+		const doc = this.ctx.renderer.domElement.ownerDocument;
+		const element = doc.createElement("style");
+		element.innerHTML = css;
+		doc.head.appendChild(element);
+		this._styleElements.push(element);
+		return element;
+	}
+};
+function setVec3(target, value) {
+	if (Array.isArray(value)) target.set(value[0], value[1], value[2]);
+	else target.set(value.x, value.y, value.z);
+}
+function isAbsoluteUrl(url) {
+	return /^(?:[a-z]+:)?\/\//i.test(url) || url.startsWith("data:");
+}
+//#endregion
+//#region packages/world-runtime/src/version.gen.ts
+var RUNTIME_VERSION = "0.1.0";
+//#endregion
+//#region packages/world-runtime/src/version.ts
+/**
+* Format version of the generated world. The codegen stamps it into the artifact,
+* the runtime checks it on load. A breaking format change = package major bump.
+* Not to be confused with {@link RUNTIME_VERSION} — the package's own version
+* (from package.json, generated into version.gen.ts by gen-runtime-version).
+*/
+var WORLD_FORMAT_VERSION = 1;
+/** Throws if the artifact was built by an incompatible generator version. */
+function assertFormatVersion(version) {
+	if (version === 1) return;
+	throw new Error(`@kvyverse/world-runtime: world format v${version} is not supported by runtime (expected v1). Re-export the world or pin a matching runtime version.`);
+}
+//#endregion
+//#region packages/world-runtime/src/bootstrap.ts
+/**
+* World assembly order. The only place where it is fixed: the artifact supplies
+* the data and steps, the runtime owns the sequence. Mirrors the game's
+* classic-load (`/docs/scripting/game-runtime.md`).
+*/
+async function bootstrapWorld(definition, options) {
+	assertFormatVersion(definition.formatVersion);
+	const runtime = new WorldRuntime(definition, options);
+	if (options.dracoPath) configureAssetLoaders({ dracoPath: options.dracoPath });
+	runtime.reportProgress("Loading addons");
+	await runtime.loadAddons();
+	runtime.reportProgress("Loading assets");
+	const assets = await definition.loadAssets(runtime);
+	runtime.setResources(assets);
+	runtime.reportProgress("Loading built-in behaviours");
+	await runtime.loadBuiltins();
+	runtime.reportProgress("Building scene");
+	const built = definition.buildScene(runtime, assets);
+	runtime.reportProgress("Initializing 3D context");
+	const world = await createWorld(definition, runtime);
+	runtime.setContext(world.ctx);
+	await runtime.applyRequiredPatches(world);
+	runtime.reportProgress("Applying scene settings");
+	definition.applySceneSettings?.(runtime, world.ctx.scene);
+	if (built.camera) world.ctx.camera = built.camera;
+	runtime.reportProgress("Running scripts");
+	runtime.mountFonts();
+	runtime.mountStyles();
+	runtime.executeEntryScript();
+	runtime.emitter.emit(WorldEvent.BeforeSceneReady);
+	world.ctx.scene.add(...built.children);
+	runtime.emitter.emit(WorldEvent.SceneReady);
+	runtime.reportProgress("Ready");
+	return world;
+}
+/** Renderer + the world's three-start app. */
+async function createWorld(definition, runtime) {
+	const config = definition.renderer ?? {};
+	const renderer = new THREE.WebGPURenderer({
+		antialias: true,
+		...config.renderer
+	});
+	await renderer.init();
+	const world = new World({
+		renderer,
+		camera: new THREE.PerspectiveCamera(),
+		scene: new THREE.Scene(),
+		autoInitRenderer: false
+	}, runtime);
+	world.addModules(createWorldModules("prod"));
+	applyRendererConfig(renderer, config);
+	if (config.bloom?.enabled) {
+		if (config.bloom.mode === "emissive") enableSceneEmissiveMrt(world.ctx.scenePass);
+		const bloom = await SceneBloom.createAsync({
+			scenePass: world.ctx.scenePass,
+			config: config.bloom
+		});
+		world.ctx.renderPipeline.outputNode = bloom.sceneWithBloom;
+		world.ctx.renderPipeline.needsUpdate = true;
+		runtime.setBloom(bloom);
+	}
+	return world;
+}
+//#endregion
+//#region packages/world-runtime/src/define-world.ts
+/**
+* Entry point of the generated artifact: world definition → public `loadWorld`.
+* The codegen prints `export const { loadWorld } = defineWorld({ ... })`.
+*/
+function defineWorld(definition) {
+	return { loadWorld: (options = {}) => bootstrapWorld(definition, options) };
+}
+//#endregion
+//#region packages/world-runtime/src/values.ts
+/**
+* Writes a color into an object field, creating a `Color` if the slot is empty.
+* Mirrors the `$C` branch of `applyValues` — needed by generated code for fields
+* like `scene.background` that may be `null`.
+*/
+function setColor(target, key, hex) {
+	const holder = target;
+	const current = holder[key];
+	if (current?.isColor) {
+		current.set(hex);
+		return;
+	}
+	if (current !== void 0 && current !== null) throw new Error(`setColor: "${key}" is not a Color`);
+	holder[key] = new THREE.Color(hex);
+}
+//#endregion
+//#region packages/world-runtime/src/resources/default-resources.ts
+/**
+* Built-in engine resources with fixed uuids: world values reference them via
+* a regular ref (`{$A:"6"}`), so the identifiers must never change.
+*/
+var DefaultResourceId = {
+	EmptyGeometry: "0",
+	BoxGeometry: "1",
+	SphereGeometry: "2",
+	PlaneGeometry: "3",
+	CylinderGeometry: "4",
+	PyramidGeometry: "5",
+	Material: "6",
+	SpriteMaterial: "7",
+	Texture: "8"
+};
+var FACTORIES = {
+	[DefaultResourceId.EmptyGeometry]: () => {
+		const geometry = new THREE.BufferGeometry();
+		geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array(0), 3));
+		geometry.setIndex(new THREE.BufferAttribute(new Uint16Array(0), 1));
+		return geometry;
+	},
+	[DefaultResourceId.BoxGeometry]: () => new THREE.BoxGeometry(),
+	[DefaultResourceId.SphereGeometry]: () => new THREE.SphereGeometry(),
+	[DefaultResourceId.PlaneGeometry]: () => new THREE.PlaneGeometry(),
+	[DefaultResourceId.CylinderGeometry]: () => new THREE.CylinderGeometry(),
+	[DefaultResourceId.PyramidGeometry]: () => new THREE.ConeGeometry(1, 1, 4, 1),
+	[DefaultResourceId.Material]: () => new THREE.MeshStandardNodeMaterial(),
+	[DefaultResourceId.SpriteMaterial]: () => new THREE.SpriteNodeMaterial(),
+	[DefaultResourceId.Texture]: () => {
+		const texture = new THREE.DataTexture(new Uint8Array([
+			255,
+			255,
+			255,
+			255
+		]), 1, 1);
+		texture.needsUpdate = true;
+		return texture;
+	}
+};
+var NAMES = {
+	[DefaultResourceId.EmptyGeometry]: "Empty",
+	[DefaultResourceId.BoxGeometry]: "Box",
+	[DefaultResourceId.SphereGeometry]: "Sphere",
+	[DefaultResourceId.PlaneGeometry]: "Plane",
+	[DefaultResourceId.CylinderGeometry]: "Cylinder",
+	[DefaultResourceId.PyramidGeometry]: "Pyramid",
+	[DefaultResourceId.Material]: "Default Material",
+	[DefaultResourceId.SpriteMaterial]: "Sprite Material",
+	[DefaultResourceId.Texture]: "Default Texture"
+};
+var CACHE = /* @__PURE__ */ new Map();
+/**
+* Resource by its uuid. Lazy and cached: an exported world creates only
+* what it actually references.
+*/
+function getDefaultResource(id) {
+	const cached = CACHE.get(id);
+	if (cached) return cached;
+	const resource = FACTORIES[id]();
+	resource.name = NAMES[id];
+	resource.uuid = id;
+	CACHE.set(id, resource);
+	return resource;
+}
+var DEFAULT_RESOURCE_IDS = Object.values(DefaultResourceId);
+function isDefaultResourceId(uuid) {
+	return DEFAULT_RESOURCE_IDS.includes(uuid);
+}
+//#endregion
+//#region packages/world-runtime/src/resources/texture.ts
+/**
+* World texture defaults: clamp wrapping switches to repeat, color space
+* is sRGB. Identical in the editor, the game and the exported world.
+*/
+function applyTextureDefaults(texture, name) {
+	if (texture.wrapS === THREE.ClampToEdgeWrapping) texture.wrapS = THREE.RepeatWrapping;
+	if (texture.wrapT === THREE.ClampToEdgeWrapping) texture.wrapT = THREE.RepeatWrapping;
+	texture.colorSpace = THREE.SRGBColorSpace;
+	if (name !== void 0) texture.name = name;
+}
+/** Texture from a URL with defaults applied. */
+async function loadTexture(url, name) {
+	const texture = await AssetLoaders.texture.get().loadAsync(url);
+	applyTextureDefaults(texture, name);
+	return texture;
+}
+//#endregion
+//#region packages/world-runtime/src/resources/model.ts
+/** Parses model bytes into a hierarchy. `data`: ArrayBuffer, for obj — text. */
+async function parseModel(data, format, name) {
+	let root;
+	switch (format) {
+		case "gltf":
+		case "glb": {
+			const gltf = await (await AssetLoaders.gltf.get()).parseAsync(data, "");
+			root = gltf.scene;
+			root.animations = gltf.animations;
+			break;
+		}
+		case "fbx":
+			root = (await AssetLoaders.fbx.get()).parse(data, "");
+			break;
+		case "obj":
+			root = (await AssetLoaders.obj.get()).parse(data);
+			break;
+	}
+	if (name !== void 0) root.name = name;
+	return root;
+}
+/** Loads a model from a URL and parses it. */
+async function loadModel(url, format, name) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to load model "${url}": ${response.status}`);
+	return parseModel(format === "obj" ? await response.text() : await response.arrayBuffer(), format, name);
+}
+/**
+* Collects model sub-resources in a single traversal. The only implementation:
+* used by `Model3DAsset` in the editor and by the export generator — otherwise
+* refs to the model's materials and geometries drift apart by index.
+*/
+function collectModelSubResources(root) {
+	const geometries = /* @__PURE__ */ new Set();
+	const materials = /* @__PURE__ */ new Set();
+	const textures = /* @__PURE__ */ new Set();
+	const animations = /* @__PURE__ */ new Set();
+	const skeletons = /* @__PURE__ */ new Set();
+	root.traverse((node) => {
+		for (const animation of node.animations) animations.add(animation);
+		const mesh = node;
+		if (mesh.isMesh && mesh.geometry) {
+			geometries.add(mesh.geometry);
+			if (mesh.geometry.name.length === 0) mesh.geometry.name = node.name;
+			const material = mesh.material;
+			if (Array.isArray(material)) for (const item of material) materials.add(item);
+			else if (material) materials.add(material);
+		}
+		const skinned = node;
+		if (skinned.isSkinnedMesh && skinned.skeleton) skeletons.add(skinned.skeleton);
+	});
+	for (const material of materials) {
+		const record = material;
+		for (const key in record) {
+			if (!Object.prototype.hasOwnProperty.call(record, key)) continue;
+			const value = record[key];
+			if (value?.isTexture) textures.add(value);
+		}
+	}
+	return {
+		geometries: Array.from(geometries),
+		materials: Array.from(materials),
+		textures: Array.from(textures),
+		animations: Array.from(animations),
+		skeletons: Array.from(skeletons)
+	};
+}
+//#endregion
+//#region packages/world-runtime/src/resources/hdr.ts
+/** Parses hdr/exr into a `DataTexture` with environment defaults (equirect, no mipmaps). */
+async function parseHdr(data, format, name) {
+	let texture;
+	if (format === "hdr") {
+		const result = await AssetLoaders.rgbe.get().then((loader) => loader.parse(data));
+		texture = new THREE.DataTexture(result.data, result.width, result.height, THREE.RGBAFormat, THREE.HalfFloatType);
+	} else {
+		const result = await AssetLoaders.exr.get().then((loader) => loader.parse(data));
+		texture = new THREE.DataTexture(result.data, result.width, result.height, result.format, result.type);
+		texture.colorSpace = result.colorSpace;
+	}
+	texture.minFilter = THREE.LinearFilter;
+	texture.magFilter = THREE.LinearFilter;
+	texture.flipY = true;
+	texture.generateMipmaps = false;
+	texture.mapping = THREE.EquirectangularReflectionMapping;
+	texture.needsUpdate = true;
+	if (name !== void 0) texture.name = name;
+	return texture;
+}
+/** Loads hdr/exr from a URL and parses it. */
+async function loadHdr(url, format, name) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to load hdr "${url}": ${response.status}`);
+	return parseHdr(await response.arrayBuffer(), format, name);
+}
+//#endregion
+//#region packages/world-runtime/src/resources/geometry.ts
+/** Geometry from our json format (`BufferGeometry.toJSON`). */
+function parseGeometryJson(json, name) {
+	const geometry = AssetLoaders.bufferGeometry.get().parse(json);
+	if (name !== void 0) geometry.name = name;
+	return geometry;
+}
+/** Loads geometry from a URL and parses it. */
+async function loadGeometry(url, name) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to load geometry "${url}": ${response.status}`);
+	return parseGeometryJson(await response.json(), name);
+}
+//#endregion
+//#region packages/world-runtime/src/resources/audio.ts
+/**
+* Audio asset source: a `Howl` with identity — this is what scripts get
+* from `require("/Sounds/...")`.
+*/
+var AudioSource = class extends Howl {
+	_url;
+	name = "";
+	uuid = crypto.randomUUID();
+	constructor(_url, ...args) {
+		super(...args);
+		this._url = _url;
+	}
+	/** Revoke blob URLs (the editor keeps the file in memory); external URLs stay. */
+	dispose() {
+		this.unload();
+		if (this._url.startsWith("blob:")) URL.revokeObjectURL(this._url);
+	}
+};
+/** Loaded audio from a URL. `format` — extension hint when it's absent from the URL. */
+function createAudio(url, format, name) {
+	const source = new AudioSource(url, {
+		src: url,
+		format
+	});
+	if (name !== void 0) source.name = name;
+	return new Promise((resolve, reject) => {
+		source.once("load", () => resolve(source));
+		source.once("loaderror", (_id, error) => reject(/* @__PURE__ */ new Error(`Failed to load audio "${url}": ${String(error)}`)));
+		source.load();
+	});
+}
+//#endregion
+//#region packages/world-runtime/src/resources/video.ts
+/**
+* Video asset source: a `<video>` with identity — this is what scripts get
+* from `require("/Videos/...")` (and `THREE.VideoTexture` from `element`).
+*/
+var VideoSource = class {
+	element;
+	_url;
+	name = "";
+	uuid = crypto.randomUUID();
+	constructor(element, _url) {
+		this.element = element;
+		this._url = _url;
+	}
+	dispose() {
+		const video = this.element;
+		try {
+			video.pause();
+			video.removeAttribute("src");
+			video.load();
+		} catch (error) {
+			console.warn("Failed to stop video", error);
+		}
+		if (this._url?.startsWith("blob:")) URL.revokeObjectURL(this._url);
+		this._url = null;
+	}
+};
+/** Playback-ready `<video>` from a URL (waits for `loadeddata`). */
+async function createVideo(url, name) {
+	const video = document.createElement("video");
+	video.src = url;
+	video.crossOrigin = "anonymous";
+	video.loop = true;
+	video.playsInline = true;
+	video.muted = true;
+	video.load();
+	await new Promise((resolve, reject) => {
+		const cleanup = () => {
+			video.removeEventListener("loadeddata", onReady);
+			video.removeEventListener("error", onError);
+		};
+		const onReady = () => {
+			cleanup();
+			resolve();
+		};
+		const onError = (event) => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`Failed to load video "${url}": ${event.message}`));
+		};
+		video.addEventListener("loadeddata", onReady);
+		video.addEventListener("error", onError);
+	});
+	const source = new VideoSource(video, url);
+	if (name !== void 0) source.name = name;
+	return source;
+}
+//#endregion
+//#region packages/world-runtime/src/rendering/tsl-node.ts
+/**
+* World TSL node: the built graph node + its uniform nodes. This is what
+* `require("/Shaders/....tsl")` returns, so the method set matches the editor's
+* `TslNodeSource` (`setUniformValue` / `getUniformValue` / `uniformValues`).
+*/
+var TslNode = class {
+	uniforms;
+	node;
+	_uniformValuesView;
+	constructor(uniforms, build, name = "TslNode") {
+		this.uniforms = uniforms;
+		let node;
+		try {
+			node = build(TSL, uniforms);
+		} catch (error) {
+			console.warn(`TSL node "${name}" build failed`, error);
+		}
+		this.node = node ?? TSL.float(1);
+	}
+	/** Flat view of uniform values: reads and writes go straight to `node.value`. */
+	get uniformValues() {
+		return this._uniformValuesView ??= new Proxy({}, {
+			get: (_target, key) => typeof key === "string" ? this.getUniformValue(key) : void 0,
+			set: (_target, key, value) => {
+				if (typeof key === "string") this.setUniformValue(key, value);
+				return true;
+			}
+		});
+	}
+	setUniformValue(key, value) {
+		const node = this.uniforms[key];
+		if (node) node.value = value;
+	}
+	getUniformValue(key) {
+		return this.uniforms[key]?.value;
+	}
+};
+/** Factory for the generated code: builds the node and wraps it. */
+function createTslNode(uniforms, build, name) {
+	return new TslNode(uniforms, build, name);
+}
+//#endregion
+//#region packages/world-runtime/src/rendering/tsl-uniforms.ts
+var UNIFORM_TYPES = [
+	"float",
+	"int",
+	"vec2",
+	"vec3",
+	"vec4",
+	"color",
+	"bool",
+	"texture"
+];
+function isUniformType(x) {
+	return UNIFORM_TYPES.includes(x);
+}
+/** Uniform node type. Texture is a separate class; the rest carry an explicit `nodeType`. */
+function uniformType(node) {
+	if (node.isTextureNode) return "texture";
+	const t = node.nodeType;
+	return t && isUniformType(t) ? t : "float";
+}
+var makeUniform = TSL.uniform;
+/** Creates a uniform node with the type's baked-in default. The type is set
+* explicitly — otherwise `int`/`float` and `color`/`vec3` are indistinguishable
+* from the value. */
+function createUniformNode(type) {
+	switch (type) {
+		case "float": return makeUniform(1, "float");
+		case "int": return makeUniform(1, "int");
+		case "vec2": return makeUniform(new THREE.Vector2(1, 1), "vec2");
+		case "vec3": return makeUniform(new THREE.Vector3(1, 1, 1), "vec3");
+		case "vec4": return makeUniform(new THREE.Vector4(1, 1, 1, 1), "vec4");
+		case "color": return makeUniform(new THREE.Color(1, 1, 1), "color");
+		case "bool": return makeUniform(false, "bool");
+		case "texture": return TSL.texture(getDefaultResource(DefaultResourceId.Texture));
+	}
+}
+/** Default value per type — for `Property.setDefault` (value==default is not
+* serialized, restored on load). Factories, since Color/Vec are mutable. */
+var UNIFORM_DEFAULTS = {
+	float: () => 1,
+	int: () => 1,
+	vec2: () => ({
+		x: 1,
+		y: 1
+	}),
+	vec3: () => ({
+		x: 1,
+		y: 1,
+		z: 1
+	}),
+	vec4: () => ({
+		x: 1,
+		y: 1,
+		z: 1,
+		w: 1
+	}),
+	color: () => new THREE.Color(1, 1, 1),
+	bool: () => false,
+	texture: () => getDefaultResource(DefaultResourceId.Texture)
+};
+//#endregion
+//#region packages/world-runtime/src/settings/externals.ts
+var EXTERNAL_TYPES = ["umd", "module"];
+//#endregion
+//#region packages/world-runtime/src/rendering/renderer-options.ts
+/**
+* String names for renderer options set as words in the config and mapped to
+* THREE constants at runtime (game). Single source for the JSON schema
+* (`renderer.schema`) and the runtime mapping (`game`).
+*/
+var SHADOW_MAP_TYPES = [
+	"Basic",
+	"PCF",
+	"PCFSoft",
+	"VSM"
+];
+var BLOOM_MODES = ["threshold", "emissive"];
+var TONE_MAPPING_NAMES = [
+	"None",
+	"Linear",
+	"Reinhard",
+	"Cineon",
+	"ACESFilmic",
+	"AgX",
+	"Neutral"
+];
+//#endregion
+export { AddonsRuntime, AssetLoaders, AudioSource, BLOOM_MODES, BUILTIN_BEHAVIOURS, BUILTIN_BEHAVIOUR_LIST, DEFAULT_RESOURCE_IDS, DefaultResourceId, EXTERNAL_TYPES, EnvModule, FontSource, HtmlHudModule, InputSystemModule, LIBS, LIB_DESCRIPTORS, LIB_IDS, LOADING_MANAGER, LibId, MODULE_IDS, ModuleId, PHYSICS_ENGINES, RUNTIME_VERSION, SHADOW_MAP_TYPES, SceneBloom, SoundsModule, TONE_MAPPING_NAMES, TslNode, UNIFORM_DEFAULTS, UNIFORM_TYPES, UtilsModule, VideoSource, WORLD_FORMAT_VERSION, World, WorldEvent, applyRapierPhysicsPatch, applyRendererConfig, applyTextureDefaults, collectModelSubResources, configureAssetLoaders, createAudio, createFont, createTslNode, createUniformNode, createVideo, createWorldModules, defineWorld, enableSceneEmissiveMrt, fontFormatFromMime, getBuiltinBehaviour, getDefaultResource, getHalfheightRadiusScale, getRadiusScale, isDefaultResourceId, isMobileDevice, isUniformType, lazyRapier, libByRequireKey, loadGeometry, loadHdr, loadModel, loadTexture, normalizePhysics, parseGeometryJson, parseHdr, parseModel, setColor, uniformType };