@kvyverse/world-runtime 0.1.0

package/dist/modules/EnvModule.d.ts

@@ -0,0 +1,11 @@
+import { ContextModule } from "three-start";
+import type { EnvModuleApi } from "./contracts/env.module-api";
+/** Where the world runs: `dev` — testplay from the editor, `prod` — the game. */
+export type EnvMode = EnvModuleApi["mode"];
+export declare class EnvModule extends ContextModule implements EnvModuleApi {
+    dev: boolean;
+    prod: boolean;
+    mode: EnvMode;
+    isMobile: boolean;
+    constructor(mode: EnvMode);
+}

package/dist/modules/HtmlHudModule.d.ts

@@ -0,0 +1,14 @@
+import { ContextModule } from "three-start";
+import type { HtmlModuleApi } from "./contracts/html.module-api";
+export declare class HtmlHudModule extends ContextModule implements HtmlModuleApi {
+    readonly root: HTMLDivElement;
+    readonly crosshair: HTMLDivElement;
+    constructor();
+    onAwake(): void;
+    append(...nodes: Array<Node | string>): void;
+    setCrosshair(innerHtml: string): void;
+    /** three-start ContextModule has no onDestroy; teardown is explicit. */
+    dispose(): void;
+    private readonly onMount;
+    private readonly onUnmount;
+}

package/dist/modules/InputSystemModule.d.ts

@@ -0,0 +1,87 @@
+import { ContextModule } from "three-start";
+import EventEmitter from "eventemitter3";
+import * as THREE from "three/webgpu";
+import type { InputModuleApi } from "./contracts/input.module-api";
+declare class PlayerInput extends EventEmitter<{
+    dirchanged: [forward: number, lateral: number];
+    forcechanged: [force: number];
+    jump: [];
+}> {
+    private _forward;
+    private _lateral;
+    private _force;
+    /**
+     * @default 0
+     */
+    get forward(): number;
+    /**
+     * @default 0
+     */
+    get lateral(): number;
+    /**
+     * @default 1
+     */
+    get force(): number;
+    setDir(forward: number, lateral: number): void;
+    setForce(force: number): void;
+    jump(): void;
+    /**
+     * 0 is keyboard, 1 is joystick
+     * @default 0
+     */
+    mode: 0 | 1;
+}
+export declare class InputSystemModule extends ContextModule<{
+    keyschanged: [];
+}> implements InputModuleApi {
+    private _dom;
+    private readonly _keys;
+    private _shift;
+    private _alt;
+    private _ctrl;
+    private _meta;
+    private _isDragging;
+    private readonly _pointerNdc;
+    private readonly _averageActivePointersCoords;
+    private _pointerXStack;
+    private _pointerYStack;
+    private _domBoundingClientRect;
+    readonly activePointers: Map<number, PointerEvent>;
+    get pointerDeltaX(): number;
+    get pointerDeltaY(): number;
+    get isDragging(): boolean;
+    /** Pointer position {x,y} in normalized device coordinates (-1 to +1) */
+    get pointerNdc(): THREE.Vector2;
+    get shiftKey(): boolean;
+    get altKey(): boolean;
+    get ctrlKey(): boolean;
+    get metaKey(): boolean;
+    isKeyDown: (key: string) => boolean;
+    readonly player: PlayerInput;
+    onAwake(): void;
+    /** three-start `ContextModule` has no `onDestroy`; teardown is explicit. */
+    dispose(): void;
+    private onWindowResize;
+    private onWindowScroll;
+    private onDomResize;
+    private onFocus;
+    private onBlur;
+    private onKeyDown;
+    private onKeyUp;
+    private onPointerEnter;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private onPointerLeave;
+    private resetKeys;
+    private updFnKeys;
+    private updateAverageActivePointersCoords;
+    private updateStackAndNdcByActivePointers;
+    private updateStackAndNdcByPointer;
+    private pushPointerStack;
+    private fillPointerStack;
+    private resetPointers;
+    private recalculatePointerNdc;
+    private updateDomBoundingClientRect;
+}
+export {};

package/dist/modules/SoundsModule.d.ts

@@ -0,0 +1,7 @@
+import { ContextModule } from "three-start";
+import type { SoundsModuleApi } from "./contracts/sounds.module-api";
+export declare class SoundsModule extends ContextModule implements SoundsModuleApi {
+    readonly global: HowlerGlobal;
+    /** three-start ContextModule has no onDestroy; teardown is explicit. */
+    dispose(): void;
+}

package/dist/modules/UtilsModule.d.ts

@@ -0,0 +1,9 @@
+import { ContextModule } from "three-start";
+import { mergeGeometries } from "three/examples/jsm/utils/BufferGeometryUtils.js";
+import { clone } from "three/examples/jsm/utils/SkeletonUtils.js";
+import type { UtilsModuleApi } from "./contracts/utils.module-api";
+export declare class UtilsModule extends ContextModule implements UtilsModuleApi {
+    cloneObject3D: typeof clone;
+    mergeGeometries: typeof mergeGeometries;
+    constructor();
+}

package/dist/modules/contracts/env.module-api.d.ts

@@ -0,0 +1,7 @@
+/** Public API of the `env` module — environment flags (dev/prod, mobile). */
+export interface EnvModuleApi {
+    readonly dev: boolean;
+    readonly prod: boolean;
+    readonly mode: "dev" | "prod";
+    readonly isMobile: boolean;
+}

package/dist/modules/contracts/html.module-api.d.ts

@@ -0,0 +1,7 @@
+/** Public API of the `html` module — fullscreen HTML HUD on top of the canvas. */
+export interface HtmlModuleApi {
+    readonly root: HTMLDivElement;
+    readonly crosshair: HTMLDivElement;
+    append: (...nodes: Array<Node | string>) => void;
+    setCrosshair: (innerHtml: string) => void;
+}

package/dist/modules/contracts/input.module-api.d.ts

@@ -0,0 +1,31 @@
+import type * as THREE from "three/webgpu";
+/**
+ * Public API of the input module, available in user scripts
+ * (`this.modules.input` / `Game.ctx.modules.input`).
+ *
+ * Source of truth: the real `InputSystemModule implements InputModuleApi` —
+ * if the class stops matching the contract, the project won't compile.
+ * This same file is fed into Monaco (see `monaco/monaco-lib-types.ts`).
+ */
+export interface InputModuleApi {
+    readonly pointerDeltaX: number;
+    readonly pointerDeltaY: number;
+    readonly isDragging: boolean;
+    readonly pointerNdc: THREE.Vector2;
+    readonly activePointers: ReadonlyMap<number, PointerEvent>;
+    readonly shiftKey: boolean;
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly metaKey: boolean;
+    isKeyDown: (key: string) => boolean;
+    readonly player: PlayerInputApi;
+}
+/** Player's virtual gamepad stick (`input.player`). */
+export interface PlayerInputApi {
+    readonly forward: number;
+    readonly lateral: number;
+    readonly force: number;
+    setDir: (forward: number, lateral: number) => void;
+    setForce: (force: number) => void;
+    jump: () => void;
+}

package/dist/modules/contracts/rapier.module-api.d.ts

@@ -0,0 +1,11 @@
+import type RAPIER from "@dimforge/rapier3d-compat";
+export type RapierJsModule = typeof RAPIER;
+/** Public API of the `rapier` module — Rapier physics world, event queue, simulation step. */
+export interface RapierModuleApi {
+    readonly isRapierPhysics: true;
+    readonly api: RapierJsModule;
+    readonly world: RAPIER.World;
+    readonly eventQueue: RAPIER.EventQueue;
+    /** @default "vary" */
+    timeStep: number | "vary";
+}

package/dist/modules/contracts/rapierDebug.module-api.d.ts

@@ -0,0 +1,5 @@
+/** Public API of the `rapierDebug` module — toggleable line rendering of the Rapier world. */
+export interface RapierDebugModuleApi {
+    enabled: boolean;
+    init: () => void;
+}

package/dist/modules/contracts/sounds.module-api.d.ts

@@ -0,0 +1,5 @@
+import type { Howler } from "howler";
+/** Public API of the `sounds` module — global Howler audio controller. */
+export interface SoundsModuleApi {
+    readonly global: typeof Howler;
+}

package/dist/modules/contracts/utils.module-api.d.ts

@@ -0,0 +1,7 @@
+import type { mergeGeometries } from "three/examples/jsm/utils/BufferGeometryUtils.js";
+import type { clone } from "three/examples/jsm/utils/SkeletonUtils.js";
+/** Public API of the `utils` module — three.js helpers (clone, merge geometries, type-guard). */
+export interface UtilsModuleApi {
+    readonly cloneObject3D: typeof clone;
+    readonly mergeGeometries: typeof mergeGeometries;
+}

package/dist/modules/index.d.ts

@@ -0,0 +1,22 @@
+import { EnvModule } from "./EnvModule";
+import { HtmlHudModule } from "./HtmlHudModule";
+import { InputSystemModule } from "./InputSystemModule";
+import { SoundsModule } from "./SoundsModule";
+import { UtilsModule } from "./UtilsModule";
+import type { EnvMode } from "./EnvModule";
+export { EnvModule } from "./EnvModule";
+export { HtmlHudModule } from "./HtmlHudModule";
+export { InputSystemModule } from "./InputSystemModule";
+export { SoundsModule } from "./SoundsModule";
+export { UtilsModule } from "./UtilsModule";
+export { isMobileDevice } from "./is-mobile-device";
+export type { EnvMode } from "./EnvModule";
+export type WorldModules = {
+    env: EnvModule;
+    html: HtmlHudModule;
+    input: InputSystemModule;
+    sounds: SoundsModule;
+    utils: UtilsModule;
+};
+/** World ctx modules. Registered before `start()` — three-start forbids it later. */
+export declare function createWorldModules(mode?: EnvMode): WorldModules;

package/dist/modules/is-mobile-device.d.ts

@@ -0,0 +1 @@
+export declare function isMobileDevice(): boolean;

package/dist/modules/registry.d.ts

@@ -0,0 +1,31 @@
+import type { RapierDebugRenderer } from "../behaviours/physics/rapier-addon-core/RapierDebugRenderer";
+import type { RapierPhysics } from "../behaviours/physics/rapier-addon-core/RapierPhysics";
+import type { EnvModule } from "./EnvModule";
+import type { HtmlHudModule } from "./HtmlHudModule";
+import type { InputSystemModule } from "./InputSystemModule";
+import type { SoundsModule } from "./SoundsModule";
+import type { UtilsModule } from "./UtilsModule";
+/**
+ * Single registry of the world's three-start modules: key → concrete class.
+ * Source of truth for the module list and their types inside the engine; the
+ * public contracts of the same modules (for Monaco) live in
+ * `./contracts/*.module-api.ts`, which the classes `implements`.
+ *
+ * three-start types modules globally (no per-ctx generic), so a module declared
+ * here may be missing in a particular ctx (e.g. editor-ctx registers only `input`).
+ */
+export interface KvyverseModules {
+    input: InputSystemModule;
+    env: EnvModule;
+    html: HtmlHudModule;
+    sounds: SoundsModule;
+    utils: UtilsModule;
+    rapier: RapierPhysics;
+    rapierDebug: RapierDebugRenderer;
+}
+declare module "three-start" {
+    interface ThreeStartRegister {
+        modules: KvyverseModules;
+    }
+}
+export {};

package/dist/rendering/SceneBloom.d.ts

@@ -0,0 +1,40 @@
+import type BloomNode from "three/addons/tsl/display/BloomNode.js";
+import type * as THREE from "three/webgpu";
+import type { BloomModeName } from "./renderer-options";
+import type { BloomConfig } from "../settings/types";
+/**
+ * Enables MRT `{ output, emissive }` on the scenePass. Idempotent. IMPORTANT:
+ * MRT is part of the WebGPU pipelines' attachment state; enable it either before
+ * the first frame (game), or sticky + material invalidation (editor). It must
+ * NEVER be disabled at runtime — see `./README.md` → "MRT and attachment state".
+ */
+export declare function enableSceneEmissiveMrt(scenePass: THREE.PassNode): void;
+/**
+ * Bloom post-effect over the scenePass (editor + game). `mode=threshold` —
+ * full-frame by brightness; `mode=emissive` — selective, via the emissive MRT
+ * target (MRT must be enabled by the caller via `enableSceneEmissiveMrt` BEFORE
+ * creation). SceneBloom does not own the MRT topology. Pipeline contracts — `./README.md`.
+ */
+export declare class SceneBloom {
+    readonly mode: BloomModeName;
+    /** Bloom contribution (RGB) — for custom outputNode composition (editor). */
+    readonly node: BloomNode;
+    /** `scenePassColor + bloom` — ready outputNode for the default pipeline (game). */
+    readonly sceneWithBloom: THREE.Node;
+    private constructor();
+    static createAsync(props: {
+        scenePass: THREE.PassNode;
+        config: BloomConfig;
+    }): Promise<SceneBloom>;
+    /** strength/radius/threshold are uniforms — applied on the fly without a rebuild. */
+    updateParams(cfg: BloomConfig): void;
+    get strength(): number;
+    set strength(value: number);
+    get radius(): number;
+    set radius(value: number);
+    get threshold(): number;
+    set threshold(value: number);
+    /** true — a mode change requires recreation (dispose + createAsync + new outputNode). */
+    needsRebuild(cfg: BloomConfig): boolean;
+    dispose(): void;
+}

package/dist/rendering/renderer-apply.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from "three/webgpu";
+import type { RendererConfig } from "../settings/types";
+/**
+ * Applies the runtime part of `RendererConfig` to an already created WebGPURenderer
+ * (shadowMap, toneMapping, pixelRatio). Used by game (once on load) and editor
+ * (live, see `editor/rendering`). Defaults: PCFSoft shadows, Neutral tonemap,
+ * pixelResolution=1. Construction params (`cfg.renderer`) are applied only in
+ * the renderer constructor (see `createGameCtx`).
+ *
+ * The config is NOT schema-validated at runtime (raw JSON.parse), so bad values
+ * (enum typo, non-number) fall back to defaults instead of producing an
+ * `undefined` constant / `NaN` (silently broken rendering).
+ */
+export declare function applyRendererConfig(renderer: THREE.Renderer, cfg: RendererConfig): void;

package/dist/rendering/renderer-options.d.ts

@@ -0,0 +1,11 @@
+/**
+ * String names for renderer options set as words in the config and mapped to
+ * THREE constants at runtime (game). Single source for the JSON schema
+ * (`renderer.schema`) and the runtime mapping (`game`).
+ */
+export declare const SHADOW_MAP_TYPES: readonly ["Basic", "PCF", "PCFSoft", "VSM"];
+export type ShadowMapTypeName = (typeof SHADOW_MAP_TYPES)[number];
+export declare const BLOOM_MODES: readonly ["threshold", "emissive"];
+export type BloomModeName = (typeof BLOOM_MODES)[number];
+export declare const TONE_MAPPING_NAMES: readonly ["None", "Linear", "Reinhard", "Cineon", "ACESFilmic", "AgX", "Neutral"];
+export type ToneMappingName = (typeof TONE_MAPPING_NAMES)[number];

package/dist/rendering/tsl-node.d.ts

@@ -0,0 +1,21 @@
+import * as TSL from "three/tsl";
+import type { Node } from "three/webgpu";
+/** TSL node body: returns a graph node, receiving `TSL` and the uniform nodes. */
+export type TslNodeBuilder = (tsl: typeof TSL, uniforms: Record<string, Node>) => Node | null | undefined;
+/**
+ * World TSL node: the built graph node + its uniform nodes. This is what
+ * `require("/Shaders/....tsl")` returns, so the method set matches the editor's
+ * `TslNodeSource` (`setUniformValue` / `getUniformValue` / `uniformValues`).
+ */
+export declare class TslNode {
+    readonly uniforms: Record<string, Node>;
+    readonly node: Node;
+    private _uniformValuesView?;
+    constructor(uniforms: Record<string, Node>, build: TslNodeBuilder, name?: string);
+    /** Flat view of uniform values: reads and writes go straight to `node.value`. */
+    get uniformValues(): Record<string, unknown>;
+    setUniformValue(key: string, value: unknown): void;
+    getUniformValue(key: string): unknown;
+}
+/** Factory for the generated code: builds the node and wraps it. */
+export declare function createTslNode(uniforms: Record<string, Node>, build: TslNodeBuilder, name?: string): TslNode;

package/dist/rendering/tsl-uniforms.d.ts

@@ -0,0 +1,18 @@
+import type { Node } from "three/webgpu";
+/**
+ * Uniform parameter types of a TSL node. The `uniforms` nodes on `TslNodeSource`
+ * are the single source of truth: the type is read from the node ({@link uniformType}),
+ * the default is baked in ({@link UNIFORM_DEFAULTS}). Details — `docs/tsl-shading.md`.
+ */
+export type UniformType = "float" | "int" | "vec2" | "vec3" | "vec4" | "color" | "bool" | "texture";
+export declare const UNIFORM_TYPES: readonly ["float", "int", "vec2", "vec3", "vec4", "color", "bool", "texture"];
+export declare function isUniformType(x: string): x is UniformType;
+/** Uniform node type. Texture is a separate class; the rest carry an explicit `nodeType`. */
+export declare function uniformType(node: Node): UniformType;
+/** Creates a uniform node with the type's baked-in default. The type is set
+ * explicitly — otherwise `int`/`float` and `color`/`vec3` are indistinguishable
+ * from the value. */
+export declare function createUniformNode(type: UniformType): Node;
+/** Default value per type — for `Property.setDefault` (value==default is not
+ * serialized, restored on load). Factories, since Color/Vec are mutable. */
+export declare const UNIFORM_DEFAULTS: Record<UniformType, () => unknown>;

package/dist/resources/audio.d.ts

@@ -0,0 +1,15 @@
+import { Howl } from "howler";
+/**
+ * Audio asset source: a `Howl` with identity — this is what scripts get
+ * from `require("/Sounds/...")`.
+ */
+export declare class AudioSource extends Howl {
+    private readonly _url;
+    name: string;
+    uuid: `${string}-${string}-${string}-${string}-${string}`;
+    constructor(_url: string, ...args: ConstructorParameters<typeof Howl>);
+    /** Revoke blob URLs (the editor keeps the file in memory); external URLs stay. */
+    dispose(): void;
+}
+/** Loaded audio from a URL. `format` — extension hint when it's absent from the URL. */
+export declare function createAudio(url: string, format?: string | string[], name?: string): Promise<AudioSource>;

package/dist/resources/default-resources.d.ts

@@ -0,0 +1,36 @@
+import * as THREE from "three/webgpu";
+/**
+ * Built-in engine resources with fixed uuids: world values reference them via
+ * a regular ref (`{$A:"6"}`), so the identifiers must never change.
+ */
+export declare const DefaultResourceId: {
+    readonly EmptyGeometry: "0";
+    readonly BoxGeometry: "1";
+    readonly SphereGeometry: "2";
+    readonly PlaneGeometry: "3";
+    readonly CylinderGeometry: "4";
+    readonly PyramidGeometry: "5";
+    readonly Material: "6";
+    readonly SpriteMaterial: "7";
+    readonly Texture: "8";
+};
+export type DefaultResourceIdValue = (typeof DefaultResourceId)[keyof typeof DefaultResourceId];
+/** Resource type by id — so call sites need no casts. */
+export interface DefaultResourceTypes {
+    "0": THREE.BufferGeometry;
+    "1": THREE.BoxGeometry;
+    "2": THREE.SphereGeometry;
+    "3": THREE.PlaneGeometry;
+    "4": THREE.CylinderGeometry;
+    "5": THREE.ConeGeometry;
+    "6": THREE.MeshStandardNodeMaterial;
+    "7": THREE.SpriteNodeMaterial;
+    "8": THREE.DataTexture;
+}
+/**
+ * Resource by its uuid. Lazy and cached: an exported world creates only
+ * what it actually references.
+ */
+export declare function getDefaultResource<TId extends DefaultResourceIdValue>(id: TId): DefaultResourceTypes[TId];
+export declare const DEFAULT_RESOURCE_IDS: DefaultResourceIdValue[];
+export declare function isDefaultResourceId(uuid: string): uuid is DefaultResourceIdValue;

package/dist/resources/font.d.ts

@@ -0,0 +1,32 @@
+import type { Font } from "three/examples/jsm/loaders/FontLoader.js";
+/** CSS font format by mime (for `@font-face … format(...)`). */
+export declare function fontFormatFromMime(mime: string): string;
+/**
+ * Font source: the CSS side (`family` + `toFontFaceCss`) and the three side
+ * (`getThreeFontAsync`, lazy TTFLoader/opentype chunk).
+ */
+export declare class FontSource {
+    readonly url: string;
+    /** CSS format (`truetype`, `woff2`, …) — see `fontFormatFromMime`. */
+    readonly format: string;
+    name: string;
+    uuid: `${string}-${string}-${string}-${string}-${string}`;
+    /** CSS font-family. Edited in the inspector, persisted in `values.src.family`. */
+    family: string;
+    private _threeFontPromise;
+    constructor(url: string, family: string, 
+    /** CSS format (`truetype`, `woff2`, …) — see `fontFormatFromMime`. */
+    format: string);
+    /** Ready-to-use `@font-face` rule for the game document. */
+    toFontFaceCss(): string;
+    /**
+     * three.js `Font` (for TextGeometry etc.). Lazy TTFLoader import
+     * (pulls opentype ~100kB gzip), the result is cached. woff2 is not
+     * supported by opentype — throws a clear error.
+     */
+    getThreeFontAsync(): Promise<Font>;
+    dispose(): void;
+    private _parseThreeFontAsync;
+}
+/** Font source from a URL. `mime` determines the CSS format of the `@font-face` rule. */
+export declare function createFont(url: string, family: string, mime: string, name?: string): FontSource;

package/dist/resources/geometry.d.ts

@@ -0,0 +1,5 @@
+import type * as THREE from "three/webgpu";
+/** Geometry from our json format (`BufferGeometry.toJSON`). */
+export declare function parseGeometryJson(json: unknown, name?: string): THREE.BufferGeometry;
+/** Loads geometry from a URL and parses it. */
+export declare function loadGeometry(url: string, name?: string): Promise<THREE.BufferGeometry>;

package/dist/resources/hdr.d.ts

@@ -0,0 +1,6 @@
+import * as THREE from "three/webgpu";
+export type HdrFormat = "hdr" | "exr";
+/** Parses hdr/exr into a `DataTexture` with environment defaults (equirect, no mipmaps). */
+export declare function parseHdr(data: ArrayBuffer, format: HdrFormat, name?: string): Promise<THREE.DataTexture>;
+/** Loads hdr/exr from a URL and parses it. */
+export declare function loadHdr(url: string, format: HdrFormat, name?: string): Promise<THREE.DataTexture>;

package/dist/resources/loaders.d.ts

@@ -0,0 +1,45 @@
+import { BufferGeometryLoader, LoadingManager, TextureLoader } from "three/webgpu";
+export declare const LOADING_MANAGER: LoadingManager;
+declare const options: {
+    /**
+     * Draco decoder folder (file names inside are fixed, the folder is
+     * versioned). Default — the public Google decoder: always available and
+     * served with CORS, so an exported world works without our infrastructure.
+     * The host may override it: the app serves its own copy from
+     * `public/draco/<hash>/`, a self-hosted world — via `loadWorld({ dracoPath })`.
+     */
+    dracoPath: string;
+};
+/** Loader configuration. Called by the host before the first asset load. */
+export declare function configureAssetLoaders(next: Partial<typeof options>): void;
+/** Lazy three loaders: the chunk is pulled only on first use of the format. */
+export declare const AssetLoaders: {
+    texture: {
+        get: () => TextureLoader;
+    };
+    gltf: {
+        get: () => Promise<import("three/examples/jsm/loaders/GLTFLoader.js").GLTFLoader>;
+    };
+    fbx: {
+        get: () => Promise<import("three/examples/jsm/loaders/FBXLoader.js").FBXLoader>;
+    };
+    obj: {
+        get: () => Promise<import("three/examples/jsm/loaders/OBJLoader.js").OBJLoader>;
+    };
+    rgbe: {
+        get: () => Promise<import("three/examples/jsm/loaders/RGBELoader.js").RGBELoader>;
+    };
+    exr: {
+        get: () => Promise<import("three/examples/jsm/loaders/EXRLoader.js").EXRLoader>;
+    };
+    bufferGeometry: {
+        get: () => BufferGeometryLoader;
+    };
+    font: {
+        get: () => Promise<{
+            ttfLoader: import("three/examples/jsm/loaders/TTFLoader.js").TTFLoader;
+            Font: typeof import("three/examples/jsm/loaders/FontLoader.js").Font;
+        }>;
+    };
+};
+export {};

package/dist/resources/model.d.ts

@@ -0,0 +1,24 @@
+import type * as THREE from "three/webgpu";
+export type ModelFormat = "gltf" | "glb" | "fbx" | "obj";
+/**
+ * 3D model sub-resources in traversal order. The order is part of the contract:
+ * the editor numbers sub-assets by it (`<uuid>_geom_<i>`), the export codegen
+ * resolves refs by the same indices.
+ */
+export interface ModelSubResources {
+    geometries: THREE.BufferGeometry[];
+    materials: THREE.Material[];
+    textures: THREE.Texture[];
+    animations: THREE.AnimationClip[];
+    skeletons: THREE.Skeleton[];
+}
+/** Parses model bytes into a hierarchy. `data`: ArrayBuffer, for obj — text. */
+export declare function parseModel(data: ArrayBuffer | string, format: ModelFormat, name?: string): Promise<THREE.Object3D>;
+/** Loads a model from a URL and parses it. */
+export declare function loadModel(url: string, format: ModelFormat, name?: string): Promise<THREE.Object3D>;
+/**
+ * Collects model sub-resources in a single traversal. The only implementation:
+ * used by `Model3DAsset` in the editor and by the export generator — otherwise
+ * refs to the model's materials and geometries drift apart by index.
+ */
+export declare function collectModelSubResources(root: THREE.Object3D): ModelSubResources;

package/dist/resources/texture.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from "three/webgpu";
+/**
+ * World texture defaults: clamp wrapping switches to repeat, color space
+ * is sRGB. Identical in the editor, the game and the exported world.
+ */
+export declare function applyTextureDefaults(texture: THREE.Texture, name?: string): void;
+/** Texture from a URL with defaults applied. */
+export declare function loadTexture(url: string, name?: string): Promise<THREE.Texture>;

package/dist/resources/video.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Video asset source: a `<video>` with identity — this is what scripts get
+ * from `require("/Videos/...")` (and `THREE.VideoTexture` from `element`).
+ */
+export declare class VideoSource {
+    readonly element: HTMLVideoElement;
+    private _url;
+    name: string;
+    uuid: `${string}-${string}-${string}-${string}-${string}`;
+    constructor(element: HTMLVideoElement, _url: string | null);
+    dispose(): void;
+}
+/** Playback-ready `<video>` from a URL (waits for `loadeddata`). */
+export declare function createVideo(url: string, name?: string): Promise<VideoSource>;

package/dist/rolldown-runtime-D7D4PA-g.js

@@ -0,0 +1,13 @@
+//#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
+export { __exportAll as t };

package/dist/settings/AddonsRuntime.d.ts

@@ -0,0 +1,19 @@
+import type { AddonsConfig } from "./types";
+/**
+ * Runtime loading of addons (game-only): enabled built-in libs + external
+ * scripts (externals). Exposes them to user scripts via `resolve(key)`
+ * (used in `ScriptsRuntime.require`). Replaces the old
+ * `GameLoader.loadExternalsAsync` / `getExternalLib`.
+ */
+export declare class AddonsRuntime {
+    /** libs — by requireKey (`@tweenjs/tween.js`), externals — by accessor (`Tone`). */
+    private readonly _byKey;
+    private readonly _scriptTags;
+    load(addons: AddonsConfig): Promise<void>;
+    /** Resolves a require key: enabled lib or external accessor; undefined otherwise. */
+    resolve(key: string): unknown;
+    private _loadLibs;
+    private _loadExternals;
+    private _mountScript;
+    dispose(): void;
+}

package/dist/settings/externals.d.ts

@@ -0,0 +1,14 @@
+/**
+ * External scripts enabled via `settings.addons.json → externals`.
+ * The user configures them manually. Resolved in scripts via
+ * `require("<accessor>")`. Loading/mount — game (`AddonsRuntime`):
+ *  - `umd` → `<script>` tag → `window[accessor]`,
+ *  - `module` → `await import(src)` → cached by `accessor`.
+ */
+export type ExternalType = "umd" | "module";
+export interface ExternalDescriptor {
+    accessor: string;
+    type: ExternalType;
+    src: string;
+}
+export declare const EXTERNAL_TYPES: readonly ExternalType[];

package/dist/settings/lib-loaders.d.ts

@@ -0,0 +1,7 @@
+import { LibId } from "./lib-registry";
+/**
+ * Dynamic loaders of built-in libs (game-only). Key — `LibId` from the registry;
+ * the value resolves for the user via `require("<requireKey>")`. Imports are lazy —
+ * bundled only when the lib is enabled in `settings.addons.json`.
+ */
+export declare const LIB_LOADERS: Record<LibId, () => Promise<unknown>>;