@playdrop/playdrop-cli 0.3.1-build.1 → 0.3.4-build.1

package/dist/catalogue.js

@@ -13,6 +13,12 @@ const catalogue_utils_1 = require("./catalogue-utils");
 const HEX_COLOR_REGEX = /^#?(?:[0-9a-fA-F]{6})$/;
 const SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
 const ASSET_CATEGORY_SET = new Set(types_1.ASSET_CATEGORY_VALUES);
+const LISTING_IMAGE_EXTENSIONS = new Set(['.png']);
+const LISTING_VIDEO_EXTENSIONS = new Set(['.mp4']);
+const BOXEL_GENERATED_FILE_ROLES = new Set(['mesh', 'preview']);
+const BOXEL_REQUIRED_FILE_ROLES = ['primary', 'mesh', 'preview'];
+const VOX_GENERATED_FILE_ROLES = new Set(['boxel', 'mesh', 'preview']);
+const VOX_REQUIRED_FILE_ROLES = ['primary', 'boxel', 'mesh', 'preview'];
 const ASSET_SUBCATEGORY_SET_BY_CATEGORY = types_1.ASSET_SUBCATEGORY_DEFINITIONS.reduce((acc, definition) => {
     if (!acc[definition.category]) {
         acc[definition.category] = new Set();
@@ -20,6 +26,38 @@ const ASSET_SUBCATEGORY_SET_BY_CATEGORY = types_1.ASSET_SUBCATEGORY_DEFINITIONS.
     acc[definition.category].add(definition.subcategory);
     return acc;
 }, {});
+function normalizeFileRole(role) {
+    return role.trim().toLowerCase();
+}
+function inferGeneratedModel3DFormat(category, subcategory, format, files) {
+    if (category !== 'MODEL_3D' || !(0, types_1.isModel3DAssetSubcategory)('MODEL_3D', subcategory)) {
+        return null;
+    }
+    const normalizedFormat = typeof format === 'string' ? format.trim().toUpperCase() : '';
+    if (normalizedFormat === 'PLAYDROP_BOXEL_JSON' || normalizedFormat === 'VOX') {
+        return normalizedFormat;
+    }
+    const primary = typeof files?.primary === 'string' ? files.primary.trim().toLowerCase() : '';
+    if (primary.endsWith('.boxel.json')) {
+        return 'PLAYDROP_BOXEL_JSON';
+    }
+    if (primary.endsWith('.vox')) {
+        return 'VOX';
+    }
+    return null;
+}
+function getGeneratedModel3DFileRoles(format) {
+    if (format === 'VOX') {
+        return {
+            generated: VOX_GENERATED_FILE_ROLES,
+            required: VOX_REQUIRED_FILE_ROLES,
+        };
+    }
+    return {
+        generated: BOXEL_GENERATED_FILE_ROLES,
+        required: BOXEL_REQUIRED_FILE_ROLES,
+    };
+}
 /**
  * Validates a listing asset path:
  * - Must exist
@@ -57,6 +95,16 @@ function validateListingAssetPath(baseDir, relativePath, fieldName) {
     }
     return undefined;
 }
+function validateListingAssetExtension(relativePath, fieldName, kind) {
+    const extension = (0, node_path_1.extname)(relativePath).toLowerCase();
+    if (kind === 'image' && !LISTING_IMAGE_EXTENSIONS.has(extension)) {
+        return `${fieldName} must use a .png file. Received "${relativePath}".`;
+    }
+    if (kind === 'video' && !LISTING_VIDEO_EXTENSIONS.has(extension)) {
+        return `${fieldName} must use a .mp4 file. Received "${relativePath}".`;
+    }
+    return undefined;
+}
 /**
  * Resolves a listing asset path after validation.
  */
@@ -592,60 +640,98 @@ function buildAppTasks(rootDir, catalogues, options) {
                 };
                 // Icon
                 if (typeof rawListing.icon === 'string' && rawListing.icon.trim()) {
-                    const validationError = validateListingAssetPath(file.directory, rawListing.icon.trim(), 'listing.icon');
-                    if (validationError) {
-                        errors.push(`[${label}] Skipping ${rawName}: ${validationError}`);
+                    const iconPath = rawListing.icon.trim();
+                    const extensionError = validateListingAssetExtension(iconPath, 'listing.icon', 'image');
+                    if (extensionError) {
+                        errors.push(`[${label}] Skipping ${rawName}: ${extensionError}`);
                         listingValidationFailed = true;
                     }
                     else {
-                        resolvedListing.iconPath = resolveListingAssetPath(file.directory, rawListing.icon.trim());
+                        const validationError = validateListingAssetPath(file.directory, iconPath, 'listing.icon');
+                        if (validationError) {
+                            errors.push(`[${label}] Skipping ${rawName}: ${validationError}`);
+                            listingValidationFailed = true;
+                        }
+                        else {
+                            resolvedListing.iconPath = resolveListingAssetPath(file.directory, iconPath);
+                        }
                     }
                 }
                 // Hero images
                 if (!listingValidationFailed && typeof rawListing.heroPortrait === 'string' && rawListing.heroPortrait.trim()) {
-                    const validationError = validateListingAssetPath(file.directory, rawListing.heroPortrait.trim(), 'listing.heroPortrait');
-                    if (validationError) {
-                        errors.push(`[${label}] Skipping ${rawName}: ${validationError}`);
+                    const heroPortraitPath = rawListing.heroPortrait.trim();
+                    const extensionError = validateListingAssetExtension(heroPortraitPath, 'listing.heroPortrait', 'image');
+                    if (extensionError) {
+                        errors.push(`[${label}] Skipping ${rawName}: ${extensionError}`);
                         listingValidationFailed = true;
                     }
                     else {
-                        resolvedListing.heroPortraitPath = resolveListingAssetPath(file.directory, rawListing.heroPortrait.trim());
+                        const validationError = validateListingAssetPath(file.directory, heroPortraitPath, 'listing.heroPortrait');
+                        if (validationError) {
+                            errors.push(`[${label}] Skipping ${rawName}: ${validationError}`);
+                            listingValidationFailed = true;
+                        }
+                        else {
+                            resolvedListing.heroPortraitPath = resolveListingAssetPath(file.directory, heroPortraitPath);
+                        }
                     }
                 }
                 if (!listingValidationFailed && typeof rawListing.heroLandscape === 'string' && rawListing.heroLandscape.trim()) {
-                    const validationError = validateListingAssetPath(file.directory, rawListing.heroLandscape.trim(), 'listing.heroLandscape');
-                    if (validationError) {
-                        errors.push(`[${label}] Skipping ${rawName}: ${validationError}`);
+                    const heroLandscapePath = rawListing.heroLandscape.trim();
+                    const extensionError = validateListingAssetExtension(heroLandscapePath, 'listing.heroLandscape', 'image');
+                    if (extensionError) {
+                        errors.push(`[${label}] Skipping ${rawName}: ${extensionError}`);
                         listingValidationFailed = true;
                     }
                     else {
-                        resolvedListing.heroLandscapePath = resolveListingAssetPath(file.directory, rawListing.heroLandscape.trim());
+                        const validationError = validateListingAssetPath(file.directory, heroLandscapePath, 'listing.heroLandscape');
+                        if (validationError) {
+                            errors.push(`[${label}] Skipping ${rawName}: ${validationError}`);
+                            listingValidationFailed = true;
+                        }
+                        else {
+                            resolvedListing.heroLandscapePath = resolveListingAssetPath(file.directory, heroLandscapePath);
+                        }
                     }
                 }
                 // Screenshots
                 if (!listingValidationFailed && Array.isArray(rawListing.screenshotsPortrait)) {
                     for (const p of rawListing.screenshotsPortrait) {
                         if (typeof p === 'string' && p.trim()) {
-                            const validationError = validateListingAssetPath(file.directory, p.trim(), 'listing.screenshotsPortrait item');
+                            const screenshotPath = p.trim();
+                            const extensionError = validateListingAssetExtension(screenshotPath, 'listing.screenshotsPortrait item', 'image');
+                            if (extensionError) {
+                                errors.push(`[${label}] Skipping ${rawName}: ${extensionError}`);
+                                listingValidationFailed = true;
+                                break;
+                            }
+                            const validationError = validateListingAssetPath(file.directory, screenshotPath, 'listing.screenshotsPortrait item');
                             if (validationError) {
                                 errors.push(`[${label}] Skipping ${rawName}: ${validationError}`);
                                 listingValidationFailed = true;
                                 break;
                             }
-                            resolvedListing.screenshotPortraitPaths.push(resolveListingAssetPath(file.directory, p.trim()));
+                            resolvedListing.screenshotPortraitPaths.push(resolveListingAssetPath(file.directory, screenshotPath));
                         }
                     }
                 }
                 if (!listingValidationFailed && Array.isArray(rawListing.screenshotsLandscape)) {
                     for (const p of rawListing.screenshotsLandscape) {
                         if (typeof p === 'string' && p.trim()) {
-                            const validationError = validateListingAssetPath(file.directory, p.trim(), 'listing.screenshotsLandscape item');
+                            const screenshotPath = p.trim();
+                            const extensionError = validateListingAssetExtension(screenshotPath, 'listing.screenshotsLandscape item', 'image');
+                            if (extensionError) {
+                                errors.push(`[${label}] Skipping ${rawName}: ${extensionError}`);
+                                listingValidationFailed = true;
+                                break;
+                            }
+                            const validationError = validateListingAssetPath(file.directory, screenshotPath, 'listing.screenshotsLandscape item');
                             if (validationError) {
                                 errors.push(`[${label}] Skipping ${rawName}: ${validationError}`);
                                 listingValidationFailed = true;
                                 break;
                             }
-                            resolvedListing.screenshotLandscapePaths.push(resolveListingAssetPath(file.directory, p.trim()));
+                            resolvedListing.screenshotLandscapePaths.push(resolveListingAssetPath(file.directory, screenshotPath));
                         }
                     }
                 }
@@ -653,26 +739,40 @@ function buildAppTasks(rootDir, catalogues, options) {
                 if (!listingValidationFailed && Array.isArray(rawListing.videosPortrait)) {
                     for (const p of rawListing.videosPortrait) {
                         if (typeof p === 'string' && p.trim()) {
-                            const validationError = validateListingAssetPath(file.directory, p.trim(), 'listing.videosPortrait item');
+                            const videoPath = p.trim();
+                            const extensionError = validateListingAssetExtension(videoPath, 'listing.videosPortrait item', 'video');
+                            if (extensionError) {
+                                errors.push(`[${label}] Skipping ${rawName}: ${extensionError}`);
+                                listingValidationFailed = true;
+                                break;
+                            }
+                            const validationError = validateListingAssetPath(file.directory, videoPath, 'listing.videosPortrait item');
                             if (validationError) {
                                 errors.push(`[${label}] Skipping ${rawName}: ${validationError}`);
                                 listingValidationFailed = true;
                                 break;
                             }
-                            resolvedListing.videoPortraitPaths.push(resolveListingAssetPath(file.directory, p.trim()));
+                            resolvedListing.videoPortraitPaths.push(resolveListingAssetPath(file.directory, videoPath));
                         }
                     }
                 }
                 if (!listingValidationFailed && Array.isArray(rawListing.videosLandscape)) {
                     for (const p of rawListing.videosLandscape) {
                         if (typeof p === 'string' && p.trim()) {
-                            const validationError = validateListingAssetPath(file.directory, p.trim(), 'listing.videosLandscape item');
+                            const videoPath = p.trim();
+                            const extensionError = validateListingAssetExtension(videoPath, 'listing.videosLandscape item', 'video');
+                            if (extensionError) {
+                                errors.push(`[${label}] Skipping ${rawName}: ${extensionError}`);
+                                listingValidationFailed = true;
+                                break;
+                            }
+                            const validationError = validateListingAssetPath(file.directory, videoPath, 'listing.videosLandscape item');
                             if (validationError) {
                                 errors.push(`[${label}] Skipping ${rawName}: ${validationError}`);
                                 listingValidationFailed = true;
                                 break;
                             }
-                            resolvedListing.videoLandscapePaths.push(resolveListingAssetPath(file.directory, p.trim()));
+                            resolvedListing.videoLandscapePaths.push(resolveListingAssetPath(file.directory, videoPath));
                         }
                     }
                 }
@@ -724,6 +824,11 @@ function buildAppTasks(rootDir, catalogues, options) {
                 const fileEntries = embedded?.files && typeof embedded.files === 'object' && !Array.isArray(embedded.files)
                     ? embedded.files
                     : null;
+                const embeddedFormat = typeof embedded?.format === 'string' && embedded.format.trim().length > 0
+                    ? embedded.format.trim().toUpperCase()
+                    : undefined;
+                const generatedModel3DFormat = inferGeneratedModel3DFormat(category, subcategory, embeddedFormat, fileEntries);
+                const generatedModel3DRoles = generatedModel3DFormat ? getGeneratedModel3DFileRoles(generatedModel3DFormat) : null;
                 if (!fileEntries || Object.keys(fileEntries).length === 0) {
                     errors.push(`[${label}] Skipping ${rawName}: embedded asset "${embeddedName}" must define files.`);
                     continue;
@@ -739,7 +844,14 @@ function buildAppTasks(rootDir, catalogues, options) {
                     }
                     const relativeEmbeddedPath = fileValue.trim();
                     const absoluteEmbeddedPath = (0, node_path_1.resolve)(file.directory, relativeEmbeddedPath);
+                    const normalizedRole = normalizeFileRole(role);
+                    const allowMissingGenerated = Boolean(generatedModel3DRoles?.generated.has(normalizedRole));
                     if (!(0, node_fs_1.existsSync)(absoluteEmbeddedPath) || !(0, node_fs_1.statSync)(absoluteEmbeddedPath).isFile()) {
+                        if (allowMissingGenerated) {
+                            files[role] = relativeEmbeddedPath.replace(/\\/g, '/');
+                            filePaths[role] = absoluteEmbeddedPath;
+                            continue;
+                        }
                         errors.push(`[${label}] Skipping ${rawName}: embedded asset "${embeddedName}" file not found at ${absoluteEmbeddedPath}.`);
                         embeddedHasError = true;
                         continue;
@@ -750,6 +862,14 @@ function buildAppTasks(rootDir, catalogues, options) {
                 if (embeddedHasError) {
                     continue;
                 }
+                if (generatedModel3DRoles) {
+                    const normalizedRoles = new Set(Object.keys(files).map((role) => normalizeFileRole(role)));
+                    const missingRoles = generatedModel3DRoles.required.filter((role) => !normalizedRoles.has(role));
+                    if (missingRoles.length > 0) {
+                        errors.push(`[${label}] Skipping ${rawName}: embedded asset "${embeddedName}" with subcategory=${subcategory} must define files.${missingRoles.join(' and files.')}.`);
+                        continue;
+                    }
+                }
                 if (category === 'SPRITESHEET') {
                     const hasAtlas = Object.prototype.hasOwnProperty.call(files, 'atlas');
                     const hasManifest = Object.prototype.hasOwnProperty.call(files, 'manifest');
@@ -772,10 +892,10 @@ function buildAppTasks(rootDir, catalogues, options) {
                     cataloguePath: label,
                     category,
                     subcategory,
-                    format: typeof embedded?.format === 'string' && embedded.format.trim().length > 0 ? embedded.format.trim().toUpperCase() : undefined,
+                    format: embeddedFormat,
                     visibility: normalizeAssetVisibilityValue(embedded?.visibility, errors, `${label} embedded asset \"${embeddedName}\"`),
                     shopListed: typeof embedded?.shopListed === 'boolean' ? embedded.shopListed : undefined,
-                    shopPriceCoins: Number.isInteger(embedded?.shopPriceCoins) ? Number(embedded.shopPriceCoins) : undefined,
+                    shopPriceCredits: Number.isInteger(embedded?.shopPriceCredits) ? Number(embedded.shopPriceCredits) : undefined,
                     files,
                     filePaths,
                 });
@@ -863,9 +983,12 @@ function buildAssetTasks(catalogues) {
             if (!subcategory) {
                 continue;
             }
+            const format = typeof entry.format === 'string' && entry.format.trim().length > 0 ? entry.format.trim().toUpperCase() : undefined;
             const fileEntries = entry.files && typeof entry.files === 'object' && !Array.isArray(entry.files)
                 ? entry.files
                 : null;
+            const generatedModel3DFormat = inferGeneratedModel3DFormat(category, subcategory, format, fileEntries);
+            const generatedModel3DRoles = generatedModel3DFormat ? getGeneratedModel3DFileRoles(generatedModel3DFormat) : null;
             if (!fileEntries || Object.keys(fileEntries).length === 0) {
                 errors.push(`[${label}] Asset "${name}" must define files.`);
                 continue;
@@ -881,7 +1004,14 @@ function buildAssetTasks(catalogues) {
                 }
                 const relativePath = value.trim();
                 const absolutePath = (0, node_path_1.resolve)(file.directory, relativePath);
+                const normalizedRole = normalizeFileRole(role);
+                const allowMissingGenerated = Boolean(generatedModel3DRoles?.generated.has(normalizedRole));
                 if (!(0, node_fs_1.existsSync)(absolutePath) || !(0, node_fs_1.statSync)(absolutePath).isFile()) {
+                    if (allowMissingGenerated) {
+                        files[role] = relativePath.replace(/\\/g, '/');
+                        filePaths[role] = absolutePath;
+                        continue;
+                    }
                     errors.push(`[${label}] Asset "${name}" file not found at ${absolutePath}.`);
                     hasError = true;
                     continue;
@@ -892,6 +1022,14 @@ function buildAssetTasks(catalogues) {
             if (hasError) {
                 continue;
             }
+            if (generatedModel3DRoles) {
+                const normalizedRoles = new Set(Object.keys(files).map((role) => normalizeFileRole(role)));
+                const missingRoles = generatedModel3DRoles.required.filter((role) => !normalizedRoles.has(role));
+                if (missingRoles.length > 0) {
+                    errors.push(`[${label}] Asset "${name}" with subcategory=${subcategory} must define files.${missingRoles.join(' and files.')}.`);
+                    continue;
+                }
+            }
             if (category === 'SPRITESHEET') {
                 const hasAtlas = Object.prototype.hasOwnProperty.call(files, 'atlas');
                 const hasManifest = Object.prototype.hasOwnProperty.call(files, 'manifest');
@@ -927,10 +1065,10 @@ function buildAssetTasks(catalogues) {
                 category,
                 subcategory,
                 username,
-                format: typeof entry.format === 'string' && entry.format.trim().length > 0 ? entry.format.trim().toUpperCase() : undefined,
+                format,
                 visibility: normalizeAssetVisibilityValue(entry.visibility, errors, `${label} asset \"${name}\"`),
                 shopListed: typeof entry.shopListed === 'boolean' ? entry.shopListed : undefined,
-                shopPriceCoins: Number.isInteger(entry.shopPriceCoins) ? Number(entry.shopPriceCoins) : undefined,
+                shopPriceCredits: Number.isInteger(entry.shopPriceCredits) ? Number(entry.shopPriceCredits) : undefined,
                 files,
                 filePaths,
                 relations,
@@ -1006,84 +1144,136 @@ function buildAssetPackTasks(catalogues) {
                     videoLandscapePaths: [],
                 };
                 if (typeof rawListing.icon === 'string' && rawListing.icon.trim()) {
-                    const validationError = validateListingAssetPath(file.directory, rawListing.icon.trim(), 'assetPacks.listing.icon');
-                    if (validationError) {
-                        errors.push(`[${label}] Skipping asset pack "${name}": ${validationError}`);
+                    const iconPath = rawListing.icon.trim();
+                    const extensionError = validateListingAssetExtension(iconPath, 'assetPacks.listing.icon', 'image');
+                    if (extensionError) {
+                        errors.push(`[${label}] Skipping asset pack "${name}": ${extensionError}`);
                         listingValidationFailed = true;
                     }
                     else {
-                        resolvedListing.iconPath = resolveListingAssetPath(file.directory, rawListing.icon.trim());
+                        const validationError = validateListingAssetPath(file.directory, iconPath, 'assetPacks.listing.icon');
+                        if (validationError) {
+                            errors.push(`[${label}] Skipping asset pack "${name}": ${validationError}`);
+                            listingValidationFailed = true;
+                        }
+                        else {
+                            resolvedListing.iconPath = resolveListingAssetPath(file.directory, iconPath);
+                        }
                     }
                 }
                 if (!listingValidationFailed && typeof rawListing.heroPortrait === 'string' && rawListing.heroPortrait.trim()) {
-                    const validationError = validateListingAssetPath(file.directory, rawListing.heroPortrait.trim(), 'assetPacks.listing.heroPortrait');
-                    if (validationError) {
-                        errors.push(`[${label}] Skipping asset pack "${name}": ${validationError}`);
+                    const heroPortraitPath = rawListing.heroPortrait.trim();
+                    const extensionError = validateListingAssetExtension(heroPortraitPath, 'assetPacks.listing.heroPortrait', 'image');
+                    if (extensionError) {
+                        errors.push(`[${label}] Skipping asset pack "${name}": ${extensionError}`);
                         listingValidationFailed = true;
                     }
                     else {
-                        resolvedListing.heroPortraitPath = resolveListingAssetPath(file.directory, rawListing.heroPortrait.trim());
+                        const validationError = validateListingAssetPath(file.directory, heroPortraitPath, 'assetPacks.listing.heroPortrait');
+                        if (validationError) {
+                            errors.push(`[${label}] Skipping asset pack "${name}": ${validationError}`);
+                            listingValidationFailed = true;
+                        }
+                        else {
+                            resolvedListing.heroPortraitPath = resolveListingAssetPath(file.directory, heroPortraitPath);
+                        }
                     }
                 }
                 if (!listingValidationFailed && typeof rawListing.heroLandscape === 'string' && rawListing.heroLandscape.trim()) {
-                    const validationError = validateListingAssetPath(file.directory, rawListing.heroLandscape.trim(), 'assetPacks.listing.heroLandscape');
-                    if (validationError) {
-                        errors.push(`[${label}] Skipping asset pack "${name}": ${validationError}`);
+                    const heroLandscapePath = rawListing.heroLandscape.trim();
+                    const extensionError = validateListingAssetExtension(heroLandscapePath, 'assetPacks.listing.heroLandscape', 'image');
+                    if (extensionError) {
+                        errors.push(`[${label}] Skipping asset pack "${name}": ${extensionError}`);
                         listingValidationFailed = true;
                     }
                     else {
-                        resolvedListing.heroLandscapePath = resolveListingAssetPath(file.directory, rawListing.heroLandscape.trim());
+                        const validationError = validateListingAssetPath(file.directory, heroLandscapePath, 'assetPacks.listing.heroLandscape');
+                        if (validationError) {
+                            errors.push(`[${label}] Skipping asset pack "${name}": ${validationError}`);
+                            listingValidationFailed = true;
+                        }
+                        else {
+                            resolvedListing.heroLandscapePath = resolveListingAssetPath(file.directory, heroLandscapePath);
+                        }
                     }
                 }
                 if (!listingValidationFailed && Array.isArray(rawListing.screenshotsPortrait)) {
                     for (const p of rawListing.screenshotsPortrait) {
                         if (typeof p === 'string' && p.trim()) {
-                            const validationError = validateListingAssetPath(file.directory, p.trim(), 'assetPacks.listing.screenshotsPortrait item');
+                            const screenshotPath = p.trim();
+                            const extensionError = validateListingAssetExtension(screenshotPath, 'assetPacks.listing.screenshotsPortrait item', 'image');
+                            if (extensionError) {
+                                errors.push(`[${label}] Skipping asset pack "${name}": ${extensionError}`);
+                                listingValidationFailed = true;
+                                break;
+                            }
+                            const validationError = validateListingAssetPath(file.directory, screenshotPath, 'assetPacks.listing.screenshotsPortrait item');
                             if (validationError) {
                                 errors.push(`[${label}] Skipping asset pack "${name}": ${validationError}`);
                                 listingValidationFailed = true;
                                 break;
                             }
-                            resolvedListing.screenshotPortraitPaths.push(resolveListingAssetPath(file.directory, p.trim()));
+                            resolvedListing.screenshotPortraitPaths.push(resolveListingAssetPath(file.directory, screenshotPath));
                         }
                     }
                 }
                 if (!listingValidationFailed && Array.isArray(rawListing.screenshotsLandscape)) {
                     for (const p of rawListing.screenshotsLandscape) {
                         if (typeof p === 'string' && p.trim()) {
-                            const validationError = validateListingAssetPath(file.directory, p.trim(), 'assetPacks.listing.screenshotsLandscape item');
+                            const screenshotPath = p.trim();
+                            const extensionError = validateListingAssetExtension(screenshotPath, 'assetPacks.listing.screenshotsLandscape item', 'image');
+                            if (extensionError) {
+                                errors.push(`[${label}] Skipping asset pack "${name}": ${extensionError}`);
+                                listingValidationFailed = true;
+                                break;
+                            }
+                            const validationError = validateListingAssetPath(file.directory, screenshotPath, 'assetPacks.listing.screenshotsLandscape item');
                             if (validationError) {
                                 errors.push(`[${label}] Skipping asset pack "${name}": ${validationError}`);
                                 listingValidationFailed = true;
                                 break;
                             }
-                            resolvedListing.screenshotLandscapePaths.push(resolveListingAssetPath(file.directory, p.trim()));
+                            resolvedListing.screenshotLandscapePaths.push(resolveListingAssetPath(file.directory, screenshotPath));
                         }
                     }
                 }
                 if (!listingValidationFailed && Array.isArray(rawListing.videosPortrait)) {
                     for (const p of rawListing.videosPortrait) {
                         if (typeof p === 'string' && p.trim()) {
-                            const validationError = validateListingAssetPath(file.directory, p.trim(), 'assetPacks.listing.videosPortrait item');
+                            const videoPath = p.trim();
+                            const extensionError = validateListingAssetExtension(videoPath, 'assetPacks.listing.videosPortrait item', 'video');
+                            if (extensionError) {
+                                errors.push(`[${label}] Skipping asset pack "${name}": ${extensionError}`);
+                                listingValidationFailed = true;
+                                break;
+                            }
+                            const validationError = validateListingAssetPath(file.directory, videoPath, 'assetPacks.listing.videosPortrait item');
                             if (validationError) {
                                 errors.push(`[${label}] Skipping asset pack "${name}": ${validationError}`);
                                 listingValidationFailed = true;
                                 break;
                             }
-                            resolvedListing.videoPortraitPaths.push(resolveListingAssetPath(file.directory, p.trim()));
+                            resolvedListing.videoPortraitPaths.push(resolveListingAssetPath(file.directory, videoPath));
                         }
                     }
                 }
                 if (!listingValidationFailed && Array.isArray(rawListing.videosLandscape)) {
                     for (const p of rawListing.videosLandscape) {
                         if (typeof p === 'string' && p.trim()) {
-                            const validationError = validateListingAssetPath(file.directory, p.trim(), 'assetPacks.listing.videosLandscape item');
+                            const videoPath = p.trim();
+                            const extensionError = validateListingAssetExtension(videoPath, 'assetPacks.listing.videosLandscape item', 'video');
+                            if (extensionError) {
+                                errors.push(`[${label}] Skipping asset pack "${name}": ${extensionError}`);
+                                listingValidationFailed = true;
+                                break;
+                            }
+                            const validationError = validateListingAssetPath(file.directory, videoPath, 'assetPacks.listing.videosLandscape item');
                             if (validationError) {
                                 errors.push(`[${label}] Skipping asset pack "${name}": ${validationError}`);
                                 listingValidationFailed = true;
                                 break;
                             }
-                            resolvedListing.videoLandscapePaths.push(resolveListingAssetPath(file.directory, p.trim()));
+                            resolvedListing.videoLandscapePaths.push(resolveListingAssetPath(file.directory, videoPath));
                         }
                     }
                 }

package/dist/commands/build.js

@@ -5,6 +5,7 @@ const taskSelection_1 = require("../taskSelection");
 const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
 const apps_1 = require("../apps");
+const model_artifacts_1 = require("../assets/model-artifacts");
 async function build(pathOrName) {
     const selection = (0, taskSelection_1.selectTasks)(pathOrName);
     if (selection.errors.length > 0) {
@@ -22,18 +23,30 @@ async function build(pathOrName) {
     for (const task of (0, taskUtils_1.sortTasks)(tasks)) {
         const entityId = task.name;
         try {
+            let skipped = false;
+            let detail;
             if (task.kind === 'app') {
                 await (0, apps_1.validateAppTask)(task);
                 await (0, apps_1.buildApp)(task);
             }
-            const skipped = task.kind !== 'app';
+            else if (task.kind === 'asset' || task.kind === 'embedded-asset') {
+                const generated = await (0, model_artifacts_1.prepareModel3DAssetArtifacts)(task);
+                if (!generated) {
+                    skipped = true;
+                    detail = `no build step for ${task.kind}`;
+                }
+            }
+            else {
+                skipped = true;
+                detail = `no build step for ${task.kind}`;
+            }
             const entry = {
                 action: 'build',
                 status: skipped ? 'skipped' : 'success',
                 entityType: task.kind,
                 entityId,
                 catalogue: task.cataloguePath,
-                detail: skipped ? `no build step for ${task.kind}` : undefined,
+                detail,
             };
             results.push(entry);
             console.log((0, uploadLog_1.formatTaskLogLine)(entry));

package/dist/commands/dev.js

@@ -260,8 +260,10 @@ async function dev(targetArg, _port, appOption) {
     });
     const webUrl = envConfig.webBase;
     const entryLabel = (0, node_path_1.relative)(process.cwd(), filePath) || filePath;
+    const runtimeRootLabel = (0, node_path_1.relative)(process.cwd(), (0, node_path_1.dirname)(filePath)) || (0, node_path_1.dirname)(filePath);
     console.log(`🚀 App dev server running at http://localhost:${portToUse}`);
     console.log(`Serving ${entryLabel}`);
+    console.log(`Static root ${runtimeRootLabel}`);
     if (projectInfo.projectDir && !devScriptAvailable && projectInfo.packageJsonPath) {
         const projectLabel = (0, devShared_1.formatProjectLabel)(projectInfo);
         if (projectLabel) {