incanto 0.34.0 → 0.35.0

package/dist/{behavior-CtPScDMo.d.ts → behavior-CGSCWOHB.d.ts}

@@ -1,4 +1,4 @@
-import { a as Rng, c as JsonValue, i as SceneJson, s as JsonObject } from "./schema-CcoWb32N.js";
+import { a as Rng, c as JsonValue, i as SceneJson, s as JsonObject } from "./schema-3ywbdlrv.js";
 
 //#region src/core/signal.d.ts
 /**
@@ -80,6 +80,35 @@ declare class SceneTree {
   * change shape?" check for per-step body gathers and similar caches.
   */
   _structureVersion: number;
+  /**
+  * WHAT changed, not just that something did.
+  *
+  * The version alone forces every consumer into a full-tree re-walk, and the
+  * physics step is gated on it: one bullet spawned per frame means
+  * `collectBodies` + `collectJoints` + `syncScatters` walk the entire scene at
+  * 60 Hz. A bullet-hell or a survivors-like does nothing else all game.
+  *
+  * This log lets a consumer replay just the attaches and detaches it has not
+  * seen. It is bounded — a scene load appends thousands of entries and nobody
+  * benefits from replaying those — so a consumer that falls behind
+  * `_structureLogBase` takes the full walk, exactly as before. Correctness does
+  * not depend on the log; only the fast path does.
+  */
+  private _structureLog;
+  /** The `_structureVersion` the first entry in the log corresponds to. */
+  private _structureLogBase;
+  private static readonly STRUCTURE_LOG_MAX;
+  /**
+  * Attaches and detaches since `sinceVersion`, or null when the log no longer
+  * reaches back that far (take the full walk).
+  *
+  * The returned array is the live buffer's tail — do not hold it across frames.
+  */
+  _structureSince(sinceVersion: number): ReadonlyArray<{
+    node: Node;
+    added: boolean;
+  }> | null;
+  private _logStructure;
   private _frameId;
   /**
   * Monotonic update-frame counter — bumped once per `update()`. Per-frame
@@ -89,7 +118,15 @@ declare class SceneTree {
   get frameId(): number;
   /** @internal Node attach hook. */
   _indexName(node: Node): void;
-  /** @internal Node detach/rename hook (`name` = the entry to remove). */
+  /**
+  * @internal A RENAME: same node, same place, different key in the name index.
+  *
+  * Deliberately not logged as a detach + attach. It is not a structural change,
+  * and treating it as one would make the physics step tear down and rebuild the
+  * node's Rapier body for a name edit.
+  */
+  _reindexName(node: Node, oldName: string): void;
+  /** @internal Node detach hook (`name` = the entry to remove). */
   _unindexName(node: Node, name?: string): void;
   /** @internal Every ATTACHED node named `name` (undefined = none). */
   _nodesNamed(name: string): ReadonlySet<Node> | undefined;
@@ -763,6 +800,184 @@ declare class InputMap {
   private button;
 }
 //#endregion
+//#region src/core/localization.d.ts
+/** The base locale. Every other locale falls back to it, one key at a time. */
+declare const BASE_LOCALE = "en";
+/**
+* The marker that makes a string prop translatable: `"@t:hud.score"`.
+*
+* A prefix rather than an object wrapper, matching the `"$assetKey"` reference
+* already in the engine — the prop is declared a string, so its value should
+* stay a string. It also stays authorable by hand:
+*
+* ```json
+* { "type": "UiText", "props": { "text": "@t:hud.score" } }
+* ```
+*/
+declare const T_PREFIX = "@t:";
+/** `locale → key → string`. A locale may declare any subset of the base's keys. */
+type LocaleTables = Record<string, Record<string, string>>;
+/** The key a `"@t:…"` value names, or null for an ordinary string. */
+declare function translationKey(value: string): string | null;
+declare class Localization {
+  /** Fires with the new locale after it changes — for anything that caches. */
+  readonly changed: Signal<[string]>;
+  private tables;
+  private current;
+  constructor(tables?: LocaleTables, locale?: string);
+  /**
+  * Merge a scene's `strings` table in.
+  *
+  * Merged rather than replaced: a game's shared UI strings live in the scene it
+  * boots from, and a level that adds three lines of its own should not wipe
+  * them. Per-key, so a level CAN override one string.
+  */
+  load(tables: LocaleTables): void;
+  get locale(): string;
+  /**
+  * Switch language. Setting one nobody declared is not an error — it simply
+  * resolves everything through the base locale, which is the correct outcome
+  * for a player whose browser reports a language this game does not ship.
+  */
+  set locale(next: string);
+  /** Every locale with at least one string — what a language picker offers. */
+  available(): string[];
+  /**
+  * The string for `key`: current locale, else English, else the key itself.
+  *
+  * Returning the key rather than an empty string is deliberate — a screen
+  * reading `menu.credits` tells an author exactly what to add, where a blank
+  * one tells them nothing and looks like a rendering bug.
+  */
+  t(key: string, params?: Record<string, JsonValue>): string;
+  /**
+  * Resolve a prop value: `"@t:key"` translates, anything else passes through.
+  *
+  * This is what every text-bearing widget calls, every frame. A plain string is
+  * returned untouched, so a game that never localizes anything pays a
+  * `startsWith` per widget per frame and nothing else.
+  */
+  resolve(value: string, params?: Record<string, JsonValue>): string;
+  /** Whether any locale declares this key — for the audit, not for the runtime. */
+  has(key: string): boolean;
+}
+/**
+* The player's language, if the browser will say and the game ships it.
+*
+* A starting point only — the language setting is the real answer, exactly as
+* `suggestQuality` is a starting point for the quality tier.
+*/
+declare function suggestLocale(available: readonly string[], languages?: readonly string[]): string;
+//#endregion
+//#region src/core/save.d.ts
+/**
+* Namespaced game persistence — high scores, unlocks, settings. localStorage
+* in the browser, in-memory headless (tests and SSR stay green). Values are
+* JSON round-tripped, so what you get back is what you saved.
+*
+*   const save = createSaveStore('my-game');
+*   save.set('highScore', 4200);
+*   const best = save.get('highScore', 0);
+*/
+interface SaveStore {
+  get<T extends JsonValue>(key: string, fallback: T): T;
+  set(key: string, value: JsonValue): void;
+  remove(key: string): void;
+  /** Wipe THIS namespace only. */
+  clear(): void;
+}
+declare function createSaveStore(namespace: string): SaveStore;
+//#endregion
+//#region src/core/save-slots.d.ts
+/** Behavior state, keyed by the uid of the node carrying it. */
+type BehaviorState = Record<string, JsonValue>;
+interface SaveSlot {
+  /** Which scene to load before restoring. Whatever key your game routes on. */
+  scene: string;
+  /** `uid → whatever that behavior's serialize() returned`. */
+  state: BehaviorState;
+  /** Shown in a load menu. Free text — "Chapter 2 · Emberwood". */
+  label: string;
+  /** Unix ms. Passed in, never read from a clock here, so saves stay testable. */
+  savedAt: number;
+  /** Seconds played, if the game tracks it. */
+  playtime: number;
+  /** Anything else the game wants in the slot (difficulty, seed, a thumbnail). */
+  data: JsonObject;
+}
+/** What a restore could not place, so a game can decide whether that matters. */
+interface RestoreReport {
+  /** Entries whose uid is not in this scene — a node deleted since the save. */
+  missing: string[];
+  /** Entries whose node has no behavior, or one that cannot deserialize. */
+  skipped: string[];
+  /** How many behaviors actually took their state back. */
+  restored: number;
+}
+/**
+* Every behavior in the tree that has something to say, by uid.
+*
+* A behavior with no `serialize` contributes nothing — the hook is optional in
+* exactly the way the other five are, so adding save support to a game is
+* additive and a game that never saves pays nothing.
+*
+* A node with no `uid` is skipped and reported, because state keyed by nothing
+* cannot be given back. The editor assigns a uid to every node it touches; a
+* hand-written scene may not have.
+*/
+declare function captureBehaviors(root: Node): {
+  state: BehaviorState; /** Paths of nodes that had state to save and no uid to save it under. */
+  unaddressable: string[];
+};
+/**
+* Hand each behavior its state back.
+*
+* Call this AFTER the scene has loaded and `onReady` has run: `onReady` is where
+* a behavior sets its starting values, so restoring first would be overwritten
+* by the fresh start.
+*
+* Never throws on a mismatch. A save from an older build of the game will name
+* uids that no longer exist, and refusing to load it would mean a patch that
+* moves one node deletes everyone's progress. It reports instead.
+*/
+declare function restoreBehaviors(root: Node, state: BehaviorState): RestoreReport;
+/**
+* The slot layer: a named list of saves over the existing store.
+*
+* Slot ids are yours (`'auto'`, `'1'`, `'2'`, `'3'`) — the engine does not
+* decide how many you have or whether one of them autosaves.
+*/
+declare class SaveSlots {
+  private readonly store;
+  constructor(namespace?: string, store?: SaveStore);
+  /** Slot ids that have a save, newest first. */
+  list(): string[];
+  /** Every slot with its contents — what a load menu actually renders. */
+  all(): Array<SaveSlot & {
+    id: string;
+  }>;
+  read(id: string): SaveSlot | null;
+  /**
+  * Write a slot.
+  *
+  * `savedAt` is a parameter rather than `Date.now()` so a test can assert an
+  * ordering without sleeping, and so a game that wants server time can use it.
+  */
+  write(id: string, slot: Omit<SaveSlot, "label" | "savedAt" | "playtime" | "data"> & Partial<SaveSlot>): void;
+  remove(id: string): void;
+  /** Wipe every slot — a "delete all data" button, and test isolation. */
+  clear(): void;
+}
+/**
+* Behaviors in this tree that hold state and cannot save it — the audit's
+* question, answerable before a player loses an hour.
+*
+* A behavior with props but no `serialize` is not necessarily wrong (an
+* `Oscillate` derives everything from time), so this reports rather than warns,
+* and the caller decides.
+*/
+declare function behaviorsWithoutSave(root: Node): string[];
+//#endregion
 //#region src/core/scene/scene.d.ts
 /**
 * A loaded, live scene: the node tree plus everything needed to round-trip
@@ -786,6 +1001,8 @@ declare class Scene {
   readonly constants: Record<string, JsonValue> | undefined;
   /** Input action declarations (loaded into `Engine.input` on setScene). */
   readonly input: JsonObject | undefined;
+  /** Translations by locale (merged into `Engine.locale` on setScene). */
+  readonly strings: Record<string, Record<string, string>> | undefined;
   /** Physics config (gravity etc. — interpreted by the physics modules). */
   readonly physics: JsonObject | undefined;
   /** Multiplayer config (room etc. — interpreted by incanto/net). */
@@ -800,25 +1017,6 @@ declare class Scene {
   toJSON(): SceneJson;
 }
 //#endregion
-//#region src/core/save.d.ts
-/**
-* Namespaced game persistence — high scores, unlocks, settings. localStorage
-* in the browser, in-memory headless (tests and SSR stay green). Values are
-* JSON round-tripped, so what you get back is what you saved.
-*
-*   const save = createSaveStore('my-game');
-*   save.set('highScore', 4200);
-*   const best = save.get('highScore', 0);
-*/
-interface SaveStore {
-  get<T extends JsonValue>(key: string, fallback: T): T;
-  set(key: string, value: JsonValue): void;
-  remove(key: string): void;
-  /** Wipe THIS namespace only. */
-  clear(): void;
-}
-declare function createSaveStore(namespace: string): SaveStore;
-//#endregion
 //#region src/core/settings.d.ts
 /** One of three tiers, resolved once at boot and adjustable in an options menu. */
 type QualityTier = "low" | "medium" | "high";
@@ -833,6 +1031,11 @@ interface SettingsValues {
   invertY: boolean;
   /** Reduce camera shake, flashes and other motion. */
   reduceMotion: boolean;
+  /**
+  * The player's language. `'en'` is the base and the default; anything a locale
+  * does not translate falls back to English, silently and on purpose.
+  */
+  language: string;
 }
 /** What a device probe can see without a GPU context. */
 interface DeviceHints {
@@ -864,6 +1067,14 @@ declare class Settings {
   /** Back to defaults, on disk too. */
   reset(): void;
   /**
+  * Apply the saved language, and keep it in step both ways.
+  *
+  * The same shape as `bindAudio`: a game that writes
+  * `engine.locale.locale = 'ko'` from an options menu has already persisted it
+  * without knowing this class exists. Returns the unsubscribe.
+  */
+  bindLocale(locale: Localization): () => void;
+  /**
   * Push the saved volumes into the engine's buses, and keep writing them back
   * whenever anything changes them.
   *
@@ -975,6 +1186,11 @@ declare class Engine {
   * `bindAudio` makes the volumes write themselves.
   */
   readonly settings: Settings;
+  /**
+  * Translations, and the locale in force. English is the base and the default;
+  * anything a locale does not declare falls back to it silently.
+  */
+  readonly locale: Localization;
   /** Low-latency procedural-SFX player (WebAudio, headless-safe). AudioPlayer
   *  presets play through it; games may call `engine.sfx.play(...)` directly. */
   readonly sfx: SfxEngine;
@@ -1045,6 +1261,25 @@ declare class Engine {
   * both — so a tool can list them and put them back. Walks on demand; there is
   * no per-frame bookkeeping for this.
   */
+  /**
+  * The string for `key` in the current locale — English if this locale does not
+  * declare it, the key itself if nothing does.
+  *
+  * The short form of `engine.locale.t`, because a behavior reaching for a
+  * translated string is the common case:
+  * `banner.show(this.engine.t('wave.start', { n: wave }))`.
+  */
+  t(key: string, params?: Record<string, JsonValue>): string;
+  /**
+  * Every behavior's state, ready to put in a save slot.
+  *
+  * Pairs with `restoreState` after the scene has RELOADED — see
+  * core/save-slots.ts for why a save carries state rather than a tree
+  * snapshot.
+  */
+  captureState(): BehaviorState;
+  /** Give it back, after the scene is loaded and onReady has run. */
+  restoreState(state: BehaviorState): RestoreReport;
   erroredNodes(): Node[];
   /** Un-skip every quarantined node — the "try again" after you fix the code. */
   resumeErroredNodes(): number;
@@ -1091,6 +1326,16 @@ interface PropDef {
   * dropdowns and the generated JSON-Schema enum — keep it exhaustive. */
   options?: readonly string[];
   /**
+  * This prop holds a NODE PATH (`%Unique`, `/Absolute/From/Root`, or one
+  * relative to the node that owns the prop) resolved with `getNodeOrNull`.
+  *
+  * Declaring it is what lets a tool rewrite the reference when the target is
+  * renamed. Without it a rename silently breaks the link — the resolve returns
+  * null and the game keeps running with an enemy that never chases anyone.
+  * Set it on every prop you feed to `getNode`/`getNodeOrNull`.
+  */
+  nodePath?: boolean;
+  /**
   * For an OBJECT-valued prop shaped as a tagged union — `collider`, whose
   * `shape` decides which other keys are required. One declaration gives an
   * inspector both the dropdown AND something valid to write when the tag
@@ -1173,14 +1418,57 @@ declare abstract class Behavior {
   onExitTree?(): void;
   update?(dt: number): void;
   fixedUpdate?(dt: number): void;
+  /**
+  * What this behavior needs in a save file — the sixth optional hook, and the
+  * one that made "continue where you left off" possible at all.
+  *
+  * Return the state a fresh `onReady` could NOT recreate: current health,
+  * accumulated score, which quest flags are set. Do not return anything the
+  * scene JSON already says (`maxHealth`, `speed`) — that comes back from the
+  * file, and duplicating it just makes old saves fight new balance patches.
+  *
+  * Must be plain JSON. Never a Node, a Texture, or a callback.
+  *
+  * ```ts
+  * override serialize() { return { current: this.current }; }
+  * override deserialize(data: JsonValue) {
+  *   const d = data as { current?: number };
+  *   if (typeof d.current === 'number') this.current = d.current;
+  * }
+  * ```
+  *
+  * Returning `undefined` writes nothing, so a behavior can decline to save on
+  * a given frame (a boss that is mid-death-animation, say).
+  */
+  serialize?(): JsonValue | undefined;
+  /**
+  * Take that state back, AFTER `onReady` has run.
+  *
+  * Defensive on purpose: this data may come from a save written by an older
+  * build of the game. Check what you read; do not assume shape. Throwing here
+  * costs only this one behavior's state — the restore keeps going — but
+  * quietly ignoring a field you renamed is usually the better answer.
+  */
+  deserialize?(data: JsonValue): void;
 }
 /** Explicit registration — never an import side effect (tree-shaking safety). */
 declare function registerBehavior(name: string, ctor: BehaviorCtor, opts?: {
   replace?: boolean;
 }): void;
 declare function getBehavior(name: string): BehaviorCtor;
+/**
+* A registered behavior's merged prop schema, `{}` for one nobody registered.
+*
+* The node side has had `getNodeSchema` for a long time; a behavior's props were
+* reachable only by whoever already held the class, which a tool reading scene
+* JSON never does. Deliberately non-throwing: a tool inspecting a scene that
+* names a behavior from a game it did not load should degrade, not blow up.
+*/
+declare function behaviorSchema(name: string): PropSchema;
+/** A registered behavior's signals (own + inherited), `[]` for an unknown one. */
+declare function behaviorSignals(name: string): string[];
 declare function registeredBehaviors(): string[];
 /** Test isolation helper. */
 declare function clearBehaviors(): void;
 //#endregion
-export { MusicBackend as $, suggestQuality as A, Listener as B, RendererStats as C, SettingsValues as D, Settings as E, SfxEngine as F, spatialGain as G, RolloffModel as H, SfxPlayOptions as I, SFX_PRESET_NAMES as J, spatialPan as K, isAudioContextAvailable as L, createSaveStore as M, Scene as N, qualityEnvironment as O, InputMap as P, synthSfx as Q, Voice as R, GameStats as S, QualityTier as T, SpatialParams as U, ROLLOFF_MODELS as V, Vec3 as W, SfxWave as X, SfxParams as Y, SynthOptions as Z, registeredTypes as _, registerBehavior as a, Node as at, Scheduler as b, PropDef as c, LogEntry as ct, createNode as d, Signal as dt, MusicManager as et, getNodeSchema as f, SignalListener as ft, registerNode as g, mergeStaticSignals as h, getBehavior as i, BusName as it, SaveStore as j, readDeviceHints as k, PropSchema as l, LogLevel as lt, getNodeType as m, BehaviorCtor as n, PlayMusicOptions as nt, registeredBehaviors as o, NodeLifecycle as ot, getNodeSignals as p, SFX_PRESETS as q, clearBehaviors as r, AudioBuses as rt, NodeCtor as s, SceneTree as st, Behavior as t, MusicTrack as tt, clearRegistry as u, LogManager as ut, Engine as v, DeviceHints as w, EngineStats as x, EngineOptions as y, VoicePreset as z };
+export { Voice as $, qualityEnvironment as A, restoreBehaviors as B, EngineStats as C, LogEntry as Ct, QualityTier as D, SignalListener as Dt, DeviceHints as E, Signal as Et, RestoreReport as F, Localization as G, createSaveStore as H, SaveSlot as I, translationKey as J, T_PREFIX as K, SaveSlots as L, suggestQuality as M, Scene as N, Settings as O, BehaviorState as P, isAudioContextAvailable as Q, behaviorsWithoutSave as R, Scheduler as S, SceneTree as St, RendererStats as T, LogManager as Tt, BASE_LOCALE as U, SaveStore as V, LocaleTables as W, SfxEngine as X, InputMap as Y, SfxPlayOptions as Z, mergeStaticSignals as _, PlayMusicOptions as _t, clearBehaviors as a, Vec3 as at, Engine as b, Node as bt, registeredBehaviors as c, SFX_PRESETS as ct, PropSchema as d, SfxWave as dt, VoicePreset as et, clearRegistry as f, SynthOptions as ft, getNodeType as g, MusicTrack as gt, getNodeSignals as h, MusicManager as ht, behaviorSignals as i, SpatialParams as it, readDeviceHints as j, SettingsValues as k, NodeCtor as l, SFX_PRESET_NAMES as lt, getNodeSchema as m, MusicBackend as mt, BehaviorCtor as n, ROLLOFF_MODELS as nt, getBehavior as o, spatialGain as ot, createNode as p, synthSfx as pt, suggestLocale as q, behaviorSchema as r, RolloffModel as rt, registerBehavior as s, spatialPan as st, Behavior as t, Listener as tt, PropDef as u, SfxParams as ut, registerNode as v, AudioBuses as vt, GameStats as w, LogLevel as wt, EngineOptions as x, NodeLifecycle as xt, registeredTypes as y, BusName as yt, captureBehaviors as z };

package/dist/{create-game-CFNqoqOX.js → create-game-B0Wfhi2-.js}

@@ -1,13 +1,13 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { m as diagnose, n as loadScene, o as computeViewport, s as resolveViewport, y as registerBehavior } from "./loader-BwR0DxeM.js";
-import { h as Engine, m as AudioPlayer } from "./register-G3edsjJ2.js";
+import { h as diagnose, n as loadScene, o as computeViewport, s as resolveViewport, x as registerBehavior } from "./loader-Mig5fY4n.js";
+import { h as Engine, m as AudioPlayer } from "./register-BFLg0-_i.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { i as resolveRendering, n as attachTouchControls } from "./touch-BoNg_MnF.js";
 import { i as openBundledEditor, n as crossFade, r as devServerLibrary, t as teardown } from "./teardown-ByzfDPyu.js";
-import { n as registerGameplayBehaviors } from "./gameplay-BxFtmfSe.js";
-import { g as PhysicsBody2D, n as UILayer, t as registerNodes2D, u as Camera2D, y as Node2D } from "./register-BLPC10Mj.js";
+import { n as registerGameplayBehaviors } from "./gameplay-BvhcQbfJ.js";
+import { g as PhysicsBody2D, n as UILayer, t as registerNodes2D, u as Camera2D, y as Node2D } from "./register-DSmIRAf7.js";
 import { t as debugSources } from "./debug-draw-BM3DsvtT.js";
-import { n as enablePhysics2D } from "./physics-2d-BuyAwsW5.js";
+import { n as enablePhysics2D } from "./physics-2d-DqAclql-.js";
 import { Box3, BufferAttribute, BufferGeometry, Color, LineBasicMaterial, LineSegments, LinearFilter, NearestFilter, OrthographicCamera, Raycaster, SRGBColorSpace, Scene, TextureLoader, Vector2, Vector3, WebGLRenderer } from "three";
 //#region src/2d/assets.ts
 /**
@@ -545,6 +545,7 @@ async function createGame2D(opts) {
 	if (keyboard) engine.input.attachKeyboard(keyboard);
 	cleanups.push(wireAudioUnlock(engine, scene.root, opts.canvas));
 	cleanups.push(engine.settings.bindAudio(engine.audio));
+	cleanups.push(engine.settings.bindLocale(engine.locale));
 	const touchMode = opts.touch ?? "auto";
 	if (touchMode !== false) {
 		const host = opts.touchContainer ?? opts.canvas.parentElement ?? null;

package/dist/{create-game-QTfghzwM.js → create-game-BUD89Kqh.js}

@@ -1,13 +1,13 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { m as diagnose, n as loadScene, y as registerBehavior } from "./loader-BwR0DxeM.js";
-import { h as Engine, m as AudioPlayer } from "./register-G3edsjJ2.js";
+import { h as diagnose, n as loadScene, x as registerBehavior } from "./loader-Mig5fY4n.js";
+import { h as Engine, m as AudioPlayer } from "./register-BFLg0-_i.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { i as resolveRendering, n as attachTouchControls } from "./touch-BoNg_MnF.js";
 import { a as poseFromRenderer, i as openBundledEditor, n as crossFade, r as devServerLibrary, t as teardown } from "./teardown-ByzfDPyu.js";
-import { B as createCausticsQuad, F as PhysicsBody3D, R as Node3D, n as registerGameplayBehaviors } from "./gameplay-BxFtmfSe.js";
+import { B as createCausticsQuad, F as PhysicsBody3D, R as Node3D, n as registerGameplayBehaviors } from "./gameplay-BvhcQbfJ.js";
 import { t as debugSources } from "./debug-draw-BM3DsvtT.js";
-import { E as Camera3D, g as ModelInstance3D, n as registerNodes3D, t as resolveEnvironmentHdri, v as DirectionalLight3D } from "./environment-presets-B6WiUsaO.js";
-import { n as enablePhysics3D } from "./physics-3d-C8Kn_Nyb.js";
+import { E as Camera3D, U as TextureCache3D, g as ModelInstance3D, n as registerNodes3D, t as resolveEnvironmentHdri, v as DirectionalLight3D } from "./environment-presets-TAGvmM3z.js";
+import { n as enablePhysics3D } from "./physics-3d-DxBH4sIF.js";
 import { ACESFilmicToneMapping, AmbientLight, Box3, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, HalfFloatType, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
 import { VRMLoaderPlugin, VRMUtils } from "@pixiv/three-vrm";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
@@ -32,6 +32,12 @@ var AssetStore3D = class {
 	animationKeys = /* @__PURE__ */ new Map();
 	loader;
 	/**
+	* Shared textures, store-scoped like everything else here. Instance state, not
+	* a module map: two games on one page must not share a decode cache, and the
+	* repo has one rule about module-level engine state.
+	*/
+	textures;
+	/**
 	* `engine` is optional only so a bare store still constructs in tests. Give it
 	* one and every load failure lands in `engine.log` — where the debug overlay,
 	* `runScript()` and any agent tool can see it. Without it a 404'd GLB was a
@@ -41,6 +47,7 @@ var AssetStore3D = class {
 		this.engine = engine;
 		this.loader = new GLTFLoader();
 		this.loader.register((parser) => new VRMLoaderPlugin(parser));
+		this.textures = new TextureCache3D({ diagnostics: engine ? { warn: (...parts) => diagnose(engine, "warn", ...parts) } : null });
 	}
 	/**
 	* Every asset that failed, with the reason — the answer to "why is my model
@@ -48,6 +55,11 @@ var AssetStore3D = class {
 	*/
 	errors() {
 		const out = [];
+		for (const { url, error } of this.textures.errors()) out.push({
+			ref: url,
+			url,
+			error
+		});
 		for (const [ref, url] of this.modelKeys) {
 			const entry = this.models.get(url);
 			if (entry?.error) out.push({
@@ -144,6 +156,7 @@ var AssetStore3D = class {
 		return entry;
 	}
 	dispose() {
+		this.textures.dispose();
 		for (const entry of this.models.values()) entry.scene?.traverse((obj) => {
 			const mesh = obj;
 			mesh.geometry?.dispose();
@@ -1419,7 +1432,7 @@ function walk(node, parentObj, state) {
 			return;
 		}
 		if (obj.parent !== parentObj) parentObj.add(obj);
-		node._syncObject3D(state.alpha);
+		node._syncObject3D(state.alpha, state.assets ?? null);
 		if (state.assets && node instanceof ModelInstance3D) node._syncModel(state.assets);
 		if (typeof node._onRender3D === "function") state.renderHooks.push(node);
 		if (state.sunDirection) {
@@ -2263,6 +2276,7 @@ async function createGame3D(opts) {
 		});
 	} catch {}
 	cleanups.push(engine.settings.bindAudio(engine.audio));
+	cleanups.push(engine.settings.bindLocale(engine.locale));
 	await report(1, "ready");
 	function disposeGame() {
 		teardown([

package/dist/debug.d.ts

@@ -1,4 +1,4 @@
-import { C as RendererStats, lt as LogLevel, v as Engine } from "./behavior-CtPScDMo.js";
+import { T as RendererStats, b as Engine, wt as LogLevel } from "./behavior-CGSCWOHB.js";
 
 //#region src/debug/panel.d.ts
 /** Minimal document surface the overlay needs (injectable for tests). */

package/dist/{duplicate-DlOvknDO.js → duplicate-C716f-97.js}

@@ -1,4 +1,4 @@
-import { i as serializeNode, t as buildNodeJson } from "./loader-BwR0DxeM.js";
+import { i as serializeNode, t as buildNodeJson } from "./loader-Mig5fY4n.js";
 //#region src/core/order-groups.ts
 const ORDER_GROUP_BASE = {
 	background: -2e3,

package/dist/{editor-switch-BJb-CWfA.d.ts → editor-switch-DyXEtH36.d.ts}

@@ -1,4 +1,4 @@
-import { s as JsonObject } from "./schema-CcoWb32N.js";
+import { s as JsonObject } from "./schema-3ywbdlrv.js";
 
 //#region src/core/diagnostics.d.ts
 /** The minimum an engine has to look like to receive a diagnostic. */