@playdrop/playdrop-cli 0.5.1 → 0.5.3

package/dist/catalogue.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateAppMetadata = validateAppMetadata;
+exports.resolveCatalogueTagGroups = resolveCatalogueTagGroups;
 exports.resolveCatalogueEntries = resolveCatalogueEntries;
 exports.resolveWorkspaceApp = resolveWorkspaceApp;
 exports.formatMetadataWarnings = formatMetadataWarnings;
@@ -10,6 +11,7 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const types_1 = require("@playdrop/types");
 const catalogue_utils_1 = require("./catalogue-utils");
+const assetSpecs_1 = require("./assetSpecs");
 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 LEGACY_CATALOGUE_VERSION_KEY = ['schema', 'Version'].join('');
@@ -20,6 +22,7 @@ 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 MAX_CONTENT_TAGS_PER_ITEM = 8;
 const ASSET_SUBCATEGORY_SET_BY_CATEGORY = types_1.ASSET_SUBCATEGORY_DEFINITIONS.reduce((acc, definition) => {
     if (!acc[definition.category]) {
         acc[definition.category] = new Set();
@@ -165,6 +168,69 @@ function rejectLegacyShopPriceCoinsField(value, errors, context) {
     }
     return false;
 }
+function normalizeCatalogueTags(value, errors, context) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        errors.push(`${context} tags must be an array of canonical tag refs.`);
+        return [];
+    }
+    const normalizedRefs = [];
+    const seenRefs = new Set();
+    for (let index = 0; index < value.length; index += 1) {
+        const entry = value[index];
+        if (typeof entry !== 'string' || entry.trim().length === 0) {
+            errors.push(`${context} tags[${index}] must be a non-empty canonical tag ref string.`);
+            continue;
+        }
+        let normalizedRef = '';
+        try {
+            normalizedRef = (0, types_1.normalizeTagRef)(entry);
+        }
+        catch {
+            errors.push(`${context} tags[${index}] must use group-slug/tag-slug format.`);
+            continue;
+        }
+        if (seenRefs.has(normalizedRef)) {
+            errors.push(`${context} tags contains duplicate ref "${normalizedRef}".`);
+            continue;
+        }
+        seenRefs.add(normalizedRef);
+        normalizedRefs.push(normalizedRef);
+    }
+    if (normalizedRefs.length > MAX_CONTENT_TAGS_PER_ITEM) {
+        errors.push(`${context} tags supports at most ${MAX_CONTENT_TAGS_PER_ITEM} refs.`);
+    }
+    return normalizedRefs;
+}
+function normalizeCatalogueAllowedTargetKinds(value, errors, context) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        errors.push(`${context} allowedTargetKinds must be an array of saved item kinds.`);
+        return undefined;
+    }
+    const normalizedKinds = [];
+    const seenKinds = new Set();
+    for (let index = 0; index < value.length; index += 1) {
+        const entry = value[index];
+        const normalizedKind = typeof entry === 'string' ? entry.trim().toUpperCase() : '';
+        if (!types_1.SAVED_ITEM_KIND_VALUES.includes(normalizedKind)) {
+            errors.push(`${context} allowedTargetKinds[${index}] must be one of ${types_1.SAVED_ITEM_KIND_VALUES.join(', ')}.`);
+            continue;
+        }
+        const savedItemKind = normalizedKind;
+        if (seenKinds.has(savedItemKind)) {
+            errors.push(`${context} allowedTargetKinds contains duplicate value "${savedItemKind}".`);
+            continue;
+        }
+        seenKinds.add(savedItemKind);
+        normalizedKinds.push(savedItemKind);
+    }
+    return normalizedKinds;
+}
 function normalizeRelativePath(root, target) {
     const rel = (0, node_path_1.relative)(root, target).split(node_path_1.sep).join('/');
     return rel.replace(/^\/+/, '');
@@ -206,7 +272,7 @@ function readCatalogueFile(rootDir, filePath) {
                 return { error: `catalogue.json forbids top-level "${key}"` };
             }
         }
-        const allowedKeys = new Set(['apps', 'assets', 'assetPacks']);
+        const allowedKeys = new Set(['apps', 'tagGroups', 'assetSpecs', 'assets', 'assetPacks']);
         const unknownKeys = Object.keys(parsed).filter((key) => !allowedKeys.has(key));
         if (unknownKeys.length > 0) {
             return {
@@ -752,6 +818,7 @@ function buildAppTasks(rootDir, catalogues, options) {
             const errorCountBeforePlayerMeta = errors.length;
             const achievements = validateAchievementDefinitions(entry.achievements, file.directory, errors);
             const leaderboards = validateLeaderboardDefinitions(entry.leaderboards, errors);
+            const assetSpecSupport = (0, assetSpecs_1.normalizeAssetSpecSupportEntries)(entry.assetSpecSupport, errors, `[${label}] App "${rawName}"`);
             if (errors.length > errorCountBeforePlayerMeta) {
                 continue;
             }
@@ -1044,8 +1111,13 @@ function buildAppTasks(rootDir, catalogues, options) {
             const usesPacks = Array.isArray(entry.uses?.packs)
                 ? entry.uses.packs.filter((value) => typeof value === 'string' && value.trim().length > 0)
                 : [];
+            const errorCountBeforeTagMetadata = errors.length;
             const remix = normalizeCatalogueRemixRef(entry.remix, 'app', errors, `[${label}] App "${rawName}"`);
+            const tags = normalizeCatalogueTags(entry.tags, errors, `[${label}] App "${rawName}"`);
             const graphRelations = normalizeCatalogueRelations(entry.relations, errors, `[${label}] App "${rawName}"`) ?? [];
+            if (errors.length > errorCountBeforeTagMetadata) {
+                continue;
+            }
             const embeddedAssets = [];
             const rawEmbeddedAssets = Array.isArray(entry.embeddedAssets)
                 ? entry.embeddedAssets
@@ -1173,6 +1245,7 @@ function buildAppTasks(rootDir, catalogues, options) {
                 version,
                 releaseNotes,
                 versionVisibility,
+                tags,
                 hostingMode,
                 authMode,
                 controllerMode,
@@ -1185,6 +1258,7 @@ function buildAppTasks(rootDir, catalogues, options) {
                 leaderboards,
                 remix,
                 embeddedAssets,
+                assetSpecSupport,
                 uses: {
                     assets: usesAssets,
                     packs: usesPacks,
@@ -1197,7 +1271,126 @@ function buildAppTasks(rootDir, catalogues, options) {
     }
     return { tasks, warnings, errors };
 }
-function buildAssetTasks(catalogues) {
+function buildAssetSpecTasks(catalogues) {
+    const tasks = [];
+    const warnings = [];
+    const errors = [];
+    const seen = new Map();
+    for (const file of catalogues) {
+        const label = file.relativePath || 'catalogue.json';
+        const rawAssetSpecs = Array.isArray(file.data.assetSpecs) ? file.data.assetSpecs : [];
+        for (let index = 0; index < rawAssetSpecs.length; index += 1) {
+            const entry = rawAssetSpecs[index];
+            if (!entry || typeof entry !== 'object') {
+                errors.push(`[${label}] Invalid assetSpecs[${index}] entry; expected object.`);
+                continue;
+            }
+            const name = typeof entry.name === 'string' ? entry.name.trim() : '';
+            if (!name) {
+                errors.push(`[${label}] assetSpecs[${index}] is missing a name.`);
+                continue;
+            }
+            if (!(0, assetSpecs_1.validateAssetSpecName)(name, errors, `[${label}] Asset spec "${name}"`)) {
+                continue;
+            }
+            const version = typeof entry.version === 'string' ? entry.version.trim() : '';
+            if (!SEMVER_REGEX.test(version)) {
+                errors.push(`[${label}] Asset spec "${name}" must define a semver version.`);
+                continue;
+            }
+            const dedupeKey = `${label}::${name}::${version}`;
+            if (seen.has(dedupeKey)) {
+                errors.push(`[${label}] Duplicate asset spec "${name}@${version}" in same catalogue.`);
+                continue;
+            }
+            seen.set(dedupeKey, label);
+            const displayName = typeof entry.displayName === 'string' ? entry.displayName.trim() : '';
+            if (!displayName) {
+                errors.push(`[${label}] Asset spec "${name}@${version}" must define displayName.`);
+                continue;
+            }
+            const symbol = typeof entry.symbol === 'string' ? entry.symbol.trim() : '';
+            if (!symbol) {
+                errors.push(`[${label}] Asset spec "${name}@${version}" must define symbol.`);
+                continue;
+            }
+            const symbolPath = (0, node_path_1.resolve)(file.directory, symbol);
+            if (!(0, node_fs_1.existsSync)(symbolPath) || !(0, node_fs_1.statSync)(symbolPath).isFile()) {
+                errors.push(`[${label}] Asset spec "${name}@${version}" symbol file not found at ${symbolPath}.`);
+                continue;
+            }
+            const contractField = typeof entry.contract === 'string' ? entry.contract.trim() : '';
+            if (!contractField) {
+                errors.push(`[${label}] Asset spec "${name}@${version}" must define contract.`);
+                continue;
+            }
+            const loadedContract = (0, assetSpecs_1.loadAndValidateAssetSpecContract)(file.directory, contractField, errors, `[${label}] Asset spec "${name}@${version}"`);
+            if (!loadedContract) {
+                continue;
+            }
+            let validationKind = loadedContract.validationKind;
+            if (typeof entry.validationKind === 'string' && entry.validationKind.trim().length > 0) {
+                const normalizedValidationKind = entry.validationKind.trim().toUpperCase();
+                if (!types_1.ASSET_SPEC_VALIDATION_KIND_VALUES.includes(normalizedValidationKind)) {
+                    errors.push(`[${label}] Asset spec "${name}@${version}" validationKind must be one of ${types_1.ASSET_SPEC_VALIDATION_KIND_VALUES.join(', ')}.`);
+                    continue;
+                }
+                if (normalizedValidationKind !== loadedContract.validationKind) {
+                    errors.push(`[${label}] Asset spec "${name}@${version}" validationKind must match the contract content (${loadedContract.validationKind}).`);
+                    continue;
+                }
+                validationKind = normalizedValidationKind;
+            }
+            let status = 'ACTIVE';
+            if (typeof entry.status === 'string' && entry.status.trim().length > 0) {
+                const normalizedStatus = entry.status.trim().toUpperCase();
+                if (!types_1.ASSET_SPEC_STATUS_VALUES.includes(normalizedStatus)) {
+                    errors.push(`[${label}] Asset spec "${name}@${version}" status must be one of ${types_1.ASSET_SPEC_STATUS_VALUES.join(', ')}.`);
+                    continue;
+                }
+                status = normalizedStatus;
+            }
+            const visibility = normalizeAssetVisibilityValue(entry.visibility, errors, `${label} asset spec "${name}@${version}"`);
+            const successorVersion = typeof entry.successorVersion === 'string' && entry.successorVersion.trim().length > 0
+                ? entry.successorVersion.trim()
+                : undefined;
+            if (successorVersion && !SEMVER_REGEX.test(successorVersion)) {
+                errors.push(`[${label}] Asset spec "${name}@${version}" successorVersion must be a semver string.`);
+                continue;
+            }
+            const documentationField = typeof entry.documentation === 'string' && entry.documentation.trim().length > 0
+                ? entry.documentation.trim()
+                : undefined;
+            const documentationPath = documentationField ? (0, node_path_1.resolve)(file.directory, documentationField) : undefined;
+            if (documentationPath && (!(0, node_fs_1.existsSync)(documentationPath) || !(0, node_fs_1.statSync)(documentationPath).isFile())) {
+                errors.push(`[${label}] Asset spec "${name}@${version}" documentation file not found at ${documentationPath}.`);
+                continue;
+            }
+            tasks.push({
+                kind: 'asset-spec',
+                name,
+                version,
+                displayName,
+                description: typeof entry.description === 'string' ? entry.description.trim() || undefined : undefined,
+                cataloguePath: label,
+                catalogueAbsolutePath: file.absolutePath,
+                catalogueDir: file.directory,
+                username: typeof entry.username === 'string' && entry.username.trim().length > 0 ? entry.username.trim() : undefined,
+                visibility,
+                validationKind,
+                status,
+                releaseNotes: typeof entry.releaseNotes === 'string' ? entry.releaseNotes : undefined,
+                successorVersion,
+                symbolPath,
+                contractPath: loadedContract.contractPath,
+                documentationPath,
+                contract: loadedContract.contract,
+            });
+        }
+    }
+    return { tasks, warnings, errors };
+}
+function buildAssetTasks(catalogues, _assetSpecTasks) {
     const tasks = [];
     const warnings = [];
     const errors = [];
@@ -1228,19 +1421,35 @@ function buildAssetTasks(catalogues) {
                 continue;
             }
             seen.set(dedupeKey, label);
-            const category = normalizeAssetCategoryValue(entry.category, errors, `[${label}] Asset "${name}"`);
-            if (!category) {
-                continue;
+            const assetSpec = (0, assetSpecs_1.normalizeAssetSpecVersionRef)(entry.assetSpec, errors, `[${label}] Asset "${name}"`);
+            const isCustomAsset = typeof assetSpec === 'string';
+            let category;
+            let subcategory;
+            let format;
+            if (isCustomAsset) {
+                if (entry.category !== undefined || entry.subcategory !== undefined || entry.format !== undefined) {
+                    errors.push(`[${label}] Asset "${name}" must not define category, subcategory, or format when assetSpec is set.`);
+                    continue;
+                }
+                subcategory = null;
             }
-            const subcategory = normalizeAssetSubcategoryValue(entry.subcategory, category, errors, `[${label}] Asset "${name}"`);
-            if (!subcategory) {
-                continue;
+            else {
+                category = normalizeAssetCategoryValue(entry.category, errors, `[${label}] Asset "${name}"`) ?? undefined;
+                if (!category) {
+                    continue;
+                }
+                subcategory = normalizeAssetSubcategoryValue(entry.subcategory, category, errors, `[${label}] Asset "${name}"`);
+                if (!subcategory) {
+                    continue;
+                }
+                format = typeof entry.format === 'string' && entry.format.trim().length > 0 ? entry.format.trim().toUpperCase() : undefined;
             }
-            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 generatedModel3DFormat = !isCustomAsset && category && subcategory
+                ? inferGeneratedModel3DFormat(category, subcategory, format, fileEntries)
+                : null;
             const generatedModel3DRoles = generatedModel3DFormat ? getGeneratedModel3DFileRoles(generatedModel3DFormat) : null;
             if (!fileEntries || Object.keys(fileEntries).length === 0) {
                 errors.push(`[${label}] Asset "${name}" must define files.`);
@@ -1275,7 +1484,7 @@ function buildAssetTasks(catalogues) {
             if (hasError) {
                 continue;
             }
-            if (generatedModel3DRoles) {
+            if (!isCustomAsset && 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) {
@@ -1283,7 +1492,7 @@ function buildAssetTasks(catalogues) {
                     continue;
                 }
             }
-            if (category === 'SPRITESHEET') {
+            if (!isCustomAsset && category === 'SPRITESHEET') {
                 const hasAtlas = Object.prototype.hasOwnProperty.call(files, 'atlas');
                 const hasManifest = Object.prototype.hasOwnProperty.call(files, 'manifest');
                 if (!hasAtlas || !hasManifest) {
@@ -1291,15 +1500,20 @@ function buildAssetTasks(catalogues) {
                     continue;
                 }
             }
-            if (category === 'AUDIO') {
+            if (!isCustomAsset && category === 'AUDIO') {
                 const hasPrimary = Object.prototype.hasOwnProperty.call(files, 'primary');
                 if (!hasPrimary) {
                     errors.push(`[${label}] Asset "${name}" with category=AUDIO must define files.primary.`);
                     continue;
                 }
             }
+            const errorCountBeforeTagMetadata = errors.length;
             const remix = normalizeCatalogueRemixRef(entry.remix, 'asset', errors, `[${label}] Asset "${name}"`);
+            const tags = normalizeCatalogueTags(entry.tags, errors, `[${label}] Asset "${name}"`);
             const relations = normalizeCatalogueRelations(entry.relations, errors, `[${label}] Asset "${name}"`);
+            if (errors.length > errorCountBeforeTagMetadata) {
+                continue;
+            }
             const username = typeof entry.username === 'string' && entry.username.trim().length > 0
                 ? entry.username.trim()
                 : undefined;
@@ -1313,10 +1527,12 @@ function buildAssetTasks(catalogues) {
                 cataloguePath: label,
                 category,
                 subcategory,
+                assetSpec,
                 username,
                 remix,
                 format,
                 visibility: normalizeAssetVisibilityValue(entry.visibility, errors, `${label} asset "${name}"`),
+                tags,
                 shopListed: typeof entry.shopListed === 'boolean' ? entry.shopListed : undefined,
                 shopPriceCredits: Number.isInteger(entry.shopPriceCredits) ? Number(entry.shopPriceCredits) : undefined,
                 files,
@@ -1399,8 +1615,13 @@ function buildAssetPackTasks(catalogues) {
                 errors.push(`[${label}] Asset pack "${name}" must reference at least one asset.`);
                 continue;
             }
+            const errorCountBeforeTagMetadata = errors.length;
             const remix = normalizeCatalogueRemixRef(entry.remix, 'pack', errors, `[${label}] Asset pack "${name}@${version}"`);
+            const tags = normalizeCatalogueTags(entry.tags, errors, `[${label}] Asset pack "${name}@${version}"`);
             const relations = normalizeCatalogueRelations(entry.relations, errors, `[${label}] Asset pack "${name}@${version}"`);
+            if (errors.length > errorCountBeforeTagMetadata) {
+                continue;
+            }
             const username = typeof entry.username === 'string' && entry.username.trim().length > 0
                 ? entry.username.trim()
                 : undefined;
@@ -1581,6 +1802,7 @@ function buildAssetPackTasks(catalogues) {
                 downloadUrl,
                 visibility,
                 releaseNotes: typeof entry.releaseNotes === 'string' ? entry.releaseNotes : undefined,
+                tags,
                 listing,
                 relations,
             });
@@ -1588,11 +1810,112 @@ function buildAssetPackTasks(catalogues) {
     }
     return { tasks, warnings, errors };
 }
+// eslint-disable-next-line complexity
+function resolveCatalogueTagGroups(rootDir) {
+    const { files, errors: discoveryErrors } = walkCatalogueTree(rootDir);
+    if (discoveryErrors.length > 0) {
+        return {
+            groups: [],
+            errors: discoveryErrors,
+        };
+    }
+    const rootCatalogue = files.find((file) => file.relativePath === 'catalogue.json');
+    const hasNestedCatalogues = files.some((file) => file.relativePath !== 'catalogue.json');
+    if (rootCatalogue && hasNestedCatalogues && !isCatalogueMarker(rootCatalogue)) {
+        return {
+            groups: [],
+            errors: [
+                '[catalogue.json] Workspace root catalogue.json must be {} when nested catalogue.json files exist below it.',
+            ],
+        };
+    }
+    const groups = [];
+    const errors = [];
+    const seenGroupSlugs = new Set();
+    for (const file of files) {
+        const label = file.relativePath || 'catalogue.json';
+        const rawGroups = Array.isArray(file.data.tagGroups) ? file.data.tagGroups : [];
+        for (let index = 0; index < rawGroups.length; index += 1) {
+            const entry = rawGroups[index];
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+                errors.push(`[${label}] tagGroups[${index}] must be an object.`);
+                continue;
+            }
+            const slug = typeof entry.slug === 'string' ? entry.slug.trim().toLowerCase() : '';
+            if (!slug || !(0, types_1.isValidTagSlug)(slug)) {
+                errors.push(`[${label}] tagGroups[${index}] slug must use lowercase slug format.`);
+                continue;
+            }
+            if (seenGroupSlugs.has(slug)) {
+                errors.push(`[${label}] Duplicate tag group slug "${slug}".`);
+                continue;
+            }
+            const displayName = typeof entry.displayName === 'string' ? entry.displayName.trim() : '';
+            if (!displayName) {
+                errors.push(`[${label}] tagGroups[${index}] displayName must be a non-empty string.`);
+                continue;
+            }
+            const errorCountBeforeGroup = errors.length;
+            const allowedTargetKinds = normalizeCatalogueAllowedTargetKinds(entry.allowedTargetKinds, errors, `[${label}] Tag group "${slug}"`);
+            if (!Array.isArray(entry.tags)) {
+                errors.push(`[${label}] Tag group "${slug}" must define a tags array.`);
+                continue;
+            }
+            const tags = [];
+            const seenTagSlugs = new Set();
+            for (let tagIndex = 0; tagIndex < entry.tags.length; tagIndex += 1) {
+                const rawTag = entry.tags[tagIndex];
+                if (!rawTag || typeof rawTag !== 'object' || Array.isArray(rawTag)) {
+                    errors.push(`[${label}] Tag group "${slug}" tags[${tagIndex}] must be an object.`);
+                    continue;
+                }
+                const tagSlug = typeof rawTag.slug === 'string' ? rawTag.slug.trim().toLowerCase() : '';
+                if (!tagSlug || !(0, types_1.isValidTagSlug)(tagSlug)) {
+                    errors.push(`[${label}] Tag group "${slug}" tags[${tagIndex}] slug must use lowercase slug format.`);
+                    continue;
+                }
+                if (seenTagSlugs.has(tagSlug)) {
+                    errors.push(`[${label}] Tag group "${slug}" contains duplicate tag slug "${tagSlug}".`);
+                    continue;
+                }
+                const tagDisplayName = typeof rawTag.displayName === 'string' ? rawTag.displayName.trim() : '';
+                if (!tagDisplayName) {
+                    errors.push(`[${label}] Tag group "${slug}" tag "${tagSlug}" displayName must be a non-empty string.`);
+                    continue;
+                }
+                seenTagSlugs.add(tagSlug);
+                tags.push({
+                    slug: tagSlug,
+                    displayName: tagDisplayName,
+                });
+            }
+            if (tags.length === 0) {
+                errors.push(`[${label}] Tag group "${slug}" must define at least one tag.`);
+                continue;
+            }
+            if (errors.length > errorCountBeforeGroup) {
+                continue;
+            }
+            seenGroupSlugs.add(slug);
+            groups.push({
+                slug,
+                displayName,
+                ...(allowedTargetKinds ? { allowedTargetKinds } : {}),
+                tags,
+            });
+        }
+    }
+    return {
+        groups,
+        errors,
+    };
+}
 function resolveCatalogueEntries(rootDir, options = {}) {
     const { files, errors: discoveryErrors } = walkCatalogueTree(rootDir);
     if (discoveryErrors.length > 0) {
         return {
             apps: [],
+            assetSpecs: [],
             assets: [],
             embeddedAssets: [],
             assetPacks: [],
@@ -1605,6 +1928,7 @@ function resolveCatalogueEntries(rootDir, options = {}) {
     if (rootCatalogue && hasNestedCatalogues && !isCatalogueMarker(rootCatalogue)) {
         return {
             apps: [],
+            assetSpecs: [],
             assets: [],
             embeddedAssets: [],
             assetPacks: [],
@@ -1615,13 +1939,15 @@ function resolveCatalogueEntries(rootDir, options = {}) {
         };
     }
     const { tasks: appTasks, warnings: appWarnings, errors: appErrors } = buildAppTasks(rootDir, files, options);
-    const { tasks: assetTasks, warnings: assetWarnings, errors: assetErrors } = buildAssetTasks(files);
+    const { tasks: assetSpecTasks, warnings: assetSpecWarnings, errors: assetSpecErrors } = buildAssetSpecTasks(files);
+    const { tasks: assetTasks, warnings: assetWarnings, errors: assetErrors } = buildAssetTasks(files, assetSpecTasks);
     const { tasks: assetPackTasks, warnings: assetPackWarnings, errors: assetPackErrors } = buildAssetPackTasks(files);
     const embeddedAssetTasks = appTasks.flatMap((task) => task.embeddedAssets);
-    const warnings = [...appWarnings, ...assetWarnings, ...assetPackWarnings];
-    const errors = [...appErrors, ...assetErrors, ...assetPackErrors];
+    const warnings = [...appWarnings, ...assetSpecWarnings, ...assetWarnings, ...assetPackWarnings];
+    const errors = [...appErrors, ...assetSpecErrors, ...assetErrors, ...assetPackErrors];
     return {
         apps: appTasks,
+        assetSpecs: assetSpecTasks,
         assets: assetTasks,
         embeddedAssets: embeddedAssetTasks,
         assetPacks: assetPackTasks,

package/dist/clientInfo.js

@@ -9,7 +9,23 @@ exports.getCliVersion = getCliVersion;
 exports.getCliBuild = getCliBuild;
 exports.getRuntimeInfo = getRuntimeInfo;
 const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
 const config_1 = require("@playdrop/config");
+let cachedCliPackageVersion = null;
+function readCliPackageVersion() {
+    if (cachedCliPackageVersion) {
+        return cachedCliPackageVersion;
+    }
+    const packageJsonPath = path_1.default.resolve(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, 'utf8'));
+    const version = typeof packageJson.version === 'string' ? packageJson.version.trim() : '';
+    if (!/^\d+\.\d+\.\d+$/.test(version)) {
+        throw new Error(`invalid_cli_package_version:${version}`);
+    }
+    cachedCliPackageVersion = version;
+    return version;
+}
 function mapPlatform(platform) {
     switch (platform) {
         case 'aix':
@@ -42,7 +58,7 @@ function detectPlatformVersion() {
 function buildRuntimeInfo() {
     return {
         client: 'cli',
-        clientVersion: (0, config_1.getClientVersion)(),
+        clientVersion: readCliPackageVersion(),
         clientBuild: (0, config_1.getClientBuild)(),
         platform: mapPlatform(os_1.default.platform()),
         platformVersion: detectPlatformVersion()
@@ -52,10 +68,10 @@ function createClientHeaders() {
     return (0, config_1.createClientHeaderRecord)(buildRuntimeInfo());
 }
 function getCliVersionLabel() {
-    return (0, config_1.getClientVersionLabel)();
+    return `${readCliPackageVersion()} (build ${(0, config_1.getClientBuild)()})`;
 }
 function getCliVersion() {
-    return (0, config_1.getClientVersion)();
+    return readCliPackageVersion();
 }
 function getCliBuild() {
     return (0, config_1.getClientBuild)();

package/dist/commands/ads.d.ts

@@ -0,0 +1,8 @@
+type AdsCommandOptions = {
+    app?: string;
+    days?: string | number;
+    json?: boolean;
+};
+export declare function showAdsEarnings(options?: AdsCommandOptions): Promise<void>;
+export declare function showAdsReport(options?: AdsCommandOptions): Promise<void>;
+export {};