@kvyverse/world-runtime 0.1.0

package/dist/RapierFpsPlayerController-VsNfQl6v.js

@@ -0,0 +1,142 @@
+import * as THREE from "three/webgpu";
+import { Object3DBehaviour } from "three-start";
+//#region packages/world-runtime/src/behaviours/physics/RapierFpsPlayerController.ts
+var RapierFpsPlayerController = class extends Object3DBehaviour {
+	halfHeight = .85;
+	radius = .5;
+	offset = .01;
+	walkSpeed = 3.5;
+	runSpeed = 8;
+	useShiftRun = true;
+	maxSlopeClimbAngle = 45 * Math.PI / 180;
+	minSlopeSlideAngle = 30 * Math.PI / 180;
+	slideEnabled = false;
+	snapToGround = .2;
+	applyImplusesToDynamicBodies = false;
+	enableAutostep = true;
+	autostepMaxHeight = .3;
+	autostepMinWidth = .2;
+	autostepIncludeDynamicBodies = false;
+	controlsEnabled = true;
+	rb;
+	col;
+	kcc;
+	_isVaryTimeStep = true;
+	_detach;
+	onEnable() {
+		const rapier = this.modules.rapier;
+		const world = rapier.world;
+		const RAPIER = rapier.api;
+		this._isVaryTimeStep = rapier.timeStep === "vary";
+		const pos = this.object.position;
+		const rbDesc = RAPIER.RigidBodyDesc.kinematicPositionBased().setTranslation(pos.x, pos.y, pos.z);
+		this.rb = world.createRigidBody(rbDesc);
+		const height = (this.halfHeight + this.radius) * 2;
+		this.col = world.createCollider(RAPIER.ColliderDesc.capsule(this.halfHeight, this.radius).setTranslation(0, height / 2, 0), this.rb);
+		const kcc = world.createCharacterController(this.offset);
+		kcc.setMaxSlopeClimbAngle(this.maxSlopeClimbAngle);
+		kcc.enableSnapToGround(this.snapToGround);
+		kcc.setApplyImpulsesToDynamicBodies(this.applyImplusesToDynamicBodies);
+		if (this.enableAutostep) kcc.enableAutostep(this.autostepMaxHeight, this.autostepMinWidth, this.autostepIncludeDynamicBodies);
+		this.kcc = kcc;
+		const onStep = () => {
+			if (this.controlsEnabled) this.update();
+		};
+		rapier.on("stepbefore", onStep);
+		this._detach = () => {
+			rapier.off("stepbefore", onStep);
+			world.removeCharacterController(kcc);
+		};
+	}
+	onDisable() {
+		this._detach?.();
+		this._detach = void 0;
+	}
+	_inputDir = new THREE.Vector3();
+	correctedMovement = new THREE.Vector3();
+	getDt() {
+		return this._isVaryTimeStep ? this.ctx.getDeltaTime() : this.modules.rapier.timeStep;
+	}
+	update() {
+		const kcc = this.kcc;
+		const col = this.col;
+		const dt = this.getDt();
+		const input = this.modules.input;
+		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.normalize();
+		const camera = this.ctx.camera;
+		if (dir.lengthSq() > 0) {
+			const cameraForward = _vt1;
+			camera.getWorldDirection(cameraForward);
+			cameraForward.y = 0;
+			cameraForward.normalize();
+			const cameraRight = _vt2.setScalar(0);
+			cameraRight.crossVectors(up, cameraForward).normalize();
+			const move = _vt3.setScalar(0);
+			move.addScaledVector(cameraForward, -dir.z);
+			move.addScaledVector(cameraRight, -dir.x);
+			move.normalize();
+			dir.copy(move);
+		}
+		const hitGround = this.hitGround();
+		const desiredTranslationDelta = _vt.copy(dir).multiplyScalar(speed * dt);
+		if (hitGround && hitGround.timeOfImpact > .01) desiredTranslationDelta.y = -hitGround.timeOfImpact + .08;
+		kcc.computeColliderMovement(col, desiredTranslationDelta);
+		const correctedMovement = kcc.computedMovement();
+		this.correctedMovement.copy(correctedMovement);
+		const newTranslatation = _vt.copy(this.rb.translation()).add(correctedMovement);
+		this.rb.setNextKinematicTranslation(newTranslatation);
+		_vt.copy(this.rb.translation());
+		const obj = this.object;
+		if (obj.parent) {
+			obj.parent.worldToLocal(_vt);
+			obj.position.copy(_vt);
+		}
+	}
+	_hitGround = null;
+	hitGround() {
+		const rapier = this.modules.rapier;
+		const rayOrigin = this.rb.translation();
+		const ray = new rapier.api.Ray(rayOrigin, down);
+		const hitGround = rapier.world.castRay(ray, 100, false, void 0, void 0, this.col, this.rb);
+		this._hitGround = hitGround;
+		return hitGround;
+	}
+	teleport(position) {
+		this.object.position.copy(position);
+		this.rb.setTranslation(position, true);
+	}
+};
+var _vt = new THREE.Vector3();
+var _vt1 = new THREE.Vector3();
+var _vt2 = new THREE.Vector3();
+var _vt3 = new THREE.Vector3();
+var down = {
+	x: 0,
+	y: -1,
+	z: 0
+};
+var up = new THREE.Vector3(0, 1, 0);
+//#endregion
+export { RapierFpsPlayerController as default };

package/dist/RapierPhysics-C_3b7QOn.js

@@ -0,0 +1,74 @@
+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
+});
+var RapierPhysics = class RapierPhysics extends ContextModule {
+	isRapierPhysics;
+	api;
+	world;
+	eventQueue;
+	/** @default "vary" */
+	timeStep;
+	_steppingState = { accumulator: 0 };
+	constructor(Rapier, 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]
+		});
+		this.timeStep = timeStep;
+		console.log(`Rapier version: ${Rapier.version()}`);
+		defineProps(this, {
+			isRapierPhysics: readOnly(true),
+			api: readOnly(Rapier),
+			world: readOnly(world),
+			eventQueue: readOnly(new Rapier.EventQueue(false))
+		});
+	}
+	onStart() {
+		requestAnimationFrame(() => {
+			requestAnimationFrame(() => {
+				this.ctx.on(ThreeContextEvents.RenderBefore, this.update);
+			});
+		});
+	}
+	/** three-start ContextModule has no onDestroy; teardown is explicit. */
+	dispose() {
+		this.ctx.off(ThreeContextEvents.RenderBefore, this.update);
+	}
+	update = () => {
+		const steppingState = this._steppingState;
+		const timeStep = this.timeStep;
+		const timeStepVariable = timeStep === "vary";
+		const clampedDelta = Math.max(Math.min(.1, this.ctx.getDeltaTime()), 0);
+		if (timeStepVariable) this.stepWorld(clampedDelta);
+		else {
+			steppingState.accumulator += clampedDelta;
+			while (steppingState.accumulator >= timeStep) {
+				this.stepWorld(timeStep);
+				steppingState.accumulator -= timeStep;
+			}
+		}
+	};
+	stepWorld = (delta) => {
+		this.emit("stepbefore");
+		this.world.timestep = delta;
+		this.world.step();
+		this.emit("stepafter");
+	};
+	static findInCtx(ctx) {
+		const rapier = ctx.modules.rapier;
+		return rapier instanceof RapierPhysics ? rapier : void 0;
+	}
+};
+//#endregion
+export { RapierPhysics_exports as n, RapierPhysics as t };

package/dist/Rigidbody-b7QNF4ev.js

@@ -0,0 +1,107 @@
+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 packages/world-runtime/src/behaviours/physics/Rigidbody.ts
+var Rigidbody_exports = /* @__PURE__ */ __exportAll({ default: () => Rigidbody });
+/**
+* @see {@link https://github.com/vladkrutenyuk/three-kvy-core/blob/main/src/addons/Rigidbody.ts | Source}
+*/
+var Rigidbody = class extends Object3DBehaviour {
+	isRigidbody = true;
+	get instance() {
+		return assertDefined(this._instance, "instance");
+	}
+	_instance;
+	rigidbodyType = 0;
+	_world;
+	constructor() {
+		super();
+		defineProps(this, { isRigidbody: readOnly(true) });
+	}
+	onEnable() {
+		const rapier = this.modules.rapier;
+		const Rapier = rapier.api;
+		let desc;
+		const type = Number(this.rigidbodyType);
+		console.log("creating rigidbody with type", type);
+		switch (type) {
+			case Rapier.RigidBodyType.Dynamic:
+				desc = Rapier.RigidBodyDesc.dynamic();
+				break;
+			case Rapier.RigidBodyType.Fixed:
+				desc = Rapier.RigidBodyDesc.fixed();
+				break;
+			case Rapier.RigidBodyType.KinematicPositionBased:
+				desc = Rapier.RigidBodyDesc.kinematicPositionBased();
+				break;
+			case Rapier.RigidBodyType.KinematicVelocityBased:
+				desc = Rapier.RigidBodyDesc.kinematicVelocityBased();
+				break;
+			default:
+				console.error("invalid rigidbody type", type);
+				return;
+		}
+		const pos = this.getObjWorldPos();
+		const quat = this.getObjWorldQuat();
+		desc.setTranslation(pos.x, pos.y, pos.z).setRotation(quat);
+		const world = rapier.world;
+		const rb = world.createRigidBody(desc);
+		this._instance = rb;
+		this._world = world;
+		this.emit("ready", rb);
+	}
+	onDisable() {
+		if (this._instance && this._world) this._world.removeRigidBody(this._instance);
+		this._instance = void 0;
+		this._world = void 0;
+	}
+	onBeforeRender() {
+		const rb = this._instance;
+		if (!rb) return;
+		if (rb.isDynamic()) this.syncObjectToBody();
+		else if (rb.isKinematic()) this.syncBodyToObjectKinematically();
+	}
+	syncBodyToObjectKinematically() {
+		const rb = this._instance;
+		if (!rb) return;
+		const obj = this.object;
+		obj.getWorldPosition(_v);
+		obj.getWorldQuaternion(_qt1);
+		rb.setNextKinematicTranslation(_v);
+		rb.setNextKinematicRotation(_qt1);
+	}
+	withReady(cb) {
+		if (this._instance) return cb(this._instance);
+		this.once("ready", cb);
+	}
+	getObjWorldPos() {
+		this.object.getWorldPosition(_v);
+		return _v;
+	}
+	getObjWorldQuat() {
+		this.object.getWorldQuaternion(_qt1);
+		return _qt1;
+	}
+	syncObjectToBody() {
+		const rb = this._instance;
+		if (!rb || rb.isSleeping()) return;
+		const obj = this.object;
+		const parent = obj.parent;
+		if (!parent) return;
+		_v.copy(rb.translation());
+		parent.worldToLocal(_v);
+		obj.position.copy(_v);
+		const rbWorldQuat = _qt1;
+		rbWorldQuat.copy(rb.rotation());
+		const parentWorldQuat = _qt2;
+		parent.getWorldQuaternion(parentWorldQuat);
+		_qt3.copy(parentWorldQuat).invert().multiply(rbWorldQuat);
+		obj.setRotationFromQuaternion(_qt3);
+	}
+};
+var _v = new THREE.Vector3();
+var _qt1 = new THREE.Quaternion();
+var _qt2 = new THREE.Quaternion();
+var _qt3 = new THREE.Quaternion();
+//#endregion
+export { Rigidbody_exports as n, Rigidbody as t };

package/dist/ScalingToFro-BD-E5-uR.js

@@ -0,0 +1,21 @@
+import { Object3DBehaviour } from "three-start";
+//#region packages/world-runtime/src/behaviours/animation/ScalingToFro.ts
+var ScalingToFro = class extends Object3DBehaviour {
+	scale = 1;
+	max = 2;
+	min = .2;
+	direction = 1;
+	onBeforeRender() {
+		if (this.scale >= this.max) {
+			this.direction = -1;
+			this.scale = this.max;
+		} else if (this.scale <= this.min) {
+			this.direction = 1;
+			this.scale = this.min;
+		}
+		this.scale += this.ctx.getDeltaTime() * this.direction;
+		this.object.scale.setScalar(this.scale);
+	}
+};
+//#endregion
+export { ScalingToFro as default };

package/dist/SightInteractableArea-DrqyB41W.js

@@ -0,0 +1,79 @@
+import * as THREE from "three/webgpu";
+import { Object3DBehaviour } from "three-start";
+//#region packages/world-runtime/src/behaviours/player/SightInteractableArea.ts
+var raycaster = new THREE.Raycaster();
+var SightInteractableArea = class SightInteractableArea extends Object3DBehaviour {
+	static _CURRENT = null;
+	isSightInteractableArea = true;
+	radius = 3;
+	hint = "Interact";
+	interactEnabled = true;
+	isStatic = true;
+	_sqRadius = 9;
+	_active = false;
+	_initWorldPos = new THREE.Vector3();
+	onEnable() {
+		const r = this.radius;
+		this._sqRadius = r * r;
+		this.object.getWorldPosition(this._initWorldPos);
+	}
+	onDisable() {
+		this._deactivate();
+	}
+	setRadius(r) {
+		this.radius = r;
+		this._sqRadius = r * r;
+	}
+	onBeforeRender() {
+		if (!this.interactEnabled) return;
+		const camera = this.ctx.camera;
+		const thisWorldPos = this.isStatic ? this._initWorldPos : this.object.getWorldPosition(_vt1);
+		const cameraWorldPos = camera.getWorldPosition(_vt2);
+		const inside = thisWorldPos.distanceToSquared(cameraWorldPos) <= this._sqRadius;
+		let active = false;
+		if (inside) {
+			raycaster.setFromCamera(screenCenter, camera);
+			if (raycaster.intersectObject(this.object, false).length > 0) active = true;
+		}
+		if (this._active === active) return;
+		this._active = active;
+		this.emit("activechanged", active);
+		if (active) this._activate();
+		else this._deactivate();
+	}
+	_activate() {
+		const modules = this.modules;
+		SightInteractableArea._CURRENT = this.object.id;
+		modules.html.setCrosshair(this.hint);
+		if (modules.env.isMobile) {
+			modules.html.crosshair.style.pointerEvents = "auto";
+			modules.html.crosshair.addEventListener("pointerdown", this._interact);
+		} else this.ctx.renderer.domElement.addEventListener("mousedown", this._interact);
+	}
+	_deactivate() {
+		const modules = this.modules;
+		if (SightInteractableArea._CURRENT === this.object.id) {
+			SightInteractableArea._CURRENT = null;
+			modules.html.setCrosshair("");
+		}
+		if (modules.env.isMobile) {
+			modules.html.crosshair.style.pointerEvents = "";
+			modules.html.crosshair.removeEventListener("pointerdown", this._interact);
+		} else this.ctx.renderer.domElement.removeEventListener("mousedown", this._interact);
+	}
+	_interact = () => {
+		if (!this.interactEnabled) return;
+		const current = SightInteractableArea._CURRENT;
+		if (!(current === this.object.id || current === null)) return;
+		this.interactEnabled = false;
+		this._deactivate();
+		this._active = false;
+		this.emit("interaction");
+		console.log("interaction with ", this.object.name);
+	};
+};
+var screenCenter = new THREE.Vector2(0, 0);
+var _vt1 = new THREE.Vector3();
+var _vt2 = new THREE.Vector3();
+//#endregion
+export { SightInteractableArea as default };

package/dist/SimpleWASDMovement-C2m53YYH.js

@@ -0,0 +1,17 @@
+import { Object3DBehaviour } from "three-start";
+//#region packages/world-runtime/src/behaviours/controls/SimpleWASDMovement.ts
+var SimpleWASDMovement = class extends Object3DBehaviour {
+	speed = 4;
+	onBeforeRender() {
+		const dt = this.ctx.getDeltaTime();
+		const s = this.speed;
+		const pos = this.object.position;
+		const key = this.modules.input.isKeyDown;
+		if (key("KeyW")) pos.z -= s * dt;
+		if (key("KeyS")) pos.z += s * dt;
+		if (key("KeyD")) pos.x += s * dt;
+		if (key("KeyA")) pos.x -= s * dt;
+	}
+};
+//#endregion
+export { SimpleWASDMovement as default };

package/dist/Spinning-sgUhHld8.js

@@ -0,0 +1,10 @@
+import { Object3DBehaviour } from "three-start";
+//#region packages/world-runtime/src/behaviours/animation/Spinning.ts
+var Spinning = class extends Object3DBehaviour {
+	speed = 5;
+	onBeforeRender() {
+		this.object.rotateY(this.ctx.getDeltaTime() * this.speed);
+	}
+};
+//#endregion
+export { Spinning as default };

package/dist/StartAnimation-B9eomOS2.js

@@ -0,0 +1,37 @@
+import * as THREE from "three/webgpu";
+import { Object3DBehaviour } from "three-start";
+//#region packages/world-runtime/src/behaviours/animation/StartAnimation.ts
+var StartAnimation = class extends Object3DBehaviour {
+	mixer;
+	_action;
+	onEnable() {
+		const anims = this.object.animations;
+		const mixer = new THREE.AnimationMixer(this.object);
+		this.mixer = mixer;
+		if (anims.length > 0) {
+			this._action = mixer.clipAction(anims[0]);
+			this._action.play();
+		}
+	}
+	onDisable() {
+		const mixer = this.mixer;
+		const action = this._action;
+		if (action) {
+			action.stop();
+			mixer?.uncacheAction(action.getClip(), this.object);
+		}
+		mixer?.stopAllAction();
+		mixer?.uncacheRoot(this.object);
+		if (mixer) {
+			mixer._actions = [];
+			mixer._bindings = [];
+		}
+		this.mixer = void 0;
+		this._action = void 0;
+	}
+	onBeforeRender() {
+		this.mixer?.update(this.ctx.getDeltaTime());
+	}
+};
+//#endregion
+export { StartAnimation as default };

package/dist/TrimeshCollider-7dIs_xtZ.js

@@ -0,0 +1,62 @@
+import { Object3DBehaviour } from "three-start";
+//#region packages/world-runtime/src/behaviours/physics/TrimeshCollider.ts
+var TrimeshCollider = class extends Object3DBehaviour {
+	recursive = false;
+	_detach;
+	onEnable() {
+		const { api: RAPIER, world } = this.modules.rapier;
+		if (this.recursive) {
+			const colliders = [];
+			this.object.traverse((node) => {
+				if (!isMesh(node)) return;
+				const [vertices, indices] = createTrimeshColliderArgsFromMesh(node);
+				const col = world.createCollider(RAPIER.ColliderDesc.trimesh(vertices, indices));
+				colliders.push(col);
+			});
+			this._detach = () => {
+				colliders.forEach((x) => world.removeCollider(x, false));
+			};
+			return;
+		}
+		const mesh = this.object;
+		if (!isMesh(mesh)) {
+			console.error("TrimeshCollider can be applied only for Mesh");
+			return;
+		}
+		const [vertices, indices] = createTrimeshColliderArgsFromMesh(mesh);
+		const col = world.createCollider(RAPIER.ColliderDesc.trimesh(vertices, indices));
+		this._detach = () => {
+			world.removeCollider(col, false);
+		};
+	}
+	onDisable() {
+		this._detach?.();
+		this._detach = void 0;
+	}
+};
+function isMesh(obj) {
+	return obj.isMesh;
+}
+function createTrimeshColliderArgsFromMesh(mesh) {
+	mesh.updateWorldMatrix(true, false);
+	const geom = mesh.geometry.clone();
+	geom.applyMatrix4(mesh.matrixWorld);
+	if (!geom.getAttribute("normal")) geom.computeVertexNormals();
+	const position = geom.getAttribute("position");
+	const vertices = new Float32Array(position.count * 3);
+	for (let i = 0; i < position.count; i++) {
+		vertices[i * 3 + 0] = position.getX(i);
+		vertices[i * 3 + 1] = position.getY(i);
+		vertices[i * 3 + 2] = position.getZ(i);
+	}
+	let indices;
+	if (geom.index) indices = new Uint32Array(geom.index.array);
+	else {
+		indices = new Uint32Array(position.count);
+		for (let i = 0; i < position.count; i++) indices[i] = i;
+	}
+	geom.dispose();
+	return [vertices, indices];
+}
+//#endregion
+export { createTrimeshColliderArgsFromMesh, TrimeshCollider as default };

package/dist/World.d.ts

@@ -0,0 +1,19 @@
+import { ThreeStart } from "three-start";
+import type { ThreeStartOptions } from "three-start";
+import type { WorldRuntime } from "./WorldRuntime";
+/**
+ * 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).
+ */
+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;
+    /** World lifecycle event bus — the same one as `world.events` in scripts. */
+    get events(): WorldRuntime["emitter"];
+    start(): this;
+    dispose(): void;
+}

package/dist/WorldRuntime.d.ts

@@ -0,0 +1,94 @@
+import EventEmitter from "eventemitter3";
+import * as THREE from "three/webgpu";
+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">;
+/**
+ * Owner of the world's runtime state: assets, script execution, ctx access.
+ * The only object the generated code receives.
+ */
+export declare class WorldRuntime implements RuntimeApi {
+    readonly definition: RuntimeDefinitionSlice;
+    readonly options: LoadWorldOptions;
+    /** World lifecycle event bus (`world.events` in scripts). */
+    readonly emitter: EventEmitter<string | symbol, any>;
+    private readonly _addons;
+    private readonly _executedScripts;
+    private readonly _builtins;
+    private readonly _styleElements;
+    private _resources;
+    private _ctx;
+    private _bloom;
+    private _scriptContext;
+    constructor(definition: RuntimeDefinitionSlice, options: LoadWorldOptions);
+    /** 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`. */
+    loadAddons(): Promise<void>;
+    /** @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;
+    /**
+     * Built-in behaviour class by uuid. Classes are preloaded by bootstrap,
+     * so attaching in `buildScene` is synchronous.
+     */
+    builtin: (uuid: string) => Object3DBehaviourConstructor;
+    /** @internal Loads classes of the used built-in behaviours (before scene assembly). */
+    loadBuiltins(): Promise<void>;
+    /**
+     * @internal Registers ctx modules required by built-in behaviours (physics).
+     * Strictly before `start()` — three-start forbids `addModules` afterwards.
+     */
+    applyRequiredPatches(starter: ThreeStart): Promise<void>;
+    /** Addon (built-in lib / external) → script by path → asset resource. Same
+     * resolve order as in play mode. */
+    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.
+     */
+    instantiate: (source: THREE.Object3D | PrefabFactory, options?: InstantiateOptions) => THREE.Object3D;
+    /** Runs a script once and caches its `output`. The cache entry is set before
+     * execution — this breaks cyclic `require`. */
+    executeScript(path: string): unknown;
+    /** World entry script (`main.ts`), once. */
+    executeEntryScript(): void;
+    /** Mounts world css scripts into the document where the canvas actually renders. */
+    mountStyles(): void;
+    /** `@font-face` of all world fonts in a single tag — before styles and entry script. */
+    mountFonts(): void;
+    dispose(): void;
+    /** Narrow bloom facade for scripts: mode is read-only, params are live
+     * (uniforms, can be animated per frame). `null` — bloom is disabled. */
+    private get bloomApi();
+    /** Script-scope globals: all of three-start + `world`, `require`, libs.
+     * `ctx` is a getter: script components run before the 3d context is created. */
+    private get scriptContext();
+    private appendStyle;
+}
+/** Shape of `world.rendering.bloom` in scripts. */
+export interface WorldBloomApi {
+    readonly mode: SceneBloom["mode"];
+    strength: number;
+    radius: number;
+    threshold: number;
+}
+/** A prefab in an exported world — a factory that assembles a fresh hierarchy. */
+export type PrefabFactory = () => THREE.Object3D;
+export interface InstantiateOptions {
+    position?: Vec3Like;
+    rotation?: Vec3Like;
+    scale?: Vec3Like | number;
+}
+export type Vec3Like = [number, number, number] | {
+    x: number;
+    y: number;
+    z: number;
+};

package/dist/behaviours/animation/ScalingToFro.d.ts

@@ -0,0 +1,8 @@
+import { Object3DBehaviour } from "three-start";
+export default class ScalingToFro extends Object3DBehaviour {
+    scale: number;
+    max: number;
+    min: number;
+    direction: number;
+    onBeforeRender(): void;
+}

package/dist/behaviours/animation/Spinning.d.ts

@@ -0,0 +1,5 @@
+import { Object3DBehaviour } from "three-start";
+export default class Spinning extends Object3DBehaviour {
+    speed: number;
+    onBeforeRender(): void;
+}