@playdrop/playdrop-cli 0.5.5 → 0.5.6

package/dist/catalogue.js

@@ -22,7 +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 MAX_CONTENT_TAGS_PER_ITEM = 20;
 const ASSET_SUBCATEGORY_SET_BY_CATEGORY = types_1.ASSET_SUBCATEGORY_DEFINITIONS.reduce((acc, definition) => {
     if (!acc[definition.category]) {
         acc[definition.category] = new Set();
@@ -62,6 +62,66 @@ function getGeneratedModel3DFileRoles(format) {
         required: BOXEL_REQUIRED_FILE_ROLES,
     };
 }
+function extractGlbJsonChunk(buffer) {
+    if (buffer.length < 20) {
+        throw new Error('invalid_glb_payload');
+    }
+    if (buffer.toString('utf8', 0, 4) !== 'glTF') {
+        throw new Error('invalid_glb_payload');
+    }
+    const version = buffer.readUInt32LE(4);
+    const declaredLength = buffer.readUInt32LE(8);
+    if (version !== 2 || declaredLength !== buffer.length) {
+        throw new Error('invalid_glb_payload');
+    }
+    let offset = 12;
+    while (offset + 8 <= buffer.length) {
+        const chunkLength = buffer.readUInt32LE(offset);
+        const chunkType = buffer.readUInt32LE(offset + 4);
+        offset += 8;
+        if (offset + chunkLength > buffer.length) {
+            throw new Error('invalid_glb_payload');
+        }
+        const chunk = buffer.subarray(offset, offset + chunkLength);
+        offset += chunkLength;
+        if (chunkType !== 0x4E4F534A) {
+            continue;
+        }
+        const payload = chunk.toString('utf8').replace(/\0+$/, '').trimEnd();
+        try {
+            const parsed = JSON.parse(payload);
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                throw new Error('invalid_glb_payload');
+            }
+            return parsed;
+        }
+        catch {
+            throw new Error('invalid_glb_payload');
+        }
+    }
+    throw new Error('invalid_glb_payload');
+}
+function validateSelfContainedGlb(filePath) {
+    const gltf = extractGlbJsonChunk((0, node_fs_1.readFileSync)(filePath));
+    const buffers = Array.isArray(gltf.buffers) ? gltf.buffers : [];
+    for (const entry of buffers) {
+        const uri = entry && typeof entry === 'object' && typeof entry.uri === 'string'
+            ? entry.uri.trim()
+            : '';
+        if (uri && !uri.startsWith('data:')) {
+            throw new Error('glb_external_dependency_unsupported');
+        }
+    }
+    const images = Array.isArray(gltf.images) ? gltf.images : [];
+    for (const entry of images) {
+        const uri = entry && typeof entry === 'object' && typeof entry.uri === 'string'
+            ? entry.uri.trim()
+            : '';
+        if (uri && !uri.startsWith('data:')) {
+            throw new Error('glb_external_dependency_unsupported');
+        }
+    }
+}
 /**
  * Validates a listing asset path:
  * - Must exist
@@ -161,6 +221,52 @@ function normalizeCatalogueRelations(value, errors, context) {
     }
     return rows.length > 0 ? rows : undefined;
 }
+function normalizeCatalogueAppDependencyAssets(value, errors, context) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const rows = [];
+    const seenRefs = new Set();
+    const seenRuntimeKeys = new Set();
+    for (let index = 0; index < value.length; index += 1) {
+        const entry = value[index];
+        const ref = typeof entry === 'string'
+            ? entry.trim()
+            : entry && typeof entry === 'object' && !Array.isArray(entry) && typeof entry.ref === 'string'
+                ? entry.ref.trim()
+                : '';
+        if (!ref) {
+            errors.push(`${context} uses.assets[${index}] must be a non-empty asset ref string or { ref, runtimeKey } object.`);
+            continue;
+        }
+        const parsed = (0, types_1.parseContentVersionRef)(ref);
+        if (!parsed || parsed.kind !== 'asset') {
+            errors.push(`${context} uses.assets[${index}] must be a canonical asset version ref.`);
+            continue;
+        }
+        const normalizedRef = (0, types_1.formatContentVersionRef)(parsed);
+        if (seenRefs.has(normalizedRef)) {
+            errors.push(`${context} uses.assets contains duplicate ref "${normalizedRef}".`);
+            continue;
+        }
+        const runtimeKey = entry && typeof entry === 'object' && !Array.isArray(entry) && typeof entry.runtimeKey === 'string'
+            ? entry.runtimeKey.trim()
+            : '';
+        if (runtimeKey) {
+            if (seenRuntimeKeys.has(runtimeKey)) {
+                errors.push(`${context} uses.assets contains duplicate runtimeKey "${runtimeKey}".`);
+                continue;
+            }
+            seenRuntimeKeys.add(runtimeKey);
+        }
+        seenRefs.add(normalizedRef);
+        rows.push({
+            ref: normalizedRef,
+            ...(runtimeKey ? { runtimeKey } : {}),
+        });
+    }
+    return rows;
+}
 function rejectLegacyShopPriceCoinsField(value, errors, context) {
     if (Object.prototype.hasOwnProperty.call(value, 'shopPriceCoins')) {
         errors.push(`${context} uses legacy shopPriceCoins. Rename it to shopPriceCredits.`);
@@ -450,6 +556,16 @@ function normalizeAssetCategoryValue(raw, errors, label) {
     return normalized;
 }
 function normalizeAssetSubcategoryValue(raw, category, errors, label) {
+    if (category === 'CUSTOM') {
+        if (raw === undefined || raw === null) {
+            return null;
+        }
+        if (typeof raw === 'string' && raw.trim().length === 0) {
+            return null;
+        }
+        errors.push(`${label} must not define subcategory when category is CUSTOM.`);
+        return null;
+    }
     if (typeof raw !== 'string' || raw.trim().length === 0) {
         errors.push(`${label} must define subcategory.`);
         return null;
@@ -742,12 +858,19 @@ function buildAppTasks(rootDir, catalogues, options) {
                 errors.push(`[${label}] App entry is missing a name.`);
                 continue;
             }
+            const ownedAssetNameMatch = filterName
+                ? Array.isArray(entry.ownedAssets)
+                    && entry.ownedAssets.some((ownedAsset) => ownedAsset
+                        && typeof ownedAsset === 'object'
+                        && typeof ownedAsset.name === 'string'
+                        && ownedAsset.name.trim() === filterName)
+                : true;
             const fileField = typeof entry.file === 'string' && entry.file.trim().length > 0
                 ? entry.file.trim()
                 : `${rawName}.html`;
             const absoluteFilePath = (0, node_path_1.resolve)(file.directory, fileField);
             const normalizedFile = normalizePathForComparison(absoluteFilePath);
-            const matchName = filterName ? rawName === filterName : true;
+            const matchName = filterName ? rawName === filterName || ownedAssetNameMatch : true;
             const matchFile = filterFile ? normalizedFile === filterFile : true;
             if (!matchName || !matchFile) {
                 continue;
@@ -1105,9 +1228,7 @@ function buildAppTasks(rootDir, catalogues, options) {
                 }
                 listing = resolvedListing;
             }
-            const usesAssets = Array.isArray(entry.uses?.assets)
-                ? entry.uses.assets.filter((value) => typeof value === 'string' && value.trim().length > 0)
-                : [];
+            const usesAssets = normalizeCatalogueAppDependencyAssets(entry.uses?.assets, errors, `[${label}] App "${rawName}"`);
             const usesPacks = Array.isArray(entry.uses?.packs)
                 ? entry.uses.packs.filter((value) => typeof value === 'string' && value.trim().length > 0)
                 : [];
@@ -1118,44 +1239,54 @@ function buildAppTasks(rootDir, catalogues, options) {
             if (errors.length > errorCountBeforeTagMetadata) {
                 continue;
             }
-            const embeddedAssets = [];
-            const rawEmbeddedAssets = Array.isArray(entry.embeddedAssets)
-                ? entry.embeddedAssets
+            if (Object.prototype.hasOwnProperty.call(entry, 'embeddedAssets')) {
+                errors.push(`[${label}] App "${rawName}" uses legacy embeddedAssets. Rename it to ownedAssets.`);
+                continue;
+            }
+            const ownedAssets = [];
+            const rawOwnedAssets = Array.isArray(entry.ownedAssets)
+                ? entry.ownedAssets
                 : [];
-            for (let embeddedIndex = 0; embeddedIndex < rawEmbeddedAssets.length; embeddedIndex++) {
-                const embedded = rawEmbeddedAssets[embeddedIndex];
-                const embeddedName = typeof embedded?.name === 'string' ? embedded.name.trim() : '';
-                if (!embeddedName) {
-                    errors.push(`[${label}] Skipping ${rawName}: embeddedAssets[${embeddedIndex}] is missing a name.`);
+            for (let ownedIndex = 0; ownedIndex < rawOwnedAssets.length; ownedIndex++) {
+                const owned = rawOwnedAssets[ownedIndex];
+                const ownedName = typeof owned?.name === 'string' ? owned.name.trim() : '';
+                if (!ownedName) {
+                    errors.push(`[${label}] Skipping ${rawName}: ownedAssets[${ownedIndex}] is missing a name.`);
                     continue;
                 }
-                const category = normalizeAssetCategoryValue(embedded?.category, errors, `[${label}] Skipping ${rawName}: embedded asset "${embeddedName}"`);
+                const runtimeKey = typeof owned?.runtimeKey === 'string' && owned.runtimeKey.trim().length > 0
+                    ? owned.runtimeKey.trim()
+                    : undefined;
+                const category = normalizeAssetCategoryValue(owned?.category, errors, `[${label}] Skipping ${rawName}: owned asset "${ownedName}"`);
                 if (!category) {
                     continue;
                 }
-                const subcategory = normalizeAssetSubcategoryValue(embedded?.subcategory, category, errors, `[${label}] Skipping ${rawName}: embedded asset "${embeddedName}"`);
-                if (!subcategory) {
+                const subcategory = normalizeAssetSubcategoryValue(owned?.subcategory, category, errors, `[${label}] Skipping ${rawName}: owned asset "${ownedName}"`);
+                if (subcategory === null && category !== 'CUSTOM') {
                     continue;
                 }
-                const fileEntries = embedded?.files && typeof embedded.files === 'object' && !Array.isArray(embedded.files)
-                    ? embedded.files
+                const fileEntries = owned?.files && typeof owned.files === 'object' && !Array.isArray(owned.files)
+                    ? owned.files
                     : null;
-                const embeddedFormat = typeof embedded?.format === 'string' && embedded.format.trim().length > 0
-                    ? embedded.format.trim().toUpperCase()
+                const assetSpec = (0, assetSpecs_1.normalizeAssetSpecVersionRef)(owned?.assetSpec, errors, `[${label}] App "${rawName}" owned asset "${ownedName}"`);
+                const ownedFormat = typeof owned?.format === 'string' && owned.format.trim().length > 0
+                    ? owned.format.trim().toUpperCase()
                     : undefined;
-                const generatedModel3DFormat = inferGeneratedModel3DFormat(category, subcategory, embeddedFormat, fileEntries);
+                const generatedModel3DFormat = subcategory
+                    ? inferGeneratedModel3DFormat(category, subcategory, ownedFormat, fileEntries)
+                    : null;
                 const generatedModel3DRoles = generatedModel3DFormat ? getGeneratedModel3DFileRoles(generatedModel3DFormat) : null;
                 if (!fileEntries || Object.keys(fileEntries).length === 0) {
-                    errors.push(`[${label}] Skipping ${rawName}: embedded asset "${embeddedName}" must define files.`);
+                    errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" must define files.`);
                     continue;
                 }
                 const files = {};
                 const filePaths = {};
-                let embeddedHasError = false;
+                let ownedAssetHasError = false;
                 for (const [role, fileValue] of Object.entries(fileEntries)) {
                     if (typeof fileValue !== 'string' || !fileValue.trim()) {
-                        errors.push(`[${label}] Skipping ${rawName}: embedded asset "${embeddedName}" file role "${role}" must be a non-empty string path.`);
-                        embeddedHasError = true;
+                        errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" file role "${role}" must be a non-empty string path.`);
+                        ownedAssetHasError = true;
                         continue;
                     }
                     const relativeEmbeddedPath = fileValue.trim();
@@ -1168,21 +1299,21 @@ function buildAppTasks(rootDir, catalogues, options) {
                             filePaths[role] = absoluteEmbeddedPath;
                             continue;
                         }
-                        errors.push(`[${label}] Skipping ${rawName}: embedded asset "${embeddedName}" file not found at ${absoluteEmbeddedPath}.`);
-                        embeddedHasError = true;
+                        errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" file not found at ${absoluteEmbeddedPath}.`);
+                        ownedAssetHasError = true;
                         continue;
                     }
                     files[role] = relativeEmbeddedPath.replace(/\\/g, '/');
                     filePaths[role] = absoluteEmbeddedPath;
                 }
-                if (embeddedHasError) {
+                if (ownedAssetHasError) {
                     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.')}.`);
+                        errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" with subcategory=${subcategory} must define files.${missingRoles.join(' and files.')}.`);
                         continue;
                     }
                 }
@@ -1190,35 +1321,86 @@ function buildAppTasks(rootDir, catalogues, options) {
                     const hasAtlas = Object.prototype.hasOwnProperty.call(files, 'atlas');
                     const hasManifest = Object.prototype.hasOwnProperty.call(files, 'manifest');
                     if (!hasAtlas || !hasManifest) {
-                        errors.push(`[${label}] Skipping ${rawName}: embedded asset "${embeddedName}" with category=SPRITESHEET must define files.atlas and files.manifest.`);
+                        errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" with category=SPRITESHEET must define files.atlas and files.manifest.`);
                         continue;
                     }
                 }
                 if (category === 'AUDIO') {
                     const hasPrimary = Object.prototype.hasOwnProperty.call(files, 'primary');
                     if (!hasPrimary) {
-                        errors.push(`[${label}] Skipping ${rawName}: embedded asset "${embeddedName}" with category=AUDIO must define files.primary.`);
+                        errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" with category=AUDIO must define files.primary.`);
+                        continue;
+                    }
+                }
+                if (category === 'MODEL_3D' && ownedFormat === 'GLB') {
+                    const primaryPath = filePaths.primary;
+                    if (!primaryPath) {
+                        errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" with format=GLB must define files.primary.`);
+                        continue;
+                    }
+                    try {
+                        validateSelfContainedGlb(primaryPath);
+                    }
+                    catch (error) {
+                        const message = typeof error?.message === 'string' ? error.message : 'invalid_glb_payload';
+                        if (message === 'glb_external_dependency_unsupported') {
+                            errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" GLB must embed all buffers and textures instead of referencing external files.`);
+                        }
+                        else {
+                            errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" primary GLB is invalid.`);
+                        }
                         continue;
                     }
                 }
-                if (rejectLegacyShopPriceCoinsField(embedded, errors, `[${label}] Embedded asset "${embeddedName}"`)) {
+                if (rejectLegacyShopPriceCoinsField(owned, errors, `[${label}] Owned asset "${ownedName}"`)) {
                     continue;
                 }
-                embeddedAssets.push({
-                    kind: 'embedded-asset',
+                ownedAssets.push({
+                    kind: 'owned-asset',
                     appName: rawName,
-                    name: embeddedName,
+                    name: ownedName,
+                    runtimeKey,
                     cataloguePath: label,
                     category,
                     subcategory,
-                    format: embeddedFormat,
-                    visibility: normalizeAssetVisibilityValue(embedded?.visibility, errors, `${label} embedded asset "${embeddedName}"`),
-                    shopListed: typeof embedded?.shopListed === 'boolean' ? embedded.shopListed : undefined,
-                    shopPriceCredits: Number.isInteger(embedded?.shopPriceCredits) ? Number(embedded.shopPriceCredits) : undefined,
+                    assetSpec,
+                    format: ownedFormat,
+                    visibility: normalizeAssetVisibilityValue(owned?.visibility, errors, `${label} owned asset "${ownedName}"`),
+                    shopListed: typeof owned?.shopListed === 'boolean' ? owned.shopListed : undefined,
+                    shopPriceCredits: Number.isInteger(owned?.shopPriceCredits) ? Number(owned.shopPriceCredits) : undefined,
                     files,
                     filePaths,
                 });
             }
+            const runtimeValidationErrorCount = errors.length;
+            const seenOwnedAssetNames = new Set();
+            const seenOwnedRuntimeKeys = new Set();
+            for (const ownedAsset of ownedAssets) {
+                if (seenOwnedAssetNames.has(ownedAsset.name)) {
+                    errors.push(`[${label}] App "${rawName}" ownedAssets contains duplicate name "${ownedAsset.name}".`);
+                    continue;
+                }
+                seenOwnedAssetNames.add(ownedAsset.name);
+                if (!ownedAsset.runtimeKey) {
+                    continue;
+                }
+                if (seenOwnedRuntimeKeys.has(ownedAsset.runtimeKey)) {
+                    errors.push(`[${label}] App "${rawName}" ownedAssets contains duplicate runtimeKey "${ownedAsset.runtimeKey}".`);
+                    continue;
+                }
+                seenOwnedRuntimeKeys.add(ownedAsset.runtimeKey);
+            }
+            for (const dependency of usesAssets) {
+                if (!dependency.runtimeKey) {
+                    continue;
+                }
+                if (seenOwnedRuntimeKeys.has(dependency.runtimeKey)) {
+                    errors.push(`[${label}] App "${rawName}" reuses runtimeKey "${dependency.runtimeKey}" across ownedAssets and uses.assets.`);
+                }
+            }
+            if (errors.length > runtimeValidationErrorCount) {
+                continue;
+            }
             tasks.push({
                 kind: 'app',
                 name: rawName,
@@ -1257,7 +1439,7 @@ function buildAppTasks(rootDir, catalogues, options) {
                 achievements,
                 leaderboards,
                 remix,
-                embeddedAssets,
+                ownedAssets,
                 assetSpecSupport,
                 uses: {
                     assets: usesAssets,
@@ -1390,11 +1572,25 @@ function buildAssetSpecTasks(catalogues) {
     }
     return { tasks, warnings, errors };
 }
-function buildAssetTasks(catalogues, _assetSpecTasks) {
+function buildAssetTasks(catalogues, assetSpecTasks) {
     const tasks = [];
     const warnings = [];
     const errors = [];
     const seen = new Map();
+    const exactAssetSpecTaskByRef = new Map();
+    const uniqueAssetSpecTaskByNameVersion = new Map();
+    for (const task of assetSpecTasks) {
+        if (task.username) {
+            exactAssetSpecTaskByRef.set(`asset-spec:${task.username}/${task.name}@${task.version}`, task);
+        }
+        const nameVersionKey = `${task.name}@${task.version}`;
+        if (!uniqueAssetSpecTaskByNameVersion.has(nameVersionKey)) {
+            uniqueAssetSpecTaskByNameVersion.set(nameVersionKey, task);
+        }
+        else {
+            uniqueAssetSpecTaskByNameVersion.set(nameVersionKey, null);
+        }
+    }
     for (const file of catalogues) {
         const label = file.relativePath || 'catalogue.json';
         const rawAssets = Array.isArray(file.data.assets) ? file.data.assets : [];
@@ -1520,6 +1716,22 @@ function buildAssetTasks(catalogues, _assetSpecTasks) {
             if (rejectLegacyShopPriceCoinsField(entry, errors, `[${label}] Asset "${name}"`)) {
                 continue;
             }
+            let assetSpecContract;
+            if (assetSpec) {
+                const directAssetSpecTask = exactAssetSpecTaskByRef.get(assetSpec);
+                if (directAssetSpecTask) {
+                    assetSpecContract = directAssetSpecTask.contract;
+                }
+                else {
+                    const parsedAssetSpec = (0, types_1.parseAssetSpecVersionRef)(assetSpec);
+                    if (parsedAssetSpec) {
+                        const fallbackAssetSpecTask = uniqueAssetSpecTaskByNameVersion.get(`${parsedAssetSpec.name}@${parsedAssetSpec.version}`);
+                        if (fallbackAssetSpecTask) {
+                            assetSpecContract = fallbackAssetSpecTask.contract;
+                        }
+                    }
+                }
+            }
             tasks.push({
                 kind: 'asset',
                 name,
@@ -1537,6 +1749,7 @@ function buildAssetTasks(catalogues, _assetSpecTasks) {
                 shopPriceCredits: Number.isInteger(entry.shopPriceCredits) ? Number(entry.shopPriceCredits) : undefined,
                 files,
                 filePaths,
+                assetSpecContract,
                 relations,
             });
         }
@@ -1577,6 +1790,110 @@ function buildAssetPackTasks(catalogues) {
             const assets = Array.isArray(entry.assets)
                 ? entry.assets.filter((value) => typeof value === 'string' && value.trim().length > 0).map((value) => value.trim())
                 : [];
+            const ownedAssets = [];
+            const rawOwnedAssets = Array.isArray(entry.ownedAssets)
+                ? entry.ownedAssets
+                : [];
+            for (let ownedIndex = 0; ownedIndex < rawOwnedAssets.length; ownedIndex++) {
+                const owned = rawOwnedAssets[ownedIndex];
+                const ownedName = typeof owned?.name === 'string' ? owned.name.trim() : '';
+                if (!ownedName) {
+                    errors.push(`[${label}] Skipping asset pack "${name}": ownedAssets[${ownedIndex}] is missing a name.`);
+                    continue;
+                }
+                if (typeof owned?.runtimeKey === 'string' && owned.runtimeKey.trim().length > 0) {
+                    errors.push(`[${label}] Skipping asset pack "${name}": owned asset "${ownedName}" must not define runtimeKey.`);
+                    continue;
+                }
+                const category = normalizeAssetCategoryValue(owned?.category, errors, `[${label}] Skipping asset pack "${name}": owned asset "${ownedName}"`);
+                if (!category) {
+                    continue;
+                }
+                const subcategory = normalizeAssetSubcategoryValue(owned?.subcategory, category, errors, `[${label}] Skipping asset pack "${name}": owned asset "${ownedName}"`);
+                if (subcategory === null && category !== 'CUSTOM') {
+                    continue;
+                }
+                const fileEntries = owned?.files && typeof owned.files === 'object' && !Array.isArray(owned.files)
+                    ? owned.files
+                    : null;
+                const assetSpec = (0, assetSpecs_1.normalizeAssetSpecVersionRef)(owned?.assetSpec, errors, `[${label}] Asset pack "${name}" owned asset "${ownedName}"`);
+                const ownedFormat = typeof owned?.format === 'string' && owned.format.trim().length > 0
+                    ? owned.format.trim().toUpperCase()
+                    : undefined;
+                const generatedModel3DFormat = subcategory
+                    ? inferGeneratedModel3DFormat(category, subcategory, ownedFormat, fileEntries)
+                    : null;
+                const generatedModel3DRoles = generatedModel3DFormat ? getGeneratedModel3DFileRoles(generatedModel3DFormat) : null;
+                if (!fileEntries || Object.keys(fileEntries).length === 0) {
+                    errors.push(`[${label}] Skipping asset pack "${name}": owned asset "${ownedName}" must define files.`);
+                    continue;
+                }
+                const files = {};
+                const filePaths = {};
+                let ownedAssetHasError = false;
+                for (const [role, fileValue] of Object.entries(fileEntries)) {
+                    if (typeof fileValue !== 'string' || !fileValue.trim()) {
+                        errors.push(`[${label}] Skipping asset pack "${name}": owned asset "${ownedName}" file role "${role}" must be a non-empty string path.`);
+                        ownedAssetHasError = true;
+                        continue;
+                    }
+                    const relativeOwnedPath = fileValue.trim();
+                    const absoluteOwnedPath = (0, node_path_1.resolve)(file.directory, relativeOwnedPath);
+                    const normalizedRole = normalizeFileRole(role);
+                    const allowMissingGenerated = Boolean(generatedModel3DRoles?.generated.has(normalizedRole));
+                    if (!(0, node_fs_1.existsSync)(absoluteOwnedPath) || !(0, node_fs_1.statSync)(absoluteOwnedPath).isFile()) {
+                        if (allowMissingGenerated) {
+                            files[role] = relativeOwnedPath.replace(/\\/g, '/');
+                            filePaths[role] = absoluteOwnedPath;
+                            continue;
+                        }
+                        errors.push(`[${label}] Skipping asset pack "${name}": owned asset "${ownedName}" file not found at ${absoluteOwnedPath}.`);
+                        ownedAssetHasError = true;
+                        continue;
+                    }
+                    files[role] = relativeOwnedPath.replace(/\\/g, '/');
+                    filePaths[role] = absoluteOwnedPath;
+                }
+                if (ownedAssetHasError) {
+                    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 asset pack "${name}": owned asset "${ownedName}" 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');
+                    if (!hasAtlas || !hasManifest) {
+                        errors.push(`[${label}] Skipping asset pack "${name}": owned asset "${ownedName}" with category=SPRITESHEET must define files.atlas and files.manifest.`);
+                        continue;
+                    }
+                }
+                if (category === 'AUDIO' && !Object.prototype.hasOwnProperty.call(files, 'primary')) {
+                    errors.push(`[${label}] Skipping asset pack "${name}": owned asset "${ownedName}" with category=AUDIO must define files.primary.`);
+                    continue;
+                }
+                if (rejectLegacyShopPriceCoinsField(owned, errors, `[${label}] Asset pack "${name}" owned asset "${ownedName}"`)) {
+                    continue;
+                }
+                ownedAssets.push({
+                    name: ownedName,
+                    cataloguePath: label,
+                    category,
+                    subcategory,
+                    assetSpec,
+                    format: ownedFormat,
+                    visibility: normalizeAssetVisibilityValue(owned?.visibility, errors, `${label} asset pack "${name}" owned asset "${ownedName}"`),
+                    shopListed: typeof owned?.shopListed === 'boolean' ? owned.shopListed : undefined,
+                    shopPriceCredits: Number.isInteger(owned?.shopPriceCredits) ? Number(owned.shopPriceCredits) : undefined,
+                    files,
+                    filePaths,
+                });
+            }
             let hostingMode;
             const rawHostingMode = typeof entry.hostingMode === 'string' ? entry.hostingMode.trim().toUpperCase() : '';
             if (rawHostingMode) {
@@ -1611,7 +1928,7 @@ function buildAssetPackTasks(catalogues) {
             if (externalUrl && hostingMode !== 'EXTERNAL') {
                 hostingMode = 'EXTERNAL';
             }
-            if (assets.length === 0 && hostingMode !== 'EXTERNAL') {
+            if (assets.length === 0 && ownedAssets.length === 0 && hostingMode !== 'EXTERNAL') {
                 errors.push(`[${label}] Asset pack "${name}" must reference at least one asset.`);
                 continue;
             }
@@ -1797,6 +2114,7 @@ function buildAssetPackTasks(catalogues) {
                 username,
                 remix,
                 assets,
+                ownedAssets,
                 hostingMode,
                 externalUrl,
                 downloadUrl,
@@ -1917,7 +2235,7 @@ function resolveCatalogueEntries(rootDir, options = {}) {
             apps: [],
             assetSpecs: [],
             assets: [],
-            embeddedAssets: [],
+            ownedAssets: [],
             assetPacks: [],
             warnings: [],
             errors: discoveryErrors,
@@ -1930,7 +2248,7 @@ function resolveCatalogueEntries(rootDir, options = {}) {
             apps: [],
             assetSpecs: [],
             assets: [],
-            embeddedAssets: [],
+            ownedAssets: [],
             assetPacks: [],
             warnings: [],
             errors: [
@@ -1942,14 +2260,14 @@ function resolveCatalogueEntries(rootDir, options = {}) {
     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 ownedAssetTasks = appTasks.flatMap((task) => task.ownedAssets);
     const warnings = [...appWarnings, ...assetSpecWarnings, ...assetWarnings, ...assetPackWarnings];
     const errors = [...appErrors, ...assetSpecErrors, ...assetErrors, ...assetPackErrors];
     return {
         apps: appTasks,
         assetSpecs: assetSpecTasks,
         assets: assetTasks,
-        embeddedAssets: embeddedAssetTasks,
+        ownedAssets: ownedAssetTasks,
         assetPacks: assetPackTasks,
         warnings,
         errors,

package/dist/commandContext.d.ts

@@ -2,6 +2,7 @@ import type { ApiClient } from '@playdrop/api-client';
 import type { AiClient } from '@playdrop/ai-client';
 import { type CliAccountSession, type CliConfig } from './config';
 import { type EnvironmentConfig } from './environment';
+import { type ResolvedWorkspaceAuthConfig } from './workspaceAuth';
 export type EnvironmentContext = {
     client: ApiClient;
     aiClient: AiClient;
@@ -10,11 +11,14 @@ export type EnvironmentContext = {
     token: string;
     config: CliConfig;
     account: CliAccountSession | null;
+    workspaceAuth: ResolvedWorkspaceAuthConfig | null;
 };
 type EnvironmentCallback = (ctx: EnvironmentContext) => Promise<void> | void;
-type ResolveAuthenticatedEnvironmentOptions = {
+export type ResolveAuthenticatedEnvironmentOptions = {
     workspacePath?: string;
 };
+export declare function resolveAuthenticatedEnvironmentContext(command: string, actionLabel: string, options?: ResolveAuthenticatedEnvironmentOptions): Promise<EnvironmentContext | null>;
+export declare function resolveOptionalEnvironmentContext(command: string, options?: ResolveAuthenticatedEnvironmentOptions): Promise<EnvironmentContext | null>;
 export declare function withEnvironment(command: string, actionLabel: string, callback: EnvironmentCallback, options?: ResolveAuthenticatedEnvironmentOptions): Promise<void>;
 export declare function withPublicEnvironment(command: string, callback: EnvironmentCallback): Promise<void>;
 export {};