@series-inc/stowkit-cli 0.1.12 → 0.1.13

package/dist/orchestrator.js

@@ -5,16 +5,12 @@ import { cleanupProject } from './cleanup.js';
 import { defaultAssetSettings } from './app/state.js';
 import { BlobStore } from './app/blob-store.js';
 import { readProjectConfig, scanDirectory, readFile, getFileSnapshot, } from './node-fs.js';
-import { readStowmeta, writeStowmeta, stowmetaToAssetSettings, generateDefaultStowmeta, } from './app/stowmeta-io.js';
+import { readStowmeta, writeStowmeta, stowmetaToAssetSettings, generateDefaultStowmeta, glbChildToAssetSettings, generateDefaultGlbChild, } from './app/stowmeta-io.js';
+import { parseGlb, pbrToMaterialConfig } from './encoders/glb-loader.js';
 import { readStowmat, stowmatToMaterialConfig } from './app/stowmat-io.js';
 import { readCacheBlobs, writeCacheBlobs, buildCacheStamp, isCacheValid, } from './app/process-cache.js';
-import { processAsset, buildPack } from './pipeline.js';
-// ─── Encoder initialization ────────────────────────────────────────────────
-import { NodeBasisEncoder } from './encoders/basis-encoder.js';
-import { NodeDracoEncoder } from './encoders/draco-encoder.js';
-import { NodeAacEncoder, NodeAudioDecoder } from './encoders/aac-encoder.js';
-import { NodeFbxImporter } from './encoders/fbx-loader.js';
-import { SharpImageDecoder } from './encoders/image-decoder.js';
+import { buildPack, processExtractedAnimations, validatePackDependencies } from './pipeline.js';
+import { WorkerPool } from './workers/worker-pool.js';
 export async function scanProject(projectDir, opts) {
     const config = await readProjectConfig(projectDir);
     const scan = await scanDirectory(config.srcArtDir);
@@ -102,6 +98,58 @@ export async function fullBuild(projectDir, opts) {
         }
         assets.push(asset);
         assetsById.set(id, asset);
+        // Expand GlbContainer children
+        if (type === AssetType.GlbContainer && meta.type === 'glbContainer') {
+            const glbMeta = meta;
+            if (glbMeta.children && glbMeta.children.length > 0) {
+                asset.status = 'ready'; // Container itself is always "ready"
+                for (const child of glbMeta.children) {
+                    const childId = `${id}/${child.name}`;
+                    const baseName = child.name.replace(/\.[^.]+$/, '');
+                    // Read settings from inline child entry
+                    const { type: cType, settings: cSettings } = glbChildToAssetSettings(child);
+                    const childAsset = {
+                        id: childId,
+                        fileName: child.name,
+                        stringId: child.stringId || baseName,
+                        type: cType,
+                        status: 'pending',
+                        settings: cSettings,
+                        sourceSize: 0,
+                        processedSize: 0,
+                        parentId: id,
+                        locked: true,
+                    };
+                    // Check cache
+                    if (!force && child.cache) {
+                        const cached = await readCacheBlobs(config.srcArtDir, childId);
+                        if (cached) {
+                            for (const [key, data] of cached) {
+                                if (key === `${childId}:__metadata__`) {
+                                    try {
+                                        childAsset.metadata = JSON.parse(new TextDecoder().decode(data));
+                                    }
+                                    catch { /* skip */ }
+                                }
+                                else {
+                                    BlobStore.setProcessed(key, data);
+                                }
+                            }
+                            childAsset.status = 'ready';
+                            childAsset.processedSize = BlobStore.getProcessed(childId)?.length ?? 0;
+                            if (verbose)
+                                console.log(`  [cached] ${childId}`);
+                        }
+                    }
+                    assets.push(childAsset);
+                    assetsById.set(childId, childAsset);
+                }
+            }
+            else {
+                // No children manifest yet — need to parse GLB to discover them
+                // This will be handled during processing
+            }
+        }
     }
     // Materials from .stowmat files
     for (const matFile of scan.matFiles) {
@@ -130,37 +178,209 @@ export async function fullBuild(projectDir, opts) {
         assets.push(asset);
         assetsById.set(id, asset);
     }
-    // 3. Process stale assets
-    const pending = assets.filter(a => a.status === 'pending');
-    if (pending.length === 0) {
+    // 2b. Process GLB containers that need extraction (no children yet)
+    // Store extract results so mesh/animation children can be processed after encoder init
+    const glbExtracts = new Map();
+    const glbContainers = assets.filter(a => a.type === AssetType.GlbContainer && a.status === 'pending');
+    for (const container of glbContainers) {
+        try {
+            const sourceData = await readFile(config.srcArtDir, container.id);
+            if (!sourceData)
+                throw new Error(`Could not read source file: ${container.id}`);
+            // Build inline children with full settings
+            const containerMeta = (await readStowmeta(config.srcArtDir, container.id));
+            const preserveHierarchy = containerMeta.preserveHierarchy ?? false;
+            const extract = await parseGlb(sourceData, { preserveHierarchy });
+            glbExtracts.set(container.id, extract);
+            const existingChildren = new Map((containerMeta.children ?? []).map(c => [c.name, c]));
+            const childrenManifest = [];
+            for (const tex of extract.textures) {
+                childrenManifest.push(existingChildren.get(tex.name) ?? generateDefaultGlbChild(tex.name, 'texture'));
+                BlobStore.setSource(`${container.id}/${tex.name}`, tex.data);
+            }
+            for (const mesh of extract.meshes) {
+                const typeName = mesh.hasSkeleton ? 'skinnedMesh' : 'staticMesh';
+                childrenManifest.push(existingChildren.get(mesh.name) ?? generateDefaultGlbChild(mesh.name, typeName));
+            }
+            for (const mat of extract.materials) {
+                const matName = `${mat.name}.stowmat`;
+                const existing = existingChildren.get(matName);
+                if (existing) {
+                    childrenManifest.push(existing);
+                }
+                else {
+                    const child = generateDefaultGlbChild(matName, 'materialSchema');
+                    const matConfig = pbrToMaterialConfig(mat.pbrConfig, container.id);
+                    child.materialConfig = {
+                        schemaId: matConfig.schemaId,
+                        properties: matConfig.properties.map(p => ({
+                            fieldName: p.fieldName,
+                            fieldType: typeof p.fieldType === 'number'
+                                ? (['texture', 'color', 'float', 'vec2', 'vec3', 'vec4', 'int'][p.fieldType] ?? 'color')
+                                : p.fieldType,
+                            previewFlag: typeof p.previewFlag === 'number'
+                                ? (['none', 'mainTex', 'tint', 'alphaTest'][p.previewFlag] ?? 'none')
+                                : p.previewFlag,
+                            value: [...p.value],
+                            textureAsset: p.textureAssetId,
+                        })),
+                    };
+                    childrenManifest.push(child);
+                }
+            }
+            for (const anim of extract.animations) {
+                childrenManifest.push(existingChildren.get(anim.name) ?? generateDefaultGlbChild(anim.name, 'animationClip'));
+            }
+            // Update stowmeta with inline children
+            containerMeta.children = childrenManifest;
+            await writeStowmeta(config.srcArtDir, container.id, containerMeta);
+            // Create child assets from inline entries
+            for (const child of childrenManifest) {
+                const childId = `${container.id}/${child.name}`;
+                if (assetsById.has(childId))
+                    continue;
+                const baseName = child.name.replace(/\.[^.]+$/, '');
+                const { type: cType, settings: cSettings } = glbChildToAssetSettings(child);
+                const childAsset = {
+                    id: childId,
+                    fileName: child.name,
+                    stringId: child.stringId || baseName,
+                    type: cType,
+                    status: 'pending',
+                    settings: cSettings,
+                    sourceSize: 0,
+                    processedSize: 0,
+                    parentId: container.id,
+                    locked: true,
+                };
+                // Set up material configs for extracted materials
+                if (cType === AssetType.MaterialSchema) {
+                    const matName = child.name.replace(/\.stowmat$/, '');
+                    const mat = extract.materials.find(m => m.name === matName);
+                    if (mat) {
+                        if (!childAsset.settings.materialConfig?.properties?.length) {
+                            childAsset.settings.materialConfig = pbrToMaterialConfig(mat.pbrConfig, container.id);
+                        }
+                        childAsset.status = 'ready';
+                    }
+                }
+                // Process animation children directly (no encoder needed)
+                if (cType === AssetType.AnimationClip) {
+                    const anim = extract.animations.find(a => a.name === child.name);
+                    if (anim) {
+                        const result = processExtractedAnimations(childId, anim.clips, childAsset.stringId);
+                        childAsset.status = 'ready';
+                        childAsset.metadata = result.metadata;
+                        childAsset.processedSize = result.processedSize;
+                    }
+                }
+                assets.push(childAsset);
+                assetsById.set(childId, childAsset);
+            }
+            // Auto-assign materialOverrides on mesh children from GLB sub-mesh→material mapping
+            for (const mesh of extract.meshes) {
+                const meshChildId = `${container.id}/${mesh.name}`;
+                const meshAsset = assetsById.get(meshChildId);
+                if (!meshAsset || Object.keys(meshAsset.settings.materialOverrides).length > 0)
+                    continue;
+                const overrides = {};
+                for (let si = 0; si < mesh.imported.subMeshes.length; si++) {
+                    const matIdx = mesh.imported.subMeshes[si].materialIndex;
+                    const matName = mesh.imported.materials[matIdx]?.name;
+                    if (matName) {
+                        const matChildId = `${container.id}/${matName}.stowmat`;
+                        if (assetsById.has(matChildId)) {
+                            overrides[si] = matChildId;
+                        }
+                    }
+                }
+                if (Object.keys(overrides).length > 0) {
+                    meshAsset.settings.materialOverrides = overrides;
+                    const inlineChild = childrenManifest.find(c => c.name === mesh.name);
+                    if (inlineChild) {
+                        inlineChild.materialOverrides = {};
+                        for (const [k, v] of Object.entries(overrides)) {
+                            inlineChild.materialOverrides[k] = v;
+                        }
+                    }
+                }
+            }
+            // Persist updated stowmeta with auto-assigned materialOverrides
+            containerMeta.children = childrenManifest;
+            await writeStowmeta(config.srcArtDir, container.id, containerMeta);
+            container.status = 'ready';
+            if (verbose)
+                console.log(`  [glb] ${container.id}: ${childrenManifest.length} children`);
+        }
+        catch (err) {
+            container.status = 'error';
+            container.error = err instanceof Error ? err.message : String(err);
+            console.error(`  [glb] ${container.id} FAILED: ${container.error}`);
+        }
+    }
+    // 2c. Process GLB mesh children + stale assets via worker pool
+    const glbMeshChildren = assets.filter(a => a.status === 'pending' && a.parentId && (a.type === AssetType.StaticMesh || a.type === AssetType.SkinnedMesh));
+    const pending = assets.filter(a => a.status === 'pending' && !a.parentId);
+    const totalWork = glbMeshChildren.length + pending.length;
+    if (totalWork === 0) {
         if (verbose)
             console.log('All assets cached, nothing to process.');
     }
     else {
-        console.log(`Processing ${pending.length} asset(s)...`);
-        // Initialize encoders
-        const ctx = await initializeEncoders(opts?.wasmDir);
-        // Process with concurrency limit
+        console.log(`Processing ${totalWork} asset(s)...`);
+        const pool = new WorkerPool({ wasmDir: opts?.wasmDir });
         let processed = 0;
+        // Process GLB mesh children
+        for (const child of glbMeshChildren) {
+            const extract = glbExtracts.get(child.parentId);
+            if (!extract)
+                continue;
+            const mesh = extract.meshes.find(m => `${child.parentId}/${m.name}` === child.id);
+            if (!mesh)
+                continue;
+            try {
+                const { result, blobs } = await pool.processExtractedMesh({ childId: child.id, imported: mesh.imported, hasSkeleton: mesh.hasSkeleton, stringId: child.stringId, settings: child.settings });
+                for (const [key, data] of blobs)
+                    BlobStore.setProcessed(key, data);
+                child.status = 'ready';
+                child.metadata = result.metadata;
+                child.processedSize = result.processedSize;
+                processed++;
+                if (verbose)
+                    console.log(`  [${processed}/${totalWork}] ${child.id} (glb-mesh)`);
+            }
+            catch (err) {
+                child.status = 'error';
+                child.error = err instanceof Error ? err.message : String(err);
+                processed++;
+            }
+        }
+        // Process remaining pending assets with concurrency limit
         const queue = [...pending];
         async function processNext() {
             while (queue.length > 0) {
                 const asset = queue.shift();
                 const id = asset.id;
                 try {
-                    // Load source
-                    const sourceData = await readFile(config.srcArtDir, id);
-                    if (!sourceData)
-                        throw new Error(`Could not read source file: ${id}`);
+                    // Load source (GLB texture children have source in BlobStore already)
+                    let sourceData = BlobStore.getSource(id);
+                    if (!sourceData) {
+                        const data = await readFile(config.srcArtDir, id);
+                        if (!data)
+                            throw new Error(`Could not read source file: ${id}`);
+                        sourceData = data;
+                    }
                     BlobStore.setSource(id, sourceData);
                     const t0 = performance.now();
-                    const result = await processAsset(id, sourceData, asset.type, asset.stringId, asset.settings, ctx);
+                    const { result, blobs } = await pool.processAsset({ id, sourceData, type: asset.type, stringId: asset.stringId, settings: asset.settings });
+                    for (const [key, data] of blobs)
+                        BlobStore.setProcessed(key, data);
                     const elapsed = (performance.now() - t0).toFixed(0);
                     asset.status = 'ready';
                     asset.metadata = result.metadata;
                     asset.processedSize = result.processedSize;
                     processed++;
-                    console.log(`  [${processed}/${pending.length}] ${id} (${elapsed}ms)`);
+                    console.log(`  [${processed}/${totalWork}] ${id} (${elapsed}ms)`);
                     // Write cache
                     const cacheEntries = new Map();
                     const processedBlob = BlobStore.getProcessed(id);
@@ -202,7 +422,7 @@ export async function fullBuild(projectDir, opts) {
                     asset.status = 'error';
                     asset.error = err instanceof Error ? err.message : String(err);
                     processed++;
-                    console.error(`  [${processed}/${pending.length}] ${id} FAILED: ${asset.error}`);
+                    console.error(`  [${processed}/${totalWork}] ${id} FAILED: ${asset.error}`);
                 }
             }
         }
@@ -211,6 +431,7 @@ export async function fullBuild(projectDir, opts) {
             workers.push(processNext());
         }
         await Promise.all(workers);
+        await pool.terminate();
     }
     // 4. Clean orphaned caches/metas
     await cleanupProject(config.projectDir, { verbose });
@@ -220,12 +441,22 @@ export async function fullBuild(projectDir, opts) {
     await fs.mkdir(cdnDir, { recursive: true });
     for (const pack of packs) {
         const packAssets = assets.filter(a => a.status === 'ready' &&
+            a.type !== AssetType.GlbContainer &&
+            !a.settings.excluded &&
             (a.settings.pack === pack.name || (!a.settings.pack && pack.name === 'default')));
         if (packAssets.length === 0) {
             if (verbose)
                 console.log(`Pack "${pack.name}": no assets, skipping`);
             continue;
         }
+        // Validate dependencies before building
+        const depErrors = validatePackDependencies(packAssets, assetsById);
+        if (depErrors.length > 0) {
+            console.error(`Pack "${pack.name}" has dependency errors:`);
+            for (const err of depErrors)
+                console.error(`  ${err.assetId}: ${err.message}`);
+            continue;
+        }
         console.log(`Building pack "${pack.name}" (${packAssets.length} assets)...`);
         const packData = buildPack(packAssets, assetsById);
         const outPath = path.join(cdnDir, `${pack.name}.stow`);
@@ -271,31 +502,3 @@ export async function showStatus(projectDir) {
     }
     console.log(`Cached: ${cached}, Needs processing: ${stale}`);
 }
-// ─── Initialize Encoders ────────────────────────────────────────────────────
-async function initializeEncoders(wasmDir) {
-    const textureEncoder = new NodeBasisEncoder(wasmDir);
-    const meshEncoder = new NodeDracoEncoder();
-    const aacEncoder = new NodeAacEncoder();
-    const audioDecoder = new NodeAudioDecoder();
-    const meshImporter = new NodeFbxImporter();
-    const imageDecoder = new SharpImageDecoder();
-    await Promise.all([
-        textureEncoder.initialize(),
-        meshEncoder.initialize(),
-        aacEncoder.initialize(),
-        audioDecoder.initialize(),
-    ]);
-    return {
-        textureEncoder,
-        meshEncoder,
-        meshImporter,
-        imageDecoder,
-        audioDecoder,
-        aacEncoder,
-        onProgress: (id, msg) => {
-            // Simple console progress
-            const name = id.split('/').pop() ?? id;
-            process.stdout.write(`    [${name}] ${msg}\r`);
-        },
-    };
-}

package/dist/pipeline.d.ts

@@ -1,7 +1,8 @@
 import { AssetType } from './core/types.js';
 import type { AnimationClipMetadata } from './core/types.js';
 import type { AssetSettings, ProjectAsset } from './app/state.js';
-import type { ITextureEncoder, IMeshEncoder, IMeshImporter, IImageDecoder, IAudioDecoder, IAacEncoder, ImportedMesh } from './encoders/interfaces.js';
+import type { ITextureEncoder, IMeshEncoder, IMeshImporter, IImageDecoder, IAudioDecoder, IAacEncoder, ImportedMesh, ImportedAnimation } from './encoders/interfaces.js';
+import type { GlbExtractResult } from './encoders/glb-loader.js';
 export interface ProcessingContext {
     textureEncoder: ITextureEncoder;
     meshEncoder: IMeshEncoder;
@@ -11,11 +12,29 @@ export interface ProcessingContext {
     aacEncoder: IAacEncoder;
     onProgress?: (id: string, msg: string) => void;
 }
+export interface GlbChildDescriptor {
+    name: string;
+    childType: string;
+    assetType: AssetType;
+}
 export interface ProcessResult {
     metadata?: ProjectAsset['metadata'];
     processedSize: number;
+    glbChildren?: GlbChildDescriptor[];
+    glbExtract?: GlbExtractResult;
 }
 export declare function processAsset(id: string, sourceData: Uint8Array, type: AssetType, stringId: string, settings: AssetSettings, ctx: ProcessingContext): Promise<ProcessResult>;
+export declare function processExtractedMesh(childId: string, imported: ImportedMesh, hasSkeleton: boolean, stringId: string, settings: AssetSettings, ctx: ProcessingContext): Promise<ProcessResult>;
+export declare function processExtractedAnimations(childId: string, clips: ImportedAnimation[], stringId: string): ProcessResult;
+export interface DependencyError {
+    assetId: string;
+    message: string;
+}
+/**
+ * Validate dependencies for a set of pack assets before building.
+ * Returns errors for missing/excluded/cross-pack texture and mesh references.
+ */
+export declare function validatePackDependencies(packAssets: ProjectAsset[], allAssetsById: Map<string, ProjectAsset>): DependencyError[];
 export declare function buildPack(assets: ProjectAsset[], assetsById: Map<string, ProjectAsset>): Uint8Array;
 export declare function buildAnimationDataBlobsV2(imported: ImportedMesh): {
     data: Uint8Array;

package/dist/pipeline.js

@@ -1,4 +1,5 @@
 import { AssetType, TextureChannelFormat, TextureResize, AudioSampleRate } from './core/types.js';
+import { parseGlb } from './encoders/glb-loader.js';
 import { dracoPresetToSettings } from './encoders/draco-encoder.js';
 import { buildSkinnedMeshData } from './encoders/skinned-mesh-builder.js';
 import { serializeTextureMetadata, serializeAudioMetadata, serializeMeshMetadata, serializeAnimationClipMetadata, serializeSkinnedMeshMetadata, serializeMaterialSchemaMetadata, deserializeSkinnedMeshMetadata, deserializeAnimationClipMetadata, } from './format/metadata.js';
@@ -59,7 +60,7 @@ export async function processAsset(id, sourceData, type, stringId, settings, ctx
     }
     if (type === AssetType.StaticMesh) {
         log('importing FBX...');
-        const imported = await ctx.meshImporter.import(sourceData, id);
+        const imported = await ctx.meshImporter.import(sourceData, id, { preserveHierarchy: settings.preserveHierarchy });
         const verts = imported.subMeshes.reduce((s, m) => s + m.positions.length / 3, 0);
         log(`imported (${verts} verts, ${imported.subMeshes.length} submeshes)`);
         const meshSettings = dracoPresetToSettings(settings.dracoQuality);
@@ -141,9 +142,140 @@ export async function processAsset(id, sourceData, type, stringId, settings, ctx
         log(`AAC encoded (${(aacData.length / 1024).toFixed(0)} KB)`);
         return { metadata, processedSize: aacData.length };
     }
+    if (type === AssetType.GlbContainer) {
+        log('parsing GLB...');
+        const extract = await parseGlb(sourceData, { preserveHierarchy: settings.preserveHierarchy });
+        const children = [];
+        for (const tex of extract.textures) {
+            children.push({ name: tex.name, childType: 'texture', assetType: AssetType.Texture2D });
+        }
+        for (const mesh of extract.meshes) {
+            const meshType = mesh.hasSkeleton ? AssetType.SkinnedMesh : AssetType.StaticMesh;
+            const typeName = mesh.hasSkeleton ? 'skinnedMesh' : 'staticMesh';
+            children.push({ name: mesh.name, childType: typeName, assetType: meshType });
+        }
+        for (const mat of extract.materials) {
+            children.push({ name: `${mat.name}.stowmat`, childType: 'materialSchema', assetType: AssetType.MaterialSchema });
+        }
+        for (const anim of extract.animations) {
+            children.push({ name: anim.name, childType: 'animationClip', assetType: AssetType.AnimationClip });
+        }
+        log(`extracted ${extract.textures.length} textures, ${extract.meshes.length} meshes, ${extract.materials.length} materials, ${extract.animations.length} animations`);
+        return { processedSize: 0, glbChildren: children, glbExtract: extract };
+    }
     return { processedSize: 0 };
 }
-// ─── Build Pack ──────────────────────────────────────────────────────────────
+// ─── Process pre-extracted GLB child data ────────────────────────────────────
+export async function processExtractedMesh(childId, imported, hasSkeleton, stringId, settings, ctx) {
+    if (hasSkeleton) {
+        const skinnedResult = buildSkinnedMeshData(imported, 0.01);
+        skinnedResult.metadata.stringId = stringId;
+        BlobStore.setProcessed(childId, skinnedResult.data);
+        BlobStore.setProcessed(`${childId}:skinnedMeta`, serializeSkinnedMeshMetadata(skinnedResult.metadata));
+        const animCount = imported.animations?.length ?? 0;
+        if (animCount > 0 && imported.animations) {
+            const animBlobs = buildAnimationDataBlobsV2(imported);
+            for (let ci = 0; ci < animBlobs.length; ci++) {
+                const ab = animBlobs[ci];
+                ab.metadata.stringId = animBlobs.length === 1 ? `${stringId}_anim` : `${stringId}_anim_${ci}`;
+                ab.metadata.targetMeshId = stringId;
+                BlobStore.setProcessed(`${childId}:anim:${ci}`, ab.data);
+                BlobStore.setProcessed(`${childId}:animMeta:${ci}`, serializeAnimationClipMetadata(ab.metadata));
+            }
+            BlobStore.setProcessed(`${childId}:animCount`, new Uint8Array([animBlobs.length]));
+        }
+        return { metadata: skinnedResult.metadata, processedSize: skinnedResult.data.length };
+    }
+    // Static mesh — encode with Draco
+    const meshSettings = dracoPresetToSettings(settings.dracoQuality);
+    const result = await ctx.meshEncoder.encode(imported, meshSettings);
+    result.metadata.stringId = stringId;
+    BlobStore.setProcessed(childId, result.data);
+    return { metadata: result.metadata, processedSize: result.data.length };
+}
+export function processExtractedAnimations(childId, clips, stringId) {
+    // Build a minimal ImportedMesh with just the animations
+    const dummyImported = {
+        subMeshes: [],
+        materials: [],
+        nodes: [],
+        hasSkeleton: false,
+        bones: [],
+        animations: clips,
+    };
+    const animBlobs = buildAnimationDataBlobsV2(dummyImported);
+    if (animBlobs.length === 0)
+        return { processedSize: 0 };
+    const primary = animBlobs[0];
+    primary.metadata.stringId = stringId;
+    BlobStore.setProcessed(childId, primary.data);
+    BlobStore.setProcessed(`${childId}:animMeta`, serializeAnimationClipMetadata(primary.metadata));
+    for (let ci = 1; ci < animBlobs.length; ci++) {
+        const ab = animBlobs[ci];
+        ab.metadata.stringId = `${stringId}_${ci}`;
+        BlobStore.setProcessed(`${childId}:anim:${ci}`, ab.data);
+        BlobStore.setProcessed(`${childId}:animMeta:${ci}`, serializeAnimationClipMetadata(ab.metadata));
+    }
+    BlobStore.setProcessed(`${childId}:animCount`, new Uint8Array([animBlobs.length]));
+    const totalBytes = animBlobs.reduce((s, a) => s + a.data.length, 0);
+    return { metadata: primary.metadata, processedSize: totalBytes };
+}
+/**
+ * Validate dependencies for a set of pack assets before building.
+ * Returns errors for missing/excluded/cross-pack texture and mesh references.
+ */
+export function validatePackDependencies(packAssets, allAssetsById) {
+    const errors = [];
+    const packIds = new Set(packAssets.filter(a => !a.settings.excluded).map(a => a.id));
+    for (const asset of packAssets) {
+        if (asset.settings.excluded)
+            continue;
+        if (asset.type === AssetType.GlbContainer)
+            continue;
+        // MaterialSchema: check texture references
+        if (asset.type === AssetType.MaterialSchema) {
+            for (const prop of asset.settings.materialConfig.properties) {
+                if (!prop.textureAssetId)
+                    continue;
+                const tex = allAssetsById.get(prop.textureAssetId);
+                if (!tex) {
+                    errors.push({ assetId: asset.id, message: `Material "${asset.stringId}" references missing texture "${prop.textureAssetId}"` });
+                }
+                else if (tex.settings.excluded) {
+                    errors.push({ assetId: asset.id, message: `Material "${asset.stringId}" references excluded texture "${tex.stringId}"` });
+                }
+                else if (!packIds.has(tex.id)) {
+                    errors.push({ assetId: asset.id, message: `Material "${asset.stringId}" references texture "${tex.stringId}" which is not in the same pack` });
+                }
+            }
+        }
+        // Mesh: check material override references
+        if (asset.type === AssetType.StaticMesh || asset.type === AssetType.SkinnedMesh) {
+            for (const [idx, matId] of Object.entries(asset.settings.materialOverrides)) {
+                if (!matId)
+                    continue;
+                const mat = allAssetsById.get(matId);
+                if (!mat) {
+                    errors.push({ assetId: asset.id, message: `Mesh "${asset.stringId}" sub-mesh ${idx} references missing material "${matId}"` });
+                }
+                else if (mat.settings.excluded) {
+                    errors.push({ assetId: asset.id, message: `Mesh "${asset.stringId}" sub-mesh ${idx} references excluded material "${mat.stringId}"` });
+                }
+            }
+        }
+        // AnimationClip: check target mesh reference
+        if (asset.type === AssetType.AnimationClip && asset.settings.targetMeshId) {
+            const target = allAssetsById.get(asset.settings.targetMeshId);
+            if (!target) {
+                errors.push({ assetId: asset.id, message: `Animation "${asset.stringId}" references missing target mesh "${asset.settings.targetMeshId}"` });
+            }
+            else if (target.settings.excluded) {
+                errors.push({ assetId: asset.id, message: `Animation "${asset.stringId}" references excluded target mesh "${target.stringId}"` });
+            }
+        }
+    }
+    return errors;
+}
 export function buildPack(assets, assetsById) {
     const packer = new StowPacker();
     const materialsByStringId = new Map(assets
@@ -152,6 +284,10 @@ export function buildPack(assets, assetsById) {
     for (const asset of assets) {
         if (asset.status !== 'ready')
             continue;
+        if (asset.type === AssetType.GlbContainer)
+            continue;
+        if (asset.settings.excluded)
+            continue;
         if (asset.type === AssetType.MaterialSchema) {
             const schemaMeta = buildMaterialSchemaMetadata(asset, assetsById);
             const schemaBytes = serializeMaterialSchemaMetadata(schemaMeta);