@series-inc/stowkit-cli 0.6.17 → 0.6.18

package/dist/server.js

@@ -5,13 +5,14 @@ import { WebSocketServer, WebSocket } from 'ws';
 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 { readProjectConfig, scanDirectory, readFile, writeFile, renameFile, deleteFile, getFileSnapshot, probeImageDimensions, } from './node-fs.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 { buildPack, validatePackDependencies, processExtractedAnimations } from './pipeline.js';
 import { syncRuntimeAssets } from './sync-runtime-assets.js';
 import { parseGlb, pbrToMaterialConfig } from './encoders/glb-loader.js';
+import { AAC_QUALITY_STRINGS, AUDIO_SAMPLE_RATE_STRINGS, DRACO_QUALITY_STRINGS, KTX2_QUALITY_STRINGS, TEXTURE_FILTER_STRINGS, TEXTURE_RESIZE_STRINGS, } from './app/disk-project.js';
 import { WorkerPool } from './workers/worker-pool.js';
 async function scanPrefabFiles(dir, prefix) {
     const results = [];
@@ -149,6 +150,120 @@ function resolvePackName(pack, packs) {
         return pack;
     return packs[0].name;
 }
+function normalizeOptionalProjectString(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value !== 'string') {
+        throw new Error('Project config values must be strings.');
+    }
+    const trimmed = value.trim();
+    return trimmed === '' ? undefined : trimmed;
+}
+function normalizeProjectPacks(value) {
+    if (!Array.isArray(value)) {
+        throw new Error('Project packs must be an array.');
+    }
+    const packs = value.map((pack) => {
+        if (!pack || typeof pack !== 'object' || typeof pack.name !== 'string') {
+            throw new Error('Each pack must be an object with a name.');
+        }
+        const name = pack.name.trim();
+        if (!name) {
+            throw new Error('Pack names cannot be empty.');
+        }
+        return { name };
+    });
+    const unique = new Set(packs.map((pack) => pack.name));
+    if (unique.size !== packs.length) {
+        throw new Error('Pack names must be unique.');
+    }
+    return packs.length > 0 ? packs : [{ name: 'default' }];
+}
+function normalizeProjectDefaults(value) {
+    if (value == null)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Project defaults must be an object.');
+    }
+    const rawDefaults = value;
+    const nextDefaults = {};
+    if (rawDefaults.texture !== undefined) {
+        const rawTexture = rawDefaults.texture;
+        if (!rawTexture || typeof rawTexture !== 'object' || Array.isArray(rawTexture)) {
+            throw new Error('Texture defaults must be an object.');
+        }
+        const texture = rawTexture;
+        const nextTexture = {};
+        if (texture.quality !== undefined) {
+            if (typeof texture.quality !== 'string' || !(texture.quality in KTX2_QUALITY_STRINGS)) {
+                throw new Error('Texture default quality is invalid.');
+            }
+            nextTexture.quality = texture.quality;
+        }
+        if (texture.resize !== undefined) {
+            if (typeof texture.resize !== 'string' || !(texture.resize in TEXTURE_RESIZE_STRINGS)) {
+                throw new Error('Texture default resize is invalid.');
+            }
+            nextTexture.resize = texture.resize;
+        }
+        if (texture.filtering !== undefined) {
+            if (typeof texture.filtering !== 'string' || !(texture.filtering in TEXTURE_FILTER_STRINGS)) {
+                throw new Error('Texture default filtering is invalid.');
+            }
+            nextTexture.filtering = texture.filtering;
+        }
+        if (texture.generateMipmaps !== undefined) {
+            if (typeof texture.generateMipmaps !== 'boolean') {
+                throw new Error('Texture default mipmap setting must be true or false.');
+            }
+            nextTexture.generateMipmaps = texture.generateMipmaps;
+        }
+        if (Object.keys(nextTexture).length > 0) {
+            nextDefaults.texture = nextTexture;
+        }
+    }
+    if (rawDefaults.audio !== undefined) {
+        const rawAudio = rawDefaults.audio;
+        if (!rawAudio || typeof rawAudio !== 'object' || Array.isArray(rawAudio)) {
+            throw new Error('Audio defaults must be an object.');
+        }
+        const audio = rawAudio;
+        const nextAudio = {};
+        if (audio.aacQuality !== undefined) {
+            if (typeof audio.aacQuality !== 'string' || !(audio.aacQuality in AAC_QUALITY_STRINGS)) {
+                throw new Error('Audio default AAC quality is invalid.');
+            }
+            nextAudio.aacQuality = audio.aacQuality;
+        }
+        if (audio.sampleRate !== undefined) {
+            if (typeof audio.sampleRate !== 'string' || !(audio.sampleRate in AUDIO_SAMPLE_RATE_STRINGS)) {
+                throw new Error('Audio default sample rate is invalid.');
+            }
+            nextAudio.sampleRate = audio.sampleRate;
+        }
+        if (Object.keys(nextAudio).length > 0) {
+            nextDefaults.audio = nextAudio;
+        }
+    }
+    if (rawDefaults.mesh !== undefined) {
+        const rawMesh = rawDefaults.mesh;
+        if (!rawMesh || typeof rawMesh !== 'object' || Array.isArray(rawMesh)) {
+            throw new Error('Mesh defaults must be an object.');
+        }
+        const mesh = rawMesh;
+        const nextMesh = {};
+        if (mesh.dracoQuality !== undefined) {
+            if (typeof mesh.dracoQuality !== 'string' || !(mesh.dracoQuality in DRACO_QUALITY_STRINGS)) {
+                throw new Error('Mesh default Draco quality is invalid.');
+            }
+            nextMesh.dracoQuality = mesh.dracoQuality;
+        }
+        if (Object.keys(nextMesh).length > 0) {
+            nextDefaults.mesh = nextMesh;
+        }
+    }
+    return Object.keys(nextDefaults).length > 0 ? nextDefaults : undefined;
+}
 // ─── GLB Container helpers ──────────────────────────────────────────────────
 function childTypeToAssetType(childType) {
     switch (childType) {
@@ -232,14 +347,14 @@ async function processGlbContainer(containerId) {
     // Process textures
     for (const tex of extract.textures) {
         const existing = existingChildren.get(tex.name);
-        childrenManifest.push(existing ?? generateDefaultGlbChild(tex.name, 'texture'));
+        childrenManifest.push(existing ?? generateDefaultGlbChild(tex.name, 'texture', projectConfig.config.defaults));
         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 meshChild = existingChildren.get(mesh.name) ?? generateDefaultGlbChild(mesh.name, typeName);
+        const meshChild = existingChildren.get(mesh.name) ?? generateDefaultGlbChild(mesh.name, typeName, projectConfig.config.defaults);
         // Store scene node names so AI agents can see the hierarchy in the stowmeta
         if (mesh.imported.nodes.length > 1) {
             meshChild.sceneNodeNames = mesh.imported.nodes.map(n => n.name);
@@ -257,7 +372,7 @@ async function processGlbContainer(containerId) {
             childrenManifest.push(existing);
         }
         else {
-            const child = generateDefaultGlbChild(matName, 'materialSchema');
+            const child = generateDefaultGlbChild(matName, 'materialSchema', projectConfig.config.defaults);
             // Store extracted PBR config as materialConfig on the inline child
             const matConfig = pbrToMaterialConfig(mat.pbrConfig, containerId);
             child.materialConfig = {
@@ -280,7 +395,7 @@ async function processGlbContainer(containerId) {
     // Process animations
     for (const anim of extract.animations) {
         const existing = existingChildren.get(anim.name);
-        childrenManifest.push(existing ?? generateDefaultGlbChild(anim.name, 'animationClip'));
+        childrenManifest.push(existing ?? generateDefaultGlbChild(anim.name, 'animationClip', projectConfig.config.defaults));
     }
     // Clear old cache stamps on all children — processGlbContainer always re-processes
     // everything (the container was marked pending, so children must be reprocessed too).
@@ -480,7 +595,10 @@ async function openProject(projectDir) {
         const fileName = file.relativePath.split('/').pop() ?? file.relativePath;
         let meta = await readStowmeta(projectConfig.srcArtDir, file.relativePath);
         if (!meta) {
-            meta = generateDefaultStowmeta(file.relativePath, type);
+            const imageDimensions = type === AssetType.Texture2D
+                ? await probeImageDimensions(projectConfig.srcArtDir, file.relativePath)
+                : null;
+            meta = generateDefaultStowmeta(file.relativePath, type, projectConfig.config.defaults, imageDimensions);
             await writeStowmeta(projectConfig.srcArtDir, file.relativePath, meta);
         }
         const { type: metaType, settings: metaSettings } = stowmetaToAssetSettings(meta);
@@ -536,7 +654,7 @@ async function openProject(projectDir) {
         const baseName = fileName.replace(/\.[^.]+$/, '');
         let meta = await readStowmeta(projectConfig.srcArtDir, id);
         if (!meta) {
-            meta = generateDefaultStowmeta(id, AssetType.MaterialSchema);
+            meta = generateDefaultStowmeta(id, AssetType.MaterialSchema, projectConfig.config.defaults);
             await writeStowmeta(projectConfig.srcArtDir, id, meta);
         }
         const materialConfig = mat ? stowmatToMaterialConfig(mat) : { schemaId: '', properties: [] };
@@ -913,6 +1031,21 @@ async function handleRequest(req, res, staticApps) {
         const packs = projectConfig.config.packs ?? [{ name: 'default' }];
         const cdnDir = path.resolve(projectConfig.projectDir, projectConfig.config.cdnAssetsPath ?? 'public/cdn-assets');
         await fs.mkdir(cdnDir, { recursive: true });
+        // Validate unique stringIds before building
+        const idCounts = new Map();
+        for (const a of assets) {
+            if (a.status !== 'ready' || a.settings.excluded)
+                continue;
+            const files = idCounts.get(a.stringId) ?? [];
+            files.push(a.id);
+            idCounts.set(a.stringId, files);
+        }
+        const duplicates = [...idCounts.entries()].filter(([, files]) => files.length > 1);
+        if (duplicates.length > 0) {
+            const lines = duplicates.map(([id, files]) => `"${id}" used by: ${files.join(', ')}`);
+            json(res, { error: `Duplicate stringIds found: ${lines.join('; ')}` }, 400);
+            return;
+        }
         const results = [];
         const allErrors = [];
         for (const pack of packs) {
@@ -993,7 +1126,7 @@ async function handleRequest(req, res, staticApps) {
             }
         }
         // Check if needs reprocessing
-        const needsReprocess = (asset.type === AssetType.Texture2D && (body.settings.quality !== undefined || body.settings.resize !== undefined || body.settings.generateMipmaps !== undefined)) ||
+        const needsReprocess = (asset.type === AssetType.Texture2D && (body.settings.quality !== undefined || body.settings.resize !== undefined || body.settings.filtering !== undefined || body.settings.generateMipmaps !== 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);
@@ -1008,6 +1141,64 @@ async function handleRequest(req, res, staticApps) {
         json(res, { ok: true });
         return;
     }
+    // POST /api/resolve-duplicate-ids — fix duplicate stringIds by switching them to path-based IDs
+    if (pathname === '/api/resolve-duplicate-ids' && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        // Find duplicates
+        const stringIdToAssets = new Map();
+        for (const a of assets) {
+            if (a.settings.excluded || a.type === AssetType.GlbContainer)
+                continue;
+            const list = stringIdToAssets.get(a.stringId) ?? [];
+            list.push(a);
+            stringIdToAssets.set(a.stringId, list);
+        }
+        let fixed = 0;
+        for (const [, group] of stringIdToAssets) {
+            if (group.length <= 1)
+                continue;
+            for (const asset of group) {
+                const pathId = asset.id.replace(/\.[^.]+$/, '').toLowerCase();
+                if (asset.stringId === pathId)
+                    continue;
+                asset.stringId = pathId;
+                // Persist to disk
+                const meta = assetSettingsToStowmeta(asset);
+                await writeStowmeta(projectConfig.srcArtDir, asset.id, meta);
+                broadcast({ type: 'asset-update', id: asset.id, updates: { stringId: pathId } });
+                fixed++;
+            }
+        }
+        json(res, { ok: true, fixed });
+        return;
+    }
+    // POST /api/reset-string-ids — reset all stringIds to match their file paths
+    if (pathname === '/api/reset-string-ids' && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        let updated = 0;
+        for (const asset of assets) {
+            if (asset.settings.excluded || asset.type === AssetType.GlbContainer)
+                continue;
+            const pathId = asset.type === AssetType.MaterialSchema
+                ? asset.id.replace(/\.[^.]+$/, '')
+                : asset.id.replace(/\.[^.]+$/, '').toLowerCase();
+            if (asset.stringId === pathId)
+                continue;
+            asset.stringId = pathId;
+            const meta = assetSettingsToStowmeta(asset);
+            await writeStowmeta(projectConfig.srcArtDir, asset.id, meta);
+            broadcast({ type: 'asset-update', id: asset.id, updates: { stringId: pathId } });
+            updated++;
+        }
+        json(res, { ok: true, updated });
+        return;
+    }
     // PUT /api/asset/:id/type — change asset type
     if (pathname.startsWith('/api/asset/') && pathname.endsWith('/type') && req.method === 'PUT') {
         const id = decodeURIComponent(pathname.slice('/api/asset/'.length, -'/type'.length));
@@ -1273,7 +1464,10 @@ async function handleRequest(req, res, staticApps) {
         await writeFile(projectConfig.srcArtDir, relativePath, sourceData);
         const type = detectAssetType(fileName);
         const configuredPacks = projectConfig.config.packs ?? [];
-        const meta = generateDefaultStowmeta(relativePath, type);
+        const imageDimensions = type === AssetType.Texture2D
+            ? await probeImageDimensions(projectConfig.srcArtDir, relativePath)
+            : null;
+        const meta = generateDefaultStowmeta(relativePath, type, projectConfig.config.defaults, imageDimensions);
         meta.pack = resolvePackName(meta.pack ?? '', configuredPacks);
         await writeStowmeta(projectConfig.srcArtDir, relativePath, meta);
         const settings = defaultAssetSettings();
@@ -1367,23 +1561,89 @@ async function handleRequest(req, res, staticApps) {
             return;
         }
         const body = JSON.parse(await readBody(req));
-        if (body.packs !== undefined) {
-            projectConfig.config.packs = body.packs;
+        const currentConfig = projectConfig.config;
+        const nextConfig = { ...currentConfig };
+        if (Object.prototype.hasOwnProperty.call(body, 'srcArtDir')) {
+            nextConfig.srcArtDir = normalizeOptionalProjectString(body.srcArtDir) ?? '';
+        }
+        if (!nextConfig.srcArtDir) {
+            json(res, { error: '.felicityproject must include "srcArtDir".' }, 400);
+            return;
         }
-        if (body.renamedPack) {
-            const { oldName, newName } = body.renamedPack;
+        if (Object.prototype.hasOwnProperty.call(body, 'name')) {
+            nextConfig.name = normalizeOptionalProjectString(body.name);
+        }
+        if (Object.prototype.hasOwnProperty.call(body, 'cdnAssetsPath')) {
+            nextConfig.cdnAssetsPath = normalizeOptionalProjectString(body.cdnAssetsPath);
+        }
+        if (Object.prototype.hasOwnProperty.call(body, 'prefabsPath')) {
+            nextConfig.prefabsPath = normalizeOptionalProjectString(body.prefabsPath);
+        }
+        if (Object.prototype.hasOwnProperty.call(body, 'packs')) {
+            nextConfig.packs = normalizeProjectPacks(body.packs);
+        }
+        if (Object.prototype.hasOwnProperty.call(body, 'defaults')) {
+            nextConfig.defaults = normalizeProjectDefaults(body.defaults);
+        }
+        const renamedPacks = Array.isArray(body.renamedPacks)
+            ? body.renamedPacks.filter((rename) => typeof rename?.oldName === 'string'
+                && typeof rename?.newName === 'string'
+                && rename.oldName.trim() !== ''
+                && rename.newName.trim() !== '').map((rename) => ({
+                oldName: rename.oldName.trim(),
+                newName: rename.newName.trim(),
+            }))
+            : [];
+        const srcArtDirChanged = nextConfig.srcArtDir !== currentConfig.srcArtDir;
+        projectConfig.config = nextConfig;
+        projectConfig.projectName = nextConfig.name || path.basename(projectConfig.projectDir);
+        const configPath = path.join(projectConfig.projectDir, '.felicityproject');
+        await fs.writeFile(configPath, JSON.stringify(nextConfig, null, 2));
+        if (srcArtDirChanged) {
+            await openProject(projectConfig.projectDir);
+            const pending = assets
+                .filter((asset) => asset.status === 'loading' || asset.status === 'pending')
+                .map((asset) => asset.id);
+            if (pending.length > 0) {
+                queueProcessing({ ids: pending });
+            }
+        }
+        else if (Object.prototype.hasOwnProperty.call(body, 'packs') || renamedPacks.length > 0) {
+            const configuredPacks = nextConfig.packs ?? [{ name: 'default' }];
             for (const asset of assets) {
-                if ((asset.settings.pack ?? 'default') === oldName) {
-                    asset.settings.pack = newName;
-                    const meta = assetSettingsToStowmeta(asset);
-                    writeStowmeta(projectConfig.srcArtDir, asset.id, meta);
+                let nextPack = asset.settings.pack ?? 'default';
+                const renamed = renamedPacks.find((entry) => entry.oldName === nextPack);
+                if (renamed) {
+                    nextPack = renamed.newName;
                 }
+                nextPack = resolvePackName(nextPack, configuredPacks);
+                if (nextPack === asset.settings.pack)
+                    continue;
+                asset.settings.pack = nextPack;
+                if (asset.parentId) {
+                    const childName = asset.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, asset.settings);
+                    continue;
+                }
+                const meta = assetSettingsToStowmeta(asset);
+                if (asset.type === AssetType.GlbContainer) {
+                    const existing = await readStowmeta(projectConfig.srcArtDir, asset.id);
+                    if (existing && existing.type === 'glbContainer') {
+                        meta.children = existing.children;
+                        meta.preserveHierarchy = asset.settings.preserveHierarchy || undefined;
+                    }
+                }
+                await writeStowmeta(projectConfig.srcArtDir, asset.id, meta);
             }
         }
-        const configPath = path.join(projectConfig.projectDir, '.felicityproject');
-        await fs.writeFile(configPath, JSON.stringify(projectConfig.config, null, 2));
         broadcast({ type: 'config-updated', config: projectConfig.config });
-        json(res, { ok: true });
+        json(res, { ok: true, projectName: projectConfig.projectName, config: projectConfig.config });
         return;
     }
     // ── Editor endpoints: prefabs + packs ─────────────────────────────────────
@@ -1493,6 +1753,293 @@ async function handleRequest(req, res, staticApps) {
         queueProcessing();
         return;
     }
+    // ─── Asset Store Endpoints ──────────────────────────────────────────────
+    // GET /api/asset-store/registry — fetch the public registry
+    if (pathname === '/api/asset-store/registry' && req.method === 'GET') {
+        try {
+            const bucketParam = url.searchParams.get('bucket') ?? 'venus-shared-assets-test';
+            const bucketName = bucketParam.replace(/^gs:\/\//, '').replace(/\/$/, '');
+            const registryUrl = `https://storage.googleapis.com/${bucketName}/registry.json?t=${Date.now()}`;
+            const fetchRes = await fetch(registryUrl);
+            if (!fetchRes.ok) {
+                if (fetchRes.status === 404) {
+                    json(res, { schemaVersion: 1, packages: {} });
+                }
+                else {
+                    json(res, { error: `Failed to fetch registry: ${fetchRes.status}` }, 502);
+                }
+                return;
+            }
+            const registry = await fetchRes.json();
+            json(res, registry);
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
+    // GET /api/asset-store/search — search assets using ranked scoring
+    if (pathname === '/api/asset-store/search' && req.method === 'GET') {
+        try {
+            const query = url.searchParams.get('q') ?? '';
+            const type = url.searchParams.get('type') ?? undefined;
+            const pkg = url.searchParams.get('package') ?? undefined;
+            const bucketParam = url.searchParams.get('bucket') ?? undefined;
+            const { fetchRegistry, searchAssets } = await import('./store.js');
+            const registry = await fetchRegistry(bucketParam);
+            const results = searchAssets(registry, query, { type, package: pkg });
+            json(res, results);
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
+    // GET /api/asset-store/packages — list all packages
+    if (pathname === '/api/asset-store/packages' && req.method === 'GET') {
+        try {
+            const bucketParam = url.searchParams.get('bucket') ?? undefined;
+            const { fetchRegistry, listPackages } = await import('./store.js');
+            const registry = await fetchRegistry(bucketParam);
+            const packages = listPackages(registry);
+            json(res, packages);
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
+    // POST /api/asset-store/download — download assets (with transitive deps) into project
+    if (pathname === '/api/asset-store/download' && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        try {
+            const body = JSON.parse(await readBody(req));
+            const { packageName, version, stringIds, bucket: bucketParam } = body;
+            if (!packageName || !version || !stringIds?.length) {
+                json(res, { error: 'Missing packageName, version, or stringIds' }, 400);
+                return;
+            }
+            const bucketName = (bucketParam ?? 'venus-shared-assets-test').replace(/^gs:\/\//, '').replace(/\/$/, '');
+            const baseUrl = `https://storage.googleapis.com/${bucketName}`;
+            // Fetch registry to resolve deps
+            const regRes = await fetch(`${baseUrl}/registry.json`);
+            if (!regRes.ok) {
+                json(res, { error: 'Could not fetch registry' }, 502);
+                return;
+            }
+            const registry = await regRes.json();
+            const pkg = registry.packages[packageName];
+            if (!pkg) {
+                json(res, { error: `Package "${packageName}" not found` }, 404);
+                return;
+            }
+            const ver = pkg.versions[version];
+            if (!ver) {
+                json(res, { error: `Version "${version}" not found` }, 404);
+                return;
+            }
+            // Resolve transitive dependencies
+            const { resolveTransitiveDeps, resolveFiles } = await import('./assets-package.js');
+            const allIds = resolveTransitiveDeps(stringIds, ver.assets);
+            const files = resolveFiles(allIds, ver.assets);
+            const prefix = `packages/${packageName}/${version}`;
+            let downloaded = 0;
+            const errors = [];
+            for (const filePath of files) {
+                const fileUrl = `${baseUrl}/${prefix}/${encodeURIComponent(filePath)}`;
+                try {
+                    const fileRes = await fetch(fileUrl);
+                    if (!fileRes.ok) {
+                        errors.push(`${filePath}: HTTP ${fileRes.status}`);
+                        continue;
+                    }
+                    const data = new Uint8Array(await fileRes.arrayBuffer());
+                    const destPath = path.join(projectConfig.srcArtDir, filePath);
+                    await fs.mkdir(path.dirname(destPath), { recursive: true });
+                    await fs.writeFile(destPath, data);
+                    downloaded++;
+                }
+                catch (err) {
+                    errors.push(`${filePath}: ${err.message}`);
+                }
+            }
+            // Trigger rescan so packer picks up the new files
+            await openProject(projectConfig.projectDir);
+            broadcast({ type: 'project-reloaded' });
+            queueProcessing();
+            json(res, {
+                ok: true,
+                downloaded,
+                totalFiles: files.length,
+                resolvedAssets: allIds,
+                errors: errors.length > 0 ? errors : undefined,
+            });
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
+    // POST /api/publish — publish assets to GCS (SSE stream with progress)
+    if (pathname === '/api/publish' && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+        });
+        const sendEvent = (event, data) => {
+            res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+        };
+        try {
+            const body = JSON.parse(await readBody(req));
+            const { thumbnails, options } = body;
+            if (options?.version || options?.author !== undefined || options?.description !== undefined || options?.tags) {
+                const { readAssetsPackage, writeAssetsPackage, initAssetsPackage } = await import('./assets-package.js');
+                let pkg = await readAssetsPackage(projectConfig.projectDir);
+                if (!pkg) {
+                    pkg = await initAssetsPackage(projectConfig.projectDir, { name: projectConfig.projectName });
+                }
+                if (options.version && pkg.version !== options.version)
+                    pkg.version = options.version;
+                if (options.author !== undefined)
+                    pkg.author = options.author;
+                if (options.description !== undefined)
+                    pkg.description = options.description;
+                if (options.tags)
+                    pkg.tags = options.tags;
+                await writeAssetsPackage(projectConfig.projectDir, pkg);
+            }
+            const { publishPackage } = await import('./publish.js');
+            const result = await publishPackage(projectConfig.projectDir, {
+                force: options?.force,
+                bucket: options?.bucket,
+                verbose: true,
+                thumbnails: thumbnails ?? undefined,
+                onProgress: (progress) => sendEvent('progress', progress),
+            });
+            sendEvent('done', result);
+            res.end();
+        }
+        catch (err) {
+            sendEvent('error', { error: err.message });
+            res.end();
+        }
+        return;
+    }
+    // GET /api/publish/config — check if assets-package.json exists
+    if (pathname === '/api/publish/config' && req.method === 'GET') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        try {
+            const { readAssetsPackage } = await import('./assets-package.js');
+            const pkg = await readAssetsPackage(projectConfig.projectDir);
+            json(res, { exists: !!pkg, config: pkg });
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
+    // GET /api/thumbnails/cached — return which thumbnails are still valid in the cache
+    if (pathname === '/api/thumbnails/cached' && req.method === 'GET') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        try {
+            const { readManifest, computeSettingsHash, computeMaterialDepsHash, isThumbnailCacheValid } = await import('./app/thumbnail-cache.js');
+            const manifest = await readManifest(projectConfig.srcArtDir);
+            const validEntries = {};
+            for (const asset of assets) {
+                const entry = manifest[asset.stringId];
+                if (!entry)
+                    continue;
+                const settingsHash = computeSettingsHash(asset.settings);
+                const materialDepsHash = computeMaterialDepsHash(asset.settings, assets.map(a => ({ id: a.id, stringId: a.stringId, sourceSize: a.sourceSize, settings: a.settings })));
+                if (isThumbnailCacheValid(entry, asset.sourceSize, settingsHash, materialDepsHash)) {
+                    validEntries[asset.stringId] = { format: entry.format };
+                }
+            }
+            json(res, validEntries);
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
+    // GET /api/thumbnails/:stringId — return cached thumbnail binary
+    if (pathname.startsWith('/api/thumbnails/') && req.method === 'GET' && pathname !== '/api/thumbnails/cached') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        const stringId = decodeURIComponent(pathname.slice('/api/thumbnails/'.length));
+        try {
+            const { readManifest, readThumbnailFile } = await import('./app/thumbnail-cache.js');
+            const manifest = await readManifest(projectConfig.srcArtDir);
+            const entry = manifest[stringId];
+            if (!entry) {
+                res.writeHead(404);
+                res.end('Not found');
+                return;
+            }
+            const data = await readThumbnailFile(projectConfig.srcArtDir, stringId, entry.format);
+            if (!data) {
+                res.writeHead(404);
+                res.end('Not found');
+                return;
+            }
+            const contentType = entry.format === 'webm' ? 'video/webm' : entry.format === 'webp' ? 'image/webp' : 'image/png';
+            res.writeHead(200, { 'Content-Type': contentType, 'Access-Control-Allow-Origin': '*' });
+            res.end(data);
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
+    // POST /api/thumbnails — store newly captured thumbnails and update manifest
+    if (pathname === '/api/thumbnails' && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        try {
+            const body = JSON.parse(await readBody(req));
+            const thumbnails = body.thumbnails;
+            const { readManifest, writeManifest, writeThumbnailFile, computeSettingsHash, computeMaterialDepsHash } = await import('./app/thumbnail-cache.js');
+            const manifest = await readManifest(projectConfig.srcArtDir);
+            const allAssetData = assets.map(a => ({ id: a.id, stringId: a.stringId, sourceSize: a.sourceSize, settings: a.settings }));
+            for (const [stringId, thumb] of Object.entries(thumbnails)) {
+                const asset = assets.find(a => a.stringId === stringId);
+                if (!asset)
+                    continue;
+                const data = Buffer.from(thumb.data, 'base64');
+                await writeThumbnailFile(projectConfig.srcArtDir, stringId, thumb.format, data);
+                manifest[stringId] = {
+                    format: thumb.format,
+                    sourceSize: asset.sourceSize,
+                    settingsHash: computeSettingsHash(asset.settings),
+                    materialDepsHash: computeMaterialDepsHash(asset.settings, allAssetData),
+                };
+            }
+            await writeManifest(projectConfig.srcArtDir, manifest);
+            json(res, { ok: true, stored: Object.keys(thumbnails).length });
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
     // Static file serving for GUI apps (packer, editor)
     // Sort: longer prefixes first so /packer matches before /
     const mimeTypes = {