@playdrop/playdrop-cli 0.3.8-build.3 → 0.3.9

package/dist/commands/upload.js

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upload = upload;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const types_1 = require("@playdrop/types");
-const http_1 = require("../http");
-const commandContext_1 = require("../commandContext");
-const uploadLog_1 = require("../uploadLog");
 const apps_1 = require("../apps");
+const commandContext_1 = require("../commandContext");
+const http_1 = require("../http");
 const taskSelection_1 = require("../taskSelection");
 const taskUtils_1 = require("../taskUtils");
-const model_artifacts_1 = require("../assets/model-artifacts");
+const uploadLog_1 = require("../uploadLog");
+const upload_content_1 = require("./upload-content");
+const upload_graph_1 = require("./upload-graph");
 const DEFAULT_PORTAL_BASE = 'https://www.playdrop.ai';
 const APP_TYPE_TO_SLUG = {
     GAME: 'game',
@@ -18,39 +17,20 @@ const APP_TYPE_TO_SLUG = {
     TOOL: 'tool',
     TEMPLATE: 'template',
 };
-const EXTENSION_TO_FORMAT = {
-    '.png': 'PNG',
-    '.jpg': 'JPEG',
-    '.jpeg': 'JPEG',
-    '.webp': 'WEBP',
-    '.gif': 'GIF',
-    '.aseprite': 'ASEPRITE',
-    '.mp4': 'MP4',
-    '.webm': 'WEBM',
-    '.mp3': 'MP3',
-    '.wav': 'WAV',
-    '.ogg': 'OGG',
-    '.vox': 'VOX',
-    '.gltf': 'GLTF',
-    '.glb': 'GLB',
-};
-const EXTENSION_TO_MIME = {
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.webp': 'image/webp',
-    '.gif': 'image/gif',
-    '.aseprite': 'application/octet-stream',
-    '.mp4': 'video/mp4',
-    '.webm': 'video/webm',
-    '.mp3': 'audio/mpeg',
-    '.wav': 'audio/wav',
-    '.ogg': 'audio/ogg',
-    '.vox': 'application/octet-stream',
-    '.gltf': 'model/gltf+json',
-    '.glb': 'model/gltf-binary',
-    '.json': 'application/json',
-};
+function buildApiUnavailableMessage(apiBase) {
+    if (apiBase && typeof apiBase === 'string') {
+        return `Could not reach the Playdrop API at ${apiBase}. Check your internet connection, then ensure the server is running before retrying.`;
+    }
+    return 'Could not reach the Playdrop API. Check your internet connection, then ensure the server is running before retrying.';
+}
+function isConnectionRefusedError(error) {
+    const networkCode = error?.cause?.code;
+    if (error instanceof TypeError || networkCode === 'ECONNREFUSED') {
+        return true;
+    }
+    const aggregateErrors = error?.cause?.errors;
+    return Array.isArray(aggregateErrors) && aggregateErrors.some((entry) => entry?.code === 'ECONNREFUSED');
+}
 async function fetchCurrentUserInfo(client, apiBase) {
     try {
         const data = await client.me();
@@ -70,16 +50,8 @@ async function fetchCurrentUserInfo(client, apiBase) {
         if (error instanceof types_1.ApiError) {
             return { username: null, role: null };
         }
-        const message = apiBase && typeof apiBase === 'string'
-            ? `Could not reach the Playdrop API at ${apiBase}. Check your internet connection, then ensure the server is running before retrying.`
-            : 'Could not reach the Playdrop API. Check your internet connection, then ensure the server is running before retrying.';
-        const networkCode = error?.cause?.code;
-        const aggregateErrors = error?.cause?.errors;
-        if (error instanceof TypeError || networkCode === 'ECONNREFUSED') {
-            throw new Error(message);
-        }
-        if (Array.isArray(aggregateErrors) && aggregateErrors.some((entry) => entry?.code === 'ECONNREFUSED')) {
-            throw new Error(message);
+        if (isConnectionRefusedError(error)) {
+            throw new Error(buildApiUnavailableMessage(apiBase));
         }
         throw error;
     }
@@ -132,548 +104,297 @@ function appendOverviewLink(entry, task, portalBase, creator) {
     }
     entry.detail = entry.detail ? `${entry.detail} | view: ${url}` : `view: ${url}`;
 }
-function createFileFromPath(filePath) {
-    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
-    const mimeType = EXTENSION_TO_MIME[extension] ?? 'application/octet-stream';
-    const data = (0, node_fs_1.readFileSync)(filePath);
-    return new File([data], (0, node_path_1.basename)(filePath), { type: mimeType });
+function buildTaskEntityId(task, creatorUsername) {
+    return task.kind === 'embedded-asset'
+        ? `${creatorUsername}/${task.appName}:${task.name}`
+        : `${creatorUsername}/${task.name}`;
 }
-function isPngSignature(buffer) {
-    if (buffer.length < 8) {
-        return false;
-    }
-    return (buffer[0] === 0x89
-        && buffer[1] === 0x50
-        && buffer[2] === 0x4e
-        && buffer[3] === 0x47
-        && buffer[4] === 0x0d
-        && buffer[5] === 0x0a
-        && buffer[6] === 0x1a
-        && buffer[7] === 0x0a);
-}
-function isMp4Signature(buffer) {
-    if (buffer.length < 12) {
-        return false;
-    }
-    return buffer.toString('ascii', 4, 8) === 'ftyp';
-}
-function createListingFileFromPath(filePath, expectedMime) {
-    const data = (0, node_fs_1.readFileSync)(filePath);
-    if (expectedMime === 'image/png' && !isPngSignature(data)) {
-        throw new Error(`Invalid listing file signature for ${filePath}. Expected image/png.`);
-    }
-    if (expectedMime === 'video/mp4' && !isMp4Signature(data)) {
-        throw new Error(`Invalid listing file signature for ${filePath}. Expected video/mp4.`);
-    }
-    return new File([data], (0, node_path_1.basename)(filePath), { type: expectedMime });
-}
-function resolveAssetFormat(task) {
-    if (typeof task.format === 'string' && task.format.trim().length > 0) {
-        return task.format.trim().toUpperCase();
-    }
-    if (task.category === 'MODEL_3D') {
-        const primaryFile = task.filePaths.primary;
-        if (typeof primaryFile === 'string') {
-            const normalizedPrimary = primaryFile.trim().toLowerCase();
-            if (normalizedPrimary.endsWith('.boxel.json')) {
-                return 'PLAYDROP_BOXEL_JSON';
-            }
-            if (normalizedPrimary.endsWith('.vox')) {
-                return 'VOX';
-            }
-            const primaryExtension = (0, node_path_1.extname)(normalizedPrimary);
-            if (primaryExtension === '.glb') {
-                return 'GLB';
-            }
-            if (primaryExtension === '.gltf') {
-                return 'GLTF';
-            }
-        }
-        const boxelFile = task.filePaths.boxel;
-        if (typeof boxelFile === 'string' && boxelFile.trim().toLowerCase().endsWith('.boxel.json')) {
-            return 'PLAYDROP_BOXEL_JSON';
-        }
-        const meshFile = task.filePaths.mesh;
-        if (typeof meshFile === 'string') {
-            const meshExtension = (0, node_path_1.extname)(meshFile).toLowerCase();
-            if (meshExtension === '.glb') {
-                return 'GLB';
-            }
-            if (meshExtension === '.gltf') {
-                return 'GLTF';
-            }
-        }
-        throw new Error(`Asset "${task.name}" is missing files.primary or uses an unsupported MODEL_3D primary extension.`);
-    }
-    const filePaths = Object.values(task.filePaths);
-    if (filePaths.length === 0) {
-        throw new Error(`Asset "${task.name}" has no files.`);
-    }
-    if (filePaths.length > 1) {
-        throw new Error(`Asset "${task.name}" is missing format and has multiple files. Set "format" explicitly in catalogue.json.`);
-    }
-    const extension = (0, node_path_1.extname)(filePaths[0]).toLowerCase();
-    const inferred = EXTENSION_TO_FORMAT[extension];
-    if (!inferred) {
-        throw new Error(`Asset "${task.name}" uses unsupported file extension "${extension}". Set "format" explicitly.`);
-    }
-    return inferred;
+function pushLoggedEntry(results, entry) {
+    results.push(entry);
+    console.log((0, uploadLog_1.formatTaskLogLine)(entry));
 }
-function validateAssetSubcategoryCompatibility(task, format) {
-    const category = typeof task.category === 'string' ? task.category.trim().toUpperCase() : '';
-    const subcategory = typeof task.subcategory === 'string' ? task.subcategory.trim().toLowerCase() : '';
-    const definition = types_1.ASSET_SUBCATEGORY_DEFINITIONS_BY_KEY[`${category}:${subcategory}`];
-    if (!definition) {
-        throw new Error(`Asset "${task.name}" uses unsupported subcategory "${task.subcategory}" for category "${task.category}".`);
+function buildUploadErrorDetail(error) {
+    const message = typeof error?.message === 'string' && error.message.trim()
+        ? error.message.trim()
+        : 'upload failed';
+    if (/status\s+413/i.test(message)) {
+        return 'upload failed: asset bundle too large (HTTP 413). Reduce the size of your app files and try again.';
     }
-    if (!definition.formats.includes(format)) {
-        throw new Error(`Asset "${task.name}" uses format "${format}" not allowed for subcategory "${subcategory}".`);
+    if (!message.startsWith('upload failed')) {
+        return `upload failed: ${message}`;
     }
-    (0, model_artifacts_1.assertGeneratedModel3DAssetRoles)(task, format);
-    return subcategory;
+    return message;
 }
-async function uploadAssetTask(client, task, sourceAppVersionId, creatorUsername) {
-    const format = resolveAssetFormat(task);
-    const subcategory = validateAssetSubcategoryCompatibility(task, format);
-    await (0, model_artifacts_1.prepareModel3DAssetArtifacts)(task);
-    const visibility = task.visibility;
-    const files = Object.entries(task.filePaths).map(([role, filePath]) => ({
-        file: createFileFromPath(filePath),
-        fieldName: role,
-        filename: (0, node_path_1.basename)(filePath),
-    }));
-    const targetCreatorUsername = typeof creatorUsername === 'string' ? creatorUsername.trim() : '';
-    if (!targetCreatorUsername) {
-        throw new Error(`Asset "${task.name}" upload is missing creator username.`);
-    }
-    const response = await client.createAssetVersion(targetCreatorUsername, task.name, {
-        displayName: task.kind === 'asset' ? task.displayName : undefined,
-        category: task.category,
-        subcategory,
-        format,
-        remixRef: task.kind === 'asset' ? task.remix : undefined,
-        visibility: visibility,
-        sourceKind: sourceAppVersionId ? 'APP_EMBEDDED' : 'UPLOAD',
-        sourceAppVersionId,
-        shopListed: task.shopListed,
-        shopPriceCredits: task.shopPriceCredits,
-        files,
-    });
-    const uploadedCreatorUsername = response.asset.creatorUsername;
-    const name = response.asset.name;
-    const revision = response.version.revision;
-    const versionNodeId = typeof response.versionNodeId === 'string' ? response.versionNodeId.trim() : '';
-    if (typeof uploadedCreatorUsername !== 'string' || uploadedCreatorUsername.trim().length === 0) {
-        throw new Error(`Asset "${task.name}" upload did not return creatorUsername.`);
-    }
-    if (!versionNodeId) {
-        throw new Error(`Asset "${task.name}" upload did not return versionNodeId.`);
-    }
+function buildTaskErrorEntry(task, entityId, error) {
     return {
-        creatorUsername: uploadedCreatorUsername,
-        name,
-        revision,
-        ref: `asset:${uploadedCreatorUsername}/${name}@r${revision}`,
-        versionNodeId,
+        action: 'upload',
+        status: 'error',
+        entityType: task.kind,
+        entityId,
+        catalogue: task.cataloguePath,
+        detail: buildUploadErrorDetail(error),
     };
 }
-function parseAssetRef(raw) {
-    const trimmed = raw.trim();
-    const canonicalMatch = /^asset:([^/]+)\/([^@]+)@r(\d+)$/i.exec(trimmed);
-    if (canonicalMatch) {
-        return {
-            creatorUsername: canonicalMatch[1],
-            name: canonicalMatch[2],
-            revision: Number.parseInt(canonicalMatch[3], 10),
-        };
-    }
-    const plainMatch = /^([^/]+)\/([^@]+)@r(\d+)$/i.exec(trimmed);
-    if (plainMatch) {
-        return {
-            creatorUsername: plainMatch[1],
-            name: plainMatch[2],
-            revision: Number.parseInt(plainMatch[3], 10),
-        };
-    }
-    return null;
+function buildPackPlanningFailureEntry(task, defaultCreator, currentUserRole, message) {
+    const creator = (0, upload_content_1.getTaskCreatorResult)(task, defaultCreator, currentUserRole);
+    return {
+        action: 'upload',
+        status: 'error',
+        entityType: task.kind,
+        entityId: buildTaskEntityId(task, creator.taskCreator),
+        catalogue: task.cataloguePath,
+        detail: `upload failed: ${message}`,
+    };
 }
-async function resolveAssetReference(client, rawRef, fallbackCreator, uploadedAssets) {
-    const trimmed = rawRef.trim();
-    if (!trimmed) {
-        throw new Error('Asset pack has an empty asset reference.');
-    }
-    const parsed = parseAssetRef(trimmed);
-    if (parsed) {
-        return `asset:${parsed.creatorUsername}/${parsed.name}@r${parsed.revision}`;
-    }
-    if (trimmed.includes('@')) {
-        throw new Error(`Invalid asset ref "${trimmed}". Use "asset:creator/name@rN" format.`);
-    }
-    const slashIndex = trimmed.indexOf('/');
-    const creatorUsername = slashIndex > 0 ? trimmed.slice(0, slashIndex) : fallbackCreator;
-    const name = slashIndex > 0 ? trimmed.slice(slashIndex + 1) : trimmed;
-    if (!creatorUsername || !name) {
-        throw new Error(`Invalid asset reference "${trimmed}".`);
-    }
-    const key = `${creatorUsername}/${name}`;
-    const uploaded = uploadedAssets.get(key);
-    if (uploaded) {
-        return uploaded.ref;
-    }
-    const detail = await client.fetchAssetBySlug(creatorUsername, name);
-    const revision = detail?.asset?.currentVersion?.revision;
-    if (typeof revision !== 'number' || !Number.isInteger(revision) || revision <= 0) {
-        throw new Error(`Asset "${creatorUsername}/${name}" has no current version to reference from asset pack.`);
-    }
-    return `asset:${creatorUsername}/${name}@r${revision}`;
+function appendTaskRelations(graphState, fromNodeId, relations, contextLabel) {
+    (relations ?? []).forEach((relation, index) => {
+        if (relation.type === 'REMIXES') {
+            throw new Error(`${contextLabel} relations[${index}] must use remix instead of REMIXES.`);
+        }
+        (0, upload_graph_1.appendPendingRelation)(graphState, fromNodeId, relation.type, relation.to, `${contextLabel} relations[${index}]`);
+    });
 }
-async function uploadAssetPackTask(client, task, creatorUsername, uploadedAssets, targetCreatorUsername) {
-    const assetRefs = [];
-    for (const ref of task.assets) {
-        assetRefs.push(await resolveAssetReference(client, ref, creatorUsername, uploadedAssets));
-    }
-    const mutationCreatorUsername = typeof targetCreatorUsername === 'string' && targetCreatorUsername.trim().length > 0
-        ? targetCreatorUsername.trim()
-        : creatorUsername.trim();
-    if (!mutationCreatorUsername) {
-        throw new Error(`Asset pack "${task.name}@${task.version}" upload is missing creator username.`);
-    }
-    const response = await client.uploadAssetPackVersion(mutationCreatorUsername, task.name, {
-        request: {
-            version: task.version,
-            remixRef: task.remix,
-            visibility: task.visibility,
-            hostingMode: task.hostingMode,
-            externalUrl: task.externalUrl,
-            downloadUrl: task.downloadUrl,
-            releaseNotes: task.releaseNotes,
-            assets: assetRefs.map((assetRef) => ({ assetRef })),
-        },
-        icon: task.listing?.iconPath ? createListingFileFromPath(task.listing.iconPath, 'image/png') : undefined,
-        heroPortrait: task.listing?.heroPortraitPath ? createListingFileFromPath(task.listing.heroPortraitPath, 'image/png') : undefined,
-        heroLandscape: task.listing?.heroLandscapePath ? createListingFileFromPath(task.listing.heroLandscapePath, 'image/png') : undefined,
-        screenshotsPortrait: task.listing?.screenshotPortraitPaths?.map((filePath) => createListingFileFromPath(filePath, 'image/png')),
-        screenshotsLandscape: task.listing?.screenshotLandscapePaths?.map((filePath) => createListingFileFromPath(filePath, 'image/png')),
-        videosPortrait: task.listing?.videoPortraitPaths?.map((filePath) => createListingFileFromPath(filePath, 'video/mp4')),
-        videosLandscape: task.listing?.videoLandscapePaths?.map((filePath) => createListingFileFromPath(filePath, 'video/mp4')),
+async function uploadAppTask(state, task, taskCreator, options) {
+    const { upload } = await (0, apps_1.runAppPipeline)(state.client, task, {
+        skipEcs: options?.skipEcs,
+        creatorUsername: taskCreator,
     });
-    const versionNodeId = typeof response.versionNodeId === 'string' ? response.versionNodeId.trim() : '';
-    if (!versionNodeId) {
-        throw new Error(`Asset pack "${task.name}@${task.version}" upload did not return versionNodeId.`);
-    }
-    return {
-        assetRefs,
-        versionNodeId,
-        ref: `pack:${creatorUsername}/${task.name}@${task.version}`,
+    if (!upload.versionCreated || !upload.version) {
+        throw new Error(`App "${task.name}" upload did not return a created version.`);
+    }
+    if (typeof upload.versionId !== 'number') {
+        throw new Error(`App "${task.name}" upload did not return version ID.`);
+    }
+    if (typeof upload.versionNodeId !== 'string' || upload.versionNodeId.trim().length === 0) {
+        throw new Error(`App "${task.name}" upload did not return versionNodeId.`);
+    }
+    const appRef = `app:${taskCreator}/${task.name}@${upload.version}`;
+    const uploadedApp = {
+        creatorUsername: taskCreator,
+        name: task.name,
+        version: upload.version,
+        versionId: upload.versionId,
+        versionNodeId: upload.versionNodeId,
+        ref: appRef,
     };
-}
-const RELATION_TYPES = new Set([
-    'USES',
-    'CONTAINS',
-    'REMIXES',
-]);
-function buildEmptyGraphState() {
-    return {
-        canonicalNodeByRef: new Map(),
-        localAppNodeByName: new Map(),
-        localAssetNodeByName: new Map(),
-        localPackNodeByNameVersion: new Map(),
-        ambiguousAppNames: new Set(),
-        ambiguousAssetNames: new Set(),
-        ambiguousPackNameVersions: new Set(),
-        pendingRelations: [],
+    state.uploadedAppsByName.set(task.name, uploadedApp);
+    (0, upload_graph_1.registerCanonicalNode)(state.graphState, appRef, uploadedApp.versionNodeId);
+    (0, upload_graph_1.registerLocalRef)(state.graphState.localAppNodeByName, state.graphState.ambiguousAppNames, task.name, uploadedApp.versionNodeId);
+    task.uses.assets.forEach((toRef, index) => {
+        (0, upload_graph_1.appendPendingRelation)(state.graphState, uploadedApp.versionNodeId, 'USES', toRef, `[${task.cataloguePath}] app "${task.name}" uses.assets[${index}]`);
+    });
+    task.uses.packs.forEach((toRef, index) => {
+        (0, upload_graph_1.appendPendingRelation)(state.graphState, uploadedApp.versionNodeId, 'USES', toRef, `[${task.cataloguePath}] app "${task.name}" uses.packs[${index}]`);
+    });
+    appendTaskRelations(state.graphState, uploadedApp.versionNodeId, task.graph.relations, `[${task.cataloguePath}] app "${task.name}"`);
+    const entry = {
+        action: 'upload',
+        status: 'success',
+        entityType: 'app',
+        entityId: buildTaskEntityId(task, taskCreator),
+        catalogue: task.cataloguePath,
+        detail: `version ${upload.version} created`,
     };
+    appendOverviewLink(entry, task, state.portalBase, taskCreator);
+    return entry;
 }
-function registerLocalRef(map, ambiguous, key, nodeId) {
-    const normalized = key.trim();
-    if (!normalized) {
-        return;
-    }
-    const existing = map.get(normalized);
-    if (!existing) {
-        map.set(normalized, nodeId);
-        return;
-    }
-    if (existing !== nodeId) {
-        ambiguous.add(normalized);
+async function uploadStandaloneAssetTask(state, task, taskCreator) {
+    const ownedPack = state.packPlanning.ownedPackByAssetKey.get((0, upload_content_1.buildAssetKey)(taskCreator, task.name));
+    if (ownedPack) {
+        return {
+            action: 'upload',
+            status: 'success',
+            entityType: 'asset',
+            entityId: buildTaskEntityId(task, taskCreator),
+            catalogue: task.cataloguePath,
+            detail: `staged with asset pack ${ownedPack.packTask.name}@${ownedPack.packTask.version}`,
+        };
     }
+    const uploaded = await (0, upload_content_1.uploadAssetTask)(state.client, task, undefined, taskCreator);
+    state.uploadedAssetsByKey.set(`${uploaded.creatorUsername}/${uploaded.name}`, uploaded);
+    (0, upload_graph_1.registerCanonicalNode)(state.graphState, uploaded.ref, uploaded.versionNodeId);
+    (0, upload_graph_1.registerLocalRef)(state.graphState.localAssetNodeByName, state.graphState.ambiguousAssetNames, task.name, uploaded.versionNodeId);
+    appendTaskRelations(state.graphState, uploaded.versionNodeId, task.relations, `[${task.cataloguePath}] asset "${task.name}"`);
+    const entry = {
+        action: 'upload',
+        status: 'success',
+        entityType: 'asset',
+        entityId: buildTaskEntityId(task, taskCreator),
+        catalogue: task.cataloguePath,
+        detail: uploaded.ref,
+    };
+    appendOverviewLink(entry, task, state.portalBase, uploaded.creatorUsername);
+    return entry;
 }
-function registerCanonicalNode(state, ref, nodeId) {
-    const normalized = ref.trim();
-    if (!normalized) {
-        return;
-    }
-    state.canonicalNodeByRef.set(normalized, nodeId);
+async function uploadEmbeddedAssetTask(state, task, taskCreator) {
+    const sourceApp = state.uploadedAppsByName.get(task.appName);
+    if (!sourceApp) {
+        throw new Error(`Embedded asset "${task.name}" references app "${task.appName}" that was not uploaded in this run.`);
+    }
+    const uploaded = await (0, upload_content_1.uploadAssetTask)(state.client, task, sourceApp.versionId, sourceApp.creatorUsername);
+    state.uploadedAssetsByKey.set(`${uploaded.creatorUsername}/${uploaded.name}`, uploaded);
+    (0, upload_graph_1.registerCanonicalNode)(state.graphState, uploaded.ref, uploaded.versionNodeId);
+    (0, upload_graph_1.registerLocalRef)(state.graphState.localAssetNodeByName, state.graphState.ambiguousAssetNames, task.name, uploaded.versionNodeId);
+    const entry = {
+        action: 'upload',
+        status: 'success',
+        entityType: 'embedded-asset',
+        entityId: buildTaskEntityId(task, taskCreator),
+        catalogue: task.cataloguePath,
+        detail: `${uploaded.ref} (source app version ${sourceApp.versionId})`,
+    };
+    appendOverviewLink(entry, task, state.portalBase, uploaded.creatorUsername);
+    return entry;
 }
-function appendPendingRelation(state, fromNodeId, type, toRef, context) {
-    state.pendingRelations.push({
-        fromNodeId,
-        type,
-        toRef,
-        context,
+function collectPackLocalAssetTasks(state, task, taskCreator) {
+    const packKey = (0, upload_content_1.buildPackKey)(taskCreator, task.name, task.version);
+    const packPlan = state.packPlanning.packPlansByKey.get(packKey);
+    if (!packPlan) {
+        throw new Error(`Asset pack "${task.name}@${task.version}" is missing an upload plan.`);
+    }
+    const localAssetTasks = packPlan.ownedAssetKeys.map((assetKey) => {
+        const ownedTask = state.sortedTasks.find((candidate) => candidate.kind === 'asset' && (0, upload_content_1.buildAssetKey)(taskCreator, candidate.name) === assetKey);
+        if (!ownedTask || ownedTask.kind !== 'asset') {
+            throw new Error(`Asset pack "${task.name}@${task.version}" is missing local asset task "${assetKey}".`);
+        }
+        return ownedTask;
     });
+    return { packKey, packPlan, localAssetTasks };
 }
-function parseRelationType(raw, context) {
-    const normalized = raw.trim().toUpperCase();
-    if (!RELATION_TYPES.has(normalized)) {
-        throw new Error(`${context}: relation type "${raw}" is not supported.`);
-    }
-    return normalized;
-}
-function resolveLocalRefNodeId(map, ambiguous, key, context, kindLabel) {
-    if (ambiguous.has(key)) {
-        throw new Error(`${context}: local ${kindLabel} ref "${key}" is ambiguous. Use a canonical ref.`);
-    }
-    const nodeId = map.get(key);
-    if (!nodeId) {
-        throw new Error(`${context}: local ${kindLabel} ref "${key}" was not created in this upload run.`);
-    }
-    return nodeId;
-}
-function resolveRelationTargetNodeId(state, rawRef, context) {
-    const ref = rawRef.trim();
-    if (!ref) {
-        throw new Error(`${context}: relation target ref is empty.`);
-    }
-    if (ref.startsWith('@app/')) {
-        const name = ref.slice('@app/'.length).trim();
-        if (!name) {
-            throw new Error(`${context}: invalid local app ref "${ref}". Use "@app/<name>".`);
+function registerUploadedLocalPackAssets(state, task, taskCreator, packPlan, localAssetTasks, uploadedPack) {
+    const localTaskByUploadKey = new Map();
+    for (const localAssetTask of localAssetTasks) {
+        const uploadKey = packPlan.uploadKeyByAssetKey.get((0, upload_content_1.buildAssetKey)(taskCreator, localAssetTask.name));
+        if (!uploadKey) {
+            throw new Error(`Asset pack "${task.name}@${task.version}" is missing upload key for local asset "${localAssetTask.name}".`);
         }
-        return resolveLocalRefNodeId(state.localAppNodeByName, state.ambiguousAppNames, name, context, 'app');
+        localTaskByUploadKey.set(uploadKey, localAssetTask);
     }
-    if (ref.startsWith('@asset/')) {
-        const name = ref.slice('@asset/'.length).trim();
-        if (!name) {
-            throw new Error(`${context}: invalid local asset ref "${ref}". Use "@asset/<name>".`);
+    for (const uploadedLocalAsset of uploadedPack.uploadedLocalAssets) {
+        const localTask = localTaskByUploadKey.get(uploadedLocalAsset.uploadKey);
+        if (!localTask) {
+            continue;
         }
-        return resolveLocalRefNodeId(state.localAssetNodeByName, state.ambiguousAssetNames, name, context, 'asset');
+        const uploadedLocalRef = {
+            creatorUsername: uploadedLocalAsset.creatorUsername,
+            name: uploadedLocalAsset.name,
+            revision: uploadedLocalAsset.revision,
+            ref: `asset:${uploadedLocalAsset.creatorUsername}/${uploadedLocalAsset.name}@r${uploadedLocalAsset.revision}`,
+            versionNodeId: uploadedLocalAsset.versionNodeId,
+        };
+        state.uploadedAssetsByKey.set((0, upload_content_1.buildAssetKey)(uploadedLocalAsset.creatorUsername, uploadedLocalAsset.name), uploadedLocalRef);
+        (0, upload_graph_1.registerCanonicalNode)(state.graphState, uploadedLocalRef.ref, uploadedLocalRef.versionNodeId);
+        (0, upload_graph_1.registerLocalRef)(state.graphState.localAssetNodeByName, state.graphState.ambiguousAssetNames, localTask.name, uploadedLocalRef.versionNodeId);
+        appendTaskRelations(state.graphState, uploadedLocalRef.versionNodeId, localTask.relations, `[${localTask.cataloguePath}] asset "${localTask.name}"`);
     }
-    if (ref.startsWith('@pack/')) {
-        const target = ref.slice('@pack/'.length).trim();
-        const index = target.lastIndexOf('@');
-        if (index <= 0 || index === target.length - 1) {
-            throw new Error(`${context}: invalid local pack ref "${ref}". Use "@pack/<name>@<semver>".`);
-        }
-        return resolveLocalRefNodeId(state.localPackNodeByNameVersion, state.ambiguousPackNameVersions, target, context, 'pack');
+}
+async function uploadPackTask(state, task, taskCreator) {
+    const { packPlan, localAssetTasks } = collectPackLocalAssetTasks(state, task, taskCreator);
+    const mutationTargetCreator = typeof task.username === 'string' && task.username.trim().length > 0
+        ? taskCreator
+        : undefined;
+    const uploadedPack = await (0, upload_content_1.uploadAssetPackTask)(state.client, task, taskCreator, state.uploadedAssetsByKey, localAssetTasks, packPlan.uploadKeyByAssetKey, mutationTargetCreator);
+    (0, upload_graph_1.registerCanonicalNode)(state.graphState, uploadedPack.ref, uploadedPack.versionNodeId);
+    (0, upload_graph_1.registerLocalRef)(state.graphState.localPackNodeByNameVersion, state.graphState.ambiguousPackNameVersions, `${task.name}@${task.version}`, uploadedPack.versionNodeId);
+    registerUploadedLocalPackAssets(state, task, taskCreator, packPlan, localAssetTasks, uploadedPack);
+    appendTaskRelations(state.graphState, uploadedPack.versionNodeId, task.relations, `[${task.cataloguePath}] assetPack "${task.name}@${task.version}"`);
+    const entry = {
+        action: 'upload',
+        status: 'success',
+        entityType: 'asset-pack',
+        entityId: buildTaskEntityId(task, taskCreator),
+        catalogue: task.cataloguePath,
+        detail: `version ${task.version} created (${uploadedPack.assetRefs.length} assets)`,
+    };
+    appendOverviewLink(entry, task, state.portalBase, taskCreator);
+    return entry;
+}
+async function processSingleUploadTask(state, task, taskCreator, options) {
+    if (task.kind === 'app') {
+        return await uploadAppTask(state, task, taskCreator, options);
     }
-    const canonicalPattern = /^(app|asset|pack):[^/]+\/[^@]+@.+$/i;
-    if (!canonicalPattern.test(ref)) {
-        throw new Error(`${context}: invalid relation target ref "${ref}". Use canonical refs (app:/asset:/pack:) or local refs (@app/@asset/@pack).`);
+    if (task.kind === 'asset') {
+        return await uploadStandaloneAssetTask(state, task, taskCreator);
     }
-    const nodeId = state.canonicalNodeByRef.get(ref);
-    if (!nodeId) {
-        throw new Error(`${context}: canonical ref "${ref}" was not resolved in this upload run.`);
+    if (task.kind === 'embedded-asset') {
+        return await uploadEmbeddedAssetTask(state, task, taskCreator);
     }
-    return nodeId;
+    if (task.kind === 'asset-pack') {
+        return await uploadPackTask(state, task, taskCreator);
+    }
+    throw new Error(`Unsupported task kind "${task.kind}".`);
 }
-async function applyGraphOperations(client, state) {
-    if (state.pendingRelations.length > 0) {
-        const relations = state.pendingRelations.map((row) => ({
-            fromNodeId: row.fromNodeId,
-            toNodeId: resolveRelationTargetNodeId(state, row.toRef, row.context),
-            type: parseRelationType(row.type, row.context),
-        }));
-        await client.batchUpsertGraphRelations({ relations });
+async function flushGraphState(client, graphState, results) {
+    try {
+        await (0, upload_graph_1.applyGraphOperations)(client, graphState);
+    }
+    catch (error) {
+        const message = typeof error?.message === 'string' && error.message.trim().length > 0
+            ? error.message.trim()
+            : 'graph batch upload failed';
+        const entry = {
+            action: 'upload',
+            status: 'error',
+            entityType: 'app',
+            entityId: 'graph',
+            catalogue: 'graph:batch',
+            detail: `upload failed: ${message}`,
+        };
+        pushLoggedEntry(results, entry);
+        process.exitCode = process.exitCode || 1;
     }
 }
 async function processUploadTasks(client, tasks, owner, ownerUsername, currentUserRole, webBase, options) {
     const portalBase = webBase ? normalizePortalBase(webBase) : null;
     const defaultCreator = normalizeCreatorUsername(ownerUsername) ?? owner;
-    const uploadedAppsByName = new Map();
-    const uploadedAssetsByKey = new Map();
-    const graphState = buildEmptyGraphState();
     const results = [];
     let aborted = false;
-    for (const task of (0, taskUtils_1.sortTasks)(tasks)) {
-        let taskOwner = defaultCreator;
-        let taskOwnerUsername = defaultCreator;
-        const requestedTaskOwner = 'username' in task && typeof task.username === 'string'
-            ? String(task.username).trim()
-            : '';
-        const creatorTargetError = requestedTaskOwner && currentUserRole !== 'ADMIN'
-            ? `Task "${task.name}" sets username="${requestedTaskOwner}", but only admins can target another creator.`
-            : null;
-        if (requestedTaskOwner && !creatorTargetError) {
-            taskOwner = requestedTaskOwner;
-            taskOwnerUsername = requestedTaskOwner;
-            console.log(`[Admin] Publishing ${task.name} as user: ${requestedTaskOwner}`);
+    const sortedTasks = (0, taskUtils_1.sortTasks)(tasks);
+    const packPlanning = (0, upload_content_1.buildAssetPackUploadPlans)(sortedTasks, defaultCreator, currentUserRole);
+    if (!packPlanning.ok) {
+        const entry = buildPackPlanningFailureEntry(packPlanning.task, defaultCreator, currentUserRole, packPlanning.message);
+        pushLoggedEntry(results, entry);
+        process.exitCode = process.exitCode || 1;
+        return results;
+    }
+    const state = {
+        client,
+        sortedTasks,
+        defaultCreator,
+        currentUserRole,
+        portalBase,
+        uploadedAppsByName: new Map(),
+        uploadedAssetsByKey: new Map(),
+        graphState: (0, upload_graph_1.buildEmptyGraphState)(),
+        packPlanning,
+    };
+    for (const task of sortedTasks) {
+        const creatorResult = (0, upload_content_1.getTaskCreatorResult)(task, defaultCreator, currentUserRole);
+        if (creatorResult.requestedTaskOwner && !creatorResult.creatorTargetError) {
+            console.log(`[Admin] Publishing ${task.name} as user: ${creatorResult.taskCreator}`);
         }
-        const entityId = task.kind === 'embedded-asset' ? `${taskOwner}/${task.appName}:${task.name}` : `${taskOwner}/${task.name}`;
-        const taskCreator = normalizeCreatorUsername(taskOwnerUsername) ?? taskOwner;
+        const entityId = buildTaskEntityId(task, creatorResult.taskCreator);
+        const taskCreator = creatorResult.taskCreator;
         try {
-            if (creatorTargetError) {
-                throw new Error(creatorTargetError);
-            }
-            if (task.kind === 'app') {
-                const { upload } = await (0, apps_1.runAppPipeline)(client, task, {
-                    skipEcs: options?.skipEcs,
-                    creatorUsername: taskCreator,
-                });
-                if (!upload.versionCreated || !upload.version) {
-                    throw new Error(`App "${task.name}" upload did not return a created version.`);
-                }
-                if (typeof upload.versionId !== 'number') {
-                    throw new Error(`App "${task.name}" upload did not return version ID.`);
-                }
-                if (typeof upload.versionNodeId !== 'string' || upload.versionNodeId.trim().length === 0) {
-                    throw new Error(`App "${task.name}" upload did not return versionNodeId.`);
-                }
-                const appRef = `app:${taskCreator}/${task.name}@${upload.version}`;
-                const uploadedApp = {
-                    creatorUsername: taskCreator,
-                    name: task.name,
-                    version: upload.version,
-                    versionId: upload.versionId,
-                    versionNodeId: upload.versionNodeId,
-                    ref: appRef,
-                };
-                uploadedAppsByName.set(task.name, uploadedApp);
-                registerCanonicalNode(graphState, appRef, uploadedApp.versionNodeId);
-                registerLocalRef(graphState.localAppNodeByName, graphState.ambiguousAppNames, task.name, uploadedApp.versionNodeId);
-                task.uses.assets.forEach((toRef, index) => {
-                    appendPendingRelation(graphState, uploadedApp.versionNodeId, 'USES', toRef, `[${task.cataloguePath}] app "${task.name}" uses.assets[${index}]`);
-                });
-                task.uses.packs.forEach((toRef, index) => {
-                    appendPendingRelation(graphState, uploadedApp.versionNodeId, 'USES', toRef, `[${task.cataloguePath}] app "${task.name}" uses.packs[${index}]`);
-                });
-                task.graph.relations.forEach((relation, index) => {
-                    if (relation.type === 'REMIXES') {
-                        throw new Error(`[${task.cataloguePath}] app "${task.name}" relations[${index}] must use remix instead of REMIXES.`);
-                    }
-                    appendPendingRelation(graphState, uploadedApp.versionNodeId, relation.type, relation.to, `[${task.cataloguePath}] app "${task.name}" relations[${index}]`);
-                });
-                const entry = {
-                    action: 'upload',
-                    status: 'success',
-                    entityType: 'app',
-                    entityId,
-                    catalogue: task.cataloguePath,
-                    detail: `version ${upload.version} created`,
-                };
-                appendOverviewLink(entry, task, portalBase, taskCreator);
-                results.push(entry);
-                console.log((0, uploadLog_1.formatTaskLogLine)(entry));
-            }
-            else if (task.kind === 'asset') {
-                const uploaded = await uploadAssetTask(client, task, undefined, taskCreator);
-                uploadedAssetsByKey.set(`${uploaded.creatorUsername}/${uploaded.name}`, uploaded);
-                registerCanonicalNode(graphState, uploaded.ref, uploaded.versionNodeId);
-                registerLocalRef(graphState.localAssetNodeByName, graphState.ambiguousAssetNames, task.name, uploaded.versionNodeId);
-                (task.relations ?? []).forEach((relation, index) => {
-                    if (relation.type === 'REMIXES') {
-                        throw new Error(`[${task.cataloguePath}] asset "${task.name}" relations[${index}] must use remix instead of REMIXES.`);
-                    }
-                    appendPendingRelation(graphState, uploaded.versionNodeId, relation.type, relation.to, `[${task.cataloguePath}] asset "${task.name}" relations[${index}]`);
-                });
-                const entry = {
-                    action: 'upload',
-                    status: 'success',
-                    entityType: 'asset',
-                    entityId,
-                    catalogue: task.cataloguePath,
-                    detail: uploaded.ref,
-                };
-                appendOverviewLink(entry, task, portalBase, uploaded.creatorUsername);
-                results.push(entry);
-                console.log((0, uploadLog_1.formatTaskLogLine)(entry));
-            }
-            else if (task.kind === 'embedded-asset') {
-                const sourceApp = uploadedAppsByName.get(task.appName);
-                if (!sourceApp) {
-                    throw new Error(`Embedded asset "${task.name}" references app "${task.appName}" that was not uploaded in this run.`);
-                }
-                const uploaded = await uploadAssetTask(client, task, sourceApp.versionId, sourceApp.creatorUsername);
-                uploadedAssetsByKey.set(`${uploaded.creatorUsername}/${uploaded.name}`, uploaded);
-                registerCanonicalNode(graphState, uploaded.ref, uploaded.versionNodeId);
-                registerLocalRef(graphState.localAssetNodeByName, graphState.ambiguousAssetNames, task.name, uploaded.versionNodeId);
-                const entry = {
-                    action: 'upload',
-                    status: 'success',
-                    entityType: 'embedded-asset',
-                    entityId,
-                    catalogue: task.cataloguePath,
-                    detail: `${uploaded.ref} (source app version ${sourceApp.versionId})`,
-                };
-                appendOverviewLink(entry, task, portalBase, uploaded.creatorUsername);
-                results.push(entry);
-                console.log((0, uploadLog_1.formatTaskLogLine)(entry));
-            }
-            else if (task.kind === 'asset-pack') {
-                const mutationTargetCreator = typeof task.username === 'string' && task.username.trim().length > 0
-                    ? taskCreator
-                    : undefined;
-                const uploadedPack = await uploadAssetPackTask(client, task, taskCreator, uploadedAssetsByKey, mutationTargetCreator);
-                registerCanonicalNode(graphState, uploadedPack.ref, uploadedPack.versionNodeId);
-                registerLocalRef(graphState.localPackNodeByNameVersion, graphState.ambiguousPackNameVersions, `${task.name}@${task.version}`, uploadedPack.versionNodeId);
-                (task.relations ?? []).forEach((relation, index) => {
-                    if (relation.type === 'REMIXES') {
-                        throw new Error(`[${task.cataloguePath}] assetPack "${task.name}@${task.version}" relations[${index}] must use remix instead of REMIXES.`);
-                    }
-                    appendPendingRelation(graphState, uploadedPack.versionNodeId, relation.type, relation.to, `[${task.cataloguePath}] assetPack "${task.name}@${task.version}" relations[${index}]`);
-                });
-                const entry = {
-                    action: 'upload',
-                    status: 'success',
-                    entityType: 'asset-pack',
-                    entityId,
-                    catalogue: task.cataloguePath,
-                    detail: `version ${task.version} created (${uploadedPack.assetRefs.length} assets)`,
-                };
-                appendOverviewLink(entry, task, portalBase, taskCreator);
-                results.push(entry);
-                console.log((0, uploadLog_1.formatTaskLogLine)(entry));
-            }
-            else {
-                throw new Error(`Unsupported task kind "${task.kind}".`);
+            if (creatorResult.creatorTargetError) {
+                throw new Error(creatorResult.creatorTargetError);
             }
+            const entry = await processSingleUploadTask(state, task, taskCreator, options);
+            pushLoggedEntry(results, entry);
         }
         catch (error) {
             if (error instanceof http_1.CLIUnsupportedClientError) {
                 throw error;
             }
-            let message = typeof error?.message === 'string' && error.message.trim() ? error.message.trim() : 'upload failed';
-            if (/status\s+413/i.test(message)) {
-                message = 'upload failed: asset bundle too large (HTTP 413). Reduce the size of your app files and try again.';
-            }
-            else if (!message.startsWith('upload failed')) {
-                message = `upload failed: ${message}`;
-            }
-            const entry = {
-                action: 'upload',
-                status: 'error',
-                entityType: task.kind,
-                entityId,
-                catalogue: task.cataloguePath,
-                detail: message,
-            };
-            results.push(entry);
-            console.log((0, uploadLog_1.formatTaskLogLine)(entry));
+            const entry = buildTaskErrorEntry(task, entityId, error);
+            pushLoggedEntry(results, entry);
             process.exitCode = process.exitCode || 1;
             aborted = true;
             break;
         }
     }
     if (!aborted) {
-        try {
-            await applyGraphOperations(client, graphState);
-        }
-        catch (error) {
-            const message = typeof error?.message === 'string' && error.message.trim().length > 0
-                ? error.message.trim()
-                : 'graph batch upload failed';
-            const entry = {
-                action: 'upload',
-                status: 'error',
-                entityType: 'app',
-                entityId: 'graph',
-                catalogue: 'graph:batch',
-                detail: `upload failed: ${message}`,
-            };
-            results.push(entry);
-            console.log((0, uploadLog_1.formatTaskLogLine)(entry));
-            process.exitCode = process.exitCode || 1;
-        }
+        await flushGraphState(client, state.graphState, results);
     }
     return results;
 }