@playdrop/playdrop-cli 0.5.4 → 0.5.6

package/README.md

@@ -36,7 +36,8 @@ playdrop project publish .
 - CLI docs: [playdrop.ai/docs/cli](https://www.playdrop.ai/docs/cli)
 - Runtime docs: [playdrop.ai/docs/runtime](https://www.playdrop.ai/docs/runtime)
 - Templates and demos: [playdrop.ai/docs/examples#templates-and-demos](https://www.playdrop.ai/docs/examples#templates-and-demos)
-- Public Playdrop skill: [skills.sh/playdrop-ai/playdrop-skills/playdrop](https://skills.sh/playdrop-ai/playdrop-skills/playdrop)
+- Canonical public plugin repo: [github.com/playdrop-ai/playdrop-plugin](https://github.com/playdrop-ai/playdrop-plugin)
+- Legacy public skill surface: [skills.sh/playdrop-ai/playdrop-skills/playdrop](https://skills.sh/playdrop-ai/playdrop-skills/playdrop)
 
 ## Live Examples
 

package/config/client-meta.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.5.4",
+  "version": "0.5.6",
   "build": 1,
   "platforms": {
     "ios": {
@@ -26,11 +26,11 @@
   },
   "clients": {
     "web": {
-      "minimumVersion": "0.5.4",
+      "minimumVersion": "0.5.6",
       "minimumBuild": 1
     },
     "admin": {
-      "minimumVersion": "0.5.4",
+      "minimumVersion": "0.5.6",
       "minimumBuild": 1
     },
     "apple": {
@@ -38,7 +38,7 @@
       "minimumBuild": 1
     },
     "cli": {
-      "minimumVersion": "0.5.4"
+      "minimumVersion": "0.5.6"
     }
   }
 }

package/dist/apps/upload.js

@@ -1,11 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadApp = uploadApp;
+const node_crypto_1 = require("node:crypto");
 const types_1 = require("@playdrop/types");
 const config_1 = require("@playdrop/config");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const http_1 = require("../http");
+const EXTENSION_TO_MIME = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.json': 'application/json',
+    '.gltf': 'model/gltf+json',
+    '.glb': 'model/gltf-binary',
+    '.vox': 'application/octet-stream',
+};
 function isPngSignature(content) {
     if (content.length < 8) {
         return false;
@@ -50,6 +67,59 @@ function createFileFromPath(filePath, mimeType, maxBytes, sizeCode, typeCode, la
         size: content.length,
     };
 }
+async function bufferFromFile(file) {
+    return Buffer.from(await file.arrayBuffer());
+}
+function computeSha256Hex(buffer) {
+    return (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+}
+function resolveMimeType(filename, fallback = 'application/octet-stream') {
+    const type = EXTENSION_TO_MIME[(0, node_path_1.extname)(filename).toLowerCase()];
+    return type ?? fallback;
+}
+async function buildPreparedSessionFile(fileKey, file) {
+    const buffer = await bufferFromFile(file);
+    return {
+        fileKey,
+        file,
+        filename: file.name,
+        contentType: file.type || resolveMimeType(file.name),
+        sizeBytes: buffer.length,
+        sha256: computeSha256Hex(buffer),
+    };
+}
+function createGenericFileFromPath(filePath) {
+    const content = (0, node_fs_1.readFileSync)(filePath);
+    const name = (0, node_path_1.basename)(filePath);
+    return new File([content], name, { type: resolveMimeType(name) });
+}
+async function prepareOwnedAssetUpload(task) {
+    const files = await Promise.all(Object.entries(task.filePaths).map(async ([role, filePath]) => {
+        const file = createGenericFileFromPath(filePath);
+        const buffer = await bufferFromFile(file);
+        return {
+            role,
+            file,
+            filename: file.name,
+            contentType: file.type || resolveMimeType(file.name),
+            sizeBytes: buffer.length,
+            sha256: computeSha256Hex(buffer),
+        };
+    }));
+    return {
+        uploadKey: task.name,
+        runtimeKey: task.runtimeKey,
+        name: task.name,
+        category: task.category,
+        subcategory: task.subcategory,
+        format: task.format || (0, node_path_1.extname)(files[0]?.filename || '').replace(/^\./, '').toUpperCase() || 'GLB',
+        visibility: task.visibility,
+        assetSpec: task.assetSpec,
+        shopListed: task.shopListed,
+        shopPriceCredits: task.shopPriceCredits,
+        files,
+    };
+}
 // eslint-disable-next-line complexity -- Source archive failures need distinct guidance when publish-only media is already excluded.
 function ensurePreparedArtifactSize(file, maxBytes, code, label, task) {
     if (!file) {
@@ -109,21 +179,99 @@ async function uploadAppVersion(client, task, artifacts, options) {
     const achievements = task.achievements ?? [];
     const leaderboards = task.leaderboards ?? [];
     const listing = task.listing;
-    const versionOptions = {
+    const preparedSessionFiles = [];
+    const preparedOwnedAssets = await Promise.all(task.ownedAssets.map((ownedAsset) => prepareOwnedAssetUpload(ownedAsset)));
+    for (const ownedAsset of preparedOwnedAssets) {
+        for (const file of ownedAsset.files) {
+            totalUploadBytes = accumulateUploadBytes(task.name, totalUploadBytes, file.sizeBytes);
+        }
+    }
+    for (const definition of achievements) {
+        const prepared = createFileFromPath(definition.iconPath, 'image/png', config_1.MAX_VERSION_ICON_BYTES, 'achievement_icon_too_large', 'invalid_achievement_icon_content_type', `Achievement icon "${definition.key}"`, isPngSignature);
+        totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+        preparedSessionFiles.push(await buildPreparedSessionFile(`achievementIcon:${definition.key}`, prepared.file));
+    }
+    if (task.hostingMode === 'EXTERNAL') {
+        // no hosted files
+    }
+    else if (artifacts) {
+        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.bundleFile, config_1.MAX_VERSION_BUNDLE_BYTES, 'bundle_too_large', 'Bundle');
+        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.sourceFile, config_1.MAX_APP_SOURCE_BYTES, 'source_too_large', 'Source archive');
+        preparedSessionFiles.push(await buildPreparedSessionFile('bundle', artifacts.bundleFile));
+        preparedSessionFiles.push(await buildPreparedSessionFile('source', artifacts.sourceFile));
+        if (!options?.skipEcs) {
+            if (artifacts.ecsFile) {
+                totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.ecsFile, config_1.MAX_APP_ECS_BYTES, 'ecs_too_large', 'ECS config');
+                preparedSessionFiles.push(await buildPreparedSessionFile('ecs', artifacts.ecsFile));
+            }
+            if (artifacts.serverFile) {
+                totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.serverFile, config_1.MAX_APP_SERVER_BYTES, 'server_too_large', 'Server.js');
+                preparedSessionFiles.push(await buildPreparedSessionFile('server', artifacts.serverFile));
+            }
+        }
+    }
+    if (listing?.iconPath) {
+        const prepared = createFileFromPath(listing.iconPath, 'image/png', config_1.MAX_VERSION_ICON_BYTES, 'icon_too_large', 'invalid_icon_content_type', 'Icon', isPngSignature);
+        totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+        preparedSessionFiles.push(await buildPreparedSessionFile('icon', prepared.file));
+    }
+    if (listing?.heroPortraitPath) {
+        const prepared = createFileFromPath(listing.heroPortraitPath, 'image/png', config_1.MAX_VERSION_HERO_BYTES, 'hero_portrait_too_large', 'invalid_hero_portrait_content_type', 'Hero portrait', isPngSignature);
+        totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+        preparedSessionFiles.push(await buildPreparedSessionFile('heroPortrait', prepared.file));
+    }
+    if (listing?.heroLandscapePath) {
+        const prepared = createFileFromPath(listing.heroLandscapePath, 'image/png', config_1.MAX_VERSION_HERO_BYTES, 'hero_landscape_too_large', 'invalid_hero_landscape_content_type', 'Hero landscape', isPngSignature);
+        totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+        preparedSessionFiles.push(await buildPreparedSessionFile('heroLandscape', prepared.file));
+    }
+    for (let index = 0; index < (listing?.screenshotPortraitPaths ?? []).length; index += 1) {
+        const filePath = listing.screenshotPortraitPaths[index];
+        const prepared = createFileFromPath(filePath, 'image/png', config_1.MAX_VERSION_SCREENSHOT_BYTES, 'screenshot_portrait_too_large', 'invalid_screenshot_portrait_content_type', `Portrait screenshot ${index + 1}`, isPngSignature);
+        totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+        preparedSessionFiles.push(await buildPreparedSessionFile(`screenshotsPortrait:${index}`, prepared.file));
+    }
+    for (let index = 0; index < (listing?.screenshotLandscapePaths ?? []).length; index += 1) {
+        const filePath = listing.screenshotLandscapePaths[index];
+        const prepared = createFileFromPath(filePath, 'image/png', config_1.MAX_VERSION_SCREENSHOT_BYTES, 'screenshot_landscape_too_large', 'invalid_screenshot_landscape_content_type', `Landscape screenshot ${index + 1}`, isPngSignature);
+        totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+        preparedSessionFiles.push(await buildPreparedSessionFile(`screenshotsLandscape:${index}`, prepared.file));
+    }
+    for (let index = 0; index < (listing?.videoPortraitPaths ?? []).length; index += 1) {
+        const filePath = listing.videoPortraitPaths[index];
+        const prepared = createFileFromPath(filePath, 'video/mp4', config_1.MAX_VERSION_VIDEO_BYTES, 'video_portrait_too_large', 'invalid_video_portrait_content_type', `Portrait video ${index + 1}`, isMp4Signature);
+        totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+        preparedSessionFiles.push(await buildPreparedSessionFile(`videosPortrait:${index}`, prepared.file));
+    }
+    for (let index = 0; index < (listing?.videoLandscapePaths ?? []).length; index += 1) {
+        const filePath = listing.videoLandscapePaths[index];
+        const prepared = createFileFromPath(filePath, 'video/mp4', config_1.MAX_VERSION_VIDEO_BYTES, 'video_landscape_too_large', 'invalid_video_landscape_content_type', `Landscape video ${index + 1}`, isMp4Signature);
+        totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
+        preparedSessionFiles.push(await buildPreparedSessionFile(`videosLandscape:${index}`, prepared.file));
+    }
+    const initializeRequest = {
         version: task.version,
         releaseNotes: task.releaseNotes,
         visibility: task.versionVisibility,
         remixRef: task.remix,
+        usesAssets: task.uses.assets.map((entry) => ({
+            ref: entry.ref,
+            ...(entry.runtimeKey ? { runtimeKey: entry.runtimeKey } : {}),
+        })),
+        usesPacks: task.uses.packs,
         tags: task.tags,
         clearTags: options?.clearTags,
         surfaceTargets: task.surfaceTargets,
-        assetSpecSupport: task.assetSpecSupport,
+        assetSpecSupport: (task.assetSpecSupport ?? []).map((row) => ({
+            assetSpecRef: row.assetSpec,
+            versionRange: row.versionRange,
+            capabilities: row.capabilities,
+        })),
         entryPoint: artifacts?.metadata?.entryPoint ?? undefined,
         authMode: task.authMode,
         controllerMode: task.controllerMode,
         previewable: task.previewable,
         skipReview: options?.skipReview,
-        // App metadata (used when creating app if it doesn't exist)
         displayName: task.displayName,
         description: task.description,
         type: task.type,
@@ -148,93 +296,91 @@ async function uploadAppVersion(client, task, artifacts, options) {
             ...(definition.unitLabel ? { unitLabel: definition.unitLabel } : {}),
             status: definition.status,
         })),
-        achievementIconFiles: achievements.map((definition) => {
-            const prepared = createFileFromPath(definition.iconPath, 'image/png', config_1.MAX_VERSION_ICON_BYTES, 'achievement_icon_too_large', 'invalid_achievement_icon_content_type', `Achievement icon "${definition.key}"`, isPngSignature);
-            totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-            return {
-                key: definition.key,
-                file: prepared.file,
-            };
-        }),
+        externalUrl: task.hostingMode === 'EXTERNAL' ? task.externalUrl : undefined,
+        files: preparedSessionFiles.map((file) => ({
+            fileKey: file.fileKey,
+            filename: file.filename,
+            contentType: file.contentType,
+            sizeBytes: file.sizeBytes,
+            sha256: file.sha256,
+        })),
+        ownedAssets: preparedOwnedAssets.map((ownedAsset) => ({
+            uploadKey: ownedAsset.uploadKey,
+            runtimeKey: ownedAsset.runtimeKey,
+            name: ownedAsset.name,
+            category: ownedAsset.category,
+            subcategory: ownedAsset.subcategory,
+            format: ownedAsset.format,
+            assetSpec: ownedAsset.assetSpec,
+            visibility: ownedAsset.visibility,
+            shopListed: ownedAsset.shopListed,
+            shopPriceCredits: ownedAsset.shopPriceCredits,
+            files: ownedAsset.files.map((file) => ({
+                role: file.role,
+                filename: file.filename,
+                contentType: file.contentType,
+                sizeBytes: file.sizeBytes,
+                sha256: file.sha256,
+            })),
+        })),
     };
-    // For EXTERNAL hosting mode, use externalUrl instead of bundle
-    if (task.hostingMode === 'EXTERNAL') {
-        versionOptions.externalUrl = task.externalUrl;
-    }
-    else if (artifacts) {
-        // HOSTED mode - include bundle and optional files
-        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.bundleFile, config_1.MAX_VERSION_BUNDLE_BYTES, 'bundle_too_large', 'Bundle');
-        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.sourceFile, config_1.MAX_APP_SOURCE_BYTES, 'source_too_large', 'Source archive');
-        versionOptions.bundle = artifacts.bundleFile;
-        versionOptions.source = artifacts.sourceFile;
-        // Include ecs/server files unless skipEcs is set
-        if (!options?.skipEcs) {
-            if (artifacts.ecsFile) {
-                totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.ecsFile, config_1.MAX_APP_ECS_BYTES, 'ecs_too_large', 'ECS config');
-                versionOptions.ecs = artifacts.ecsFile;
+    let sessionId = null;
+    try {
+        const initialized = await client.initializeAppUpload(creatorUsername, task.name, initializeRequest);
+        sessionId = initialized.session.id;
+        if (initialized.status !== 'finalized') {
+            const uploadedFileKeys = new Set(initialized.session.uploadedFileKeys);
+            const uploadedOwnedAssetKeys = new Set(initialized.session.uploadedOwnedAssetKeys);
+            for (const file of preparedSessionFiles) {
+                if (uploadedFileKeys.has(file.fileKey)) {
+                    continue;
+                }
+                await client.uploadAppSessionFile(creatorUsername, task.name, sessionId, file.fileKey, {
+                    file: file.file,
+                    filename: file.filename,
+                });
             }
-            if (artifacts.serverFile) {
-                totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.serverFile, config_1.MAX_APP_SERVER_BYTES, 'server_too_large', 'Server.js');
-                versionOptions.server = artifacts.serverFile;
+            for (const ownedAsset of preparedOwnedAssets) {
+                if (uploadedOwnedAssetKeys.has(ownedAsset.uploadKey)) {
+                    continue;
+                }
+                await client.uploadAppSessionOwnedAsset(creatorUsername, task.name, sessionId, ownedAsset.uploadKey, {
+                    files: ownedAsset.files.map((file) => ({
+                        fieldName: file.role,
+                        file: file.file,
+                        filename: file.filename,
+                    })),
+                });
             }
         }
-    }
-    // Add listing assets if provided
-    if (listing) {
-        if (listing.iconPath) {
-            const prepared = createFileFromPath(listing.iconPath, 'image/png', config_1.MAX_VERSION_ICON_BYTES, 'icon_too_large', 'invalid_icon_content_type', 'Icon', isPngSignature);
-            totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-            versionOptions.icon = prepared.file;
-        }
-        if (listing.heroPortraitPath) {
-            const prepared = createFileFromPath(listing.heroPortraitPath, 'image/png', config_1.MAX_VERSION_HERO_BYTES, 'hero_portrait_too_large', 'invalid_hero_portrait_content_type', 'Hero portrait', isPngSignature);
-            totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-            versionOptions.heroPortrait = prepared.file;
-        }
-        if (listing.heroLandscapePath) {
-            const prepared = createFileFromPath(listing.heroLandscapePath, 'image/png', config_1.MAX_VERSION_HERO_BYTES, 'hero_landscape_too_large', 'invalid_hero_landscape_content_type', 'Hero landscape', isPngSignature);
-            totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-            versionOptions.heroLandscape = prepared.file;
-        }
-        if ((listing.screenshotPortraitPaths ?? []).length > 0) {
-            versionOptions.screenshotsPortrait = listing.screenshotPortraitPaths.map((filePath, index) => {
-                const prepared = createFileFromPath(filePath, 'image/png', config_1.MAX_VERSION_SCREENSHOT_BYTES, 'screenshot_portrait_too_large', 'invalid_screenshot_portrait_content_type', `Portrait screenshot ${index + 1}`, isPngSignature);
-                totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-                return prepared.file;
-            });
+        const finalized = initialized.status === 'finalized'
+            ? initialized.finalized
+            : await client.finalizeAppUpload(creatorUsername, task.name, sessionId);
+        if (!finalized) {
+            throw new Error(`Upload failed for ${task.name}: missing finalized app upload payload`);
         }
-        if ((listing.screenshotLandscapePaths ?? []).length > 0) {
-            versionOptions.screenshotsLandscape = listing.screenshotLandscapePaths.map((filePath, index) => {
-                const prepared = createFileFromPath(filePath, 'image/png', config_1.MAX_VERSION_SCREENSHOT_BYTES, 'screenshot_landscape_too_large', 'invalid_screenshot_landscape_content_type', `Landscape screenshot ${index + 1}`, isPngSignature);
-                totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-                return prepared.file;
-            });
-        }
-        if ((listing.videoPortraitPaths ?? []).length > 0) {
-            versionOptions.videosPortrait = listing.videoPortraitPaths.map((filePath, index) => {
-                const prepared = createFileFromPath(filePath, 'video/mp4', config_1.MAX_VERSION_VIDEO_BYTES, 'video_portrait_too_large', 'invalid_video_portrait_content_type', `Portrait video ${index + 1}`, isMp4Signature);
-                totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-                return prepared.file;
-            });
-        }
-        if ((listing.videoLandscapePaths ?? []).length > 0) {
-            versionOptions.videosLandscape = listing.videoLandscapePaths.map((filePath, index) => {
-                const prepared = createFileFromPath(filePath, 'video/mp4', config_1.MAX_VERSION_VIDEO_BYTES, 'video_landscape_too_large', 'invalid_video_landscape_content_type', `Landscape video ${index + 1}`, isMp4Signature);
-                totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-                return prepared.file;
-            });
-        }
-    }
-    try {
-        const response = await client.uploadAppVersion(creatorUsername, task.name, versionOptions);
+        const version = initialized.status === 'finalized'
+            ? finalized?.version
+            : finalized.version;
+        const versionNodeId = initialized.status === 'finalized'
+            ? finalized?.versionNodeId
+            : finalized.versionNodeId;
         return {
             versionCreated: true,
-            version: response?.version?.version,
-            versionId: typeof response?.version?.id === 'number' ? response.version.id : undefined,
-            versionNodeId: typeof response?.versionNodeId === 'string' ? response.versionNodeId : undefined,
+            version: version?.version,
+            versionId: typeof version?.id === 'number' ? version.id : undefined,
+            versionNodeId: typeof versionNodeId === 'string' ? versionNodeId : undefined,
         };
     }
     catch (unknownError) {
+        if (sessionId) {
+            try {
+                await client.abortAppUpload(creatorUsername, task.name, sessionId);
+            }
+            catch {
+                // keep original error
+            }
+        }
         if (unknownError instanceof types_1.UnsupportedClientError) {
             (0, http_1.handleUnsupportedError)(unknownError, 'Upload app version');
         }

package/dist/assetSpecs.d.ts

@@ -1,4 +1,5 @@
 import { type AssetSpecCapability, type AssetSpecContract, type AssetSpecValidationKind } from '@playdrop/types';
+export declare function resolveCustomAssetRoleContentType(filePath: string, roleContract?: Pick<AssetSpecContract['roles'][number], 'contentTypes'> | null): string;
 export type AssetSpecSupportDeclaration = {
     assetSpec: string;
     versionRange: string;

package/dist/assetSpecs.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCustomAssetRoleContentType = resolveCustomAssetRoleContentType;
 exports.normalizeAssetSpecSupportEntries = normalizeAssetSpecSupportEntries;
 exports.loadAndValidateAssetSpecContract = loadAndValidateAssetSpecContract;
 exports.validateCustomAssetFilesAgainstContract = validateCustomAssetFilesAgainstContract;
@@ -54,6 +55,26 @@ function createContractValidator() {
 function resolveMimeTypeFromPath(filePath) {
     return LOCAL_EXTENSION_TO_MIME[(0, node_path_1.extname)(filePath).toLowerCase()] ?? 'application/octet-stream';
 }
+function resolveCustomAssetRoleContentType(filePath, roleContract) {
+    const resolvedContentType = resolveMimeTypeFromPath(filePath);
+    if (!roleContract) {
+        return resolvedContentType;
+    }
+    const normalizedResolvedContentType = resolvedContentType.toLowerCase();
+    for (const contentType of roleContract.contentTypes) {
+        const normalizedContentType = contentType.trim().toLowerCase();
+        if (normalizedContentType === normalizedResolvedContentType) {
+            return contentType.trim();
+        }
+    }
+    if ((0, node_path_1.extname)(filePath).toLowerCase() === '.json') {
+        const jsonLikeContentType = roleContract.contentTypes.find((contentType) => (0, types_1.isJsonLikeAssetSpecContentType)(contentType));
+        if (jsonLikeContentType) {
+            return jsonLikeContentType.trim();
+        }
+    }
+    return resolvedContentType;
+}
 // eslint-disable-next-line complexity
 function normalizeAssetSpecSupportEntries(raw, errors, context) {
     if (raw === undefined || raw === null) {
@@ -211,7 +232,7 @@ function validateCustomAssetFilesAgainstContract(contract, filePaths, errors, co
                 errors.push(`${context} role "${rawRole}" must use one of ${allowedExtensions.join(', ')}.`);
             }
         }
-        const resolvedContentType = resolveMimeTypeFromPath(filePath);
+        const resolvedContentType = resolveCustomAssetRoleContentType(filePath, roleContract);
         const normalizedContentTypes = roleContract.contentTypes.map((value) => value.trim().toLowerCase());
         if (!normalizedContentTypes.includes(resolvedContentType.toLowerCase())) {
             errors.push(`${context} role "${rawRole}" must use one of ${normalizedContentTypes.join(', ')}.`);

package/dist/assets/model-artifacts.d.ts

@@ -1,5 +1,5 @@
-import type { AssetTask, EmbeddedAssetTask } from '../catalogue';
-type ModelAssetTask = AssetTask | EmbeddedAssetTask;
+import type { AssetTask, OwnedAssetTask, PackOwnedAssetTask } from '../catalogue';
+type ModelAssetTask = AssetTask | OwnedAssetTask | PackOwnedAssetTask;
 export declare function isGeneratedModel3DAssetTask(task: ModelAssetTask, format?: string): boolean;
 export declare function assertGeneratedModel3DAssetRoles(task: ModelAssetTask, format?: string): void;
 export declare function prepareModel3DAssetArtifacts(task: ModelAssetTask, options?: {

package/dist/assets/model-artifacts.js

@@ -100,7 +100,7 @@ function normalizeRole(role) {
     return role.trim().toLowerCase();
 }
 function resolveTaskLabel(task) {
-    if (task.kind === 'embedded-asset') {
+    if ('kind' in task && task.kind === 'owned-asset') {
         return `${task.appName}:${task.name}`;
     }
     return task.name;

package/dist/captureRuntime.d.ts

@@ -19,6 +19,7 @@ export type RunCaptureOptions = {
     token?: string | null;
     user?: UserResponse | null;
     login?: LoginOptions | null;
+    savedSessionBootstrap?: boolean;
     enableCaptureBridge?: boolean;
 };
 export type CaptureRunResult = {

package/dist/captureRuntime.js

@@ -114,8 +114,9 @@ async function runCapture(options) {
     const outputLines = [];
     const expectedUrl = options.expectedUrl ? normalizeComparableUrl(options.expectedUrl) : null;
     const hasExplicitLogin = Boolean(options.login?.username);
-    const bootstrapToken = hasExplicitLogin ? null : options.token?.trim() || null;
-    const bootstrapUser = hasExplicitLogin ? null : options.user ?? null;
+    const shouldBootstrapSavedSession = options.savedSessionBootstrap !== false && !hasExplicitLogin;
+    const bootstrapToken = shouldBootstrapSavedSession ? options.token?.trim() || null : null;
+    const bootstrapUser = shouldBootstrapSavedSession ? options.user ?? null : null;
     let finalUrl = options.targetUrl;
     const record = (level, message) => {
         const line = `[capture][${level}] ${message}`;

package/dist/catalogue.d.ts

@@ -53,7 +53,7 @@ export type AppCatalogueEntry = {
     username?: string;
     achievements?: AppAchievementCatalogueDefinition[];
     leaderboards?: AppLeaderboardCatalogueDefinition[];
-    embeddedAssets?: EmbeddedAssetCatalogueEntry[];
+    ownedAssets?: OwnedAssetCatalogueEntry[];
     assetSpecSupport?: AppMetadataAssetSpecSupport[];
     uses?: {
         assets?: string[];
@@ -99,8 +99,9 @@ export type AssetSpecCatalogueEntry = {
     successorVersion?: string;
     username?: string;
 };
-export type EmbeddedAssetCatalogueEntry = {
+export type OwnedAssetCatalogueEntry = {
     name: string;
+    runtimeKey?: string;
     category?: string;
     subcategory?: string;
     format?: string;
@@ -115,6 +116,7 @@ export type AssetPackCatalogueEntry = {
     remix?: string;
     username?: string;
     assets?: string[];
+    ownedAssets?: OwnedAssetCatalogueEntry[];
     hostingMode?: string;
     externalUrl?: string;
     downloadUrl?: string;
@@ -145,6 +147,10 @@ export type ResolvedListingAssets = {
     videoPortraitPaths: string[];
     videoLandscapePaths: string[];
 };
+export type AppDependencyAssetRef = {
+    ref: string;
+    runtimeKey?: string;
+};
 export type AppTask = {
     kind: 'app';
     name: string;
@@ -181,10 +187,10 @@ export type AppTask = {
     achievements: ResolvedAppAchievementDefinition[];
     leaderboards: ResolvedAppLeaderboardDefinition[];
     remix?: string;
-    embeddedAssets: EmbeddedAssetTask[];
+    ownedAssets: OwnedAssetTask[];
     assetSpecSupport: AssetSpecSupportDeclaration[];
     uses: {
-        assets: string[];
+        assets: AppDependencyAssetRef[];
         packs: string[];
     };
     graph: {
@@ -211,6 +217,7 @@ export type AssetTask = {
     shopPriceCredits?: number;
     files: Record<string, string>;
     filePaths: Record<string, string>;
+    assetSpecContract?: AssetSpecContract;
     relations?: Array<{
         type: string;
         to: string;
@@ -236,13 +243,30 @@ export type AssetSpecTask = {
     documentationPath?: string;
     contract: AssetSpecContract;
 };
-export type EmbeddedAssetTask = {
-    kind: 'embedded-asset';
+export type OwnedAssetTask = {
+    kind: 'owned-asset';
     appName: string;
     name: string;
+    runtimeKey?: string;
     cataloguePath: string;
     category: string;
-    subcategory: string;
+    subcategory: string | null;
+    assetSpec?: string;
+    assetSpecContract?: AssetSpecContract;
+    format?: string;
+    visibility?: string;
+    shopListed?: boolean;
+    shopPriceCredits?: number;
+    files: Record<string, string>;
+    filePaths: Record<string, string>;
+};
+export type PackOwnedAssetTask = {
+    name: string;
+    cataloguePath: string;
+    category: string;
+    subcategory: string | null;
+    assetSpec?: string;
+    assetSpecContract?: AssetSpecContract;
     format?: string;
     visibility?: string;
     shopListed?: boolean;
@@ -259,6 +283,7 @@ export type AssetPackTask = {
     username?: string;
     remix?: string;
     assets: string[];
+    ownedAssets: PackOwnedAssetTask[];
     tags: string[];
     hostingMode?: AppHostingMode;
     externalUrl?: string;
@@ -279,7 +304,7 @@ export type CatalogueLoadResult = {
     apps: AppTask[];
     assetSpecs: AssetSpecTask[];
     assets: AssetTask[];
-    embeddedAssets: EmbeddedAssetTask[];
+    ownedAssets: OwnedAssetTask[];
     assetPacks: AssetPackTask[];
     warnings: string[];
     errors: string[];