@kvyverse/world-runtime 0.1.0 → 0.3.2

package/dist/RapierDebugRenderer-BQy_m-3C.js

@@ -0,0 +1,73 @@
+import * as THREE from "three/webgpu";
+//#region packages/world-runtime/src/modules/physics/RapierDebugRenderer.ts
+/**
+* Draws rapier colliders as lines. Not a ctx module: it lives inside
+* `RapierPhysics` (`enableDebug`/`disableDebug`) and is pulled dynamically —
+* worlds without debug never load this code.
+*
+* @see {@link https://github.com/vladkrutenyuk/three-kvy-core/blob/main/src/addons/RapierDebugRenderer.ts | Source}
+*/
+var RapierDebugRenderer = class {
+	_ctx;
+	_rapier;
+	_clear = null;
+	constructor(ctx, rapier) {
+		this._ctx = ctx;
+		this._rapier = rapier;
+	}
+	get enabled() {
+		return !!this._clear;
+	}
+	start() {
+		if (this._clear) return;
+		const geometry = new THREE.BufferGeometry();
+		const lines = new THREE.LineSegments(geometry, new THREE.LineBasicMaterial({
+			vertexColors: true,
+			toneMapped: false
+		}));
+		lines.frustumCulled = false;
+		lines.renderOrder = Number.MAX_SAFE_INTEGER;
+		this._ctx.scene.add(lines);
+		let positionAttr = null;
+		let colorAttr = null;
+		const rapier = this._rapier;
+		const draw = () => {
+			const { vertices, colors } = rapier.world.debugRender();
+			const vertexCount = vertices.length / 3;
+			if (!positionAttr || positionAttr.array.length < vertices.length) {
+				positionAttr = new THREE.BufferAttribute(new Float32Array(vertices.length), 3);
+				positionAttr.setUsage(THREE.DynamicDrawUsage);
+				geometry.setAttribute("position", positionAttr);
+				colorAttr = new THREE.BufferAttribute(new Float32Array(vertexCount * 3), 3);
+				colorAttr.setUsage(THREE.DynamicDrawUsage);
+				geometry.setAttribute("color", colorAttr);
+			}
+			const positions = positionAttr.array;
+			const colorValues = colorAttr.array;
+			positions.set(vertices);
+			for (let i = 0; i < vertexCount; i++) {
+				colorValues[i * 3] = colors[i * 4] ?? 1;
+				colorValues[i * 3 + 1] = colors[i * 4 + 1] ?? 1;
+				colorValues[i * 3 + 2] = colors[i * 4 + 2] ?? 1;
+			}
+			positionAttr.needsUpdate = true;
+			colorAttr.needsUpdate = true;
+			geometry.setDrawRange(0, vertexCount);
+		};
+		rapier.on("stepafter", draw);
+		this._clear = () => {
+			rapier.off("stepafter", draw);
+			lines.removeFromParent();
+			geometry.dispose();
+			lines.material.dispose();
+			positionAttr = null;
+			colorAttr = null;
+			this._clear = null;
+		};
+	}
+	stop() {
+		this._clear?.();
+	}
+};
+//#endregion
+export { RapierDebugRenderer, RapierDebugRenderer as default };

package/dist/{RapierFpsPlayerController-VsNfQl6v.js → RapierFpsPlayerController-DthD8dw9.js}

@@ -61,29 +61,12 @@ var RapierFpsPlayerController = class extends Object3DBehaviour {
 		const kcc = this.kcc;
 		const col = this.col;
 		const dt = this.getDt();
-		const input = this.modules.input;
+		const controls = this.modules.controls;
 		const dir = this._inputDir;
-		dir.setScalar(0);
-		const playerInput = input.player;
-		let speed = this.walkSpeed;
-		switch (playerInput.mode) {
-			case 0: {
-				const keys = input.isKeyDown;
-				if (keys("KeyW") || keys("ArrowUp")) dir.z -= 1;
-				if (keys("KeyS") || keys("ArrowDown")) dir.z += 1;
-				if (keys("KeyA") || keys("ArrowLeft")) dir.x -= 1;
-				if (keys("KeyD") || keys("ArrowRight")) dir.x += 1;
-				if (this.useShiftRun && input.shiftKey) speed = this.runSpeed;
-				break;
-			}
-			case 1: {
-				const { forward, lateral, force } = input.player;
-				dir.z -= forward;
-				dir.x += lateral;
-				speed = force > 2 ? THREE.MathUtils.lerp(this.walkSpeed, this.runSpeed, THREE.MathUtils.clamp(force - 2, 0, 1.5)) : this.walkSpeed;
-				break;
-			}
-		}
+		dir.set(controls.move.x, 0, -controls.move.y);
+		const analog = THREE.MathUtils.clamp(controls.force - 2, 0, 1);
+		const running = this.useShiftRun && controls.run;
+		const speed = THREE.MathUtils.lerp(this.walkSpeed, this.runSpeed, running ? 1 : analog);
 		dir.normalize();
 		const camera = this.ctx.camera;
 		if (dir.lengthSq() > 0) {

package/dist/{RapierPhysics-C_3b7QOn.js → RapierPhysics-zLwVZpwF.js}

@@ -1,10 +1,5 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { ContextModule, ThreeContextEvents, defineProps, readOnly } from "three-start";
-//#region packages/world-runtime/src/behaviours/physics/rapier-addon-core/RapierPhysics.ts
-var RapierPhysics_exports = /* @__PURE__ */ __exportAll({
-	RapierPhysics: () => RapierPhysics,
-	default: () => RapierPhysics
-});
+//#region packages/world-runtime/src/modules/physics/RapierPhysics.ts
 var RapierPhysics = class RapierPhysics extends ContextModule {
 	isRapierPhysics;
 	api;
@@ -13,24 +8,33 @@ var RapierPhysics = class RapierPhysics extends ContextModule {
 	/** @default "vary" */
 	timeStep;
 	_steppingState = { accumulator: 0 };
-	constructor(Rapier, options = {}) {
+	_debug = null;
+	_debugOnStart;
+	_gravity;
+	constructor(options = {}) {
 		super();
 		const { timeStep = "vary", gravity = [
 			0,
 			-9.81,
 			0
-		] } = options;
-		const world = new Rapier.World({
-			x: gravity[0],
-			y: gravity[1],
-			z: gravity[2]
-		});
+		], debug = false } = options;
+		this._debugOnStart = debug;
+		this._gravity = gravity;
 		this.timeStep = timeStep;
+	}
+	onAwake() {
+		const Rapier = this.modules.addons.rapier;
+		if (!Rapier) throw new Error("RapierPhysics: the physics engine is not loaded — `addons` has no rapier");
+		const [x, y, z] = this._gravity;
 		console.log(`Rapier version: ${Rapier.version()}`);
 		defineProps(this, {
 			isRapierPhysics: readOnly(true),
 			api: readOnly(Rapier),
-			world: readOnly(world),
+			world: readOnly(new Rapier.World({
+				x,
+				y,
+				z
+			})),
 			eventQueue: readOnly(new Rapier.EventQueue(false))
 		});
 	}
@@ -40,10 +44,24 @@ var RapierPhysics = class RapierPhysics extends ContextModule {
 				this.ctx.on(ThreeContextEvents.RenderBefore, this.update);
 			});
 		});
+		if (this._debugOnStart) this.enableDebug();
+	}
+	/** Whether collider outlines are being drawn right now. */
+	get isDebugEnabled() {
+		return !!this._debug?.enabled;
+	}
+	/** Turn on collider debug drawing; the renderer is fetched on demand. */
+	async enableDebug() {
+		this._debug ??= new (await (import("./RapierDebugRenderer-BQy_m-3C.js"))).RapierDebugRenderer(this.ctx, this);
+		this._debug.start();
+	}
+	disableDebug() {
+		this._debug?.stop();
 	}
 	/** three-start ContextModule has no onDestroy; teardown is explicit. */
 	dispose() {
 		this.ctx.off(ThreeContextEvents.RenderBefore, this.update);
+		this.disableDebug();
 	}
 	update = () => {
 		const steppingState = this._steppingState;
@@ -71,4 +89,4 @@ var RapierPhysics = class RapierPhysics extends ContextModule {
 	}
 };
 //#endregion
-export { RapierPhysics_exports as n, RapierPhysics as t };
+export { RapierPhysics, RapierPhysics as default };

package/dist/{Rigidbody-b7QNF4ev.js → Rigidbody-DLhN8ddv.js}

@@ -1,6 +1,17 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import * as THREE from "three/webgpu";
 import { Object3DBehaviour, assertDefined, defineProps, readOnly } from "three-start";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
 //#region packages/world-runtime/src/behaviours/physics/Rigidbody.ts
 var Rigidbody_exports = /* @__PURE__ */ __exportAll({ default: () => Rigidbody });
 /**

package/dist/World.d.ts

@@ -10,8 +10,8 @@ import type { WorldRuntime } from "./WorldRuntime";
 export declare class World extends ThreeStart {
     private readonly _runtime;
     constructor(options: ThreeStartOptions, _runtime: WorldRuntime);
-    /** Asset URL by project path — same resolving as `getUrl` in scripts. */
-    getUrl: (path: string) => string;
+    /** Asset URL by project path or resource — same resolving as `getUrl` in scripts. */
+    getUrl: (source: string | object) => string;
     /** World lifecycle event bus — the same one as `world.events` in scripts. */
     get events(): WorldRuntime["emitter"];
     start(): this;

package/dist/WorldRuntime.d.ts

@@ -1,10 +1,11 @@
 import EventEmitter from "eventemitter3";
 import * as THREE from "three/webgpu";
+import { AddonsRuntime } from "./addons/AddonsRuntime";
 import type { Object3DBehaviourConstructor, ThreeContext, ThreeStart } from "three-start";
 import type { SceneBloom } from "./rendering/SceneBloom";
 import type { LoadWorldOptions, RuntimeApi, WorldDefinition } from "./types";
 /** Slice of the world definition the runtime needs: independent of the asset bag type. */
-export type RuntimeDefinitionSlice = Pick<WorldDefinition, "assets" | "scripts" | "entryScript" | "styles" | "fontPaths" | "usedBuiltins" | "addons">;
+export type RuntimeDefinitionSlice = Pick<WorldDefinition, "assets" | "scripts" | "entryScript" | "styles" | "fontPaths" | "usedBuiltins" | "addons" | "imports">;
 /**
  * Owner of the world's runtime state: assets, script execution, ctx access.
  * The only object the generated code receives.
@@ -19,22 +20,29 @@ export declare class WorldRuntime implements RuntimeApi {
     private readonly _builtins;
     private readonly _styleElements;
     private _resources;
+    /** Reverse index for `getUrl(resource)` — play mode resolves objects too. */
+    private readonly _pathByResource;
     private _ctx;
     private _bloom;
     private _scriptContext;
     constructor(definition: RuntimeDefinitionSlice, options: LoadWorldOptions);
+    /** The world's external dependencies; also the `addons` ctx module. */
+    get addons(): AddonsRuntime;
     /** ctx appears at the 3d-context creation step; unavailable to scripts before that. */
     get ctx(): ThreeContext;
     /** @internal Set by bootstrap. */
     setContext(ctx: ThreeContext): void;
     /** @internal World bloom, if enabled in the renderer config. */
     setBloom(bloom: SceneBloom): void;
-    /** @internal Built-in libs and external scripts from `settings.addons.json`. */
+    /** @internal Built-in libs, externals and the physics engine, if the world needs one. */
     loadAddons(): Promise<void>;
+    /** Physics is on in the config, or a built-in behaviour on the scene needs it. */
+    private _usesPhysics;
     /** @internal World resources by asset path — result of `loadAssets`. */
     setResources(resources: Record<string, unknown>): void;
     reportProgress(stage: string, details?: string): void;
-    getUrl: (path: string) => string;
+    /** Accepts an asset path or a resource returned by `require` — like play mode. */
+    getUrl: (source: string | object) => string;
     /**
      * Built-in behaviour class by uuid. Classes are preloaded by bootstrap,
      * so attaching in `buildScene` is synchronous.
@@ -52,7 +60,8 @@ export declare class WorldRuntime implements RuntimeApi {
     require: (key: string) => unknown;
     /**
      * Runtime spawn: a prefab (build-time factory) is assembled anew, a regular
-     * object is cloned. Returns a detached object — the caller adds it.
+     * object is cloned. The instance is only created and returned — adding it to
+     * the scene hierarchy is up to the caller (`ctx.scene.add(obj)`).
      */
     instantiate: (source: THREE.Object3D | PrefabFactory, options?: InstantiateOptions) => THREE.Object3D;
     /** Runs a script once and caches its `output`. The cache entry is set before

package/dist/addons/AddonsRuntime.d.ts

@@ -0,0 +1,35 @@
+import { ContextModule } from "three-start";
+import type { AddonsModuleApi } from "../modules/contracts/addons.module-api";
+import type { AddonsConfig, WorldImports } from "./types";
+import type RAPIER from "@dimforge/rapier3d-compat";
+/**
+ * External dependencies of the world: built-in libs, externals and the physics
+ * engine. Loaded before the world starts; scripts reach them through
+ * `resolve(key)` (`require`), the physics module through `rapier`.
+ *
+ * This is the `addons` ctx module, but it also works without a ctx: launcher
+ * worlds have no 3d context while `require` still has to work, so there the
+ * instance is used directly. How to import packages is up to the runtime owner
+ * (see `WorldImports`).
+ */
+export declare class AddonsRuntime extends ContextModule implements AddonsModuleApi {
+    private readonly _imports;
+    /** libs — by requireKey (`@tweenjs/tween.js`), externals — by accessor (`Tone`). */
+    private readonly _byKey;
+    private readonly _scriptTags;
+    private _rapier;
+    constructor(_imports?: WorldImports);
+    /** `physics` — whether the world needs rapier (config or a physics behaviour). */
+    load(addons: AddonsConfig, options?: {
+        physics?: boolean;
+    }): Promise<void>;
+    /** Resolves a require key: enabled lib or external accessor; undefined otherwise. */
+    resolve(key: string): unknown;
+    /** The physics engine, loaded and initialized; `null` in worlds without physics. */
+    get rapier(): typeof RAPIER | null;
+    private _loadLibs;
+    private _loadRapier;
+    private _loadExternals;
+    private _mountScript;
+    dispose(): void;
+}

package/dist/addons/lib-registry.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 — and the import specifier
+ * importers are built from). Single source for:
+ *  - game: the app's importer map (`core/game/settings/optional-imports`),
+ *  - export: the `imports.libs` block the build emits into the world module,
+ *  - editor: JSON schema (`libs` props) + require typings (`AddonsRequireTypings`).
+ *
+ * Adding a lib = add an entry here (+ importer in the app, + d.ts loader in editor).
+ * The package itself never imports these — see `./optional-imports.ts`.
+ */
+export declare enum LibId {
+    Tween = "tween",
+    Anime = "anime",
+    Nipplejs = "nipplejs",
+    Stats = "stats"
+}
+export interface LibDescriptor {
+    readonly id: LibId;
+    /** Key the user gets the lib by: `require("<requireKey>")`. It is also the
+     *  import specifier — importers are generated from it. */
+    readonly requireKey: string;
+    readonly label: string;
+    /** npm package to install; defaults to `requireKey` (differs for subpaths). */
+    readonly packageName?: string;
+    /** The package exposes its API as the default export — unwrap it on load. */
+    readonly defaultExport?: boolean;
+}
+export declare const LIBS: Readonly<Record<LibId, LibDescriptor>>;
+export declare const LIB_IDS: LibId[];
+export declare const LIB_DESCRIPTORS: LibDescriptor[];
+export declare function libByRequireKey(requireKey: string): LibDescriptor | undefined;

package/dist/addons/types.d.ts

@@ -0,0 +1,28 @@
+import type { ExternalDescriptor } from "./externals";
+import type { LibId } from "./lib-registry";
+import type { ChatConfig } from "../modules/chat/chat.module-descriptor";
+import type { PhysicsConfig } from "../modules/physics/physics.module-descriptor";
+/** How to import an optional npm package. */
+export type PackageImport = () => Promise<unknown>;
+/**
+ * Importers of the world's optional packages. The runtime never spells them out
+ * itself: a literal `import("nipplejs")` in its dist would force the host
+ * project's bundler to resolve a package that may not be installed. The runtime
+ * owner supplies them — the platform on game start, an exported world through
+ * `imports` in `defineWorld`.
+ */
+export interface WorldImports {
+    /** `@dimforge/rapier3d-compat` — worlds with physics. */
+    rapier?: PackageImport;
+    /** Built-in libs by `LibId` (`settings.addons.json → libs`). */
+    libs?: Partial<Record<LibId, PackageImport>>;
+}
+/** `settings.addons.json` — pluggable modules, built-in libs, external scripts. */
+export interface AddonsConfig {
+    modules?: {
+        physics?: PhysicsConfig;
+        chat?: ChatConfig;
+    };
+    libs?: Partial<Record<LibId, boolean>>;
+    externals?: ExternalDescriptor[];
+}

package/dist/behaviours/physics/BallCollider.d.ts

@@ -1,4 +1,4 @@
-import { Collider } from "./rapier-addon-core/Collider";
+import { Collider } from "./Collider";
 import type * as RAPIER from "@dimforge/rapier3d-compat";
 export default class BallCollider extends Collider {
     readonly type = "Ball";

package/dist/behaviours/physics/CapsuleCollider.d.ts

@@ -1,4 +1,4 @@
-import { Collider } from "./rapier-addon-core/Collider";
+import { Collider } from "./Collider";
 import type * as RAPIER from "@dimforge/rapier3d-compat";
 export default class CapsuleCollider extends Collider {
     readonly type = "Capsule";

package/dist/behaviours/physics/ConeCollider.d.ts

@@ -1,4 +1,4 @@
-import { Collider } from "./rapier-addon-core/Collider";
+import { Collider } from "./Collider";
 import type * as RAPIER from "@dimforge/rapier3d-compat";
 export default class ConeCollider extends Collider {
     readonly type = "Cone";

package/dist/behaviours/physics/ConvexMeshCollider.d.ts

@@ -1,4 +1,4 @@
-import { Collider } from "./rapier-addon-core/Collider";
+import { Collider } from "./Collider";
 import type * as RAPIER from "@dimforge/rapier3d-compat";
 export default class ConvexMeshCollider extends Collider {
     readonly type = "Convex";

package/dist/behaviours/physics/CuboidCollider.d.ts

@@ -1,4 +1,4 @@
-import { Collider } from "./rapier-addon-core/Collider";
+import { Collider } from "./Collider";
 import type * as RAPIER from "@dimforge/rapier3d-compat";
 export default class CuboidCollider extends Collider {
     readonly type = "Cuboid";

package/dist/behaviours/physics/CylinderCollider.d.ts

@@ -1,4 +1,4 @@
-import { Collider } from "./rapier-addon-core/Collider";
+import { Collider } from "./Collider";
 import type * as RAPIER from "@dimforge/rapier3d-compat";
 export default class CylinderCollider extends Collider {
     readonly type = "Cylinder";

package/dist/behaviours/physics/HalfspaceCollider.d.ts

@@ -1,4 +1,4 @@
-import { Collider } from "./rapier-addon-core/Collider";
+import { Collider } from "./Collider";
 import type * as RAPIER from "@dimforge/rapier3d-compat";
 export default class HalfspaceCollider extends Collider {
     readonly type = "Halfspace";

package/dist/behaviours/physics/_required-patch.d.ts

@@ -1,10 +1,14 @@
+import type { RapierPhysics } from "../../modules/physics/RapierPhysics";
+import type { NormalizedPhysics } from "../../modules/physics/physics.module-descriptor";
 import type { ThreeStart } from "three-start";
-/** rapier loads lazily: the wasm is pulled only in worlds with physics. */
-export declare const lazyRapier: {
-    get: () => Promise<typeof import("@dimforge/rapier3d-compat")>;
-};
+/** The only place the physics module is created — called by the registry
+ *  descriptor. The module itself takes rapier from `ctx.modules.addons` on awake. */
+export declare function createRapierPhysicsModule(config: NormalizedPhysics): Promise<RapierPhysics>;
 /**
- * Registers rapier modules before bootstrap: three-start forbids `addModules`
- * after `start()`. Idempotent — a repeated call sees the module in ctx and exits.
+ * Registers physics on demand: a built-in physics behaviour declares it via
+ * `meta.requiredPatch`, so a world with a collider on the scene gets
+ * `ctx.modules.rapier` even without a line in `settings.addons.json`.
+ * Idempotent, and strictly before `start()` — three-start forbids `addModules`
+ * afterwards.
  */
 export declare function applyRapierPhysicsPatch(starter: ThreeStart): Promise<void>;

package/dist/chat.module-descriptor-BTsep-Kq.js

@@ -0,0 +1,107 @@
+//#region packages/world-runtime/src/modules/optional-module-descriptor.ts
+/**
+* Keys of the pluggable modules — the same keys as in
+* `settings.addons.json → modules`. Core modules (`addons`/`env`/`html`/`input`/
+* `controls`/`sounds`/`utils`) are not here: every world has them, with no toggle.
+*/
+var OptionalModuleId = /* @__PURE__ */ function(OptionalModuleId) {
+	OptionalModuleId["Physics"] = "physics";
+	OptionalModuleId["Chat"] = "chat";
+	return OptionalModuleId;
+}({});
+var OPTIONAL_MODULE_IDS = Object.values(OptionalModuleId);
+//#endregion
+//#region packages/world-runtime/src/modules/chat/chat.module-descriptor.ts
+/** `Slash` opens the chat with a "/" already typed — the Minecraft command gesture. */
+var CHAT_COMMAND_KEY = "Slash";
+var CHAT_INPUT_MODES = ["always", "toggle"];
+var DEFAULTS = {
+	input: "always",
+	maxLength: 80,
+	placeholder: "Chat",
+	maxMessages: 150,
+	openKeys: ["Enter", "KeyT"],
+	visibleLines: 10,
+	openedLines: 20,
+	fadeAfter: 1e4
+};
+/** Chat defaults live here: `true` = an always visible input with a limit of 80. */
+function normalizeChat(value) {
+	if (!value) return null;
+	if (value === true) return { ...DEFAULTS };
+	if (typeof value === "string") return {
+		...DEFAULTS,
+		input: value
+	};
+	return {
+		input: value.input ?? DEFAULTS.input,
+		maxLength: value.maxLength ?? DEFAULTS.maxLength,
+		placeholder: value.placeholder ?? DEFAULTS.placeholder,
+		maxMessages: value.maxMessages ?? DEFAULTS.maxMessages,
+		openKeys: value.openKeys ?? DEFAULTS.openKeys,
+		visibleLines: value.visibleLines ?? DEFAULTS.visibleLines,
+		openedLines: value.openedLines ?? DEFAULTS.openedLines,
+		fadeAfter: value.fadeAfter ?? DEFAULTS.fadeAfter
+	};
+}
+var chatModuleDescriptor = {
+	id: OptionalModuleId.Chat,
+	normalize: (raw) => normalizeChat(raw),
+	defaultConfig: () => ({ ...DEFAULTS }),
+	create: async (config) => {
+		const { ChatModule } = await import("./ChatModule-2tiWS_Yr.js");
+		return new ChatModule(config);
+	},
+	schema: {
+		description: "World chat. false | \"always\" | \"toggle\" | { input, maxLength, placeholder, maxMessages }.",
+		oneOf: [
+			{ type: "boolean" },
+			{
+				type: "string",
+				enum: [...CHAT_INPUT_MODES]
+			},
+			{
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					input: {
+						type: "string",
+						enum: [...CHAT_INPUT_MODES],
+						description: "always — the input is always visible; toggle — hidden until Enter, hides again on Escape or after sending."
+					},
+					maxLength: {
+						type: "number",
+						description: "Max message length (default 80)."
+					},
+					placeholder: {
+						type: "string",
+						description: "Input placeholder."
+					},
+					maxMessages: {
+						type: "number",
+						description: "How many messages to keep in history (default 150)."
+					},
+					openKeys: {
+						type: "array",
+						items: { type: "string" },
+						description: "Keys that open the chat — KeyboardEvent.code, layout-independent (default [\"Enter\", \"KeyT\"]). \"Slash\" always opens it with a \"/\" typed in."
+					},
+					visibleLines: {
+						type: "number",
+						description: "Lines shown while the chat is closed (default 10)."
+					},
+					openedLines: {
+						type: "number",
+						description: "Lines shown while the input is focused (default 20)."
+					},
+					fadeAfter: {
+						type: "number",
+						description: "Ms before a line fades out; 0 keeps lines until they are pushed out (default 10000)."
+					}
+				}
+			}
+		]
+	}
+};
+//#endregion
+export { OPTIONAL_MODULE_IDS as a, normalizeChat as i, CHAT_INPUT_MODES as n, OptionalModuleId as o, chatModuleDescriptor as r, CHAT_COMMAND_KEY as t };

package/dist/{get-scale-from-obj-QKv3Fig5.js → get-scale-from-obj-B7JlVPni.js}

@@ -1,5 +1,5 @@
 import * as THREE from "three/webgpu";
-//#region packages/world-runtime/src/behaviours/physics/rapier-addon-core/get-scale-from-obj.ts
+//#region packages/world-runtime/src/behaviours/physics/get-scale-from-obj.ts
 var _hrScale = {
 	radius: 1,
 	halfHeight: 1

package/dist/index.d.ts

@@ -20,29 +20,37 @@ export { createVideo, VideoSource } from "./resources/video";
 export { createFont, FontSource, fontFormatFromMime } from "./resources/font";
 export { BUILTIN_BEHAVIOUR_LIST, BUILTIN_BEHAVIOURS, getBuiltinBehaviour, } from "./behaviours/registry";
 export type { BuiltinBehaviour } from "./behaviours/registry";
-export { applyRapierPhysicsPatch, lazyRapier, } from "./behaviours/physics/_required-patch";
-export { AddonsRuntime } from "./settings/AddonsRuntime";
+export { applyRapierPhysicsPatch } from "./behaviours/physics/_required-patch";
+export { AddonsRuntime } from "./addons/AddonsRuntime";
 export { applyRendererConfig } from "./rendering/renderer-apply";
 export { enableSceneEmissiveMrt, SceneBloom } from "./rendering/SceneBloom";
 export { createTslNode, TslNode } from "./rendering/tsl-node";
 export type { TslNodeBuilder } from "./rendering/tsl-node";
 export { createUniformNode, isUniformType, UNIFORM_DEFAULTS, UNIFORM_TYPES, uniformType, } from "./rendering/tsl-uniforms";
 export type { UniformType } from "./rendering/tsl-uniforms";
-export { LIB_DESCRIPTORS, LIB_IDS, LIBS, LibId, libByRequireKey } from "./settings/lib-registry";
-export type { LibDescriptor } from "./settings/lib-registry";
-export { MODULE_IDS, ModuleId, normalizePhysics, PHYSICS_ENGINES } from "./settings/module-registry";
-export { EXTERNAL_TYPES } from "./settings/externals";
+export { LIB_DESCRIPTORS, LIB_IDS, LIBS, LibId, libByRequireKey } from "./addons/lib-registry";
+export type { LibDescriptor } from "./addons/lib-registry";
+export { OPTIONAL_MODULE_IDS, OptionalModuleId } from "./modules/optional-module-descriptor";
+export { OPTIONAL_MODULES, getOptionalModuleDescriptor } from "./modules/optional-modules";
+export { normalizePhysics, PHYSICS_ENGINES, } from "./modules/physics/physics.module-descriptor";
+export { CHAT_INPUT_MODES, normalizeChat } from "./modules/chat/chat.module-descriptor";
+export { EXTERNAL_TYPES } from "./addons/externals";
 export { BLOOM_MODES, SHADOW_MAP_TYPES, TONE_MAPPING_NAMES, } from "./rendering/renderer-options";
 export type { BloomModeName, ShadowMapTypeName, ToneMappingName, } from "./rendering/renderer-options";
-export type { ExternalDescriptor, ExternalType } from "./settings/externals";
-export type { PhysicsConfig, PhysicsEngine } from "./settings/module-registry";
-export type { AddonsConfig, BloomConfig, RendererConfig, RendererParams, } from "./settings/types";
-export { getHalfheightRadiusScale, getRadiusScale } from "./behaviours/physics/rapier-addon-core/get-scale-from-obj";
+export type { ExternalDescriptor, ExternalType } from "./addons/externals";
+export type { ModuleJsonSchema, OptionalModuleDescriptor, } from "./modules/optional-module-descriptor";
+export type { NormalizedPhysics, PhysicsConfig, PhysicsEngine, } from "./modules/physics/physics.module-descriptor";
+export type { ChatConfig, ChatInputMode, NormalizedChat, } from "./modules/chat/chat.module-descriptor";
+export type { AddonsConfig, PackageImport, WorldImports } from "./addons/types";
+export type { BloomConfig, RendererConfig, RendererParams, } from "./rendering/types";
+export { getHalfheightRadiusScale, getRadiusScale } from "./behaviours/physics/get-scale-from-obj";
+export type { AddonsModuleApi } from "./modules/contracts/addons.module-api";
 export type { EnvModuleApi } from "./modules/contracts/env.module-api";
 export type { HtmlModuleApi } from "./modules/contracts/html.module-api";
-export type { InputModuleApi, PlayerInputApi } from "./modules/contracts/input.module-api";
-export type { RapierJsModule, RapierModuleApi } from "./modules/contracts/rapier.module-api";
-export type { RapierDebugModuleApi } from "./modules/contracts/rapierDebug.module-api";
+export type { InputEvents, InputModuleApi } from "./modules/contracts/input.module-api";
+export type { ControlsDriver, ControlsEvents, ControlsModuleApi, ControlsSource, ControlsState, } from "./modules/contracts/controls.module-api";
+export type { ModuleEvents } from "./modules/contracts/module-events";
+export type { RapierEvents, RapierJsModule, RapierModuleApi, } from "./modules/contracts/rapier.module-api";
 export type { SoundsModuleApi } from "./modules/contracts/sounds.module-api";
 export type { UtilsModuleApi } from "./modules/contracts/utils.module-api";
 export type { AssetUrlTable, LoadWorldOptions, RuntimeApi, SceneBuildResult, ScriptModule, ScriptTable, WorldDefinition, WorldLoadProgress, } from "./types";