@stowkit/three-loader 0.1.9 → 0.1.11

package/dist/stowkit-three-loader.js

@@ -387,167 +387,214 @@ class MeshParser {
 }
 
 /**
- * Three.js loader for StowKit asset packs (.stow files)
- *
- * Usage:
- * ```typescript
- * const loader = new StowKitLoader();
- * loader.setTranscoderPath('/basis/');
- *
- * // Load a mesh asset
- * loader.loadMesh('assets.stow', 'path/to/mesh', (scene) => {
- *   threeScene.add(scene);
- * });
- * ```
+ * Represents an opened StowKit pack with methods to load assets by name
  */
-class StowKitLoader extends THREE__namespace.Loader {
-    constructor(manager, parameters) {
-        super(manager);
-        this.ownedReader = false;
-        // Use provided reader or create new one
-        if (parameters?.reader) {
-            this.reader = parameters.reader;
-            this.ownedReader = false;
+class StowKitPack {
+    constructor(reader, ktx2Loader, dracoLoader) {
+        this.reader = reader;
+        this.ktx2Loader = ktx2Loader;
+        this.dracoLoader = dracoLoader;
+    }
+    /**
+     * Load a mesh by its canonical path/name
+     */
+    async loadMesh(assetPath) {
+        // Find asset by path
+        const assetIndex = this.reader.findAssetByPath(assetPath);
+        if (assetIndex < 0) {
+            throw new Error(`Mesh not found: ${assetPath}`);
+        }
+        // Read mesh data and metadata
+        const data = this.reader.readAssetData(assetIndex);
+        const metadata = this.reader.readAssetMetadata(assetIndex);
+        if (!data) {
+            throw new Error(`Failed to read mesh data: ${assetPath}`);
         }
-        else {
-            const wasmPath = parameters?.wasmPath || '/stowkit_reader.wasm';
-            this.reader = new reader.StowKitReader(wasmPath);
-            this.ownedReader = true;
+        if (!metadata) {
+            throw new Error(`No metadata available: ${assetPath}`);
         }
-        // Setup KTX2 loader for textures with default path (bundled with package)
-        const transcoderPath = parameters?.transcoderPath || '/stowkit/basis/'; // Auto-copied on install
-        this.ktx2Loader = new KTX2Loader_js.KTX2Loader(manager);
-        this.ktx2Loader.setTranscoderPath(transcoderPath);
-        // Setup Draco loader for mesh decompression
-        this.dracoLoader = new DRACOLoader_js.DRACOLoader(manager);
-        this.dracoLoader.setDecoderPath('/stowkit/draco/'); // Draco files copied by postinstall
-        // Detect support with a temporary renderer
-        // This is required for KTX2Loader to work
-        const tempRenderer = new THREE__namespace.WebGLRenderer();
-        this.ktx2Loader.detectSupport(tempRenderer);
-        tempRenderer.dispose();
+        // Parse mesh data
+        const parsedData = MeshParser.parseMeshData(metadata, data);
+        // Load textures for materials
+        await this.loadMaterialTextures(parsedData.materialData, parsedData.materials);
+        // Build Three.js scene with Draco decoder
+        const scene = await MeshParser.buildScene(parsedData, data, this.dracoLoader);
+        return scene;
     }
     /**
-     * Set the path to the Draco decoder
+     * Load a texture by its canonical path/name
      */
-    setDracoDecoderPath(path) {
-        this.dracoLoader.setDecoderPath(path);
-        return this;
+    async loadTexture(assetPath) {
+        // Find asset by path
+        const assetIndex = this.reader.findAssetByPath(assetPath);
+        if (assetIndex < 0) {
+            throw new Error(`Texture not found: ${assetPath}`);
+        }
+        // Read texture data
+        const data = this.reader.readAssetData(assetIndex);
+        if (!data) {
+            throw new Error(`Failed to read texture data: ${assetPath}`);
+        }
+        // Load as KTX2
+        return await this.loadKTX2Texture(data);
     }
     /**
-     * Set the path to the Basis Universal transcoder
+     * Load audio by its canonical path/name
      */
-    setTranscoderPath(path) {
-        this.ktx2Loader.setTranscoderPath(path);
-        return this;
+    async loadAudio(assetPath, listener) {
+        // Find asset by path
+        const assetIndex = this.reader.findAssetByPath(assetPath);
+        if (assetIndex < 0) {
+            throw new Error(`Audio not found: ${assetPath}`);
+        }
+        // Read audio data
+        const data = this.reader.readAssetData(assetIndex);
+        if (!data) {
+            throw new Error(`Failed to read audio data: ${assetPath}`);
+        }
+        // Create audio object
+        const audio = new THREE__namespace.Audio(listener);
+        // Decode audio data
+        const arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+        const audioContext = listener.context;
+        const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+        audio.setBuffer(audioBuffer);
+        return audio;
     }
     /**
-     * Detect WebGL support for compressed textures
+     * Get list of all assets in pack
      */
-    detectSupport(renderer) {
-        this.ktx2Loader.detectSupport(renderer);
-        return this;
+    listAssets() {
+        return this.reader.listAssets();
     }
     /**
-     * Open a .stow pack file (call this first if loading multiple assets)
-     * @param url - URL to the .stow file
+     * Get asset count
      */
-    async openPack(url) {
-        if (this.ownedReader) {
-            await this.reader.init();
-        }
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
-        }
-        const arrayBuffer = await response.arrayBuffer();
-        await this.reader.open(arrayBuffer);
+    getAssetCount() {
+        return this.reader.getAssetCount();
     }
     /**
-     * Load and parse a mesh asset by its index
-     * @param index - Asset index
-     * @param onLoad - Callback when loading completes
-     * @param onProgress - Progress callback
-     * @param onError - Error callback
+     * Get asset info by index
      */
-    async loadMeshByIndex(index, onLoad, onProgress, onError) {
-        try {
-            // Read mesh data and metadata
-            const data = this.reader.readAssetData(index);
-            const metadata = this.reader.readAssetMetadata(index);
-            if (!data) {
-                throw new Error(`Failed to read mesh data for index ${index}`);
-            }
-            if (!metadata) {
-                throw new Error(`No metadata available for index ${index}`);
-            }
-            // Parse mesh data
-            const parsedData = MeshParser.parseMeshData(metadata, data);
-            // Load textures for materials
-            await this.loadMaterialTextures(parsedData.materialData, parsedData.materials);
-            // Build Three.js scene with Draco decoder
-            const scene = await MeshParser.buildScene(parsedData, data, this.dracoLoader);
-            if (onLoad) {
-                onLoad(scene);
-            }
-            return scene;
-        }
-        catch (error) {
-            if (onError) {
-                onError(error);
-            }
-            throw error;
-        }
+    getAssetInfo(index) {
+        return this.reader.getAssetInfo(index);
     }
     /**
-     * Load and parse a mesh asset from a StowKit pack
-     * @param url - URL to the .stow file (or omit if already opened with openPack)
-     * @param assetPath - Path to the mesh asset within the pack
-     * @param onLoad - Callback when loading completes
-     * @param onProgress - Progress callback
-     * @param onError - Error callback
+     * Read asset data by index
      */
-    async loadMesh(url, assetPath, onLoad, onProgress, onError) {
-        try {
-            // Open pack if URL provided
-            if (url) {
-                await this.openPack(url);
-            }
-            // Find the mesh asset
-            const assetIndex = this.reader.findAssetByPath(assetPath);
-            if (assetIndex < 0) {
-                throw new Error(`Asset not found: ${assetPath}`);
-            }
-            // Read mesh data and metadata
-            const data = this.reader.readAssetData(assetIndex);
-            const metadata = this.reader.readAssetMetadata(assetIndex);
-            if (!data) {
-                throw new Error(`Failed to read mesh data for ${assetPath}`);
-            }
-            if (!metadata) {
-                throw new Error(`No metadata available for ${assetPath}`);
-            }
-            // Parse mesh data
-            const parsedData = MeshParser.parseMeshData(metadata, data);
-            // Load textures for materials
-            await this.loadMaterialTextures(parsedData.materialData, parsedData.materials);
-            // Build Three.js scene with Draco decoder
-            const scene = await MeshParser.buildScene(parsedData, data, this.dracoLoader);
-            if (onLoad) {
-                onLoad(scene);
-            }
-            return scene;
-        }
-        catch (error) {
-            if (onError) {
-                onError(error);
-            }
-            throw error;
-        }
+    readAssetData(index) {
+        return this.reader.readAssetData(index);
     }
     /**
-     * Load textures for materials
+     * Read asset metadata by index
      */
+    readAssetMetadata(index) {
+        return this.reader.readAssetMetadata(index);
+    }
+    /**
+     * Parse texture metadata
+     */
+    parseTextureMetadata(metadataBytes) {
+        return this.reader.parseTextureMetadata(metadataBytes);
+    }
+    /**
+     * Load mesh by index
+     */
+    async loadMeshByIndex(index) {
+        const data = this.reader.readAssetData(index);
+        const metadata = this.reader.readAssetMetadata(index);
+        if (!data)
+            throw new Error(`Failed to read mesh data for index ${index}`);
+        if (!metadata)
+            throw new Error(`No metadata for index ${index}`);
+        const parsedData = MeshParser.parseMeshData(metadata, data);
+        await this.loadMaterialTextures(parsedData.materialData, parsedData.materials);
+        return await MeshParser.buildScene(parsedData, data, this.dracoLoader);
+    }
+    /**
+     * Load texture by index
+     */
+    async loadTextureByIndex(index) {
+        const data = this.reader.readAssetData(index);
+        if (!data)
+            throw new Error(`Failed to read texture for index ${index}`);
+        return await this.loadKTX2Texture(data);
+    }
+    /**
+     * Create HTML audio preview element
+     */
+    async createAudioPreview(index) {
+        const data = this.reader.readAssetData(index);
+        if (!data)
+            throw new Error(`Failed to read audio for index ${index}`);
+        const blob = new Blob([data], { type: 'audio/ogg' });
+        const url = URL.createObjectURL(blob);
+        const audio = document.createElement('audio');
+        audio.controls = true;
+        audio.src = url;
+        audio.addEventListener('ended', () => URL.revokeObjectURL(url));
+        audio.addEventListener('error', () => URL.revokeObjectURL(url));
+        return audio;
+    }
+    /**
+     * Get audio metadata by path
+     */
+    getAudioMetadata(assetPath) {
+        const assetIndex = this.reader.findAssetByPath(assetPath);
+        if (assetIndex < 0)
+            return null;
+        const metadata = this.reader.readAssetMetadata(assetIndex);
+        if (!metadata || metadata.length < 140)
+            return null;
+        const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
+        const decoder = new TextDecoder();
+        const stringIdBytes = metadata.slice(0, 128);
+        const nullIdx = stringIdBytes.indexOf(0);
+        const stringId = decoder.decode(stringIdBytes.slice(0, nullIdx >= 0 ? nullIdx : 128));
+        return {
+            stringId,
+            sampleRate: view.getUint32(128, true),
+            channels: view.getUint32(132, true),
+            durationMs: view.getUint32(136, true)
+        };
+    }
+    /**
+     * Load material schema by index
+     */
+    loadMaterialSchemaByIndex(index) {
+        return this.loadMaterialSchemaByIndex_internal(index);
+    }
+    /**
+     * Get mesh materials by index
+     */
+    getMeshMaterialsByIndex(index) {
+        return this.getMeshMaterialsByIndex_internal(index);
+    }
+    /**
+     * Get material schema information
+     */
+    getMaterialSchema(assetPath) {
+        const assetIndex = this.reader.findAssetByPath(assetPath);
+        if (assetIndex < 0)
+            return null;
+        return this.loadMaterialSchemaByIndex_internal(assetIndex);
+    }
+    /**
+     * Get mesh materials information
+     */
+    getMeshMaterials(assetPath) {
+        const assetIndex = this.reader.findAssetByPath(assetPath);
+        if (assetIndex < 0)
+            return null;
+        return this.getMeshMaterialsByIndex_internal(assetIndex);
+    }
+    /**
+     * Close the pack and free resources
+     */
+    dispose() {
+        this.reader.close();
+    }
+    // Private methods moved from StowKitLoader
     async loadMaterialTextures(materialData, materials) {
         for (let i = 0; i < materialData.length; i++) {
             const matData = materialData[i];
@@ -555,21 +602,7 @@ class StowKitLoader extends THREE__namespace.Loader {
             for (const prop of matData.properties) {
                 if (prop.textureId && prop.textureId.length > 0) {
                     try {
-                        // Find texture asset
-                        const textureIndex = this.reader.findAssetByPath(prop.textureId);
-                        if (textureIndex < 0) {
-                            console.warn(`Texture not found: ${prop.textureId}`);
-                            continue;
-                        }
-                        // Read texture data
-                        const textureData = this.reader.readAssetData(textureIndex);
-                        if (!textureData) {
-                            console.warn(`Failed to read texture: ${prop.textureId}`);
-                            continue;
-                        }
-                        // Load as KTX2
-                        const texture = await this.loadKTX2Texture(textureData);
-                        // Apply to material based on property name
+                        const texture = await this.loadTexture(prop.textureId);
                         this.applyTextureToMaterial(material, prop.fieldName, texture);
                     }
                     catch (error) {
@@ -579,9 +612,6 @@ class StowKitLoader extends THREE__namespace.Loader {
             }
         }
     }
-    /**
-     * Load a KTX2 texture from binary data
-     */
     async loadKTX2Texture(data) {
         const arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
         const blob = new Blob([arrayBuffer]);
@@ -590,7 +620,6 @@ class StowKitLoader extends THREE__namespace.Loader {
             return await new Promise((resolve, reject) => {
                 this.ktx2Loader.load(url, (texture) => {
                     URL.revokeObjectURL(url);
-                    // Compressed textures don't support flipY, we flip UVs in MeshParser instead
                     texture.needsUpdate = true;
                     resolve(texture);
                 }, undefined, (error) => {
@@ -604,9 +633,6 @@ class StowKitLoader extends THREE__namespace.Loader {
             throw error;
         }
     }
-    /**
-     * Apply texture to appropriate material property
-     */
     applyTextureToMaterial(material, propertyName, texture) {
         const propNameLower = propertyName.toLowerCase();
         if (propNameLower === 'maintex' || propNameLower.includes('diffuse') ||
@@ -623,422 +649,154 @@ class StowKitLoader extends THREE__namespace.Loader {
             material.roughnessMap = texture;
         }
         else {
-            // Default to main texture
             material.map = texture;
         }
         material.needsUpdate = true;
     }
-    /**
-     * Load a texture asset from a StowKit pack
-     * @param url - URL to the .stow file (or omit if already opened with openPack)
-     * @param assetPath - Path to the texture asset within the pack
-     * @param onLoad - Callback when loading completes
-     * @param onProgress - Progress callback
-     * @param onError - Error callback
-     */
-    async loadTexture(url, assetPath, onLoad, onProgress, onError) {
-        try {
-            // Open pack if URL provided
-            if (url) {
-                await this.openPack(url);
-            }
-            // Find the texture asset
-            const assetIndex = this.reader.findAssetByPath(assetPath);
-            if (assetIndex < 0) {
-                throw new Error(`Asset not found: ${assetPath}`);
-            }
-            return await this.loadTextureByIndex(assetIndex, onLoad, onProgress, onError);
-        }
-        catch (error) {
-            if (onError) {
-                onError(error);
-            }
-            throw error;
-        }
-    }
-    /**
-     * Load a texture asset by its index in the pack
-     * @param index - Asset index
-     * @param onLoad - Callback when loading completes
-     * @param onProgress - Progress callback
-     * @param onError - Error callback
-     */
-    async loadTextureByIndex(index, onLoad, onProgress, onError) {
-        try {
-            // Read texture data
-            const data = this.reader.readAssetData(index);
-            if (!data) {
-                throw new Error(`Failed to read texture data for index ${index}`);
-            }
-            // Load as KTX2
-            const texture = await this.loadKTX2Texture(data);
-            if (onLoad) {
-                onLoad(texture);
-            }
-            return texture;
-        }
-        catch (error) {
-            if (onError) {
-                onError(error);
-            }
-            throw error;
-        }
-    }
-    /**
-     * Load an audio asset from a StowKit pack
-     * @param url - URL to the .stow file (or omit if already opened with openPack)
-     * @param assetPath - Path to the audio asset within the pack
-     * @param listener - THREE.AudioListener to attach to
-     * @param onLoad - Callback when loading completes
-     * @param onProgress - Progress callback
-     * @param onError - Error callback
-     */
-    async loadAudio(url, assetPath, listener, onLoad, onProgress, onError) {
-        try {
-            // Open pack if URL provided
-            if (url) {
-                await this.openPack(url);
-            }
-            // Find the audio asset
-            const assetIndex = this.reader.findAssetByPath(assetPath);
-            if (assetIndex < 0) {
-                throw new Error(`Asset not found: ${assetPath}`);
-            }
-            // Read audio data
-            const data = this.reader.readAssetData(assetIndex);
-            if (!data) {
-                throw new Error(`Failed to read audio data for ${assetPath}`);
-            }
-            // Create audio object
-            const audio = new THREE__namespace.Audio(listener);
-            // Decode audio data
-            const arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-            const audioContext = listener.context;
-            const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
-            audio.setBuffer(audioBuffer);
-            if (onLoad) {
-                onLoad(audio);
-            }
-            return audio;
-        }
-        catch (error) {
-            if (onError) {
-                onError(error);
-            }
-            throw error;
-        }
-    }
-    /**
-     * Get metadata for an audio asset
-     * @param assetPath - Path to the audio asset within the pack
-     */
-    getAudioMetadata(assetPath) {
-        try {
-            const assetIndex = this.reader.findAssetByPath(assetPath);
-            if (assetIndex < 0)
-                return null;
-            const metadata = this.reader.readAssetMetadata(assetIndex);
-            if (!metadata || metadata.length < 140)
-                return null;
-            const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
-            const decoder = new TextDecoder();
-            // Parse AudioMetadata structure
-            const stringIdBytes = metadata.slice(0, 128);
-            const nullIdx = stringIdBytes.indexOf(0);
-            const stringId = decoder.decode(stringIdBytes.slice(0, nullIdx >= 0 ? nullIdx : 128));
-            return {
-                stringId,
-                sampleRate: view.getUint32(128, true),
-                channels: view.getUint32(132, true),
-                durationMs: view.getUint32(136, true)
-            };
-        }
-        catch (error) {
-            console.error('Failed to read audio metadata:', error);
-            return null;
-        }
-    }
-    /**
-     * Get metadata for a texture asset
-     * @param assetPath - Path to the texture asset within the pack
-     */
-    getTextureMetadata(assetPath) {
-        try {
-            const assetIndex = this.reader.findAssetByPath(assetPath);
-            if (assetIndex < 0)
-                return null;
-            const metadata = this.reader.readAssetMetadata(assetIndex);
-            if (!metadata || metadata.length < 144)
-                return null; // TextureMetadata is now 144 bytes
-            const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
-            const decoder = new TextDecoder();
-            // Parse TextureMetadata structure (width, height, channels, channel_format, string_id[128])
-            const stringIdBytes = metadata.slice(16, 144); // After 4 uint32s (16 bytes)
-            const nullIdx = stringIdBytes.indexOf(0);
-            const stringId = decoder.decode(stringIdBytes.slice(0, nullIdx >= 0 ? nullIdx : 128));
-            return {
-                width: view.getUint32(0, true),
-                height: view.getUint32(4, true),
-                channels: view.getUint32(8, true),
-                isKtx2: true, // All textures are KTX2 now
-                channelFormat: view.getUint32(12, true),
-                stringId
-            };
-        }
-        catch (error) {
-            console.error('Failed to read texture metadata:', error);
+    loadMaterialSchemaByIndex_internal(index) {
+        const metadata = this.reader.readAssetMetadata(index);
+        if (!metadata || metadata.length < 196)
             return null;
+        const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
+        const decoder = new TextDecoder();
+        const stringIdBytes = metadata.slice(0, 128);
+        const schemaNameBytes = metadata.slice(128, 192);
+        const stringId = decoder.decode(stringIdBytes.slice(0, stringIdBytes.indexOf(0) || 128));
+        const schemaName = decoder.decode(schemaNameBytes.slice(0, schemaNameBytes.indexOf(0) || 64));
+        const fieldCount = view.getUint32(192, true);
+        const fields = [];
+        let offset = 196;
+        for (let i = 0; i < fieldCount; i++) {
+            if (offset + 88 > metadata.length)
+                break;
+            const fieldNameBytes = metadata.slice(offset, offset + 64);
+            const fieldName = decoder.decode(fieldNameBytes.slice(0, fieldNameBytes.indexOf(0) || 64));
+            const fieldType = view.getUint32(offset + 64, true);
+            const previewFlags = view.getUint32(offset + 68, true);
+            const defaultValue = [
+                view.getFloat32(offset + 72, true),
+                view.getFloat32(offset + 76, true),
+                view.getFloat32(offset + 80, true),
+                view.getFloat32(offset + 84, true)
+            ];
+            const typeNames = ['Texture', 'Color', 'Float', 'Vec2', 'Vec3', 'Vec4', 'Int'];
+            const previewFlagNames = ['None', 'MainTex', 'Tint'];
+            fields.push({
+                name: fieldName,
+                type: typeNames[fieldType] || 'Float',
+                previewFlag: previewFlagNames[previewFlags] || 'None',
+                defaultValue
+            });
+            offset += 88;
         }
+        return { stringId, schemaName, fields };
     }
-    /**
-     * Load material schema information by index
-     * @param index - Asset index
-     */
-    loadMaterialSchemaByIndex(index) {
-        try {
-            const metadata = this.reader.readAssetMetadata(index);
-            if (!metadata || metadata.length < 196)
-                return null;
-            const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
-            const decoder = new TextDecoder();
-            const stringIdBytes = metadata.slice(0, 128);
-            const schemaNameBytes = metadata.slice(128, 192);
-            const stringId = decoder.decode(stringIdBytes.slice(0, stringIdBytes.indexOf(0) || 128));
-            const schemaName = decoder.decode(schemaNameBytes.slice(0, schemaNameBytes.indexOf(0) || 64));
-            const fieldCount = view.getUint32(192, true);
-            const fields = [];
-            let offset = 196;
-            for (let i = 0; i < fieldCount; i++) {
-                if (offset + 88 > metadata.length)
-                    break;
-                const fieldNameBytes = metadata.slice(offset, offset + 64);
-                const fieldName = decoder.decode(fieldNameBytes.slice(0, fieldNameBytes.indexOf(0) || 64));
-                const fieldType = view.getUint32(offset + 64, true);
-                const previewFlags = view.getUint32(offset + 68, true);
-                const defaultValue = [
-                    view.getFloat32(offset + 72, true),
-                    view.getFloat32(offset + 76, true),
-                    view.getFloat32(offset + 80, true),
-                    view.getFloat32(offset + 84, true)
-                ];
-                const typeNames = ['Texture', 'Color', 'Float', 'Vec2', 'Vec3', 'Vec4', 'Int'];
-                const previewFlagNames = ['None', 'MainTex', 'Tint'];
-                fields.push({
-                    name: fieldName,
-                    type: typeNames[fieldType] || 'Float',
-                    previewFlag: previewFlagNames[previewFlags] || 'None',
-                    defaultValue
-                });
-                offset += 88;
-            }
-            return { stringId, schemaName, fields };
-        }
-        catch (error) {
-            console.error('Failed to read material schema:', error);
+    getMeshMaterialsByIndex_internal(index) {
+        const metadata = this.reader.readAssetMetadata(index);
+        if (!metadata || metadata.length < 140)
             return null;
-        }
-    }
-    /**
-     * Load material schema information by path
-     * @param assetPath - Path to the material schema asset
-     */
-    loadMaterialSchema(assetPath) {
-        try {
-            const assetIndex = this.reader.findAssetByPath(assetPath);
-            if (assetIndex < 0)
-                return null;
-            const metadata = this.reader.readAssetMetadata(assetIndex);
-            if (!metadata || metadata.length < 196)
-                return null;
-            const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
-            const decoder = new TextDecoder();
-            // Parse MaterialSchemaMetadata: string_id[128] + schema_name[64] + field_count(4) = 196 bytes
-            const stringIdBytes = metadata.slice(0, 128);
-            const schemaNameBytes = metadata.slice(128, 192);
-            const stringId = decoder.decode(stringIdBytes.slice(0, stringIdBytes.indexOf(0) || 128));
-            const schemaName = decoder.decode(schemaNameBytes.slice(0, schemaNameBytes.indexOf(0) || 64));
-            const fieldCount = view.getUint32(192, true);
-            const fields = [];
-            let offset = 196;
-            // Parse fields: name[64] + field_type(4) + preview_flags(4) + default_value[4*4=16] = 88 bytes
-            for (let i = 0; i < fieldCount; i++) {
-                if (offset + 88 > metadata.length)
+        const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
+        const decoder = new TextDecoder();
+        const meshGeometryCount = view.getUint32(0, true);
+        const materialCount = view.getUint32(4, true);
+        const nodeCount = view.getUint32(8, true);
+        let offset = 140;
+        offset += meshGeometryCount * 40;
+        const materials = [];
+        for (let i = 0; i < materialCount; i++) {
+            if (offset + 196 > metadata.length)
+                break;
+            const nameBytes = metadata.slice(offset, offset + 64);
+            const schemaIdBytes = metadata.slice(offset + 64, offset + 192);
+            const name = decoder.decode(nameBytes.slice(0, nameBytes.indexOf(0) || 64));
+            const schemaId = decoder.decode(schemaIdBytes.slice(0, schemaIdBytes.indexOf(0) || 128));
+            const propertyCount = view.getUint32(offset + 192, true);
+            materials.push({ name, schemaId, propertyCount, properties: [] });
+            offset += 196;
+        }
+        offset += nodeCount * 116;
+        offset += nodeCount * 4;
+        for (const mat of materials) {
+            for (let j = 0; j < mat.propertyCount; j++) {
+                if (offset + 144 > metadata.length)
                     break;
                 const fieldNameBytes = metadata.slice(offset, offset + 64);
                 const fieldName = decoder.decode(fieldNameBytes.slice(0, fieldNameBytes.indexOf(0) || 64));
-                const fieldType = view.getUint32(offset + 64, true);
-                const previewFlags = view.getUint32(offset + 68, true);
-                const defaultValue = [
+                const value = [
+                    view.getFloat32(offset + 64, true),
+                    view.getFloat32(offset + 68, true),
                     view.getFloat32(offset + 72, true),
-                    view.getFloat32(offset + 76, true),
-                    view.getFloat32(offset + 80, true),
-                    view.getFloat32(offset + 84, true)
+                    view.getFloat32(offset + 76, true)
                 ];
-                const typeNames = ['Texture', 'Color', 'Float', 'Vec2', 'Vec3', 'Vec4', 'Int'];
-                const previewFlagNames = ['None', 'MainTex', 'Tint'];
-                fields.push({
-                    name: fieldName,
-                    type: typeNames[fieldType] || 'Float',
-                    previewFlag: previewFlagNames[previewFlags] || 'None',
-                    defaultValue
-                });
-                offset += 88; // MaterialSchemaField is 88 bytes total
-            }
-            return { stringId, schemaName, fields };
-        }
-        catch (error) {
-            console.error('Failed to read material schema:', error);
-            return null;
-        }
-    }
-    /**
-     * Get material information from a loaded mesh
-     * Returns material data including properties and texture references
-     */
-    getMeshMaterials(assetPath) {
-        try {
-            const assetIndex = this.reader.findAssetByPath(assetPath);
-            if (assetIndex < 0)
-                return null;
-            const metadata = this.reader.readAssetMetadata(assetIndex);
-            if (!metadata || metadata.length < 140)
-                return null;
-            const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
-            const decoder = new TextDecoder();
-            // Parse MeshMetadata
-            const meshGeometryCount = view.getUint32(0, true);
-            const materialCount = view.getUint32(4, true);
-            const nodeCount = view.getUint32(8, true);
-            let offset = 140;
-            // Skip geometries (40 bytes each - Draco compressed)
-            offset += meshGeometryCount * 40;
-            // Parse materials
-            const materials = [];
-            for (let i = 0; i < materialCount; i++) {
-                if (offset + 196 > metadata.length)
-                    break;
-                const nameBytes = metadata.slice(offset, offset + 64);
-                const schemaIdBytes = metadata.slice(offset + 64, offset + 192);
-                const name = decoder.decode(nameBytes.slice(0, nameBytes.indexOf(0) || 64));
-                const schemaId = decoder.decode(schemaIdBytes.slice(0, schemaIdBytes.indexOf(0) || 128));
-                const propertyCount = view.getUint32(offset + 192, true);
-                materials.push({ name, schemaId, propertyCount, properties: [] });
-                offset += 196;
-            }
-            // Skip nodes (116 bytes each)
-            offset += nodeCount * 116;
-            // Skip mesh indices (4 bytes each)
-            const totalMeshRefs = materials.reduce((sum, mat) => {
-                // This is a simplification - we'd need to parse nodes to get exact count
-                return sum;
-            }, 0);
-            // For now, skip based on nodeCount assumption
-            offset += nodeCount * 4;
-            // Parse material properties
-            for (const mat of materials) {
-                for (let j = 0; j < mat.propertyCount; j++) {
-                    if (offset + 144 > metadata.length)
-                        break;
-                    const fieldNameBytes = metadata.slice(offset, offset + 64);
-                    const fieldName = decoder.decode(fieldNameBytes.slice(0, fieldNameBytes.indexOf(0) || 64));
-                    const value = [
-                        view.getFloat32(offset + 64, true),
-                        view.getFloat32(offset + 68, true),
-                        view.getFloat32(offset + 72, true),
-                        view.getFloat32(offset + 76, true)
-                    ];
-                    const textureIdBytes = metadata.slice(offset + 80, offset + 144);
-                    const textureId = decoder.decode(textureIdBytes.slice(0, textureIdBytes.indexOf(0) || 64));
-                    mat.properties.push({ fieldName, value, textureId });
-                    offset += 144;
-                }
+                const textureIdBytes = metadata.slice(offset + 80, offset + 144);
+                const textureId = decoder.decode(textureIdBytes.slice(0, textureIdBytes.indexOf(0) || 64));
+                mat.properties.push({ fieldName, value, textureId });
+                offset += 144;
             }
-            return materials;
-        }
-        catch (error) {
-            console.error('Failed to read mesh materials:', error);
-            return null;
         }
+        return materials;
     }
+}
+
+/**
+ * Three.js loader for StowKit asset packs
+ *
+ * Usage:
+ * ```typescript
+ * const pack = await StowKitLoader.load('assets.stow');
+ * const mesh = await pack.loadMesh('models/character');
+ * const texture = await pack.loadTexture('textures/diffuse');
+ * const audio = await pack.loadAudio('sounds/bgm', listener);
+ * ```
+ */
+class StowKitLoader {
     /**
-     * Open a .stow file from a File or ArrayBuffer
+     * Load a .stow pack file
      */
-    async open(fileOrBuffer) {
-        // Initialize reader if needed
-        if (this.ownedReader) {
-            await this.reader.init();
+    static async load(url, options) {
+        // Initialize loaders if needed
+        if (!this.initialized) {
+            await this.initialize(options);
         }
-        return await this.reader.open(fileOrBuffer);
-    }
-    /**
-     * Get the total number of assets
-     */
-    getAssetCount() {
-        return this.reader.getAssetCount();
-    }
-    /**
-     * Get info about a specific asset
-     */
-    getAssetInfo(index) {
-        return this.reader.getAssetInfo(index);
-    }
-    /**
-     * Read asset data by index
-     */
-    readAssetData(index) {
-        return this.reader.readAssetData(index);
-    }
-    /**
-     * Read asset metadata by index
-     */
-    readAssetMetadata(index) {
-        return this.reader.readAssetMetadata(index);
-    }
-    /**
-     * Parse texture metadata
-     */
-    parseTextureMetadata(metadataBytes) {
-        return this.reader.parseTextureMetadata(metadataBytes);
-    }
-    /**
-     * Create an HTML audio element for preview
-     * @param index - Asset index
-     */
-    async createAudioPreview(index) {
-        const data = this.reader.readAssetData(index);
-        if (!data) {
-            throw new Error(`Failed to read audio data for index ${index}`);
+        // Fetch the pack file
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
         }
-        // Create blob URL for HTML5 audio
-        const blob = new Blob([data], { type: 'audio/ogg' });
-        const url = URL.createObjectURL(blob);
-        // Create and configure audio element
-        const audio = document.createElement('audio');
-        audio.controls = true;
-        audio.src = url;
-        // Clean up URL when audio ends or on error
-        audio.addEventListener('ended', () => URL.revokeObjectURL(url));
-        audio.addEventListener('error', () => URL.revokeObjectURL(url));
-        return audio;
-    }
-    /**
-     * List all assets in the opened pack
-     */
-    listAssets() {
-        return this.reader.listAssets();
+        const arrayBuffer = await response.arrayBuffer();
+        // Open pack
+        await this.reader.open(arrayBuffer);
+        // Return pack wrapper
+        return new StowKitPack(this.reader, this.ktx2Loader, this.dracoLoader);
     }
     /**
-     * Dispose of resources
+     * Initialize the loader (called automatically on first load)
      */
-    dispose() {
-        this.ktx2Loader.dispose();
-        this.dracoLoader.dispose();
-        if (this.ownedReader) {
-            this.reader.close();
-        }
+    static async initialize(options) {
+        const wasmPath = options?.wasmPath || '/stowkit_reader.wasm';
+        const basisPath = options?.basisPath || '/stowkit/basis/';
+        const dracoPath = options?.dracoPath || '/stowkit/draco/';
+        // Initialize reader
+        this.reader = new reader.StowKitReader(wasmPath);
+        await this.reader.init();
+        // Setup KTX2 loader
+        this.ktx2Loader = new KTX2Loader_js.KTX2Loader();
+        this.ktx2Loader.setTranscoderPath(basisPath);
+        // Setup Draco loader
+        this.dracoLoader = new DRACOLoader_js.DRACOLoader();
+        this.dracoLoader.setDecoderPath(dracoPath);
+        // Detect support
+        const tempRenderer = new THREE__namespace.WebGLRenderer();
+        this.ktx2Loader.detectSupport(tempRenderer);
+        tempRenderer.dispose();
+        this.initialized = true;
     }
 }
+StowKitLoader.reader = null;
+StowKitLoader.ktx2Loader = null;
+StowKitLoader.dracoLoader = null;
+StowKitLoader.initialized = false;
 
-exports.MeshParser = MeshParser;
 exports.StowKitLoader = StowKitLoader;
+exports.StowKitPack = StowKitPack;
 //# sourceMappingURL=stowkit-three-loader.js.map