@threenative/core 0.3.3 → 0.3.4

package/dist/{assets-CYKk2WTu.d.ts → assets-CqvE429w.d.ts}

@@ -1,4 +1,4 @@
-import { Texture, Object3D, AnimationClip } from 'three';
+import { Texture, Wrapping, Object3D, AnimationClip } from 'three';
 
 interface IAssetLoaderOptions {
     readonly basePath?: string;
@@ -49,10 +49,41 @@ interface ICompressedTextureSupport {
     readonly loader: Promise<IKTX2LoaderLike | undefined>;
     readonly ready: Promise<void>;
 }
+/** Which pipeline served a logical path: the compile step's manifest, or the project's own files. */
+type AssetSource = "manifest" | "source";
+/** Where one settled load's bytes actually came from. */
+interface IResolvedAsset {
+    readonly url: string;
+    readonly via: AssetSource;
+}
+interface ITextureOptions {
+    /**
+     * The pixels are data, not colour: a normal map, a roughness map, a mask. Data textures are
+     * sampled without a colour-space conversion, which is wrong for an albedo and right for these.
+     * Left out, the copy is sRGB — the space an image file is authored in. A loader leaves a plain
+     * image linear, which washes out every albedo, so an options call never inherits that.
+     */
+    readonly data?: boolean;
+    /** Both axes at once. Absent leaves the loaded texture's own wrapping. */
+    readonly wrap?: Wrapping;
+    /** Tiling counts, one for both axes or one per axis. Absent leaves the loaded texture's own. */
+    readonly repeat?: number | readonly [number, number];
+    /** Samples to take at grazing angles. Absent leaves the loaded texture's own. */
+    readonly anisotropy?: number;
+}
 interface IAssetLoader {
     readonly compressedTextures?: ICompressedTextureSupport;
     model<T = unknown>(path: string): Promise<T>;
-    texture(path: string): Promise<Texture>;
+    /**
+     * Load a texture, optionally configured in one call.
+     *
+     * @situation set color space, wrap, repeat or anisotropy on a loaded texture
+     *
+     * With no options this is the shared cached instance, exactly as before. With options it is a
+     * copy of it: the cached texture is shared by every other caller of that path, and a wrap or a
+     * colour-space write on it would silently change how another material draws.
+     */
+    texture(path: string, options?: ITextureOptions): Promise<Texture>;
     audio(path: string): Promise<AudioBuffer>;
     release(kind: "audio" | "model" | "texture", path: string): boolean;
     /**
@@ -86,6 +117,17 @@ interface IAssetLoader {
         readonly settled: number;
         readonly settledBytes: number;
     };
+    /**
+     * Where each settled load was actually served from, keyed by the logical path asked for.
+     *
+     * `progress` counts loads and cannot say which of a path's candidate urls answered, so a game
+     * whose manifest 404s and a game whose manifest named the output look identical from the game's
+     * own side — which is how an unreadable manifest became a silent uncompiled fallback on the
+     * native hosts, where a failed read arrives as a rejected fetch rather than a 404. `via` is
+     * `"manifest"` only for the compiled output the manifest named; `"source"` is the verbatim or
+     * source-directory path, and an external url, which no manifest governs.
+     */
+    readonly resolved: ReadonlyMap<string, IResolvedAsset>;
     clear(): void;
 }
 /**
@@ -107,4 +149,4 @@ interface IAssetLoader {
 declare function reconcileMirroredClips(root: Object3D, clips: readonly AnimationClip[]): boolean;
 declare function createAssetLoader(options?: IAssetLoaderOptions): IAssetLoader;
 
-export { type IAssetLoader as I, type IAssetLoaderOptions as a, createAssetLoader as c, reconcileMirroredClips as r };
+export { type IAssetLoader as I, type IAssetLoaderOptions as a, type ITextureOptions as b, createAssetLoader as c, reconcileMirroredClips as r };

package/dist/{canvas-layer-C1SnMoJ-.d.ts → canvas-layer-DDmC_VVF.d.ts}

@@ -1,6 +1,6 @@
 import * as three from 'three';
 import { Camera, Vector2, Vector3, Scene, OrthographicCamera } from 'three';
-import { I as IRendererLike } from './renderer-Cy4qeBOA.js';
+import { I as IRendererLike } from './renderer-CfsS2hxi.js';
 
 interface IViewportSize {
     readonly aspect: number;

package/dist/{game-D_6r-k4Y.d.ts → game-CljaDv4D.d.ts}

@@ -1,7 +1,7 @@
-import { I as IAssetLoader, a as IAssetLoaderOptions } from './assets-CYKk2WTu.js';
-import { F as FramePassKind, H as IRenderPassSample, m as IFramePhaseSample, n as IPipelineCensus, I as IRendererLike, ad as IRendererOptions, a as IFrameBudgetWindow, i as IFrameBudgetOptions } from './renderer-Cy4qeBOA.js';
+import { I as IAssetLoader, a as IAssetLoaderOptions } from './assets-CqvE429w.js';
+import { F as FramePassKind, K as IRenderPassSample, n as IFramePhaseSample, o as IPipelineCensus, I as IRendererLike, as as IRendererOptions, a as IFrameBudgetWindow, j as IFrameBudgetOptions } from './renderer-CfsS2hxi.js';
 import { Vector2, Vector3, Object3D, Camera, Intersection, Scene as Scene$1 } from 'three';
-import { V as Viewport, C as CanvasLayer, I as IViewportOptions } from './canvas-layer-C1SnMoJ-.js';
+import { V as Viewport, C as CanvasLayer, I as IViewportOptions } from './canvas-layer-DDmC_VVF.js';
 import { StoreApi } from 'zustand/vanilla';
 
 type ThreeNativeOrientation = "landscape" | "portrait" | "sensor";
@@ -101,6 +101,23 @@ interface IThreeNativeModelPassesConfig {
 }
 /** Model optimization options for the asset compile step; `"none"` ships sources verbatim. */
 interface IThreeNativeModelsConfig {
+    /**
+     * Lossless scene-graph compaction: flatten empty transform chains, join sibling primitives
+     * that share a material, and batch a mesh several nodes reuse as `EXT_mesh_gpu_instancing`.
+     *
+     * On by default; `false` ships the scene graph as authored. A node matching `protectedPattern`,
+     * named in `protectedNames`, targeted by an animation or a skin joint is never merged or
+     * instanced, so an exact-name lookup or a bone-driven node survives.
+     */
+    readonly compact?: boolean | {
+        readonly flatten?: boolean;
+        readonly instance?: boolean | {
+            readonly min?: number;
+        };
+        readonly join?: boolean;
+        readonly protectedNames?: readonly string[];
+        readonly protectedPattern?: string;
+    };
     /** Standard glTF TEXCOORD_1 atlas generation for offline static-light assets. */
     readonly lightmap?: {
         readonly atlasSize: number;
@@ -237,6 +254,43 @@ interface IThreeNativeLodConfig {
     readonly preset?: ThreeNativeLodPreset;
     readonly runtime?: IThreeNativeLodRuntimeConfig;
 }
+/** One measured byte ceiling on a produced artifact, and what crossing it does. */
+interface IThreeNativeArtifactBudgetLimit {
+    /** Bytes, exclusive: a build measuring exactly the limit is inside it. */
+    readonly limit: number;
+    /** `"error"` refuses the build and keeps the previous artifact; `"warn"` prints and publishes. */
+    readonly severity: "error" | "warn";
+}
+/**
+ * Runtime ceilings a profile wants every playtest of the artifact it builds to hold.
+ *
+ * The fields are the playtest harness's own `assert.performance` fields, one name for one meaning:
+ * a budget declared here is merged into each scenario's performance assertion, so a budget and a
+ * scenario bound the same number instead of two vocabularies for one measurement. Spelled out
+ * rather than imported — the harness runs against plain Three.js with no dependency on this
+ * package, and core must not invert that. A closed key list validated in both places is the price;
+ * `create-threenative/__tests__/build-report.spec.ts` fails if the two lists drift.
+ */
+interface IThreeNativePerformanceBudget {
+    /** Per-pass draw-call ceilings, keyed by pass kind: main, shadow, reflection, nested. */
+    readonly maxPassDrawCalls?: Readonly<Partial<Record<ThreeNativeRenderPassKind, number>>>;
+    /** Per-pass triangle ceilings, keyed by pass kind: main, shadow, reflection, nested. */
+    readonly maxPassTriangles?: Readonly<Partial<Record<ThreeNativeRenderPassKind, number>>>;
+    /** Per-phase millisecond ceilings at nearest-rank p95: hostGap, update, render, overlay, residual. */
+    readonly maxPhaseMsP95?: Readonly<Partial<Record<ThreeNativeFramePhase, number>>>;
+    /** Maximum renderer draw-call count across every pass combined. */
+    readonly maxDrawCalls?: number;
+    /** Maximum nearest-rank 95th-percentile frame time in milliseconds. */
+    readonly maxFrameMsP95?: number;
+    /** Maximum renderer triangle count across every pass combined. */
+    readonly maxTriangles?: number;
+    /** Frame-budget floor: the median presented frame must sustain at least this many frames a second. */
+    readonly minFps?: number;
+}
+/** The engine's frame-budget phases, as a budget spells them. */
+type ThreeNativeFramePhase = "hostGap" | "overlay" | "render" | "residual" | "update";
+/** The render-pass kinds a per-pass budget bounds. */
+type ThreeNativeRenderPassKind = "main" | "shadow" | "reflection" | "nested";
 interface IThreeNativeConfig {
     readonly app?: {
         readonly id?: string;
@@ -251,7 +305,10 @@ interface IThreeNativeConfig {
         readonly fullscreen?: boolean;
         readonly keepScreenOn?: boolean;
         /**
-         * Maximum native presentation rate in frames per second. Defaults to 60; `0` removes the
+         * Maximum native presentation rate in frames per second. Left out, it follows the display's own
+         * refresh rate capped at 120 on desktop and web, and stays 60 on mobile where the ceiling is
+         * power and heat; the resolved value and its source are reported on every `TN_FRAME_BUDGET`
+         * line as `targetFps` and `targetSource`. A number set here wins outright, and `0` removes the
          * software ceiling. Android also submits this value as the surface's preferred frame rate,
          * which the display policy may decline because of hardware, power, or thermal state. Android
          * uses non-blocking presentation above 60 fps so a missed high-refresh interval does not fall
@@ -277,6 +334,43 @@ interface IThreeNativeConfig {
         readonly maximized?: boolean;
         readonly resizable?: boolean;
     };
+    /**
+     * Named cook profiles: one authored asset tree, one compiler, a different representation per
+     * artifact. `--profile` on `threenative build` wins over `defaults[target]`; with neither, the
+     * `assets` block is used exactly as declared. An overlay changes resource-processing options
+     * only — the source root, the output root, worker concurrency and exclusions stay in `assets`.
+     */
+    readonly buildProfiles?: {
+        readonly defaults?: {
+            readonly android?: string;
+            readonly desktop?: string;
+            readonly ios?: string;
+            readonly web?: string;
+        };
+        readonly profiles: Readonly<Record<string, {
+            /**
+             * Byte ceilings on what this profile actually produced, measured after packaging and
+             * checked before the artifact is published. `artifactBytes` is the artifact itself (a
+             * file, or the recursive sum of a directory, `.app` bundle or outDir);
+             * `packagedAssetBytes` is the sum of the asset files that survived the packaging
+             * selector. `"error"` refuses the build and leaves the previous artifact in place;
+             * `"warn"` prints and publishes.
+             */
+            readonly artifactBudget?: {
+                readonly artifactBytes?: IThreeNativeArtifactBudgetLimit;
+                readonly packagedAssetBytes?: IThreeNativeArtifactBudgetLimit;
+            };
+            /**
+             * Runtime ceilings this profile's artifact must hold, published into the
+             * `<artifact>.build-report.json` a build writes beside it and merged by
+             * `threenative-playtest --build-report` into every scenario's `assert.performance`. The
+             * build measures none of it — it cannot; the numbers exist only once a runtime drew
+             * frames — so a budget never refuses a build and never passes one either.
+             */
+            readonly performanceBudget?: IThreeNativePerformanceBudget;
+            readonly assets?: Pick<NonNullable<IThreeNativeConfig["assets"]>, "audio" | "budget" | "lod" | "models" | "targets" | "textures">;
+        }>>;
+    };
     readonly assets?: {
         /**
          * Audio conditioning options, or `"none"` to ship every clip exactly as committed. Absent
@@ -294,6 +388,11 @@ interface IThreeNativeConfig {
         };
         /** Source-relative globs omitted from builds; excluded bytes are still reported. */
         readonly exclude?: readonly string[];
+        /**
+         * How many cook workers a bake may run at once; absent means the driver's default,
+         * min(4, cores - 1). Not part of any cache key, so changing it re-cooks nothing.
+         */
+        readonly concurrency?: number;
         /**
          * Automatic discrete LOD. `assets.lod: {}` opts in with the balanced default; `false` or
          * `{ enabled: false }` is the absolute kill switch, and per-asset overrides key off canonical
@@ -336,7 +435,8 @@ interface IThreeNativeConfig {
          */
         readonly alphaAntialiasing?: boolean;
         /**
-         * Whether the engine may render an internal mirror of the scene to collapse repeated draws.
+         * Whether the engine may render an internal mirror of the scene to collapse repeated draws,
+         * and how often that mirror proves a batched material still matches its group's shared draw.
          *
          * On by default, which is the shipping behaviour and is what an unset option means. The mirror
          * is opportunistic and correctness-preserving, but it pays a reconciliation cost per frame, so
@@ -345,8 +445,24 @@ interface IThreeNativeConfig {
          * eligibility scan, so the opt-out costs nothing rather than declining each frame; the authored
          * scene is what renders. The `TN_RENDER_PROJECTION` marker still reports it, with its own
          * reason code rather than one of the measured declines.
+         *
+         * An object instead of `false` names the material check:
+         *
+         * - `materialChecks: "spread"` — **the default.** A bounded slice of the batched materials is
+         *   proved per frame instead of all of them, so a frame of 4,096 colour-only materials costs
+         *   512 checks rather than 4,096. A material that gains a roughness, a map or a define still
+         *   leaves its group and is drawn exactly; it is caught up to `materialCheckStaleFrames` frames
+         *   later, and `TN_RENDER_PROJECTION` reports that bound. A base-colour edit never waits: the
+         *   per-instance colour is O(1) per member and always exact.
+         * - `materialChecks: "everyFrame"` — the named alternative, and the check exactly as it shipped
+         *   before the sweep existed: every material proved every frame, at about 1.1 µs a material. Use
+         *   it when a game would rather pay the per-frame cost than accept the bound.
+         *
+         * Any other value throws at startup rather than falling back to a default nobody asked for.
          */
-        readonly projection?: boolean;
+        readonly projection?: boolean | {
+            readonly materialChecks?: "spread" | "everyFrame";
+        };
         /**
          * Projected diameter, in raster pixels, below which the engine does not submit an object to
          * the render camera. On by default at a conservative **0.5 px**: an object under half a pixel
@@ -691,6 +807,14 @@ interface IRawInputState {
         buttons: readonly boolean[];
     };
 }
+/**
+ * Ask the browser to lock the pointer to `target`, the capture every first-person mouse look needs.
+ *
+ * Returns the platform's own promise when it has one, so the caller can wait for the lock the way
+ * the browser reports it, and `undefined` when the platform answered synchronously. A target that
+ * cannot capture at all throws rather than leaving a game with a camera that never turns.
+ */
+declare function captureMouse(target: EventTarget): Promise<void> | undefined;
 declare class InputMap {
     #private;
     readonly raw: IRawInputState;
@@ -1326,12 +1450,22 @@ interface IGamePluginRuntime {
     readonly enableRuntimeDiagnostics?: () => void;
     /** The frame's cost attribution so far, or undefined when the game turned the budget off. */
     readonly frameBudgetWindow?: () => IFrameBudgetWindow | undefined;
+    /**
+     * Stop the live clock, so a rendered frame simulates nothing and banks no wall-clock time.
+     *
+     * A run that counts fixed-step ticks must not also accumulate real seconds into the same
+     * simulation, and the frames before its first `advance()` are exactly where a boot's seconds
+     * used to land. Optional: a runtime without a clock just never freezes one.
+     */
+    readonly freezeClock?: () => void;
     /**
      * Hold start-scene entry until `gate` settles.
      *
-     * The returned promise settles after `Scene.enter()` has run. A runner can therefore release the
-     * gate after applying pre-entry setup, then await the returned promise before describing
-     * entity-derived capabilities. The frame loop remains held throughout.
+     * The returned promise settles after the scene that owns the world has entered: the start scene
+     * unless it navigated out of its own `enter()`, in which case it is the scene it navigated to,
+     * loaded and entered. A runner can therefore release the gate after applying pre-entry setup,
+     * then await the returned promise before describing entity-derived capabilities — the entities
+     * they read are the ones the world actually has. The frame loop remains held throughout.
      */
     readonly holdStart?: (gate: Promise<void>) => Promise<void>;
     readonly observations: IGameRuntimeObservations;
@@ -1521,4 +1655,4 @@ interface IGame<TState extends Record<string, unknown> = Record<string, unknown>
 }
 declare function defineGame<TState extends Record<string, unknown>, TPhysics = undefined>(config: IGameConfig<TState, TPhysics>): IGame<TState, TPhysics>;
 
-export { type IWarmUpRenderer as $, type AfterPhysicsCallback as A, type IRandom as B, type ContextMenuPolicy as C, type IRawInputPointer as D, type IRawInputPointerEdge as E, type IRawInputState as F, GEOMETRY_ASSET_KEY as G, type IRaycastOptions as H, type IGame as I, type IScenePickerOptions as J, type IThreeNativeAudioConfig as K, type IThreeNativeAudioLoop as L, type IThreeNativeAudioOverride as M, type IThreeNativeAudioSpectrum as N, type IThreeNativeBootSplash as O, type IThreeNativeConfig as P, type IThreeNativeIconVariants as Q, type IThreeNativeLodConfig as R, type IThreeNativeLodGenerationConfig as S, type IThreeNativeLodOverride as T, type IThreeNativeLodRuntimeConfig as U, type IThreeNativeTexturesConfig as V, type ITweenOptions as W, type IWarmUpCacheOptions as X, type IWarmUpObservation as Y, type IWarmUpOptions as Z, type IWarmUpProgress as _, type IGamePluginRuntime as a, type IWarmUpReport as a0, type InputBindings as a1, type InputPlatformSource as a2, type PointerEvent3DListener as a3, type PointerEvent3DType as a4, PointerEvents3D as a5, Scene as a6, type SceneFrame as a7, ScenePicker as a8, type ScheduleHandle as a9, Scheduler as aa, type ThreeNativeBackgroundMode as ab, type ThreeNativeLodMinTrianglesScope as ac, type ThreeNativeLodPreset as ad, type ThreeNativeOrientation as ae, type ThreeNativeUiRenderer as af, type WarmUpCacheStatus as ag, type WarmUpObservationStatus as ah, afterPhysics as ai, createRandom as aj, defineGame as ak, warmUpScene as al, type IGamePluginHooks as b, GEOMETRY_CAPTURE_DEFAULT_LIMIT as c, GEOMETRY_CAPTURE_MAX_LIMIT as d, GEOMETRY_CAPTURE_SORTS as e, GEOMETRY_CAPTURE_TIMEOUT_MS as f, GEOMETRY_CAPTURE_WALK_CAP as g, type GeometryCaptureSort as h, type ICtx as i, type IGameObservationContribution as j, type IGameObservationSampleRequest as k, type IGamePlatformSource as l, type IGeometryCaptureAsset as m, type IGeometryCaptureMesh as n, type IGeometryCapturePass as o, type IGeometryCaptureReport as p, type IGeometryCaptureRequest as q, type IGeometryCaptureRow as r, type IInputAction as s, type IInputGamepad as t, type IPointerDragHandle as u, type IPointerEvent3D as v, type IPointerEvents3D as w, type IPointerEvents3DOptions as x, type IPointerEvents3DPicker as y, type IPointerState as z };
+export { type IWarmUpRenderer as $, type AfterPhysicsCallback as A, type IRandom as B, type ContextMenuPolicy as C, type IRawInputPointer as D, type IRawInputPointerEdge as E, type IRawInputState as F, GEOMETRY_ASSET_KEY as G, type IRaycastOptions as H, type IGame as I, type IScenePickerOptions as J, type IThreeNativeAudioConfig as K, type IThreeNativeAudioLoop as L, type IThreeNativeAudioOverride as M, type IThreeNativeAudioSpectrum as N, type IThreeNativeBootSplash as O, type IThreeNativeConfig as P, type IThreeNativeIconVariants as Q, type IThreeNativeLodConfig as R, type IThreeNativeLodGenerationConfig as S, type IThreeNativeLodOverride as T, type IThreeNativeLodRuntimeConfig as U, type IThreeNativeTexturesConfig as V, type ITweenOptions as W, type IWarmUpCacheOptions as X, type IWarmUpObservation as Y, type IWarmUpOptions as Z, type IWarmUpProgress as _, type IGamePluginRuntime as a, type IWarmUpReport as a0, type InputBindings as a1, InputMap as a2, type InputPlatformSource as a3, type PointerEvent3DListener as a4, type PointerEvent3DType as a5, PointerEvents3D as a6, Scene as a7, type SceneFrame as a8, ScenePicker as a9, type ScheduleHandle as aa, Scheduler as ab, type ThreeNativeBackgroundMode as ac, type ThreeNativeLodMinTrianglesScope as ad, type ThreeNativeLodPreset as ae, type ThreeNativeOrientation as af, type ThreeNativeUiRenderer as ag, type WarmUpCacheStatus as ah, type WarmUpObservationStatus as ai, afterPhysics as aj, captureMouse as ak, createRandom as al, defineGame as am, warmUpScene as an, type IGamePluginHooks as b, GEOMETRY_CAPTURE_DEFAULT_LIMIT as c, GEOMETRY_CAPTURE_MAX_LIMIT as d, GEOMETRY_CAPTURE_SORTS as e, GEOMETRY_CAPTURE_TIMEOUT_MS as f, GEOMETRY_CAPTURE_WALK_CAP as g, type GeometryCaptureSort as h, type ICtx as i, type IGameObservationContribution as j, type IGameObservationSampleRequest as k, type IGamePlatformSource as l, type IGeometryCaptureAsset as m, type IGeometryCaptureMesh as n, type IGeometryCapturePass as o, type IGeometryCaptureReport as p, type IGeometryCaptureRequest as q, type IGeometryCaptureRow as r, type IInputAction as s, type IInputGamepad as t, type IPointerDragHandle as u, type IPointerEvent3D as v, type IPointerEvents3D as w, type IPointerEvents3DOptions as x, type IPointerEvents3DPicker as y, type IPointerState as z };

package/dist/{gpu-readback-CMklJs6r.d.ts → gpu-readback-CqJEfWNQ.d.ts}

@@ -1,5 +1,5 @@
-import { Object3D } from 'three';
-import { I as IRendererLike } from './renderer-Cy4qeBOA.js';
+import { Object3D, Camera } from 'three';
+import { I as IRendererLike } from './renderer-CfsS2hxi.js';
 
 /**
  * The lifecycle contract for a game-owned GPU simulation.
@@ -17,8 +17,15 @@ interface IComputeDriven {
      * existing behavior of consumers whose simulation is intentionally tied to presentation.
      */
     readonly processCadence?: "fixed" | "render";
-    /** Dispatched once per fixed step, in scene-add order unless render cadence is declared. */
-    process(renderer: IRendererLike): void;
+    /**
+     * Dispatched once per fixed step, in scene-add order unless render cadence is declared.
+     *
+     * `camera` is the frame's render camera, handed over at render cadence so a consumer that culls by
+     * the view — a streamed world narrowing its instanced windows to what the frustum covers — can do
+     * it from the driver that runs every frame rather than from a draw three will not submit. An
+     * implementation that does not need it simply declares one parameter.
+     */
+    process(renderer: IRendererLike, camera?: Camera): void;
     detach(): void;
     readonly released: boolean;
 }
@@ -34,8 +41,11 @@ declare class ComputeDrivenRegistry {
     get warmupNodes(): readonly unknown[];
     /** Dispatch fixed-step objects once; detached scene children are released before dispatch. */
     process(renderer: IRendererLike): void;
-    /** Dispatch render-cadence objects once; detached scene children are released before dispatch. */
-    processRender(renderer: IRendererLike): void;
+    /**
+     * Dispatch render-cadence objects once with the frame's render camera; detached scene children are
+     * released before dispatch.
+     */
+    processRender(renderer: IRendererLike, camera?: Camera): void;
     /** Release every registered object, continuing after a failure so no resource is stranded. */
     clear(): void;
 }

package/dist/hot.d.ts

@@ -1,10 +1,10 @@
 import { a as audioRuntimeSnapshot } from './audio-7i3Xl0l3.js';
-import { I as IGame } from './game-D_6r-k4Y.js';
+import { I as IGame } from './game-CljaDv4D.js';
 import 'three';
-import './assets-CYKk2WTu.js';
-import './renderer-Cy4qeBOA.js';
+import './assets-CqvE429w.js';
+import './renderer-CfsS2hxi.js';
 import 'three/webgpu';
-import './canvas-layer-C1SnMoJ-.js';
+import './canvas-layer-DDmC_VVF.js';
 import 'zustand/vanilla';
 
 interface IHotDiagnostics {