@threenative/core 0.3.2 → 0.3.4

package/dist/{assets-kyoF7JlJ.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;
     /**
@@ -74,11 +105,29 @@ interface IAssetLoader {
      * stay 0 for a game with no manifest, where no size is knowable before the bytes arrive.
      */
     readonly progress: {
+        /**
+         * The logical paths asked for and not yet settled, in request order. A loading screen that
+         * only shows a ratio cannot say *what* it is waiting for, which is the difference between
+         * "still loading" and "stuck on `akagi.glb`" — and a stall report that names nothing is a
+         * bug report nobody can act on.
+         */
+        readonly pending: readonly string[];
         readonly requested: number;
         readonly requestedBytes: number;
         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;
 }
 /**
@@ -100,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/{audio-BFiGneTL.d.ts → audio-7i3Xl0l3.d.ts}

@@ -14,6 +14,15 @@ interface IAudioBusOptions {
     readonly maxVoices?: number;
 }
 interface IAudioPlayOptions {
+    /**
+     * What this cue is, for anything reading back what the game played — a playtest above all.
+     *
+     * Nothing about the sound changes. Every other audio check answers "is the file right": that it
+     * exists, decodes, and is inside its byte budget. None of them can answer "did the game say the
+     * general-quarters line twice", which is the class of defect players actually report, so the bus
+     * keeps a ledger of the labels it was given.
+     */
+    readonly cue?: string;
     readonly fade?: number;
     readonly loop?: boolean;
     readonly volume?: number;
@@ -49,6 +58,21 @@ interface IAudioPlayOptions {
     readonly lowpassHz?: number;
 }
 interface IAudioRuntimeSnapshot {
+    /**
+     * How many times each labelled cue has sounded, across every live bus.
+     *
+     * This is the only observation that can answer "what did the game actually say, and how often".
+     * Every other audio check in the repository is about the *file* — that it exists, decodes and is
+     * inside its budget — and all of them stay green while a one-shot line plays a second time
+     * halfway through a match, which is the defect players report. A game opts a cue in by passing
+     * `cue` to `play`/`playAt`; unlabelled sounds never appear here.
+     */
+    readonly cues: Readonly<Record<string, number>>;
+    /** The most recent labelled cues in the order they sounded, bounded per bus. */
+    readonly recentCues: ReadonlyArray<{
+        readonly atMs: number;
+        readonly cue: string;
+    }>;
     readonly queued: number;
     readonly voices: number;
     /** Retired voices held for reuse. Bounded by peak concurrency, never by session length. */
@@ -67,6 +91,13 @@ interface IAudioRuntimeSnapshot {
      */
     readonly unsupported: readonly string[];
 }
+/**
+ * Forgets every recorded cue.
+ *
+ * @situation clear the recorded audio cue counts between tests so one test cannot read another's plays
+ * @example resetAudioCueLedger();
+ */
+declare function resetAudioCueLedger(): void;
 declare class AudioBus {
     #private;
     readonly listener: AudioListener;
@@ -153,4 +184,4 @@ declare class AudioBus {
 }
 declare function audioRuntimeSnapshot(): IAudioRuntimeSnapshot;
 
-export { AudioBus as A, type IAudioBusOptions as I, audioRuntimeSnapshot as a, type IAudioPlayOptions as b };
+export { AudioBus as A, type IAudioBusOptions as I, audioRuntimeSnapshot as a, type IAudioPlayOptions as b, resetAudioCueLedger as r };

package/dist/{canvas-layer-BLVijiUJ.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-C6hqZpoG.js';
+import { I as IRendererLike } from './renderer-CfsS2hxi.js';
 
 interface IViewportSize {
     readonly aspect: number;