@kvyverse/world-runtime 0.1.0

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

@@ -0,0 +1,9 @@
+import { Object3DBehaviour } from "three-start";
+import * as THREE from "three/webgpu";
+export default class StartAnimation extends Object3DBehaviour {
+    mixer?: THREE.AnimationMixer;
+    private _action?;
+    onEnable(): void;
+    onDisable(): void;
+    onBeforeRender(): void;
+}

package/dist/behaviours/controls/FpsCameraController.d.ts

@@ -0,0 +1,10 @@
+import { Object3DBehaviour } from "three-start";
+export default class FpsCameraController extends Object3DBehaviour {
+    sensitivity: number;
+    mobileSensitivity: number;
+    inverted: boolean;
+    useInvertedOnMobile: boolean;
+    private _detach?;
+    onEnable(): void;
+    onDisable(): void;
+}

package/dist/behaviours/controls/PointerLockCameraControls.d.ts

@@ -0,0 +1,28 @@
+import { Object3DBehaviour } from "three-start";
+import * as THREE from "three/webgpu";
+export default class PointerLockCameraControls extends Object3DBehaviour<{
+    lock: [];
+    unlock: [];
+    change: [];
+}> {
+    isLocked: boolean;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    pointerSpeed: number;
+    mobilePointerSpeed: number;
+    domElement: HTMLElement | null;
+    _canBeLocked: boolean;
+    _isMobile: boolean;
+    private _detach?;
+    onEnable(): void;
+    onDisable(): void;
+    private _onPointerMove;
+    private _onPointerlockChange;
+    private connect;
+    private disconnect;
+    getDirection(v: THREE.Vector3): THREE.Vector3;
+    moveForward(distance: number): void;
+    moveRight(distance: number): void;
+    lock(unadjustedMovement?: boolean): void;
+    unlock(): void;
+}

package/dist/behaviours/controls/SimpleWASDMovement.d.ts

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

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

@@ -0,0 +1,10 @@
+import { Collider } from "./rapier-addon-core/Collider";
+import type * as RAPIER from "@dimforge/rapier3d-compat";
+export default class BallCollider extends Collider {
+    readonly type = "Ball";
+    /**
+     * @default 0.5
+     */
+    radius: number;
+    getDesc(rapier: typeof RAPIER): RAPIER.ColliderDesc;
+}

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

@@ -0,0 +1,14 @@
+import { Collider } from "./rapier-addon-core/Collider";
+import type * as RAPIER from "@dimforge/rapier3d-compat";
+export default class CapsuleCollider extends Collider {
+    readonly type = "Capsule";
+    /**
+     * @default 0.5
+     */
+    halfHeight: number;
+    /**
+     * @default 0.5
+     */
+    radius: number;
+    getDesc(rapier: typeof RAPIER): RAPIER.ColliderDesc;
+}

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

@@ -0,0 +1,14 @@
+import { Collider } from "./rapier-addon-core/Collider";
+import type * as RAPIER from "@dimforge/rapier3d-compat";
+export default class ConeCollider extends Collider {
+    readonly type = "Cone";
+    /**
+     * @default 0.5
+     */
+    halfHeight: number;
+    /**
+     * @default 0.5
+     */
+    radius: number;
+    getDesc(rapier: typeof RAPIER): RAPIER.ColliderDesc;
+}

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

@@ -0,0 +1,6 @@
+import { Collider } from "./rapier-addon-core/Collider";
+import type * as RAPIER from "@dimforge/rapier3d-compat";
+export default class ConvexMeshCollider extends Collider {
+    readonly type = "Convex";
+    getDesc(rapier: typeof RAPIER): RAPIER.ColliderDesc | null;
+}

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

@@ -0,0 +1,22 @@
+import { Collider } from "./rapier-addon-core/Collider";
+import type * as RAPIER from "@dimforge/rapier3d-compat";
+export default class CuboidCollider extends Collider {
+    readonly type = "Cuboid";
+    /**
+     * @default 0.5
+     */
+    hx: number;
+    /**
+     * @default 0.5
+     */
+    hy: number;
+    /**
+     * @default 0.5
+     */
+    hz: number;
+    /**
+     * @default true
+     */
+    useObjectScale: boolean;
+    getDesc(rapier: typeof RAPIER): RAPIER.ColliderDesc;
+}

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

@@ -0,0 +1,18 @@
+import { Collider } from "./rapier-addon-core/Collider";
+import type * as RAPIER from "@dimforge/rapier3d-compat";
+export default class CylinderCollider extends Collider {
+    readonly type = "Cylinder";
+    /**
+     * @default 0.5
+     */
+    halfHeight: number;
+    /**
+     * @default 0.5
+     */
+    radius: number;
+    /**
+     * @default true
+     */
+    useObjectScale: boolean;
+    getDesc(rapier: typeof RAPIER): RAPIER.ColliderDesc;
+}

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

@@ -0,0 +1,7 @@
+import { Collider } from "./rapier-addon-core/Collider";
+import type * as RAPIER from "@dimforge/rapier3d-compat";
+export default class HalfspaceCollider extends Collider {
+    readonly type = "Halfspace";
+    radius: number;
+    getDesc(rapier: typeof RAPIER): RAPIER.ColliderDesc | null;
+}

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

@@ -0,0 +1,35 @@
+import { Object3DBehaviour } from "three-start";
+import * as THREE from "three/webgpu";
+import type { Collider, KinematicCharacterController, RayColliderHit, RigidBody } from "@dimforge/rapier3d-compat";
+export default class RapierFpsPlayerController extends Object3DBehaviour {
+    halfHeight: number;
+    radius: number;
+    offset: number;
+    walkSpeed: number;
+    runSpeed: number;
+    useShiftRun: boolean;
+    maxSlopeClimbAngle: number;
+    minSlopeSlideAngle: number;
+    slideEnabled: boolean;
+    snapToGround: number;
+    applyImplusesToDynamicBodies: boolean;
+    enableAutostep: boolean;
+    autostepMaxHeight: number;
+    autostepMinWidth: number;
+    autostepIncludeDynamicBodies: boolean;
+    controlsEnabled: boolean;
+    rb: RigidBody;
+    col: Collider;
+    kcc: KinematicCharacterController;
+    _isVaryTimeStep: boolean;
+    private _detach?;
+    onEnable(): void;
+    onDisable(): void;
+    _inputDir: THREE.Vector3;
+    correctedMovement: THREE.Vector3;
+    getDt(): number;
+    update(): void;
+    _hitGround: RayColliderHit | null;
+    hitGround(): RayColliderHit | null;
+    teleport(position: THREE.Vector3): void;
+}

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

@@ -0,0 +1,24 @@
+import { Object3DBehaviour } from "three-start";
+import * as THREE from "three/webgpu";
+import type * as RAPIER from "@dimforge/rapier3d-compat";
+/**
+ * @see {@link https://github.com/vladkrutenyuk/three-kvy-core/blob/main/src/addons/Rigidbody.ts | Source}
+ */
+export default class Rigidbody extends Object3DBehaviour<{
+    ready: [rb: RAPIER.RigidBody];
+}> {
+    readonly isRigidbody = true;
+    get instance(): RAPIER.RigidBody;
+    protected _instance?: RAPIER.RigidBody;
+    readonly rigidbodyType: RAPIER.RigidBodyType;
+    private _world?;
+    constructor();
+    onEnable(): void;
+    onDisable(): void;
+    onBeforeRender(): void;
+    syncBodyToObjectKinematically(): void;
+    withReady(cb: (rb: RAPIER.RigidBody) => void): void;
+    getObjWorldPos(): THREE.Vector3;
+    getObjWorldQuat(): THREE.Quaternion;
+    syncObjectToBody(): void;
+}

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

@@ -0,0 +1,9 @@
+import { Object3DBehaviour } from "three-start";
+import type * as THREE from "three/webgpu";
+export default class TrimeshCollider extends Object3DBehaviour {
+    recursive: boolean;
+    private _detach?;
+    onEnable(): void;
+    onDisable(): void;
+}
+export declare function createTrimeshColliderArgsFromMesh(mesh: THREE.Mesh): readonly [Float32Array<ArrayBuffer>, Uint32Array<ArrayBuffer>];

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

@@ -0,0 +1,10 @@
+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")>;
+};
+/**
+ * Registers rapier modules before bootstrap: three-start forbids `addModules`
+ * after `start()`. Idempotent — a repeated call sees the module in ctx and exits.
+ */
+export declare function applyRapierPhysicsPatch(starter: ThreeStart): Promise<void>;

package/dist/behaviours/physics/rapier-addon-core/Collider.d.ts

@@ -0,0 +1,14 @@
+import { Object3DBehaviour } from "three-start";
+import * as THREE from "three/webgpu";
+import type * as RAPIER from "@dimforge/rapier3d-compat";
+export type ColliderType = keyof typeof RAPIER.ColliderDesc;
+export declare abstract class Collider extends Object3DBehaviour {
+    get instance(): RAPIER.Collider;
+    private _instance?;
+    private _world?;
+    protected _vt: THREE.Vector3;
+    abstract readonly type: string;
+    abstract getDesc(rapier: typeof RAPIER): RAPIER.ColliderDesc | null;
+    onEnable(): void;
+    onDisable(): void;
+}

package/dist/behaviours/physics/rapier-addon-core/RapierDebugRenderer.d.ts

@@ -0,0 +1,17 @@
+import { ContextModule } from "three-start";
+import type { RapierDebugModuleApi } from "../../../modules/contracts/rapierDebug.module-api";
+/**
+ * @see {@link https://github.com/vladkrutenyuk/three-kvy-core/blob/main/src/addons/RapierDebugRenderer.ts | Source}
+ */
+export declare class RapierDebugRenderer extends ContextModule implements RapierDebugModuleApi {
+    private _lines?;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    private _enabled;
+    private _clear?;
+    private _inited;
+    /** three-start ContextModule has no onDestroy; teardown is explicit. */
+    dispose(): void;
+    init(): void;
+}
+export default RapierDebugRenderer;

package/dist/behaviours/physics/rapier-addon-core/RapierPhysics.d.ts

@@ -0,0 +1,131 @@
+import { ContextModule } from "three-start";
+import type { ThreeContext } from "three-start";
+import type * as THREE from "three/webgpu";
+import type * as RAPIER from "@dimforge/rapier3d-compat";
+import type { RapierModuleApi } from "../../../modules/contracts/rapier.module-api";
+export type ModulesWithRapierPhysics = {
+    rapier: RapierPhysics;
+};
+export type RapierJsModule = typeof RAPIER;
+export declare class RapierPhysics extends ContextModule<{
+    stepbefore: [];
+    stepafter: [];
+}> implements RapierModuleApi {
+    readonly isRapierPhysics: true;
+    readonly api: RapierJsModule;
+    readonly world: RAPIER.World;
+    readonly eventQueue: RAPIER.EventQueue;
+    /** @default "vary" */
+    timeStep: RapierPhysicsOptions["timeStep"];
+    private _steppingState;
+    constructor(Rapier: RapierJsModule, options?: Partial<RapierPhysicsOptions>);
+    onStart(): void;
+    /** three-start ContextModule has no onDestroy; teardown is explicit. */
+    dispose(): void;
+    private update;
+    private stepWorld;
+    static findInCtx(ctx: ThreeContext): RapierPhysics | undefined;
+}
+export default RapierPhysics;
+export interface RapierPhysicsOptions {
+    /**
+     * Set the gravity of the physics world
+     * @defaultValue [0, -9.81, 0]
+     */
+    gravity: THREE.Vector3Tuple;
+    /**
+     * Amount of penetration the engine wont attempt to correct
+     * @defaultValue 0.001
+     */
+    allowedLinearError: number;
+    /**
+     * The number of solver iterations run by the constraints solver for calculating forces.
+     * The greater this value is, the most rigid and realistic the physics simulation will be.
+     * However a greater number of iterations is more computationally intensive.
+     *
+     * @defaultValue 4
+     */
+    numSolverIterations: number;
+    /**
+     * Number of addition friction resolution iteration run during the last solver sub-step.
+     * The greater this value is, the most realistic friction will be.
+     * However a greater number of iterations is more computationally intensive.
+     *
+     * @defaultValue 4
+     */
+    numAdditionalFrictionIterations: number;
+    /**
+     * Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration.
+     * Increasing this parameter will improve stability of the simulation. It will have a lesser effect than
+     * increasing `numSolverIterations` but is also less computationally expensive.
+     *
+     * @defaultValue 1
+     */
+    numInternalPgsIterations: number;
+    /**
+     * The maximal distance separating two objects that will generate predictive contacts
+     *
+     * @defaultValue 0.002
+     *
+     */
+    predictionDistance: number;
+    /**
+     * Minimum number of dynamic bodies in each active island
+     *
+     * @defaultValue 128
+     */
+    minIslandSize: number;
+    /**
+     * Maximum number of substeps performed by the solver
+     *
+     * @defaultValue 1
+     */
+    maxCcdSubsteps: number;
+    /**
+     * Directly affects the `erp` (Error Reduction Parameter) which is the proportion (0 to 1) of the positional error to be corrected at each time step.
+     * The higher this value is, the more the physics engine will try to correct errors.
+     *
+     * This prop is currently undocumented in the Rapier documentation.
+     *
+     * @see https://github.com/dimforge/rapier/pull/651 where this change was made to Rapier
+     * @defaultValue 30
+     */
+    contactNaturalFrequency: number;
+    /**
+     * The approximate size of most dynamic objects in the scene.
+     *
+     * This value is used internally to estimate some length-based tolerance.
+     * This value can be understood as the number of units-per-meter in your physical world compared to a human-sized world in meter.
+     *
+     * @defaultValue 1
+     */
+    lengthUnit: number;
+    /**
+     * Set the timestep for the simulation.
+     * Setting this to a number (eg. 1/60) will run the
+     * simulation at that framerate. Alternatively, you can set this to
+     * "vary", which will cause the simulation to always synchronize with
+     * the current frame delta times.
+     *
+     * @defaultValue 1/60
+     */
+    timeStep: number | "vary";
+    /**
+     * Pause the physics simulation
+     *
+     * @defaultValue false
+     */
+    paused: boolean;
+    /**
+     * Interpolate the world transform using the frame delta times.
+     * Has no effect if timeStep is set to "vary".
+     *
+     * @defaultValue true
+     **/
+    interpolate: boolean;
+    /**
+     * Enable debug rendering of the physics world.
+     * @defaultValue false
+     */
+    debug: boolean;
+}

package/dist/behaviours/physics/rapier-addon-core/get-scale-from-obj.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from "three/webgpu";
+export declare const getHalfheightRadiusScale: (object: THREE.Object3D) => {
+    radius: number;
+    halfHeight: number;
+};
+export declare const getRadiusScale: (object: THREE.Object3D) => {
+    radius: number;
+};

package/dist/behaviours/player/SightInteractableArea.d.ts

@@ -0,0 +1,23 @@
+import { Object3DBehaviour } from "three-start";
+import * as THREE from "three/webgpu";
+export default class SightInteractableArea extends Object3DBehaviour<{
+    activechanged: [active: boolean];
+    interaction: [];
+}> {
+    private static _CURRENT;
+    readonly isSightInteractableArea = true;
+    radius: number;
+    hint: string;
+    interactEnabled: boolean;
+    isStatic: boolean;
+    _sqRadius: number;
+    _active: boolean;
+    _initWorldPos: THREE.Vector3;
+    onEnable(): void;
+    onDisable(): void;
+    setRadius(r: number): void;
+    onBeforeRender(): void;
+    private _activate;
+    private _deactivate;
+    private _interact;
+}

package/dist/behaviours/registry.d.ts

@@ -0,0 +1,16 @@
+import type { Object3DBehaviourConstructor, ThreeStart } from "three-start";
+/**
+ * Built-in behaviour: uuid is its identity in user worlds — it must never
+ * change. The class loads lazily, so a world without physics doesn't pull rapier.
+ */
+export interface BuiltinBehaviour {
+    uuid: string;
+    name: string;
+    load: () => Promise<Object3DBehaviourConstructor>;
+    /** Registers ctx modules the behaviour needs. Strictly before `start()`. */
+    requiredPatch?: (starter: ThreeStart) => Promise<void>;
+}
+/** Registry of built-in behaviours by uuid — source of truth for both game and export. */
+export declare const BUILTIN_BEHAVIOURS: Record<string, BuiltinBehaviour | undefined>;
+export declare const BUILTIN_BEHAVIOUR_LIST: readonly BuiltinBehaviour[];
+export declare function getBuiltinBehaviour(uuid: string): BuiltinBehaviour | undefined;

package/dist/behaviours/utils/MeshInstansing.d.ts

@@ -0,0 +1,12 @@
+import { Object3DBehaviour } from "three-start";
+import * as THREE from "three/webgpu";
+export default class MeshInstansing extends Object3DBehaviour {
+    private static _totalInstance;
+    geometry: THREE.BufferGeometry | null;
+    material: THREE.Material | null;
+    transformsRoot: THREE.Object3D | null;
+    useThisAsRoot: boolean;
+    private _detach?;
+    onEnable(): void;
+    onDisable(): void;
+}

package/dist/bootstrap.d.ts

@@ -0,0 +1,8 @@
+import { World } from "./World";
+import type { LoadWorldOptions, WorldDefinition } from "./types";
+/**
+ * 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`).
+ */
+export declare function bootstrapWorld<TAssets>(definition: WorldDefinition<TAssets>, options: LoadWorldOptions): Promise<World>;

package/dist/define-world.d.ts

@@ -0,0 +1,9 @@
+import type { World } from "./World";
+import type { LoadWorldOptions, WorldDefinition } from "./types";
+/**
+ * Entry point of the generated artifact: world definition → public `loadWorld`.
+ * The codegen prints `export const { loadWorld } = defineWorld({ ... })`.
+ */
+export declare function defineWorld<TAssets>(definition: WorldDefinition<TAssets>): {
+    loadWorld: (options?: LoadWorldOptions) => Promise<World>;
+};

package/dist/get-scale-from-obj-QKv3Fig5.js

@@ -0,0 +1,22 @@
+import * as THREE from "three/webgpu";
+//#region packages/world-runtime/src/behaviours/physics/rapier-addon-core/get-scale-from-obj.ts
+var _hrScale = {
+	radius: 1,
+	halfHeight: 1
+};
+var _v = new THREE.Vector3();
+var getHalfheightRadiusScale = (object) => {
+	const scale = object.getWorldScale(_v);
+	_hrScale.radius = Math.max(scale.x, scale.z);
+	_hrScale.halfHeight = scale.y;
+	return _hrScale;
+};
+var getRadiusScale = (object) => {
+	const scale = object.getWorldScale(_v);
+	scale.x = Math.max(scale.x, scale.y);
+	scale.x = Math.max(scale.x, scale.z);
+	_hrScale.radius = scale.x;
+	return _hrScale;
+};
+//#endregion
+export { getRadiusScale as n, getHalfheightRadiusScale as t };

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+export { defineWorld } from "./define-world";
+export { World } from "./World";
+export type { InstantiateOptions, PrefabFactory } from "./WorldRuntime";
+export { setColor } from "./values";
+export { RUNTIME_VERSION, WORLD_FORMAT_VERSION } from "./version";
+export { WorldEvent } from "./world-events";
+export { createWorldModules, EnvModule, HtmlHudModule, InputSystemModule, isMobileDevice, SoundsModule, UtilsModule, } from "./modules";
+export type { EnvMode, WorldModules } from "./modules";
+export { DEFAULT_RESOURCE_IDS, DefaultResourceId, getDefaultResource, isDefaultResourceId, } from "./resources/default-resources";
+export type { DefaultResourceIdValue, DefaultResourceTypes, } from "./resources/default-resources";
+export { AssetLoaders, configureAssetLoaders, LOADING_MANAGER } from "./resources/loaders";
+export { applyTextureDefaults, loadTexture } from "./resources/texture";
+export { collectModelSubResources, loadModel, parseModel } from "./resources/model";
+export type { ModelFormat, ModelSubResources } from "./resources/model";
+export { loadHdr, parseHdr } from "./resources/hdr";
+export type { HdrFormat } from "./resources/hdr";
+export { loadGeometry, parseGeometryJson } from "./resources/geometry";
+export { AudioSource, createAudio } from "./resources/audio";
+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 { 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 { 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 { 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 { 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";