@kvyverse/world-runtime 0.1.0 → 0.4.2

package/dist/modules/controls/ControlsModule.d.ts

@@ -0,0 +1,45 @@
+import { ContextModule } from "three-start";
+import * as THREE from "three/webgpu";
+import type { ControlsDriver, ControlsEvents, ControlsModuleApi, ControlsSource } from "../contracts/controls.module-api";
+/**
+ * The player's movement intent — what they want to do, whatever the hardware is.
+ * Input sources register as drivers (`addDriver`); the module polls them once a
+ * frame and decides which one is driving. Details — `./README.md`.
+ */
+export declare class ControlsModule extends ContextModule<ControlsEvents> implements ControlsModuleApi {
+    /** x — strafe, y — forward. Reused vector: copy it before storing. */
+    readonly move: THREE.Vector2;
+    private readonly _drivers;
+    private readonly _state;
+    private _keyboard;
+    private _active;
+    private _source;
+    private _force;
+    private _run;
+    private _jump;
+    onAwake(): void;
+    /** Speed multiplier: 1 is a normal walk, higher means a stronger stick tilt. */
+    get force(): number;
+    /** Run modifier: shift, a stick pushed past its ring, a UI button. */
+    get run(): boolean;
+    /** Kind of the device driving right now. */
+    get source(): ControlsSource;
+    get drivers(): readonly ControlsDriver[];
+    /** The built-in keyboard driver — detach it with `removeDriver`. */
+    get keyboard(): ControlsDriver;
+    addDriver(driver: ControlsDriver): () => void;
+    removeDriver(driver: ControlsDriver): void;
+    jump(): void;
+    onUpdate(): void;
+    /**
+     * The active driver keeps the channel while it produces input — otherwise the
+     * keyboard and a stick would steal control from each other every frame. Once it
+     * goes quiet, the first driver with input takes over. The state is left filled
+     * by the winner, so nobody is read twice.
+     */
+    private _readActiveDriver;
+    private _readDriver;
+    private _resetState;
+    private _apply;
+}
+export default ControlsModule;

package/dist/modules/controls/KeyboardControlsDriver.d.ts

@@ -0,0 +1,12 @@
+import type { InputSystemModule } from "../InputSystemModule";
+import type { ControlsDriver, ControlsState } from "../contracts/controls.module-api";
+/**
+ * Keyboard driver for `controls`: WASD/arrows, shift to run, Space to jump.
+ * Reads key state from the `input` module and binds no listeners of its own.
+ */
+export declare class KeyboardControlsDriver implements ControlsDriver {
+    private readonly _input;
+    readonly kind = "keyboard";
+    constructor(_input: InputSystemModule);
+    read(state: ControlsState): void;
+}

package/dist/modules/index.d.ts

@@ -1,9 +1,16 @@
+import { ControlsModule } from "./controls/ControlsModule";
 import { EnvModule } from "./EnvModule";
 import { HtmlHudModule } from "./HtmlHudModule";
 import { InputSystemModule } from "./InputSystemModule";
 import { SoundsModule } from "./SoundsModule";
 import { UtilsModule } from "./UtilsModule";
+import type { AddonsRuntime } from "../addons/AddonsRuntime";
+import type { AddonsConfig } from "../addons/types";
 import type { EnvMode } from "./EnvModule";
+import type { KvyverseModules } from "./registry";
+export type { ChatModule } from "./chat/ChatModule";
+export type { ChatDom, ChatDomOptions } from "./chat/ChatDom";
+export { ControlsModule } from "./controls/ControlsModule";
 export { EnvModule } from "./EnvModule";
 export { HtmlHudModule } from "./HtmlHudModule";
 export { InputSystemModule } from "./InputSystemModule";
@@ -11,12 +18,32 @@ export { SoundsModule } from "./SoundsModule";
 export { UtilsModule } from "./UtilsModule";
 export { isMobileDevice } from "./is-mobile-device";
 export type { EnvMode } from "./EnvModule";
-export type WorldModules = {
+/** Modules every world has — no toggle for them. */
+export type CoreWorldModules = {
+    addons: AddonsRuntime;
+    controls: ControlsModule;
     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;
+/** @deprecated kept for compatibility; see `CoreWorldModules`. */
+export type WorldModules = CoreWorldModules;
+export interface CreateWorldModulesOptions {
+    /** The world's external dependencies, already loaded (libs, externals, rapier). */
+    addons: AddonsRuntime;
+    /** `settings.addons.json → modules`: which pluggable modules are on, and how. */
+    modules?: AddonsConfig["modules"];
+}
+/**
+ * Assembles the world's ctx modules: core ones always, pluggable ones per config.
+ * Pluggable classes are pulled dynamically, so a disabled module never reaches
+ * the bundle. Call strictly before `start()` and with addons already loaded: the
+ * physics module takes rapier from `ctx.modules.addons`.
+ *
+ * A module the scene needs without a line in the config (physics when a physics
+ * behaviour is present) is added separately — through the behaviour's
+ * `meta.requiredPatch`, with the same descriptor and idempotently.
+ */
+export declare function createWorldModules(mode: EnvMode | undefined, options: CreateWorldModulesOptions): Promise<CoreWorldModules & Partial<KvyverseModules>>;

package/dist/modules/optional-module-descriptor.d.ts

@@ -0,0 +1,39 @@
+import type { ContextModule } from "three-start";
+import type { LibId } from "../addons/lib-registry";
+/**
+ * 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.
+ */
+export declare enum OptionalModuleId {
+    Physics = "physics",
+    Chat = "chat"
+}
+export declare const OPTIONAL_MODULE_IDS: OptionalModuleId[];
+/** A JSON Schema (draft-07) fragment; structurally the platform's `JSONSchema`. */
+export type ModuleJsonSchema = Record<string, unknown>;
+/**
+ * Describes a pluggable module: how to read its value from the world config, how
+ * to create it and how to validate the config in the code editor. Defaults (is
+ * it on, in which mode) live in `normalize` — the registry knows nothing of them.
+ *
+ * Rule: `create` pulls the module class through a **dynamic** import, otherwise a
+ * disabled module still ends up in the bundle.
+ */
+export interface OptionalModuleDescriptor<TConfig = unknown> {
+    id: OptionalModuleId;
+    /** Config value → normalized config; `null` means the module is off. */
+    normalize: (raw: unknown) => TConfig | null;
+    /** Config for an on-demand enable (a behaviour pulled the module in without config). */
+    defaultConfig: () => TConfig;
+    /** The module class is pulled here — a disabled module never reaches the bundle. */
+    create: (config: TConfig) => Promise<ContextModule>;
+    /** Libs the module cannot work without: enabling it loads them (physics → rapier). */
+    requiredLibs?: LibId[];
+    /**
+     * JSON Schema fragment for `modules.<id>`: the platform assembles the
+     * `settings.addons.json` schema from these, so module keys never drift from the
+     * registry. The type is deliberately wide — the package knows nothing of Monaco.
+     */
+    schema: ModuleJsonSchema;
+}

package/dist/modules/optional-modules.d.ts

@@ -0,0 +1,11 @@
+import type { OptionalModuleDescriptor, OptionalModuleId } from "./optional-module-descriptor";
+/**
+ * Table of contents for the world's pluggable modules: what can be enabled from
+ * `settings.addons.json → modules`. The descriptors themselves live next to
+ * their module code; this is only the list.
+ *
+ * Add a descriptor here and the module shows up both in the runtime and in the
+ * config's JSON schema (the platform builds it from `descriptor.schema`).
+ */
+export declare const OPTIONAL_MODULES: ReadonlyArray<OptionalModuleDescriptor<any>>;
+export declare function getOptionalModuleDescriptor(id: OptionalModuleId): OptionalModuleDescriptor<any>;

package/dist/modules/physics/RapierDebugRenderer.d.ts

@@ -0,0 +1,19 @@
+import type { RapierPhysics } from "./RapierPhysics";
+import type { ThreeContext } from "three-start";
+/**
+ * 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}
+ */
+export declare class RapierDebugRenderer {
+    private readonly _ctx;
+    private readonly _rapier;
+    private _clear;
+    constructor(ctx: ThreeContext, rapier: RapierPhysics);
+    get enabled(): boolean;
+    start(): void;
+    stop(): void;
+}
+export default RapierDebugRenderer;

package/dist/{behaviours/physics/rapier-addon-core → modules/physics}/RapierPhysics.d.ts

@@ -2,7 +2,7 @@ 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";
+import type { RapierModuleApi } from "../contracts/rapier.module-api";
 export type ModulesWithRapierPhysics = {
     rapier: RapierPhysics;
 };
@@ -18,8 +18,17 @@ export declare class RapierPhysics extends ContextModule<{
     /** @default "vary" */
     timeStep: RapierPhysicsOptions["timeStep"];
     private _steppingState;
-    constructor(Rapier: RapierJsModule, options?: Partial<RapierPhysicsOptions>);
+    private _debug;
+    private readonly _debugOnStart;
+    private readonly _gravity;
+    constructor(options?: Partial<RapierPhysicsOptions>);
+    onAwake(): void;
     onStart(): void;
+    /** Whether collider outlines are being drawn right now. */
+    get isDebugEnabled(): boolean;
+    /** Turn on collider debug drawing; the renderer is fetched on demand. */
+    enableDebug(): Promise<void>;
+    disableDebug(): void;
     /** three-start ContextModule has no onDestroy; teardown is explicit. */
     dispose(): void;
     private update;
@@ -124,7 +133,8 @@ export interface RapierPhysicsOptions {
      **/
     interpolate: boolean;
     /**
-     * Enable debug rendering of the physics world.
+     * Start with the collider debug renderer on. The renderer itself is loaded
+     * on demand (`enableDebug()`), so worlds without debug never fetch it.
      * @defaultValue false
      */
     debug: boolean;

package/dist/modules/physics/physics.module-descriptor.d.ts

@@ -0,0 +1,16 @@
+import type { OptionalModuleDescriptor } from "../optional-module-descriptor";
+export type PhysicsEngine = "rapier";
+/** `modules.physics`: off | engine shorthand | an object with options. */
+export type PhysicsConfig = false | PhysicsEngine | {
+    engine: PhysicsEngine;
+    debug?: boolean;
+};
+export interface NormalizedPhysics {
+    engine: PhysicsEngine;
+    /** Turn collider debug drawing on right away (the renderer loads on demand). */
+    debug: boolean;
+}
+export declare const PHYSICS_ENGINES: readonly PhysicsEngine[];
+/** Physics defaults: the rapier engine, debug off. */
+export declare function normalizePhysics(value: PhysicsConfig | undefined): NormalizedPhysics | null;
+export declare const physicsModuleDescriptor: OptionalModuleDescriptor<NormalizedPhysics>;

package/dist/modules/registry.d.ts

@@ -1,5 +1,7 @@
-import type { RapierDebugRenderer } from "../behaviours/physics/rapier-addon-core/RapierDebugRenderer";
-import type { RapierPhysics } from "../behaviours/physics/rapier-addon-core/RapierPhysics";
+import type { RapierPhysics } from "./physics/RapierPhysics";
+import type { AddonsRuntime } from "../addons/AddonsRuntime";
+import type { ChatModule } from "./chat/ChatModule";
+import type { ControlsModule } from "./controls/ControlsModule";
 import type { EnvModule } from "./EnvModule";
 import type { HtmlHudModule } from "./HtmlHudModule";
 import type { InputSystemModule } from "./InputSystemModule";
@@ -15,13 +17,15 @@ import type { UtilsModule } from "./UtilsModule";
  * here may be missing in a particular ctx (e.g. editor-ctx registers only `input`).
  */
 export interface KvyverseModules {
+    addons: AddonsRuntime;
     input: InputSystemModule;
+    chat: ChatModule;
+    controls: ControlsModule;
     env: EnvModule;
     html: HtmlHudModule;
     sounds: SoundsModule;
     utils: UtilsModule;
     rapier: RapierPhysics;
-    rapierDebug: RapierDebugRenderer;
 }
 declare module "three-start" {
     interface ThreeStartRegister {

package/dist/rendering/SceneBloom.d.ts

@@ -1,7 +1,7 @@
 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";
+import type { BloomConfig } from "./types";
 /**
  * Enables MRT `{ output, emissive }` on the scenePass. Idempotent. IMPORTANT:
  * MRT is part of the WebGPU pipelines' attachment state; enable it either before

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

@@ -1,5 +1,5 @@
 import * as THREE from "three/webgpu";
-import type { RendererConfig } from "../settings/types";
+import type { RendererConfig } from "./types";
 /**
  * Applies the runtime part of `RendererConfig` to an already created WebGPURenderer
  * (shadowMap, toneMapping, pixelRatio). Used by game (once on load) and editor

package/dist/{settings → rendering}/types.d.ts

@@ -1,15 +1,4 @@
-import type { ExternalDescriptor } from "./externals";
-import type { LibId } from "./lib-registry";
-import type { PhysicsConfig } from "./module-registry";
-import type { BloomModeName, ShadowMapTypeName, ToneMappingName } from "../rendering/renderer-options";
-/** `settings.addons.json` — pluggable modules, built-in libs, external scripts. */
-export interface AddonsConfig {
-    modules?: {
-        physics?: PhysicsConfig;
-    };
-    libs?: Partial<Record<LibId, boolean>>;
-    externals?: ExternalDescriptor[];
-}
+import type { BloomModeName, ShadowMapTypeName, ToneMappingName } from "./renderer-options";
 /** Subset of `WebGPURendererParameters` configurable via the config. */
 export interface RendererParams {
     antialias?: boolean;

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import type { Object3DBehaviourConstructor } from "three-start";
-import type { AddonsConfig, RendererConfig } from "./settings/types";
+import type { AddonsConfig, WorldImports } from "./addons/types";
+import type { RendererConfig } from "./rendering/types";
 import type * as THREE from "three/webgpu";
 /** World assets: asset path in the project (`/Folder/name.ext`) → URL. */
 export type AssetUrlTable = Record<string, string>;
@@ -22,8 +23,8 @@ export interface WorldLoadProgress {
  * scripts and behaviours. The only object the world hooks receive.
  */
 export interface RuntimeApi {
-    /** Asset URL by its project path. Same resolving as `getUrl` in scripts. */
-    getUrl: (path: string) => string;
+    /** Asset URL by project path or by a resource returned by `require`. */
+    getUrl: (source: string | object) => string;
     /** `require` value by asset path or addon key. */
     require: (key: string) => unknown;
     /** Built-in behaviour class by uuid (preloaded by bootstrap). */
@@ -51,6 +52,12 @@ export interface WorldDefinition<TAssets = unknown> {
     renderer?: RendererConfig;
     /** `settings.addons.json`: built-in libs and external scripts for `require`. */
     addons?: AddonsConfig;
+    /**
+     * How to import the optional packages this world uses (rapier, built-in
+     * libs). The build emits only what the world needs, so your bundler never
+     * has to resolve a package you did not install.
+     */
+    imports?: WorldImports;
     /** User scripts keyed by asset paths — same keys as `require`. */
     scripts?: ScriptTable;
     /** Path of the world entry script (`main.ts`). */

package/dist/utils/lazy.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Object that forwards every access to `resolve()`. For script globals that are
+ * shortcuts into something created later (`modules` → `ctx.modules`): the script
+ * bag is destructured eagerly, so a plain reference or a getter would be read
+ * before the target exists.
+ */
+export declare function lazyProxy<T extends object>(resolve: () => T): T;
 /** Lazy cached value: the factory is called once on the first `get()`. */
 export declare function lazy<T>(factory: () => T): {
     get: () => T;

package/dist/version.gen.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.1.0";
+export declare const RUNTIME_VERSION = "0.4.2";

package/dist/world-stores.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A single reactive value of `world.stores`. Narrow facade over a nanostores
+ * atom: scripts see exactly these four methods.
+ */
+export interface WorldStore<T> {
+    get: () => T | undefined;
+    set: (value: T | undefined) => void;
+    /** Fires on every change; returns unsubscribe. */
+    listen: (listener: (value: T | undefined) => void) => () => void;
+    /** Same as `listen`, but also fires immediately with the current value. */
+    subscribe: (listener: (value: T | undefined) => void) => () => void;
+}
+/**
+ * Shared reactive key-value state of a world (`world.stores` in scripts) — the
+ * state counterpart of the `world.events` bus. Stores are created lazily on
+ * first touch; `undefined` means "no value", so `delete`/`clear` only reset
+ * values and never invalidate a reference taken from `of()`.
+ */
+export declare class WorldStores {
+    private readonly _stores;
+    /** The store behind a key, created on first touch. */
+    of<T = unknown>(key: string): WorldStore<T>;
+    get<T = unknown>(key: string): T | undefined;
+    set<T = unknown>(key: string, value: T | undefined): void;
+    /** Subscribe to a key; returns unsubscribe. Not called with the current value. */
+    listen<T = unknown>(key: string, listener: (value: T | undefined) => void): () => void;
+    /** Same as `listen`, but also fires immediately with the current value. */
+    subscribe<T = unknown>(key: string, listener: (value: T | undefined) => void): () => void;
+    /** A value has been written to the key and not deleted since. */
+    has(key: string): boolean;
+    /** Keys that currently hold a value. */
+    keys(): string[];
+    /** Plain object with all current values — for debugging and saves. */
+    snapshot(): Record<string, unknown>;
+    /** Resets the key to `undefined`; listeners are notified. */
+    delete(key: string): void;
+    /** Resets every key; listeners are notified. */
+    clear(): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kvyverse/world-runtime",
-	"version": "0.1.0",
+	"version": "0.4.2",
 	"description": "Runtime for worlds exported from the Kvyverse platform for self-hosting",
 	"license": "SEE LICENSE IN LICENSE.md",
 	"author": "Vladislav Kruteniuk",
@@ -35,6 +35,9 @@
 		"animejs": "^4.5.0",
 		"eventemitter3": "^5.0.1",
 		"howler": "^2.2.4",
+		"nanostores": "^1.3.0",
+		"nipplejs": "^0.10.2",
+		"stats.js": "^0.17.0",
 		"three": "^0.184.0",
 		"three-start": "^0.1.2",
 		"vanjs-core": "^1.6.0"
@@ -48,6 +51,12 @@
 		},
 		"animejs": {
 			"optional": true
+		},
+		"nipplejs": {
+			"optional": true
+		},
+		"stats.js": {
+			"optional": true
 		}
 	}
 }

package/dist/RapierDebugRenderer-sURZDLP4.js

@@ -1,55 +0,0 @@
-import { t as RapierPhysics } from "./RapierPhysics-C_3b7QOn.js";
-import * as THREE from "three/webgpu";
-import { ContextModule } from "three-start";
-//#region packages/world-runtime/src/behaviours/physics/rapier-addon-core/RapierDebugRenderer.ts
-/**
-* @see {@link https://github.com/vladkrutenyuk/three-kvy-core/blob/main/src/addons/RapierDebugRenderer.ts | Source}
-*/
-var RapierDebugRenderer = class extends ContextModule {
-	_lines;
-	get enabled() {
-		return this._enabled;
-	}
-	set enabled(value) {
-		const lines = this._lines;
-		if (lines) lines.visible = value;
-		this._enabled = value;
-	}
-	_enabled = true;
-	_clear;
-	_inited = false;
-	/** three-start ContextModule has no onDestroy; teardown is explicit. */
-	dispose() {
-		this._clear?.();
-	}
-	init() {
-		if (this._inited) return;
-		this._inited = true;
-		const ctx = this.ctx;
-		const rapier = RapierPhysics.findInCtx(ctx);
-		if (!rapier) return;
-		const lines = new THREE.LineSegments(new THREE.BufferGeometry(), new THREE.LineBasicMaterial({
-			color: 16777215,
-			vertexColors: true
-		}));
-		lines.frustumCulled = false;
-		lines.visible = this._enabled;
-		ctx.scene.add(lines);
-		const draw = () => {
-			const { vertices, colors } = rapier.world.debugRender();
-			lines.geometry.setAttribute("position", new THREE.BufferAttribute(vertices, 3));
-			lines.geometry.setAttribute("color", new THREE.BufferAttribute(colors, 4));
-			lines.visible = true;
-		};
-		rapier.on("stepafter", draw);
-		this._clear = () => {
-			this._lines = void 0;
-			lines.removeFromParent();
-			lines.geometry.dispose();
-			lines.material.dispose();
-			rapier.off("stepafter", draw);
-		};
-	}
-};
-//#endregion
-export { RapierDebugRenderer, RapierDebugRenderer as default };

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

@@ -1,17 +0,0 @@
-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/modules/contracts/rapierDebug.module-api.d.ts

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

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

@@ -1,13 +0,0 @@
-//#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

@@ -1,19 +0,0 @@
-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/lib-loaders.d.ts

@@ -1,7 +0,0 @@
-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>>;

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

@@ -1,24 +0,0 @@
-/**
- * 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). Single source for:
- *  - game: dynamic loading (`lib-loaders`),
- *  - editor: JSON schema (`libs` props) + require typings (`AddonsRequireTypings`).
- *
- * Adding a lib = add an entry here (+ loader in game, + d.ts loader in editor).
- */
-export declare enum LibId {
-    Tween = "tween",
-    Anime = "anime"
-}
-export interface LibDescriptor {
-    readonly id: LibId;
-    /** Key the user gets the lib by: `require("<requireKey>")`. */
-    readonly requireKey: string;
-    readonly label: string;
-}
-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/settings/module-registry.d.ts

@@ -1,25 +0,0 @@
-/**
- * Registry of pluggable engine modules (`settings.addons.json → modules`).
- * These are three-start modules that must be registered before `start()`.
- * Feature toggles (chat/joystick/debugPerf) are NOT here — they live in
- * `settings.json` (see `../features/feature-registry`).
- *
- * The only module so far is physics.
- * Installation lives in game (`game/settings/module-installers`).
- */
-export declare enum ModuleId {
-    Physics = "physics"
-}
-export type PhysicsEngine = "rapier";
-/** `modules.physics` value: off | engine shorthand | object with options. */
-export type PhysicsConfig = false | PhysicsEngine | {
-    engine: PhysicsEngine;
-    debug?: boolean;
-};
-export declare const PHYSICS_ENGINES: readonly PhysicsEngine[];
-export declare const MODULE_IDS: ModuleId.Physics[];
-/** Normalizes the physics config to an object (or null if disabled). */
-export declare function normalizePhysics(value: PhysicsConfig | undefined): {
-    engine: PhysicsEngine;
-    debug: boolean;
-} | null;