@kvyverse/world-runtime 0.1.0 → 0.3.2

package/README.md

@@ -1,87 +1,105 @@
 # @kvyverse/world-runtime
 
 Runtime for worlds exported from [Kvyverse](https://kvyverse.com) — a web-based
-3D world editor. A world exported for self-hosting is a single generated JS
-module; this package is the engine that module runs on.
+3D world editor. When you export a world for self-hosting, Kvyverse gives you a
+generated JS module; this package is the engine that module runs on.
 
-You normally don't install this package by hand out of curiosity: it is only
-useful together with a world module built by the Kvyverse editor
-(`Export → Build for self-hosting`).
+Install it only together with such a module: on its own it does nothing.
 
-## Install
+## 1. Export the world from Kvyverse
 
-```
-npm i @kvyverse/world-runtime three three-start
-```
+In the editor: **burger menu → Export → Build for self-hosting**. You get a
+`<world>.zip` with `index.js` (the world) and `index.d.ts` (its types), plus a
+dialog with two ready-to-copy snippets — the install command and the import.
 
-All runtime dependencies are `peerDependencies`: the required ones (`howler`,
-`vanjs-core`, `eventemitter3`) are auto-installed by npm 7+, while optional
-ones (`@dimforge/rapier3d-compat` for physics, `@tweenjs/tween.js`, `animejs`)
-are only needed when the world uses them — the export dialog shows the exact
-install command for your world.
+## 2. Put the world into your project
 
-Requirements: ES modules, a bundler, WebGPU-capable browser
-(`three/webgpu` renderer).
+Unzip the folder into your sources, for example `src/my-world/`. Nothing else
+from the archive is needed: your bundler picks the module up like any local file.
 
-## Usage
+Asset files (models, textures, audio, fonts) are **not** in the archive — they
+stay on the Kvyverse CDN, and the module carries a table of their URLs.
 
-```js
-import { loadWorld } from "./my-world-3f9a1c02.js"; // file built by Kvyverse
+## 3. Install the dependencies
 
-const world = await loadWorld({ onProgress: (p) => console.log(p.stage) });
-world.mount(document.getElementById("app")); // canvas + render loop
-world.start(); // activates world behaviours
+Copy the command from the export dialog — it already lists exactly what your
+world needs and pins the runtime version the world was built with, for example:
+
+```
+npm i @kvyverse/world-runtime@<version> three three-start @dimforge/rapier3d-compat
 ```
 
-`World` extends `ThreeStart` (from `three-start`), so the standard lifecycle
-and context are available: `world.ctx.scene`, `world.ctx.camera`,
-`world.ctx.renderer`, `unmount()`, `runLoop()` / `stopLoop()`, `dispose()`.
-Extra: `world.getUrl(path)` resolves a world asset URL, `world.events` is the
-world lifecycle emitter.
+Everything the runtime needs is a **peer dependency**, so nothing is duplicated
+in your `node_modules`:
+
+| Package | When |
+| --- | --- |
+| `three`, `three-start` | always |
+| `howler`, `vanjs-core`, `eventemitter3` | always — npm 7+ installs them for you |
+| `@dimforge/rapier3d-compat` | worlds with physics |
+| `@tweenjs/tween.js`, `animejs`, `nipplejs` | worlds that enable these built-in libs |
 
-`loadWorld` options: `onProgress` callback, `dracoPath` (self-hosted Draco
-decoder folder; defaults to Google's public one), `assetsBaseUrl` (only for
-worlds built with relative asset paths).
+The optional ones are listed in the dialog only when the world actually uses
+them. Skip one it does need and the build fails with a clear
+`failed to resolve import` — install it and rebuild.
 
-Call `start()` after a user gesture if the world plays audio or captures the
-pointer — browser policies require it.
+Requirements for your project: ES modules, a bundler (Vite, webpack, Rollup, …),
+and a browser with WebGPU (the world renders through `three/webgpu`).
 
-## License
+## 4. Run it
 
-Proprietary, see [LICENSE.md](./LICENSE.md). In short: free to use (including
-commercially) **only to run worlds exported from Kvyverse**; no modification or
-redistribution; bundling the unmodified package into your app build is allowed.
+```js
+import { loadWorld } from "./my-world/index.js";
 
----
+const world = await loadWorld({
+	onProgress: (p) => console.log(p.stage), // optional loading screen
+});
 
-## Development (internal)
+world.mount(document.getElementById("app")); // creates the canvas, starts the render loop
+world.start();                               // activates the world's behaviours
+```
+
+`mount` and `start` are separate on purpose: you can show your own intro or wait
+for a click before the world comes alive. If the world plays audio or locks the
+pointer, call `start()` from a user gesture — browsers require it.
 
-The app consumes this package **from sources** via the path alias
-`@kvyverse/world-runtime` → `packages/world-runtime/src`; no build needed
-locally. `npm run build:world-runtime` from the repo root produces
-`dist/index.js` + `.d.ts`. The package is covered by the root `tsc -b` and
-`npm run lint`.
+### `loadWorld(options)`
 
-| Folder | Contents |
+| Option | What it does |
 | --- | --- |
-| `modules/` | three-start ctx modules (`env`, `html`, `input`, `sounds`, `utils`) + their contracts and the `ThreeStartRegister` augment. `createWorldModules(mode)` is the single registration point (used by the game too). |
-| `behaviours/` | Built-in behaviour classes (animation, controls, rapier physics), required patches, and the `uuid → class` registry — source of truth for the editor and the export. |
-| `resources/` | Lazy three loaders (`AssetLoaders`), resource factories (`loadTexture`, `parseModel`/`loadModel`, `collectModelSubResources`, `parseHdr`, `parseGeometryJson`, `createAudio`, `createVideo`, `createFont`), built-in resources with fixed uuids (`getDefaultResource`). |
-| `rendering/` | `SceneBloom` (+ MRT contracts), renderer config application, TSL node/uniform factories (`createTslNode`, `createUniformNode`). |
-| `settings/` | World config types (`RendererConfig`, `AddonsConfig`), lib/module registries, `AddonsRuntime`. |
-| `bootstrap.ts` | The world assembly order — the only place it is defined. |
-| `World.ts` / `WorldRuntime.ts` | `ThreeStart` subclass for the host and the runtime state owner (resources by path, `require`, script execution, styles/fonts, `world.events`). |
-| `world-events.ts` | `WorldEvent` lifecycle enum, shared with the game. |
+| `onProgress` | `({ stage, details }) => void` while the world loads — for your loading screen |
+| `dracoPath` | Folder with your own Draco decoder for compressed models; defaults to Google's public one |
+| `assetsBaseUrl` | Prefix for relative asset paths (only for worlds built that way) |
 
-Feature docs: [`/docs/self-hosted-export.md`](../../docs/self-hosted-export.md),
-maintenance rules: [`/docs/self-hosted-export-maintenance.md`](../../docs/self-hosted-export-maintenance.md).
+### The `world` object
 
-### Publishing
+`World` extends `ThreeStart` from `three-start`, so the usual lifecycle and
+context are yours:
 
+```js
+world.ctx.scene, world.ctx.camera, world.ctx.renderer
+world.unmount(), world.runLoop(), world.stopLoop(), world.dispose()
 ```
-npm run build:world-runtime
-cd packages/world-runtime && npm publish   # publishConfig.access = public
-```
 
-Versioning: exported worlds pin `^<version>` and update only via `npm update`,
-so breaking runtime changes require a major bump (see maintenance doc).
+On top of that: `world.getUrl(path)` resolves an asset URL the same way scripts
+inside the world do, and `world.events` is the world lifecycle emitter (the same
+`world.events` your scripts use).
+
+## Good to know
+
+- **Scripts, behaviours, materials and shaders** written in the editor are baked
+  into the module — no Kvyverse code runs at load time to interpret them.
+- **Re-exporting** a world overwrites the same folder with the same file names,
+  so your import never changes.
+- **Runtime version.** The module records the runtime version it was built with
+  and the world format version, and refuses to load on an incompatible runtime.
+  Re-export the world after a major runtime update.
+- **Not everything crosses over.** Platform features (multiplayer server, user
+  state, launcher worlds, the editor's debug overlay) stay in Kvyverse; the
+  export report lists whatever your particular world loses.
+
+## License
+
+Proprietary, see [LICENSE.md](./LICENSE.md). In short: free to use (including
+commercially) **only to run worlds exported from Kvyverse**; no modification or
+redistribution; bundling the unmodified package into your app build is allowed.

package/dist/{BallCollider-8ZrxReEd.js → BallCollider-3L5vOrcL.js}

@@ -1,5 +1,5 @@
-import { n as getRadiusScale } from "./get-scale-from-obj-QKv3Fig5.js";
-import { t as Collider } from "./Collider-4_rCTHVA.js";
+import { n as getRadiusScale } from "./get-scale-from-obj-B7JlVPni.js";
+import { t as Collider } from "./Collider-CPUCG3RA.js";
 //#region packages/world-runtime/src/behaviours/physics/BallCollider.ts
 var BallCollider = class extends Collider {
 	type = "Ball";

package/dist/{CapsuleCollider-bynyf6Mc.js → CapsuleCollider-CBTsR-Ys.js}

@@ -1,5 +1,5 @@
-import { t as getHalfheightRadiusScale } from "./get-scale-from-obj-QKv3Fig5.js";
-import { t as Collider } from "./Collider-4_rCTHVA.js";
+import { t as getHalfheightRadiusScale } from "./get-scale-from-obj-B7JlVPni.js";
+import { t as Collider } from "./Collider-CPUCG3RA.js";
 //#region packages/world-runtime/src/behaviours/physics/CapsuleCollider.ts
 var CapsuleCollider = class extends Collider {
 	type = "Capsule";

package/dist/ChatModule-2tiWS_Yr.js

@@ -0,0 +1,411 @@
+import { t as CHAT_COMMAND_KEY } from "./chat.module-descriptor-BTsep-Kq.js";
+import { ContextModule, ThreeContextEvents } from "three-start";
+import van from "vanjs-core";
+//#region packages/world-runtime/src/modules/chat/chat.css?inline
+var chat_default = "/* Neutral base for the chat input: only what it breaks without on real devices.\n   Looks are left to the world. */\n\n.kvy-chat {\n	position: absolute;\n	left: 0;\n	bottom: 0;\n	width: 100%;\n	box-sizing: border-box;\n	display: flex;\n	flex-direction: column;\n	justify-content: flex-end;\n	/* On-screen keyboard: ChatDom writes the overlap height here. */\n	padding-bottom: var(--kvy-chat-keyboard-inset, 0px);\n	/* Click-through like the HUD around it: the root stretches over the whole feed,\n	   so catching events here would kill clicks on the world behind the messages.\n	   Only the input takes events back. */\n	pointer-events: none;\n}\n\n.kvy-chat__form {\n	display: flex;\n	margin: 0;\n}\n\n.kvy-chat__input {\n	flex: 1 1 auto;\n	min-width: 0;\n	/* 16px — below that iOS Safari zooms the page on focus. */\n	font: inherit;\n	font-size: 16px;\n	line-height: 1.25;\n	color: inherit;\n	background: transparent;\n	border: 0;\n	outline: none;\n	padding: 4px 6px;\n	-webkit-appearance: none;\n	appearance: none;\n	border-radius: 0;\n	/* The one interactive part of the chat. */\n	pointer-events: auto;\n	/* No 300ms delay and no double-tap zoom on the input. */\n	touch-action: manipulation;\n}\n\n/* The message feed is a TTL queue, not a scroll container. It sticks to the\n   bottom and extra lines are cut from the top — no scrollbar here by design. */\n.kvy-chat__feed {\n	display: flex;\n	flex-direction: column;\n	justify-content: flex-end;\n	max-height: 40vh;\n	overflow: hidden;\n	/* Belt and braces: the root is already click-through, but a world restyling it\n	   must not accidentally make messages catch clicks. */\n	pointer-events: none;\n}\n\n.kvy-chat__line {\n	opacity: 1;\n	transition: opacity 300ms ease;\n	overflow-wrap: anywhere;\n}\n\n/* The line has outlived its time: it fades but stays in the DOM — opening the\n   chat shows it again instead of rebuilding the feed. */\n.kvy-chat__line--faded {\n	opacity: 0;\n}\n\n/* Hidden submit button: backs up implicit submission in old webviews. */\n.kvy-chat__submit {\n	position: absolute;\n	width: 1px;\n	height: 1px;\n	padding: 0;\n	margin: -1px;\n	overflow: hidden;\n	clip-path: inset(50%);\n	white-space: nowrap;\n	border: 0;\n}\n\n/* Toggle mode: the input is hidden until entered (Enter on the canvas).\n   Opacity, not visibility/display: an element hidden by those cannot be focused\n   programmatically, leaving nothing to open the chat with. */\n.kvy-chat--idle-hidden .kvy-chat__input {\n	opacity: 0;\n	pointer-events: none;\n}\n";
+//#endregion
+//#region packages/world-runtime/src/modules/chat/ChatDom.ts
+var { button, div, form, input } = van.tags;
+var STYLE_ID = "kvyverse-chat-styles";
+/**
+* Chat DOM: the message feed plus the input field.
+*
+* Built to survive real devices: submit through a `<form>` (Enter/Go/Send on any
+* mobile keyboard), an IME composition guard, and lifting above the on-screen
+* keyboard via `visualViewport`. Details —
+* `./README.md`.
+*/
+var ChatDom = class ChatDom {
+	root;
+	feed;
+	form;
+	input;
+	_options;
+	_lines = [];
+	_isComposing = false;
+	_viewportRaf = 0;
+	_mounted = false;
+	constructor(options = {}) {
+		this._options = options;
+		this.input = input({
+			class: "kvy-chat__input",
+			type: "text",
+			enterkeyhint: "send",
+			inputmode: "text",
+			autocomplete: "off",
+			"aria-label": "Chat message",
+			placeholder: options.placeholder ?? "",
+			...options.maxLength ? { maxlength: String(options.maxLength) } : {}
+		});
+		this.input.spellcheck = false;
+		this.input.setAttribute("autocorrect", "off");
+		this.input.setAttribute("autocapitalize", "sentences");
+		this.form = form({
+			class: "kvy-chat__form",
+			novalidate: true
+		}, this.input, button({
+			class: "kvy-chat__submit",
+			type: "submit",
+			tabindex: "-1"
+		}, "Send"));
+		this.feed = div({ class: "kvy-chat__feed" });
+		this.root = div({ class: "kvy-chat" }, this.feed, this.form);
+	}
+	/** The focus policy is only known at runtime (mobile/desktop, canvas). */
+	setFocusPolicy(policy) {
+		this._options.keepFocusAfterSubmit = policy.keepFocusAfterSubmit;
+		this._options.returnFocusTo = policy.returnFocusTo;
+	}
+	get isMounted() {
+		return this._mounted;
+	}
+	/** Whether to hide the input while unfocused (`toggle` mode). */
+	setHideWhenIdle(hide) {
+		this._options.hideWhenIdle = hide;
+		this._syncVisibility();
+	}
+	get isFocused() {
+		return document.activeElement === this.input;
+	}
+	get value() {
+		return this.input.value;
+	}
+	set value(next) {
+		this.input.value = next;
+	}
+	/**
+	* Syncs the feed with the history: new lines are appended at the bottom, lines
+	* gone from the history are removed, extra ones are cut from the top. There is
+	* no scrolling — what does not fit is not shown.
+	*/
+	renderMessages(messages) {
+		const byId = new Map(this._lines.map((line) => [line.id, line]));
+		const next = [];
+		for (const message of messages.slice(-this._maxLines)) {
+			const existing = byId.get(message.id);
+			if (existing) {
+				byId.delete(message.id);
+				next.push(existing);
+				continue;
+			}
+			next.push(this._createLine(message));
+		}
+		for (const stale of byId.values()) this._removeLine(stale);
+		this.feed.replaceChildren(...next.map((line) => line.el));
+		this._lines = next;
+		this._syncLines();
+	}
+	mount(container) {
+		if (this._mounted) return;
+		ChatDom._ensureStyles();
+		container.append(this.root);
+		this._bind();
+		this._mounted = true;
+		this._syncVisibility();
+		this._syncKeyboardInset();
+	}
+	unmount() {
+		if (!this._mounted) return;
+		this._unbind();
+		this.root.remove();
+		this._mounted = false;
+	}
+	focus() {
+		this.input.focus({ preventScroll: true });
+		const end = this.input.value.length;
+		this.input.setSelectionRange(end, end);
+	}
+	blur() {
+		this.input.blur();
+	}
+	clear() {
+		this.input.value = "";
+	}
+	dispose() {
+		this.unmount();
+		for (const line of this._lines) this._removeLine(line);
+		this._lines = [];
+	}
+	/** Keep in the DOM as much as an opened chat could need. */
+	get _maxLines() {
+		return Math.max(this._options.visibleLines ?? 10, this._options.openedLines ?? 20);
+	}
+	_createLine(message) {
+		const fadeAfter = this._options.fadeAfter ?? 1e4;
+		return {
+			id: message.id,
+			el: div({ class: "kvy-chat__line" }, message.text),
+			deadline: fadeAfter > 0 ? message.timestamp + fadeAfter : Infinity,
+			timer: 0,
+			faded: false
+		};
+	}
+	_removeLine(line) {
+		if (line.timer) clearTimeout(line.timer);
+		line.el.remove();
+	}
+	/**
+	* While the input is focused more lines are shown, including expired ones (an
+	* opened chat is meant to be read). Once closed, every line lives by its own
+	* deadline again: expired ones fade at once, the rest sit out their remainder.
+	*/
+	_syncLines() {
+		const opened = this.isFocused;
+		const visible = opened ? this._options.openedLines ?? 20 : this._options.visibleLines ?? 10;
+		const offscreen = this._lines.length - visible;
+		this._lines.forEach((line, index) => {
+			line.el.style.display = index < offscreen ? "none" : "";
+		});
+		const now = Date.now();
+		for (const line of this._lines) {
+			if (line.timer) {
+				clearTimeout(line.timer);
+				line.timer = 0;
+			}
+			if (opened) {
+				this._setFaded(line, false);
+				continue;
+			}
+			const remaining = line.deadline - now;
+			if (remaining <= 0) {
+				this._setFaded(line, true);
+				continue;
+			}
+			this._setFaded(line, false);
+			if (remaining === Infinity) continue;
+			line.timer = window.setTimeout(() => {
+				line.timer = 0;
+				this._setFaded(line, true);
+			}, remaining);
+		}
+	}
+	_setFaded(line, faded) {
+		if (line.faded === faded) return;
+		line.faded = faded;
+		line.el.classList.toggle("kvy-chat__line--faded", faded);
+	}
+	_bind() {
+		this.form.addEventListener("submit", this._onSubmit);
+		this.input.addEventListener("compositionstart", this._onCompositionStart);
+		this.input.addEventListener("compositionend", this._onCompositionEnd);
+		this.input.addEventListener("beforeinput", this._onBeforeInput);
+		this.input.addEventListener("keydown", this._onKeyDown);
+		this.input.addEventListener("keyup", this._stopPropagation);
+		this.input.addEventListener("focus", this._onFocus);
+		this.input.addEventListener("blur", this._onBlur);
+		const vv = window.visualViewport;
+		if (vv) {
+			vv.addEventListener("resize", this._onViewportChange);
+			vv.addEventListener("scroll", this._onViewportChange);
+		}
+	}
+	_unbind() {
+		this.form.removeEventListener("submit", this._onSubmit);
+		this.input.removeEventListener("compositionstart", this._onCompositionStart);
+		this.input.removeEventListener("compositionend", this._onCompositionEnd);
+		this.input.removeEventListener("beforeinput", this._onBeforeInput);
+		this.input.removeEventListener("keydown", this._onKeyDown);
+		this.input.removeEventListener("keyup", this._stopPropagation);
+		this.input.removeEventListener("focus", this._onFocus);
+		this.input.removeEventListener("blur", this._onBlur);
+		const vv = window.visualViewport;
+		if (vv) {
+			vv.removeEventListener("resize", this._onViewportChange);
+			vv.removeEventListener("scroll", this._onViewportChange);
+		}
+		if (this._viewportRaf) {
+			cancelAnimationFrame(this._viewportRaf);
+			this._viewportRaf = 0;
+		}
+	}
+	_onSubmit = (e) => {
+		e.preventDefault();
+		if (this._isComposing) return;
+		const text = this.input.value.trim();
+		this.clear();
+		if (!text) return;
+		this._options.onSubmit?.(text);
+		if (this._options.keepFocusAfterSubmit) {
+			this.focus();
+			return;
+		}
+		this.blur();
+		this._options.returnFocusTo?.focus({ preventScroll: true });
+	};
+	_onCompositionStart = () => {
+		this._isComposing = true;
+	};
+	_onCompositionEnd = () => {
+		this._isComposing = false;
+	};
+	/** Some Android keyboards send no Enter keydown, only `insertLineBreak`. */
+	_onBeforeInput = (e) => {
+		if (e.inputType !== "insertLineBreak") return;
+		e.preventDefault();
+		this.form.requestSubmit();
+	};
+	_onKeyDown = (e) => {
+		e.stopPropagation();
+		if (e.key !== "Escape") return;
+		this.blur();
+		this._options.returnFocusTo?.focus({ preventScroll: true });
+	};
+	_stopPropagation = (e) => {
+		e.stopPropagation();
+	};
+	_onFocus = () => {
+		this._options.onFocusChange?.(true);
+		this._syncVisibility();
+		this._syncLines();
+		this._syncKeyboardInset();
+	};
+	_onBlur = () => {
+		this._options.onFocusChange?.(false);
+		this._syncVisibility();
+		this._syncLines();
+		this._syncKeyboardInset();
+	};
+	/** In `toggle` mode a hidden input must catch neither clicks nor tab focus. */
+	_syncVisibility() {
+		const hidden = !!this._options.hideWhenIdle && !this.isFocused;
+		this.root.classList.toggle("kvy-chat--idle-hidden", hidden);
+		this.input.tabIndex = hidden ? -1 : 0;
+	}
+	_onViewportChange = () => {
+		if (this._viewportRaf) return;
+		this._viewportRaf = requestAnimationFrame(() => {
+			this._viewportRaf = 0;
+			this._syncKeyboardInset();
+		});
+	};
+	/**
+	* The keyboard changes the layout viewport neither on iOS nor (by default) on
+	* Android — anything fixed to the bottom ends up underneath it. We measure the
+	* overlap through `visualViewport` and lift the chat by that much.
+	*/
+	_syncKeyboardInset() {
+		const vv = window.visualViewport;
+		if (!vv) return;
+		const overlap = Math.max(0, window.innerHeight - (vv.height + vv.offsetTop));
+		this.root.style.setProperty("--kvy-chat-keyboard-inset", `${Math.round(overlap)}px`);
+	}
+	/** Styles are inlined once per document: the package ships no separate css file. */
+	static _ensureStyles() {
+		if (document.getElementById(STYLE_ID)) return;
+		const style = document.createElement("style");
+		style.id = STYLE_ID;
+		style.textContent = chat_default;
+		document.head.append(style);
+	}
+};
+//#endregion
+//#region packages/world-runtime/src/modules/chat/ChatModule.ts
+/**
+* The world chat as a pluggable ctx module: message history plus its own DOM
+* input (`dom`), no React. Enabled from `settings.addons.json → modules`; it
+* mounts its DOM itself. Details and mobile quirks — `./README.md`.
+*/
+var ChatModule = class extends ContextModule {
+	dom;
+	_maxMessages;
+	_openKeys;
+	_messages = [];
+	_seq = 0;
+	constructor(config) {
+		super();
+		this._maxMessages = config.maxMessages;
+		this._openKeys = config.openKeys;
+		this.dom = new ChatDom({
+			placeholder: config.placeholder,
+			maxLength: config.maxLength,
+			hideWhenIdle: config.input === "toggle",
+			visibleLines: config.visibleLines,
+			openedLines: config.openedLines,
+			fadeAfter: config.fadeAfter,
+			onSubmit: (text) => this.send(text),
+			onFocusChange: (focused) => this.emit("inputfocuschanged", focused)
+		});
+	}
+	get messages() {
+		return this._messages;
+	}
+	onAwake() {
+		const ctx = this.ctx;
+		const isMobile = ctx.modules.env.isMobile;
+		this.dom.setFocusPolicy({
+			keepFocusAfterSubmit: isMobile,
+			returnFocusTo: ctx.renderer.domElement
+		});
+		if (isMobile) this.dom.setHideWhenIdle(false);
+		ctx.modules.input.on("keydown", this._onKeyDown);
+		if (ctx.canvasContainer) this._onMount(ctx.canvasContainer);
+		ctx.on(ThreeContextEvents.Mount, this._onMount);
+		ctx.on(ThreeContextEvents.Unmount, this._onUnmount);
+	}
+	/** Print a line into the feed as is. */
+	print(text) {
+		this._messages.push(this._createMessage(text));
+		if (this._messages.length > this._maxMessages) this._messages = this._messages.slice(-this._maxMessages);
+		this._emitChanged();
+	}
+	/**
+	* Send a line the way a player does: commands are handled here, everything else
+	* goes out as `sent`. It prints nothing by itself — what to show is up to the world.
+	*/
+	send(text) {
+		const value = text.trim();
+		if (!value) return;
+		if (value === "/clear") {
+			this.clear();
+			return;
+		}
+		this.emit("sent", value);
+	}
+	/** Redraw the whole feed — animation frames, tables, ASCII art. */
+	setMessages(texts) {
+		const tail = texts.length > this._maxMessages ? texts.slice(-this._maxMessages) : texts;
+		this._messages = tail.map((text) => this._createMessage(text));
+		this._emitChanged();
+	}
+	clear() {
+		this._messages = [];
+		this._emitChanged();
+	}
+	_emitChanged() {
+		this.dom.renderMessages(this._messages);
+		this.emit("changed", this._messages);
+	}
+	_createMessage(text) {
+		return {
+			id: `m${++this._seq}`,
+			text: text.trim(),
+			timestamp: Date.now()
+		};
+	}
+	/** three-start ContextModule has no onDestroy; teardown is explicit. */
+	dispose() {
+		const ctx = this.ctx;
+		ctx.modules.input.off("keydown", this._onKeyDown);
+		ctx.off(ThreeContextEvents.Mount, this._onMount);
+		ctx.off(ThreeContextEvents.Unmount, this._onUnmount);
+		this.dom.dispose();
+	}
+	_onKeyDown = (e) => {
+		if (e.repeat) return;
+		if (!this.dom.isMounted || this.dom.isFocused) return;
+		const isCommandKey = e.code === CHAT_COMMAND_KEY;
+		if (!isCommandKey && !this._openKeys.includes(e.code)) return;
+		e.preventDefault();
+		if (isCommandKey) this.dom.value = "/";
+		this.dom.focus();
+	};
+	_onMount = (container) => {
+		this.dom.mount(container);
+		this.dom.renderMessages(this._messages);
+	};
+	_onUnmount = () => {
+		this.dom.unmount();
+	};
+};
+//#endregion
+export { ChatModule };

package/dist/{Collider-4_rCTHVA.js → Collider-CPUCG3RA.js}

@@ -1,7 +1,7 @@
-import { t as Rigidbody } from "./Rigidbody-b7QNF4ev.js";
+import { t as Rigidbody } from "./Rigidbody-DLhN8ddv.js";
 import * as THREE from "three/webgpu";
 import { Object3DBehaviour, assertDefined, getComponents } from "three-start";
-//#region packages/world-runtime/src/behaviours/physics/rapier-addon-core/Collider.ts
+//#region packages/world-runtime/src/behaviours/physics/Collider.ts
 /** Walk the parent chain (ancestors only); stop when `cb` returns `false`. */
 function traverseUp(obj, cb) {
 	let cur = obj.parent;

package/dist/{ConeCollider-DtRZmgK8.js → ConeCollider-C3XU3Y9X.js}

@@ -1,5 +1,5 @@
-import { t as getHalfheightRadiusScale } from "./get-scale-from-obj-QKv3Fig5.js";
-import { t as Collider } from "./Collider-4_rCTHVA.js";
+import { t as getHalfheightRadiusScale } from "./get-scale-from-obj-B7JlVPni.js";
+import { t as Collider } from "./Collider-CPUCG3RA.js";
 //#region packages/world-runtime/src/behaviours/physics/ConeCollider.ts
 var ConeCollider = class extends Collider {
 	type = "Cone";

package/dist/{ConvexMeshCollider-BSmDM4o3.js → ConvexMeshCollider-DzNV4HTO.js}

@@ -1,4 +1,4 @@
-import { t as Collider } from "./Collider-4_rCTHVA.js";
+import { t as Collider } from "./Collider-CPUCG3RA.js";
 //#region packages/world-runtime/src/behaviours/physics/ConvexMeshCollider.ts
 var ConvexMeshCollider = class extends Collider {
 	type = "Convex";

package/dist/{CuboidCollider-CJvq7--s.js → CuboidCollider-Dp1DZoFM.js}

@@ -1,4 +1,4 @@
-import { t as Collider } from "./Collider-4_rCTHVA.js";
+import { t as Collider } from "./Collider-CPUCG3RA.js";
 //#region packages/world-runtime/src/behaviours/physics/CuboidCollider.ts
 var CuboidCollider = class extends Collider {
 	type = "Cuboid";

package/dist/{CylinderCollider-CQPSh4tu.js → CylinderCollider-C0h_nhB5.js}

@@ -1,5 +1,5 @@
-import { t as getHalfheightRadiusScale } from "./get-scale-from-obj-QKv3Fig5.js";
-import { t as Collider } from "./Collider-4_rCTHVA.js";
+import { t as getHalfheightRadiusScale } from "./get-scale-from-obj-B7JlVPni.js";
+import { t as Collider } from "./Collider-CPUCG3RA.js";
 //#region packages/world-runtime/src/behaviours/physics/CylinderCollider.ts
 var CylinderCollider = class extends Collider {
 	type = "Cylinder";

package/dist/{FpsCameraController-BE2EirRj.js → FpsCameraController-2GNWJM5D.js}

@@ -11,7 +11,7 @@ var FpsCameraController = class extends Object3DBehaviour {
 		let isDragging = false;
 		let prevX = 0;
 		let prevY = 0;
-		const isMobile = !!this.modules.input.player.mode;
+		const isMobile = this.modules.env.isMobile;
 		const sensitivity = isMobile ? this.mobileSensitivity : this.sensitivity;
 		const inverted = isMobile && this.useInvertedOnMobile ? true : this.inverted;
 		const onMouseDown = (e) => {