@series-inc/stowkit-cli 0.1.12 → 0.1.14

package/dist/server.js

@@ -6,15 +6,12 @@ import { AssetType } from './core/types.js';
 import { defaultAssetSettings } from './app/state.js';
 import { BlobStore } from './app/blob-store.js';
 import { readProjectConfig, scanDirectory, readFile, writeFile, renameFile, deleteFile, getFileSnapshot, } from './node-fs.js';
-import { detectAssetType, readStowmeta, writeStowmeta, stowmetaToAssetSettings, assetSettingsToStowmeta, generateDefaultStowmeta, } from './app/stowmeta-io.js';
+import { detectAssetType, readStowmeta, writeStowmeta, stowmetaToAssetSettings, assetSettingsToStowmeta, generateDefaultStowmeta, glbChildToAssetSettings, generateDefaultGlbChild, writeGlbChildSettings, } from './app/stowmeta-io.js';
 import { readStowmat, writeStowmat, stowmatToMaterialConfig, materialConfigToStowmat } from './app/stowmat-io.js';
 import { readCacheBlobs, writeCacheBlobs, buildCacheStamp, isCacheValid, } from './app/process-cache.js';
-import { processAsset, buildPack } from './pipeline.js';
-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, validatePackDependencies, processExtractedAnimations } from './pipeline.js';
+import { parseGlb, pbrToMaterialConfig } from './encoders/glb-loader.js';
+import { WorkerPool } from './workers/worker-pool.js';
 async function scanPrefabFiles(dir, prefix) {
     const results = [];
     let entries;
@@ -40,7 +37,7 @@ async function scanPrefabFiles(dir, prefix) {
 let projectConfig = null;
 let assets = [];
 let folders = [];
-let processingCtx = null;
+let workerPool = null;
 let encodersReady = false;
 let lastScanTime = 0;
 // Track in-flight processing
@@ -55,6 +52,97 @@ function broadcast(msg) {
             ws.send(data);
     }
 }
+/**
+ * Single entry point for all processing orchestration.
+ * - Skips materials (they don't need processing)
+ * - Routes GLB children through their parent container
+ * - Ensures containers are processed before direct assets
+ * - Deduplicates with the `processing` Set
+ * - Runs up to maxConcurrent workers in parallel
+ */
+function queueProcessing(opts = {}) {
+    const { force = false, maxConcurrent = 8 } = opts;
+    // Wait for encoders, then build and drain the queue
+    const task = (async () => {
+        while (!workerPool)
+            await new Promise(r => setTimeout(r, 100));
+        // Determine which assets to process
+        let targets;
+        if (opts.ids) {
+            targets = opts.ids
+                .map(id => assets.find(a => a.id === id))
+                .filter((a) => !!a);
+        }
+        else if (force) {
+            targets = assets.filter(a => a.type !== AssetType.MaterialSchema);
+        }
+        else {
+            targets = assets.filter(a => a.status === 'pending' && a.type !== AssetType.MaterialSchema);
+        }
+        if (targets.length === 0)
+            return;
+        // Mark assets as pending if force
+        if (force) {
+            for (const a of targets) {
+                if (a.type !== AssetType.MaterialSchema) {
+                    a.status = 'pending';
+                }
+            }
+        }
+        // Build the processing queue:
+        // - GLB children → promote their parent container
+        // - Containers go first (they process their own children internally)
+        // - Deduplicate
+        const containerIds = new Set();
+        const directIds = [];
+        const seen = new Set();
+        for (const a of targets) {
+            if (a.parentId) {
+                // GLB child — process via parent container
+                if (!containerIds.has(a.parentId)) {
+                    containerIds.add(a.parentId);
+                    const container = assets.find(x => x.id === a.parentId);
+                    if (container)
+                        container.status = 'pending';
+                }
+            }
+            else if (!seen.has(a.id)) {
+                seen.add(a.id);
+                directIds.push(a.id);
+            }
+        }
+        // Containers first, then other assets (containers already in directIds stay in place)
+        const queue = [];
+        for (const cid of containerIds) {
+            if (!seen.has(cid)) {
+                queue.push(cid);
+                seen.add(cid);
+            }
+        }
+        queue.push(...directIds);
+        if (queue.length === 0)
+            return;
+        console.log(`[server] Processing ${queue.length} asset(s)${force ? ' (force)' : ''}...`);
+        // Drain with concurrent workers
+        async function drain() {
+            while (queue.length > 0) {
+                const id = queue.shift();
+                await processOneAsset(id);
+            }
+        }
+        const workers = [];
+        for (let i = 0; i < Math.min(maxConcurrent, queue.length); i++) {
+            workers.push(drain());
+        }
+        await Promise.all(workers);
+        broadcast({ type: 'processing-complete' });
+    })();
+    if (opts.await)
+        return task;
+    // Fire-and-forget: log errors but don't block caller
+    task.catch(err => console.error('[server] queueProcessing error:', err));
+    return Promise.resolve();
+}
 // ─── Helpers ────────────────────────────────────────────────────────────────
 function resolvePackName(pack, packs) {
     if (packs.length === 0)
@@ -63,6 +151,231 @@ function resolvePackName(pack, packs) {
         return pack;
     return packs[0].name;
 }
+// ─── GLB Container helpers ──────────────────────────────────────────────────
+function childTypeToAssetType(childType) {
+    switch (childType) {
+        case 'texture': return AssetType.Texture2D;
+        case 'staticMesh': return AssetType.StaticMesh;
+        case 'skinnedMesh': return AssetType.SkinnedMesh;
+        case 'animationClip': return AssetType.AnimationClip;
+        case 'materialSchema': return AssetType.MaterialSchema;
+        default: return AssetType.Unknown;
+    }
+}
+async function expandGlbChildren(srcArtDir, containerId, containerMeta, configuredPacks) {
+    const children = [];
+    for (const child of containerMeta.children) {
+        const childId = `${containerId}/${child.name}`;
+        const baseName = child.name.replace(/\.[^.]+$/, '');
+        // Read settings from inline child entry
+        const { type: childType, settings: childSettings } = glbChildToAssetSettings(child);
+        childSettings.pack = resolvePackName(childSettings.pack, configuredPacks);
+        const asset = {
+            id: childId,
+            fileName: child.name,
+            stringId: child.stringId || baseName,
+            type: childType,
+            status: 'pending',
+            settings: childSettings,
+            sourceSize: 0,
+            processedSize: 0,
+            parentId: containerId,
+            locked: true,
+        };
+        // Check cache for child
+        if (child.cache) {
+            const cached = await readCacheBlobs(srcArtDir, childId);
+            if (cached && cached.size > 0) {
+                for (const [key, data] of cached) {
+                    if (key.endsWith(':__metadata__')) {
+                        try {
+                            asset.metadata = JSON.parse(new TextDecoder().decode(data));
+                        }
+                        catch { /* skip */ }
+                    }
+                    else {
+                        BlobStore.setProcessed(key, data);
+                    }
+                }
+                asset.status = 'ready';
+                asset.processedSize = BlobStore.getProcessed(childId)?.length ?? 0;
+            }
+        }
+        children.push(asset);
+    }
+    return children;
+}
+async function processGlbContainer(containerId) {
+    if (!projectConfig || !workerPool)
+        return;
+    const containerAsset = assets.find(a => a.id === containerId);
+    if (!containerAsset || containerAsset.type !== AssetType.GlbContainer)
+        return;
+    // Load source
+    let sourceData = BlobStore.getSource(containerId);
+    if (!sourceData) {
+        const data = await readFile(projectConfig.srcArtDir, containerId);
+        if (!data)
+            throw new Error(`Could not read source: ${containerId}`);
+        BlobStore.setSource(containerId, data);
+        sourceData = data;
+    }
+    // Read container stowmeta (for preserveHierarchy and existing children)
+    const containerStowmeta = await readStowmeta(projectConfig.srcArtDir, containerId);
+    const preserveHierarchy = containerStowmeta?.preserveHierarchy ?? false;
+    // Parse GLB
+    const extract = await parseGlb(sourceData, { preserveHierarchy });
+    const configuredPacks = projectConfig.config.packs ?? [];
+    // Build inline children with full settings
+    // Preserve existing child settings from the container stowmeta when possible
+    const existingChildren = new Map((containerStowmeta?.children ?? []).map(c => [c.name, c]));
+    const childrenManifest = [];
+    // Process textures
+    for (const tex of extract.textures) {
+        const existing = existingChildren.get(tex.name);
+        childrenManifest.push(existing ?? generateDefaultGlbChild(tex.name, 'texture'));
+        const childId = `${containerId}/${tex.name}`;
+        BlobStore.setSource(childId, tex.data);
+    }
+    // Process meshes
+    for (const mesh of extract.meshes) {
+        const typeName = mesh.hasSkeleton ? 'skinnedMesh' : 'staticMesh';
+        const existing = existingChildren.get(mesh.name);
+        childrenManifest.push(existing ?? generateDefaultGlbChild(mesh.name, typeName));
+    }
+    // Process materials
+    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');
+            // Store extracted PBR config as materialConfig on the inline child
+            const matConfig = pbrToMaterialConfig(mat.pbrConfig, containerId);
+            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);
+        }
+    }
+    // Process animations
+    for (const anim of extract.animations) {
+        const existing = existingChildren.get(anim.name);
+        childrenManifest.push(existing ?? generateDefaultGlbChild(anim.name, 'animationClip'));
+    }
+    // Update container stowmeta with full inline children
+    if (containerStowmeta) {
+        containerStowmeta.children = childrenManifest;
+        await writeStowmeta(projectConfig.srcArtDir, containerId, containerStowmeta);
+    }
+    // Remove old child assets from the list
+    const prefix = containerId + '/';
+    assets = assets.filter(a => !a.id.startsWith(prefix));
+    // Create child assets from inline entries
+    const childAssets = await expandGlbChildren(projectConfig.srcArtDir, containerId, { ...containerStowmeta, children: childrenManifest }, configuredPacks);
+    // Set up material configs for extracted GLB materials (runtime config from inline)
+    for (const mat of extract.materials) {
+        const matName = `${mat.name}.stowmat`;
+        const childId = `${containerId}/${matName}`;
+        const childAsset = childAssets.find(a => a.id === childId);
+        if (childAsset) {
+            // If the child didn't already have a materialConfig from an existing inline entry,
+            // set it from the extracted PBR data
+            if (!childAsset.settings.materialConfig?.properties?.length) {
+                childAsset.settings.materialConfig = pbrToMaterialConfig(mat.pbrConfig, containerId);
+            }
+            childAsset.status = 'ready';
+        }
+    }
+    assets.push(...childAssets);
+    containerAsset.status = 'ready';
+    // Process mesh and animation children directly from extract result
+    // (they can't go through processOneAsset because there's no file on disk to read)
+    for (const mesh of extract.meshes) {
+        const childId = `${containerId}/${mesh.name}`;
+        const childAsset = childAssets.find(a => a.id === childId);
+        if (childAsset && childAsset.status === 'pending') {
+            try {
+                // Auto-assign materialOverrides from GLB sub-mesh→material mapping
+                // (only if user hasn't already set explicit overrides)
+                if (Object.keys(childAsset.settings.materialOverrides).length === 0) {
+                    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 = `${containerId}/${matName}.stowmat`;
+                            if (childAssets.some(a => a.id === matChildId)) {
+                                overrides[si] = matChildId;
+                            }
+                        }
+                    }
+                    if (Object.keys(overrides).length > 0) {
+                        childAsset.settings.materialOverrides = overrides;
+                        // Persist the auto-assigned overrides into the inline child entry
+                        const childName = childAsset.id.split('/').pop();
+                        const inlineChild = childrenManifest.find(c => c.name === childName);
+                        if (inlineChild) {
+                            inlineChild.materialOverrides = {};
+                            for (const [k, v] of Object.entries(overrides)) {
+                                inlineChild.materialOverrides[k] = v;
+                            }
+                        }
+                    }
+                }
+                const { result, blobs } = await workerPool.processExtractedMesh({ childId, imported: mesh.imported, hasSkeleton: mesh.hasSkeleton, stringId: childAsset.stringId, settings: childAsset.settings }, (pid, msg) => broadcast({ type: 'progress', id: pid, message: msg }));
+                for (const [key, data] of blobs)
+                    BlobStore.setProcessed(key, data);
+                childAsset.status = 'ready';
+                childAsset.metadata = result.metadata;
+                childAsset.processedSize = result.processedSize;
+            }
+            catch (err) {
+                childAsset.status = 'error';
+                childAsset.error = err instanceof Error ? err.message : String(err);
+            }
+        }
+    }
+    for (const anim of extract.animations) {
+        const childId = `${containerId}/${anim.name}`;
+        const childAsset = childAssets.find(a => a.id === childId);
+        if (childAsset && childAsset.status === 'pending') {
+            try {
+                const result = processExtractedAnimations(childId, anim.clips, childAsset.stringId);
+                childAsset.status = 'ready';
+                childAsset.metadata = result.metadata;
+                childAsset.processedSize = result.processedSize;
+            }
+            catch (err) {
+                childAsset.status = 'error';
+                childAsset.error = err instanceof Error ? err.message : String(err);
+            }
+        }
+    }
+    // Persist updated stowmeta (may have auto-assigned materialOverrides)
+    if (containerStowmeta) {
+        containerStowmeta.children = childrenManifest;
+        await writeStowmeta(projectConfig.srcArtDir, containerId, containerStowmeta);
+    }
+    // Queue texture children for processing (their raw image data is in BlobStore)
+    const pendingTextures = childAssets.filter(a => a.status === 'pending' && a.type === AssetType.Texture2D);
+    for (const child of pendingTextures) {
+        processOneAsset(child.id);
+    }
+}
 async function readBody(req) {
     const chunks = [];
     for await (const chunk of req)
@@ -87,35 +400,14 @@ function cors(res) {
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
 }
-// ─── Initialize encoders ────────────────────────────────────────────────────
-async function initEncoders(wasmDir) {
-    console.log('[server] Initializing encoders...');
-    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(),
-    ]);
-    console.log('[server] All encoders ready');
+// ─── Initialize worker pool ──────────────────────────────────────────────────
+function initWorkerPool(wasmDir) {
+    console.log('[server] Initializing worker pool...');
+    const pool = new WorkerPool({ wasmDir });
+    console.log('[server] Worker pool ready');
     encodersReady = true;
     broadcast({ type: 'encoders-ready' });
-    return {
-        textureEncoder,
-        meshEncoder,
-        meshImporter,
-        imageDecoder,
-        audioDecoder,
-        aacEncoder,
-        onProgress: (id, msg) => {
-            broadcast({ type: 'progress', id, message: msg });
-        },
-    };
+    return pool;
 }
 // ─── Open project ──────────────────────────────────────────────────────────
 async function openProject(projectDir) {
@@ -173,6 +465,15 @@ async function openProject(projectDir) {
             }
         }
         assets.push(asset);
+        // If this is a GlbContainer, expand its children
+        if (metaType === AssetType.GlbContainer && meta.type === 'glbContainer') {
+            const glbMeta = meta;
+            if (glbMeta.children && glbMeta.children.length > 0) {
+                asset.status = 'ready';
+                const childAssets = await expandGlbChildren(projectConfig.srcArtDir, file.relativePath, glbMeta, configuredPacks);
+                assets.push(...childAssets);
+            }
+        }
     }
     // Materials from .stowmat files
     for (const matFile of scan.matFiles) {
@@ -205,8 +506,11 @@ async function openProject(projectDir) {
 }
 // ─── Process single asset ─────────────────────────────────────────────────
 async function processOneAsset(id) {
-    if (!projectConfig || !processingCtx)
+    if (!projectConfig)
         return;
+    // Wait for encoders to be ready
+    while (!workerPool)
+        await new Promise(r => setTimeout(r, 100));
     if (processing.has(id))
         return;
     const asset = assets.find(a => a.id === id);
@@ -214,6 +518,110 @@ async function processOneAsset(id) {
         return;
     if (asset.type === AssetType.MaterialSchema)
         return;
+    // GLB children: if source data isn't in BlobStore, re-extract from parent GLB
+    // and process just this child (not the entire container)
+    if (asset.parentId && !BlobStore.getSource(id)) {
+        const parentAsset = assets.find(a => a.id === asset.parentId);
+        if (!parentAsset)
+            return;
+        processing.add(id);
+        asset.status = 'processing';
+        broadcast({ type: 'asset-update', id, updates: { status: 'processing' } });
+        try {
+            let parentSource = BlobStore.getSource(asset.parentId);
+            if (!parentSource) {
+                const data = await readFile(projectConfig.srcArtDir, asset.parentId);
+                if (!data)
+                    throw new Error(`Could not read parent GLB: ${asset.parentId}`);
+                parentSource = data;
+            }
+            const extract = await parseGlb(parentSource);
+            const childName = id.split('/').pop();
+            if (asset.type === AssetType.Texture2D) {
+                const tex = extract.textures.find(t => t.name === childName);
+                if (!tex)
+                    throw new Error(`Texture "${childName}" not found in GLB`);
+                BlobStore.setSource(id, tex.data);
+                // Process via worker pool
+                const { result, blobs } = await workerPool.processAsset({ id, sourceData: tex.data, type: asset.type, stringId: asset.stringId, settings: asset.settings }, (pid, msg) => broadcast({ type: 'progress', id: pid, message: msg }));
+                for (const [key, data] of blobs)
+                    BlobStore.setProcessed(key, data);
+                if (asset.status !== 'pending') {
+                    asset.status = 'ready';
+                    asset.metadata = result.metadata;
+                    asset.processedSize = result.processedSize;
+                    broadcast({
+                        type: 'asset-update', id,
+                        updates: { status: 'ready', metadata: result.metadata, processedSize: result.processedSize },
+                    });
+                }
+            }
+            else if (asset.type === AssetType.StaticMesh || asset.type === AssetType.SkinnedMesh) {
+                const mesh = extract.meshes.find(m => m.name === childName);
+                if (!mesh)
+                    throw new Error(`Mesh "${childName}" not found in GLB`);
+                const { result, blobs } = await workerPool.processExtractedMesh({ childId: id, imported: mesh.imported, hasSkeleton: mesh.hasSkeleton, stringId: asset.stringId, settings: asset.settings }, (pid, msg) => broadcast({ type: 'progress', id: pid, message: msg }));
+                for (const [key, data] of blobs)
+                    BlobStore.setProcessed(key, data);
+                if (asset.status !== 'pending') {
+                    asset.status = 'ready';
+                    asset.metadata = result.metadata;
+                    asset.processedSize = result.processedSize;
+                    broadcast({
+                        type: 'asset-update', id,
+                        updates: { status: 'ready', metadata: result.metadata, processedSize: result.processedSize },
+                    });
+                }
+            }
+            else {
+                // Animation or other — fall back to full container reprocess
+                processing.delete(id);
+                if (!processing.has(asset.parentId)) {
+                    parentAsset.status = 'pending';
+                    await processOneAsset(asset.parentId);
+                }
+                return;
+            }
+            console.log(`[server] Re-processed GLB child ${id}`);
+        }
+        catch (err) {
+            asset.status = 'error';
+            asset.error = err instanceof Error ? err.message : String(err);
+            broadcast({ type: 'asset-update', id, updates: { status: 'error', error: asset.error } });
+            console.error(`[server] Failed re-processing GLB child ${id}: ${asset.error}`);
+        }
+        finally {
+            processing.delete(id);
+            if (asset.status === 'pending')
+                queueProcessing({ ids: [id] });
+        }
+        return;
+    }
+    // GlbContainer: use special processing flow
+    if (asset.type === AssetType.GlbContainer) {
+        processing.add(id);
+        asset.status = 'processing';
+        broadcast({ type: 'asset-update', id, updates: { status: 'processing' } });
+        try {
+            await processGlbContainer(id);
+            if (asset.status !== 'pending') {
+                asset.status = 'ready';
+                broadcast({ type: 'asset-update', id, updates: { status: 'ready' } });
+            }
+        }
+        catch (err) {
+            asset.status = 'error';
+            asset.error = err instanceof Error ? err.message : String(err);
+            console.error(`[server] processGlbContainer(${id}) failed:`, err);
+            broadcast({ type: 'asset-update', id, updates: { status: 'error', error: asset.error } });
+        }
+        finally {
+            processing.delete(id);
+            if (asset.status === 'pending')
+                queueProcessing({ ids: [id] });
+        }
+        return;
+    }
     processing.add(id);
     asset.status = 'processing';
     broadcast({ type: 'asset-update', id, updates: { status: 'processing' } });
@@ -228,21 +636,26 @@ async function processOneAsset(id) {
             sourceData = data;
         }
         const t0 = performance.now();
-        const result = await processAsset(id, sourceData, asset.type, asset.stringId, asset.settings, processingCtx);
+        const { result, blobs } = await workerPool.processAsset({ id, sourceData, type: asset.type, stringId: asset.stringId, settings: asset.settings }, (pid, msg) => broadcast({ type: 'progress', id: pid, message: msg }));
+        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;
-        asset.sourceSize = sourceData.length;
-        broadcast({
-            type: 'asset-update', id,
-            updates: {
-                status: 'ready',
-                metadata: result.metadata,
-                processedSize: result.processedSize,
-                sourceSize: sourceData.length,
-            },
-        });
+        // Only mark ready if settings didn't change mid-processing (which sets status back to 'pending')
+        if (asset.status !== 'pending') {
+            asset.status = 'ready';
+            asset.metadata = result.metadata;
+            asset.processedSize = result.processedSize;
+            asset.sourceSize = sourceData.length;
+            broadcast({
+                type: 'asset-update', id,
+                updates: {
+                    status: 'ready',
+                    metadata: result.metadata,
+                    processedSize: result.processedSize,
+                    sourceSize: sourceData.length,
+                },
+            });
+        }
         console.log(`[server] Processed ${id} (${elapsed}ms)`);
         // Write cache
         const cacheEntries = new Map();
@@ -286,6 +699,11 @@ async function processOneAsset(id) {
     }
     finally {
         processing.delete(id);
+        // If settings changed while we were processing, the asset will have been
+        // reset to 'pending'. Re-queue so it doesn't get stuck.
+        if (asset.status === 'pending') {
+            queueProcessing({ ids: [id] });
+        }
     }
 }
 // ─── Route handler ──────────────────────────────────────────────────────────
@@ -303,16 +721,54 @@ async function handleRequest(req, res, staticApps) {
         if (projectConfig && Date.now() - lastScanTime > 5000) {
             lastScanTime = Date.now();
             const scan = await scanDirectory(projectConfig.srcArtDir);
-            const currentIds = new Set(assets.map(a => a.id));
-            const diskIds = new Set([
-                ...scan.sourceFiles.map(f => f.relativePath),
-                ...scan.matFiles.map(f => f.relativePath),
+            // Compare top-level (non-child) asset IDs with disk files
+            const currentAssets = assets.filter(a => !a.parentId);
+            const currentIds = new Set(currentAssets.map(a => a.id));
+            const diskFiles = new Map([
+                ...scan.sourceFiles.map(f => [f.relativePath, f]),
+                ...scan.matFiles.map(f => [f.relativePath, f]),
             ]);
-            const changed = currentIds.size !== diskIds.size ||
+            const diskIds = new Set(diskFiles.keys());
+            // Check for added/removed files
+            let changed = currentIds.size !== diskIds.size ||
                 [...currentIds].some(id => !diskIds.has(id)) ||
                 [...diskIds].some(id => !currentIds.has(id));
+            // Check for modified files (size or mtime changed)
+            const modifiedIds = [];
+            if (!changed) {
+                for (const asset of currentAssets) {
+                    const diskFile = diskFiles.get(asset.id);
+                    if (diskFile && asset.sourceSize > 0 && diskFile.size !== asset.sourceSize) {
+                        modifiedIds.push(asset.id);
+                    }
+                }
+            }
             if (changed) {
                 await openProject(projectConfig.projectDir);
+                queueProcessing();
+            }
+            else if (modifiedIds.length > 0) {
+                // Re-read source and reprocess modified assets without full project reload
+                for (const id of modifiedIds) {
+                    const asset = assets.find(a => a.id === id);
+                    if (!asset)
+                        continue;
+                    const diskFile = diskFiles.get(id);
+                    if (diskFile)
+                        asset.sourceSize = diskFile.size;
+                    BlobStore.remove(id);
+                    // Also clear children for GLB containers
+                    if (asset.type === AssetType.GlbContainer) {
+                        const prefix = id + '/';
+                        for (const child of assets) {
+                            if (child.id.startsWith(prefix))
+                                BlobStore.remove(child.id);
+                        }
+                    }
+                    asset.status = 'pending';
+                    broadcast({ type: 'asset-update', id, updates: { status: 'pending', sourceSize: asset.sourceSize } });
+                }
+                queueProcessing({ ids: modifiedIds });
             }
         }
         json(res, {
@@ -343,35 +799,11 @@ async function handleRequest(req, res, staticApps) {
     // POST /api/process — process all pending or specific IDs
     if (pathname === '/api/process' && req.method === 'POST') {
         const body = JSON.parse(await readBody(req));
-        const ids = body.ids ?? assets.filter(a => a.status === 'pending').map(a => a.id);
         const force = body.force ?? false;
-        if (force) {
-            for (const id of ids) {
-                const asset = assets.find(a => a.id === id);
-                if (asset && asset.type !== AssetType.MaterialSchema) {
-                    asset.status = 'pending';
-                }
-            }
-        }
-        // Process concurrently (max 8)
-        const pending = ids.filter(id => {
-            const a = assets.find(x => x.id === id);
-            return a && (a.status === 'pending' || force) && a.type !== AssetType.MaterialSchema;
-        });
-        const queue = [...pending];
-        async function drain() {
-            while (queue.length > 0) {
-                const id = queue.shift();
-                await processOneAsset(id);
-            }
-        }
-        const workers = [];
-        for (let i = 0; i < Math.min(8, pending.length); i++)
-            workers.push(drain());
-        Promise.all(workers).then(() => {
-            broadcast({ type: 'processing-complete' });
-        });
-        json(res, { ok: true, queued: pending.length });
+        const ids = body.ids;
+        queueProcessing({ force, ids });
+        const count = ids?.length ?? assets.filter(a => a.status === 'pending' || force).length;
+        json(res, { ok: true, queued: count });
         return;
     }
     // POST /api/build — build .stow packs
@@ -385,19 +817,34 @@ async function handleRequest(req, res, staticApps) {
         const cdnDir = path.resolve(projectConfig.projectDir, projectConfig.config.cdnAssetsPath ?? 'public/cdn-assets');
         await fs.mkdir(cdnDir, { recursive: true });
         const results = [];
+        const allErrors = [];
         for (const pack of packs) {
             const packAssets = assets.filter(a => a.status === 'ready' &&
                 (a.settings.pack === pack.name || (!a.settings.pack && pack.name === 'default')));
             if (packAssets.length === 0)
                 continue;
+            // Validate dependencies before building
+            const depErrors = validatePackDependencies(packAssets, assetsById);
+            if (depErrors.length > 0) {
+                allErrors.push({ pack: pack.name, errors: depErrors });
+                for (const err of depErrors)
+                    console.error(`[server] ${pack.name}: ${err.message}`);
+                continue;
+            }
             const packData = buildPack(packAssets, assetsById);
             const outPath = path.join(cdnDir, `${pack.name}.stow`);
             await fs.writeFile(outPath, packData);
             results.push({ name: pack.name, size: packData.length, assetCount: packAssets.length });
             console.log(`[server] Built ${pack.name}.stow (${packAssets.length} assets, ${(packData.length / 1024).toFixed(0)} KB)`);
         }
-        broadcast({ type: 'build-complete', packs: results });
-        json(res, { ok: true, packs: results });
+        if (allErrors.length > 0) {
+            broadcast({ type: 'build-complete', packs: results, errors: allErrors });
+            json(res, { ok: false, packs: results, errors: allErrors });
+        }
+        else {
+            broadcast({ type: 'build-complete', packs: results });
+            json(res, { ok: true, packs: results });
+        }
         return;
     }
     // PUT /api/asset/:id/settings — update settings
@@ -409,26 +856,51 @@ async function handleRequest(req, res, staticApps) {
             json(res, { error: 'Asset not found' }, 404);
             return;
         }
+        // Allow stringId updates via the settings endpoint
+        if (body.stringId !== undefined) {
+            asset.stringId = body.stringId;
+        }
         const merged = { ...asset.settings, ...body.settings };
         asset.settings = merged;
         // Persist to disk
         if (projectConfig) {
-            const meta = assetSettingsToStowmeta(asset);
-            await writeStowmeta(projectConfig.srcArtDir, id, meta);
-            if (asset.type === AssetType.MaterialSchema && body.settings.materialConfig) {
-                const stowmat = materialConfigToStowmat(merged.materialConfig);
-                await writeStowmat(projectConfig.srcArtDir, id, stowmat);
+            if (asset.parentId) {
+                // GLB child: write inline entry into container stowmeta
+                const childName = id.split('/').pop();
+                const childType = asset.type === AssetType.Texture2D ? 'texture'
+                    : asset.type === AssetType.StaticMesh ? 'staticMesh'
+                        : asset.type === AssetType.SkinnedMesh ? 'skinnedMesh'
+                            : asset.type === AssetType.AnimationClip ? 'animationClip'
+                                : asset.type === AssetType.MaterialSchema ? 'materialSchema'
+                                    : 'unknown';
+                await writeGlbChildSettings(projectConfig.srcArtDir, asset.parentId, childName, asset.stringId, childType, merged);
+            }
+            else {
+                const meta = assetSettingsToStowmeta(asset);
+                // For GlbContainers, preserve existing children in stowmeta
+                if (asset.type === AssetType.GlbContainer && projectConfig) {
+                    const existing = await readStowmeta(projectConfig.srcArtDir, id);
+                    if (existing && existing.type === 'glbContainer') {
+                        meta.children = existing.children;
+                        meta.preserveHierarchy = merged.preserveHierarchy || undefined;
+                    }
+                }
+                await writeStowmeta(projectConfig.srcArtDir, id, meta);
+                if (asset.type === AssetType.MaterialSchema && body.settings.materialConfig) {
+                    const stowmat = materialConfigToStowmat(merged.materialConfig);
+                    await writeStowmat(projectConfig.srcArtDir, id, stowmat);
+                }
             }
         }
         // Check if needs reprocessing
         const needsReprocess = (asset.type === AssetType.Texture2D && (body.settings.quality !== undefined || body.settings.resize !== undefined || body.settings.generateMipmaps !== undefined)) ||
-            (asset.type === AssetType.StaticMesh && body.settings.dracoQuality !== undefined) ||
-            (asset.type === AssetType.Audio && (body.settings.aacQuality !== undefined || body.settings.audioSampleRate !== undefined));
+            (asset.type === AssetType.StaticMesh && (body.settings.dracoQuality !== undefined || body.settings.preserveHierarchy !== undefined)) ||
+            (asset.type === AssetType.Audio && (body.settings.aacQuality !== undefined || body.settings.audioSampleRate !== undefined)) ||
+            (asset.type === AssetType.GlbContainer && body.settings.preserveHierarchy !== undefined);
         if (needsReprocess) {
             asset.status = 'pending';
             broadcast({ type: 'asset-update', id, updates: { settings: merged, status: 'pending' } });
-            // Auto-trigger processing
-            processOneAsset(id);
+            queueProcessing({ ids: [id] });
         }
         else {
             broadcast({ type: 'asset-update', id, updates: { settings: merged } });
@@ -453,7 +925,7 @@ async function handleRequest(req, res, staticApps) {
             await writeStowmeta(projectConfig.srcArtDir, id, meta);
         }
         broadcast({ type: 'asset-update', id, updates: { type: body.type, status: 'pending', metadata: undefined } });
-        processOneAsset(id);
+        queueProcessing({ ids: [id] });
         json(res, { ok: true });
         return;
     }
@@ -475,6 +947,10 @@ async function handleRequest(req, res, staticApps) {
             json(res, { error: 'Asset not found' }, 404);
             return;
         }
+        if (asset.locked) {
+            json(res, { error: 'Cannot rename locked child asset' }, 403);
+            return;
+        }
         // Build new ID: same folder, new filename (preserve original extension)
         const folder = id.includes('/') ? id.slice(0, id.lastIndexOf('/') + 1) : '';
         const oldBase = id.split('/').pop() ?? id;
@@ -500,6 +976,64 @@ async function handleRequest(req, res, staticApps) {
         json(res, { ok: true, newId });
         return;
     }
+    // PUT /api/asset/:id/move — move asset to a different folder
+    if (pathname.startsWith('/api/asset/') && pathname.endsWith('/move') && req.method === 'PUT') {
+        const id = decodeURIComponent(pathname.slice('/api/asset/'.length, -'/move'.length));
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        const body = JSON.parse(await readBody(req));
+        const targetFolder = body.targetFolder ?? '';
+        const asset = assets.find(a => a.id === id);
+        if (!asset) {
+            json(res, { error: 'Asset not found' }, 404);
+            return;
+        }
+        if (asset.locked) {
+            json(res, { error: 'Cannot move locked child asset' }, 403);
+            return;
+        }
+        const fileName = id.split('/').pop() ?? id;
+        const newId = targetFolder ? `${targetFolder}/${fileName}` : fileName;
+        if (newId === id) {
+            json(res, { ok: true, newId });
+            return;
+        }
+        // Move source file, .stowmeta, .stowcache
+        await renameFile(projectConfig.srcArtDir, id, newId);
+        await renameFile(projectConfig.srcArtDir, `${id}.stowmeta`, `${newId}.stowmeta`);
+        await renameFile(projectConfig.srcArtDir, `${id}.stowcache`, `${newId}.stowcache`);
+        // For GlbContainer, also move the .children companion directory
+        if (asset.type === AssetType.GlbContainer) {
+            await renameFile(projectConfig.srcArtDir, `${id}.children`, `${newId}.children`);
+            // Update all child assets
+            const oldPrefix = id + '/';
+            const newPrefix = newId + '/';
+            for (const child of assets) {
+                if (child.parentId === id) {
+                    const oldChildId = child.id;
+                    child.id = newPrefix + child.id.slice(oldPrefix.length);
+                    child.parentId = newId;
+                    BlobStore.renameAll(oldChildId, child.id);
+                    // Update texture references in material configs
+                    if (child.type === AssetType.MaterialSchema && child.settings.materialConfig) {
+                        for (const prop of child.settings.materialConfig.properties) {
+                            if (prop.textureAssetId?.startsWith(oldPrefix)) {
+                                prop.textureAssetId = newPrefix + prop.textureAssetId.slice(oldPrefix.length);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Update the asset itself
+        asset.id = newId;
+        BlobStore.renameAll(id, newId);
+        lastScanTime = Date.now();
+        json(res, { ok: true, newId });
+        return;
+    }
     // DELETE /api/asset/:id — delete asset
     if (pathname.startsWith('/api/asset/') && req.method === 'DELETE') {
         const id = decodeURIComponent(pathname.slice('/api/asset/'.length));
@@ -507,6 +1041,22 @@ async function handleRequest(req, res, staticApps) {
             json(res, { error: 'No project open' }, 400);
             return;
         }
+        const asset = assets.find(a => a.id === id);
+        if (asset?.locked) {
+            json(res, { error: 'Cannot delete locked child asset' }, 403);
+            return;
+        }
+        // If it's a container, cascade delete all children
+        if (asset?.type === AssetType.GlbContainer) {
+            for (const child of assets.filter(a => a.parentId === id)) {
+                BlobStore.remove(child.id);
+                broadcast({ type: 'asset-removed', id: child.id });
+            }
+            assets = assets.filter(a => a.parentId !== id);
+            // Remove the .children/ cache directory
+            const childrenDir = path.join(projectConfig.srcArtDir, `${id}.children`);
+            fs.rm(childrenDir, { recursive: true, force: true }).catch(() => { });
+        }
         assets = assets.filter(a => a.id !== id);
         BlobStore.remove(id);
         deleteFile(projectConfig.srcArtDir, id);
@@ -558,7 +1108,18 @@ async function handleRequest(req, res, staticApps) {
             json(res, { error: 'No project open' }, 400);
             return;
         }
-        const data = await readFile(projectConfig.srcArtDir, id);
+        let data = BlobStore.getSource(id);
+        if (!data)
+            data = await readFile(projectConfig.srcArtDir, id) ?? undefined;
+        // For GLB children (mesh/texture), fall back to the parent GLB source
+        if (!data) {
+            const asset = assets.find(a => a.id === id);
+            if (asset?.parentId) {
+                data = BlobStore.getSource(asset.parentId);
+                if (!data)
+                    data = await readFile(projectConfig.srcArtDir, asset.parentId) ?? undefined;
+            }
+        }
         if (!data) {
             res.writeHead(404);
             res.end();
@@ -630,7 +1191,8 @@ async function handleRequest(req, res, staticApps) {
         BlobStore.setSource(relativePath, sourceData);
         assets.push(asset);
         broadcast({ type: 'asset-added', asset });
-        processOneAsset(relativePath);
+        // Queue processing in the background (don't block the HTTP response)
+        queueProcessing({ ids: [relativePath] });
         json(res, { ok: true, id: relativePath });
         return;
     }
@@ -828,6 +1390,7 @@ async function handleRequest(req, res, staticApps) {
         await openProject(projectConfig.projectDir);
         broadcast({ type: 'project-reloaded' });
         json(res, { ok: true, assetCount: assets.length });
+        queueProcessing();
         return;
     }
     // Static file serving for GUI apps (packer, editor)
@@ -914,37 +1477,12 @@ export async function startServer(opts = {}) {
         }));
         ws.on('close', () => wsClients.delete(ws));
     });
-    // Initialize encoders in background
-    initEncoders(opts.wasmDir).then(ctx => {
-        processingCtx = ctx;
-    }).catch(err => {
-        console.error('[server] Encoder init failed:', err);
-    });
+    // Initialize worker pool
+    workerPool = initWorkerPool(opts.wasmDir);
     // Open project if specified
     if (opts.projectDir) {
         await openProject(opts.projectDir);
-        // Auto-process pending assets once encoders are ready
-        const waitForEncoders = async () => {
-            while (!processingCtx)
-                await new Promise(r => setTimeout(r, 100));
-            const pending = assets.filter(a => a.status === 'pending' && a.type !== AssetType.MaterialSchema);
-            if (pending.length > 0) {
-                console.log(`[server] Auto-processing ${pending.length} pending assets...`);
-                const queue = pending.map(a => a.id);
-                async function drain() {
-                    while (queue.length > 0) {
-                        const id = queue.shift();
-                        await processOneAsset(id);
-                    }
-                }
-                const workers = [];
-                for (let i = 0; i < Math.min(8, pending.length); i++)
-                    workers.push(drain());
-                await Promise.all(workers);
-                broadcast({ type: 'processing-complete' });
-            }
-        };
-        waitForEncoders();
+        queueProcessing();
     }
     return new Promise((resolve) => {
         server.listen(port, () => {