@playdrop/playdrop-cli 0.7.2 → 0.7.4

package/dist/commands/upload.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.upload = upload;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const semver_1 = require("semver");
 const types_1 = require("@playdrop/types");
 const apps_1 = require("../apps");
 const commandContext_1 = require("../commandContext");
@@ -182,6 +183,522 @@ function normalizeCreatorUsername(username) {
     }
     return trimmed;
 }
+function isNotFoundApiError(error) {
+    return error instanceof types_1.ApiError && error.status === 404;
+}
+function createRemoteDependencyCache() {
+    return {
+        assetSpecVersionExists: new Map(),
+        assetSpecSupportExists: new Map(),
+        assetVersionExists: new Map(),
+        packVersionExists: new Map(),
+    };
+}
+function createTaskExecutionId(task, creator, index) {
+    if (task.kind === 'asset-spec') {
+        return `${index}:${task.kind}:${creator}/${task.name}@${task.version}`;
+    }
+    if (task.kind === 'asset-pack') {
+        return `${index}:${task.kind}:${creator}/${task.name}@${task.version}`;
+    }
+    if (task.kind === 'owned-asset') {
+        return `${index}:${task.kind}:${creator}/${task.appName}:${task.name}`;
+    }
+    return `${index}:${task.kind}:${creator}/${task.name}`;
+}
+function buildTaskDetailEntry(task, entityId, status, detail) {
+    return {
+        action: 'upload',
+        status,
+        entityType: task.kind,
+        entityId,
+        catalogue: task.cataloguePath,
+        detail,
+    };
+}
+function buildTaskDirectErrorEntry(task, entityId, detail) {
+    return buildTaskDetailEntry(task, entityId, 'error', detail.startsWith('upload failed:') ? detail : `upload failed: ${detail}`);
+}
+function buildTaskBlockedEntry(task, entityId, detail) {
+    return buildTaskDetailEntry(task, entityId, 'blocked', detail);
+}
+function buildAssetSpecFamilyKey(creatorUsername, name) {
+    return `${creatorUsername}/${name}`;
+}
+function buildAssetSpecVersionKey(creatorUsername, name, version) {
+    return `${creatorUsername}/${name}@${version}`;
+}
+function pushIndexedNode(map, key, node) {
+    const existing = map.get(key);
+    if (existing) {
+        existing.push(node);
+        return;
+    }
+    map.set(key, [node]);
+}
+function pickSingleLocalDependency(candidates, ref) {
+    if (!candidates || candidates.length === 0) {
+        return { node: null, blockedDetail: null };
+    }
+    if (candidates.length > 1) {
+        return {
+            node: null,
+            blockedDetail: `local_dependency_ambiguous:${ref}`,
+        };
+    }
+    return { node: candidates[0], blockedDetail: null };
+}
+function pickCompatibleLocalAssetSpecTask(candidates, versionRange) {
+    if (!candidates || candidates.length === 0) {
+        return null;
+    }
+    const matching = candidates.filter((candidate) => (candidate.task.kind === 'asset-spec' && (0, semver_1.satisfies)(candidate.task.version, versionRange)));
+    if (matching.length === 0) {
+        return null;
+    }
+    matching.sort((left, right) => (0, semver_1.compare)(right.task.version, left.task.version));
+    return matching[0];
+}
+async function validateRemoteAssetSpecVersionExists(client, rawRef, cache) {
+    if (cache.assetSpecVersionExists.has(rawRef)) {
+        return cache.assetSpecVersionExists.get(rawRef);
+    }
+    const parsed = (0, types_1.parseAssetSpecVersionRef)(rawRef);
+    if (!parsed) {
+        cache.assetSpecVersionExists.set(rawRef, false);
+        return false;
+    }
+    try {
+        await client.fetchAssetSpecVersion(parsed.creatorUsername, parsed.name, parsed.version);
+        cache.assetSpecVersionExists.set(rawRef, true);
+        return true;
+    }
+    catch (error) {
+        if (isNotFoundApiError(error)) {
+            cache.assetSpecVersionExists.set(rawRef, false);
+            return false;
+        }
+        throw error;
+    }
+}
+async function validateRemoteAssetSpecSupportExists(client, familyRef, versionRange, cache) {
+    const cacheKey = `${familyRef}@@${versionRange}`;
+    if (cache.assetSpecSupportExists.has(cacheKey)) {
+        return cache.assetSpecSupportExists.get(cacheKey);
+    }
+    const parsed = (0, types_1.parseAssetSpecFamilyRef)(familyRef);
+    if (!parsed) {
+        cache.assetSpecSupportExists.set(cacheKey, false);
+        return false;
+    }
+    try {
+        const response = await client.listAssetSpecVersions(parsed.creatorUsername, parsed.name, { limit: 200, offset: 0 });
+        const exists = response.versions.some((version) => (0, semver_1.satisfies)(version.version, versionRange));
+        cache.assetSpecSupportExists.set(cacheKey, exists);
+        return exists;
+    }
+    catch (error) {
+        if (isNotFoundApiError(error)) {
+            cache.assetSpecSupportExists.set(cacheKey, false);
+            return false;
+        }
+        throw error;
+    }
+}
+async function validateRemoteAssetVersionExists(client, rawRef, cache) {
+    if (cache.assetVersionExists.has(rawRef)) {
+        return cache.assetVersionExists.get(rawRef);
+    }
+    const parsed = (0, types_1.parseContentVersionRef)(rawRef);
+    if (!parsed || parsed.kind !== 'asset') {
+        cache.assetVersionExists.set(rawRef, false);
+        return false;
+    }
+    try {
+        const detail = await client.fetchAssetBySlug(parsed.creatorUsername, parsed.name);
+        if (detail.asset.currentVersion?.revision === parsed.revision) {
+            cache.assetVersionExists.set(rawRef, true);
+            return true;
+        }
+        const versions = await client.listAssetVersions(parsed.creatorUsername, parsed.name, { limit: 200, offset: 0 });
+        const exists = versions.versions.some((version) => version.revision === parsed.revision);
+        cache.assetVersionExists.set(rawRef, exists);
+        return exists;
+    }
+    catch (error) {
+        if (isNotFoundApiError(error)) {
+            cache.assetVersionExists.set(rawRef, false);
+            return false;
+        }
+        throw error;
+    }
+}
+async function validateRemotePackVersionExists(client, rawRef, cache) {
+    if (cache.packVersionExists.has(rawRef)) {
+        return cache.packVersionExists.get(rawRef);
+    }
+    const parsed = (0, types_1.parseContentVersionRef)(rawRef);
+    if (!parsed || parsed.kind !== 'pack') {
+        cache.packVersionExists.set(rawRef, false);
+        return false;
+    }
+    try {
+        const detail = await client.fetchAssetPackBySlug(parsed.creatorUsername, parsed.name);
+        if (detail.pack.currentVersion?.version === parsed.version) {
+            cache.packVersionExists.set(rawRef, true);
+            return true;
+        }
+        const versions = await client.listAssetPackVersions(parsed.creatorUsername, parsed.name, { limit: 200, offset: 0 });
+        const exists = versions.versions.some((version) => version.version === parsed.version);
+        cache.packVersionExists.set(rawRef, exists);
+        return exists;
+    }
+    catch (error) {
+        if (isNotFoundApiError(error)) {
+            cache.packVersionExists.set(rawRef, false);
+            return false;
+        }
+        throw error;
+    }
+}
+function addLocalDependency(node, dependencyTaskId, ref) {
+    if (node.localDependencies.some((dependency) => dependency.taskId === dependencyTaskId)) {
+        return;
+    }
+    node.localDependencies.push({ taskId: dependencyTaskId, ref });
+}
+function normalizePackDependencyRef(rawRef) {
+    const parsed = (0, types_1.parseContentVersionRef)(rawRef);
+    if (!parsed || parsed.kind !== 'pack') {
+        return null;
+    }
+    return (0, types_1.formatContentVersionRef)(parsed);
+}
+function buildTagRegistryEntry(allowedTargetKinds) {
+    return {
+        allowedTargetKinds: normalizeSavedItemKinds(allowedTargetKinds),
+        tags: new Set(),
+    };
+}
+function mergeTagRegistryEntry(registry, groupSlug, entry, options) {
+    const existing = registry.get(groupSlug);
+    if (!existing) {
+        registry.set(groupSlug, {
+            allowedTargetKinds: [...entry.allowedTargetKinds],
+            tags: new Set(entry.tags),
+        });
+        return;
+    }
+    if (options.replaceAllowedTargetKinds) {
+        existing.allowedTargetKinds = [...entry.allowedTargetKinds];
+    }
+    entry.tags.forEach((tagSlug) => existing.tags.add(tagSlug));
+}
+async function buildRemoteTagRegistry(client) {
+    const registry = new Map();
+    let directoryOffset = 0;
+    while (true) {
+        const directory = await client.fetchTagDirectory({
+            limit: 200,
+            ...(directoryOffset > 0 ? { offset: directoryOffset } : {}),
+            tagLimit: 1,
+        });
+        for (const summary of directory.groups) {
+            const groupSlug = summary.group.slug;
+            const tagCount = Math.max(summary.tagCount, summary.tags.length);
+            const entry = buildTagRegistryEntry(summary.group.allowedTargetKinds);
+            let offset = 0;
+            while (offset < tagCount || (tagCount === 0 && offset === 0)) {
+                const response = await client.fetchTagGroup(groupSlug, {
+                    sort: 'alpha',
+                    limit: 200,
+                    ...(offset > 0 ? { offset } : {}),
+                });
+                response.tags.forEach((tag) => entry.tags.add(tag.slug));
+                if (response.tags.length === 0 || response.tags.length < 200) {
+                    break;
+                }
+                offset += response.tags.length;
+            }
+            mergeTagRegistryEntry(registry, groupSlug, entry, { replaceAllowedTargetKinds: true });
+        }
+        if (!directory.pagination?.hasMore) {
+            break;
+        }
+        directoryOffset += directory.groups.length;
+    }
+    return registry;
+}
+function buildLocalTagRegistry(groups) {
+    const registry = new Map();
+    for (const group of groups) {
+        const entry = buildTagRegistryEntry(group.allowedTargetKinds);
+        group.tags.forEach((tag) => entry.tags.add(tag.slug));
+        mergeTagRegistryEntry(registry, group.slug, entry, { replaceAllowedTargetKinds: true });
+    }
+    return registry;
+}
+async function buildUploadTagRegistry(client, localGroups) {
+    const registry = await buildRemoteTagRegistry(client);
+    const localRegistry = buildLocalTagRegistry(localGroups);
+    for (const [groupSlug, entry] of localRegistry.entries()) {
+        mergeTagRegistryEntry(registry, groupSlug, entry, { replaceAllowedTargetKinds: true });
+    }
+    return registry;
+}
+function validateTagRefsForTarget(tagRegistry, target) {
+    for (const rawTagRef of target.tags) {
+        let normalizedRef = '';
+        try {
+            normalizedRef = (0, types_1.normalizeTagRef)(rawTagRef);
+        }
+        catch {
+            return `invalid_tag_ref:${String(rawTagRef ?? '').trim() || String(rawTagRef ?? '')}`;
+        }
+        const [groupSlug, tagSlug] = normalizedRef.split('/');
+        if (!groupSlug || !tagSlug) {
+            return `invalid_tag_ref:${normalizedRef}`;
+        }
+        const registryEntry = tagRegistry.get(groupSlug);
+        if (!registryEntry || !registryEntry.tags.has(tagSlug)) {
+            return `unknown_tag_ref:${normalizedRef}`;
+        }
+        if (registryEntry.allowedTargetKinds.length > 0
+            && !registryEntry.allowedTargetKinds.includes(target.targetKind)) {
+            return `tag_not_allowed_for_target_kind:${normalizedRef}:${target.targetKind}`;
+        }
+    }
+    return null;
+}
+function collectTaskTagValidationTargets(task) {
+    if (task.kind === 'app') {
+        return [
+            { tags: task.tags, targetKind: 'APP' },
+            ...task.ownedAssets.map((ownedAsset) => ({
+                tags: ownedAsset.tags,
+                targetKind: 'ASSET',
+            })),
+        ];
+    }
+    if (task.kind === 'asset') {
+        return [{ tags: task.tags, targetKind: 'ASSET' }];
+    }
+    if (task.kind === 'owned-asset') {
+        return [{ tags: task.tags, targetKind: 'ASSET' }];
+    }
+    if (task.kind === 'asset-pack') {
+        return [
+            { tags: task.tags, targetKind: 'PACK' },
+            ...task.ownedAssets.map((ownedAsset) => ({
+                tags: ownedAsset.tags,
+                targetKind: 'ASSET',
+            })),
+        ];
+    }
+    return [];
+}
+function tasksRequireTagValidation(tasks) {
+    return tasks.some((task) => collectTaskTagValidationTargets(task).some((target) => target.tags.length > 0));
+}
+async function buildUploadPreflight(client, tasks, defaultCreator, currentUserRole, localTagGroups) {
+    const nodes = (0, taskUtils_1.sortTasks)(tasks).map((task, index) => {
+        const creatorResult = (0, upload_content_1.getTaskCreatorResult)(task, defaultCreator, currentUserRole);
+        const entityId = buildTaskEntityId(task, creatorResult.taskCreator);
+        const node = {
+            id: createTaskExecutionId(task, creatorResult.taskCreator, index),
+            task,
+            creator: creatorResult.taskCreator,
+            entityId,
+            localDependencies: [],
+            localAppAssetKeysByRef: new Map(),
+            localAppPackRefsByRef: new Map(),
+        };
+        return { node, creatorResult };
+    });
+    const initialEntries = [];
+    for (const { node, creatorResult } of nodes) {
+        if (creatorResult.creatorTargetError) {
+            initialEntries.push({
+                taskId: node.id,
+                entry: buildTaskDirectErrorEntry(node.task, node.entityId, creatorResult.creatorTargetError),
+            });
+        }
+    }
+    const assetSpecVersionTasksByKey = new Map();
+    const assetSpecFamilyTasksByKey = new Map();
+    const assetTasksByKey = new Map();
+    const packTasksByKey = new Map();
+    for (const { node } of nodes) {
+        if (node.task.kind === 'asset-spec') {
+            pushIndexedNode(assetSpecVersionTasksByKey, buildAssetSpecVersionKey(node.creator, node.task.name, node.task.version), node);
+            pushIndexedNode(assetSpecFamilyTasksByKey, buildAssetSpecFamilyKey(node.creator, node.task.name), node);
+            continue;
+        }
+        if (node.task.kind === 'asset') {
+            pushIndexedNode(assetTasksByKey, (0, upload_content_1.buildAssetKey)(node.creator, node.task.name), node);
+            continue;
+        }
+        if (node.task.kind === 'asset-pack') {
+            pushIndexedNode(packTasksByKey, (0, upload_content_1.buildPackKey)(node.creator, node.task.name, node.task.version), node);
+        }
+    }
+    const remoteCache = createRemoteDependencyCache();
+    const tagRegistry = tasksRequireTagValidation(tasks)
+        ? await buildUploadTagRegistry(client, localTagGroups)
+        : null;
+    const initialStatusByTaskId = new Map(initialEntries.map((entry) => [entry.taskId, entry.entry.status]));
+    for (const { node } of nodes) {
+        if (initialStatusByTaskId.has(node.id)) {
+            continue;
+        }
+        let blockedDetail = null;
+        if (!blockedDetail && tagRegistry) {
+            for (const target of collectTaskTagValidationTargets(node.task)) {
+                blockedDetail = validateTagRefsForTarget(tagRegistry, target);
+                if (blockedDetail) {
+                    break;
+                }
+            }
+        }
+        if (!blockedDetail && node.task.kind === 'asset' && node.task.assetSpec) {
+            const parsedAssetSpec = (0, types_1.parseAssetSpecVersionRef)(node.task.assetSpec);
+            if (!parsedAssetSpec) {
+                blockedDetail = `dependency_invalid:${node.task.assetSpec}`;
+            }
+            else {
+                const assetSpecKey = buildAssetSpecVersionKey(parsedAssetSpec.creatorUsername, parsedAssetSpec.name, parsedAssetSpec.version);
+                const localDependency = pickSingleLocalDependency(assetSpecVersionTasksByKey.get(assetSpecKey), (0, types_1.formatAssetSpecVersionRef)(parsedAssetSpec));
+                if (localDependency.blockedDetail) {
+                    blockedDetail = localDependency.blockedDetail;
+                }
+                else if (localDependency.node) {
+                    addLocalDependency(node, localDependency.node.id, (0, types_1.formatAssetSpecVersionRef)(parsedAssetSpec));
+                }
+                else if (!(await validateRemoteAssetSpecVersionExists(client, (0, types_1.formatAssetSpecVersionRef)(parsedAssetSpec), remoteCache))) {
+                    blockedDetail = `dependency_missing:${(0, types_1.formatAssetSpecVersionRef)(parsedAssetSpec)}`;
+                }
+            }
+        }
+        if (!blockedDetail && node.task.kind === 'app') {
+            for (const support of node.task.assetSpecSupport) {
+                const parsedFamily = (0, types_1.parseAssetSpecFamilyRef)(support.assetSpec);
+                if (!parsedFamily) {
+                    blockedDetail = `dependency_invalid:${support.assetSpec}`;
+                    break;
+                }
+                const familyKey = buildAssetSpecFamilyKey(parsedFamily.creatorUsername, parsedFamily.name);
+                const localDependency = pickCompatibleLocalAssetSpecTask(assetSpecFamilyTasksByKey.get(familyKey), support.versionRange);
+                if (localDependency) {
+                    addLocalDependency(node, localDependency.id, `${support.assetSpec}@${support.versionRange}`);
+                    continue;
+                }
+                const remoteExists = await validateRemoteAssetSpecSupportExists(client, support.assetSpec, support.versionRange, remoteCache);
+                if (!remoteExists) {
+                    blockedDetail = `dependency_missing:${support.assetSpec}@${support.versionRange}`;
+                    break;
+                }
+            }
+        }
+        if (!blockedDetail && node.task.kind === 'app') {
+            for (const assetDependency of node.task.uses.assets) {
+                const parsedAsset = (0, types_1.parseContentVersionRef)(assetDependency.ref);
+                if (!parsedAsset || parsedAsset.kind !== 'asset') {
+                    blockedDetail = `dependency_invalid:${assetDependency.ref}`;
+                    break;
+                }
+                const assetRef = (0, types_1.formatContentVersionRef)(parsedAsset);
+                const assetKey = (0, upload_content_1.buildAssetKey)(parsedAsset.creatorUsername, parsedAsset.name);
+                const localDependency = pickSingleLocalDependency(assetTasksByKey.get(assetKey), assetRef);
+                if (localDependency.blockedDetail) {
+                    blockedDetail = localDependency.blockedDetail;
+                    break;
+                }
+                if (localDependency.node) {
+                    addLocalDependency(node, localDependency.node.id, assetRef);
+                    node.localAppAssetKeysByRef.set(assetRef, (0, upload_content_1.buildAssetKey)(localDependency.node.creator, localDependency.node.task.name));
+                    continue;
+                }
+                if (!(await validateRemoteAssetVersionExists(client, assetRef, remoteCache))) {
+                    blockedDetail = `dependency_missing:${assetRef}`;
+                    break;
+                }
+            }
+        }
+        if (!blockedDetail && node.task.kind === 'app') {
+            for (const rawPackRef of node.task.uses.packs) {
+                const normalizedPackRef = normalizePackDependencyRef(rawPackRef);
+                if (!normalizedPackRef) {
+                    blockedDetail = `dependency_invalid:${rawPackRef.trim() || rawPackRef}`;
+                    break;
+                }
+                const parsedPack = (0, types_1.parseContentVersionRef)(normalizedPackRef);
+                if (!parsedPack || parsedPack.kind !== 'pack') {
+                    blockedDetail = `dependency_invalid:${normalizedPackRef}`;
+                    break;
+                }
+                const localDependency = pickSingleLocalDependency(packTasksByKey.get((0, upload_content_1.buildPackKey)(parsedPack.creatorUsername, parsedPack.name, parsedPack.version)), normalizedPackRef);
+                if (localDependency.blockedDetail) {
+                    blockedDetail = localDependency.blockedDetail;
+                    break;
+                }
+                if (localDependency.node) {
+                    addLocalDependency(node, localDependency.node.id, normalizedPackRef);
+                    if (localDependency.node.task.kind === 'asset-pack') {
+                        node.localAppPackRefsByRef.set(normalizedPackRef, `pack:${localDependency.node.creator}/${localDependency.node.task.name}@${localDependency.node.task.version}`);
+                    }
+                    continue;
+                }
+                if (!(await validateRemotePackVersionExists(client, normalizedPackRef, remoteCache))) {
+                    blockedDetail = `dependency_missing:${normalizedPackRef}`;
+                    break;
+                }
+            }
+        }
+        if (blockedDetail) {
+            initialEntries.push({
+                taskId: node.id,
+                entry: buildTaskBlockedEntry(node.task, node.entityId, blockedDetail),
+            });
+        }
+    }
+    return {
+        nodes: nodes.map((entry) => entry.node),
+        initialEntries,
+    };
+}
+function resolveAppTaskLocalDependencies(task, node, state) {
+    if (node.localAppAssetKeysByRef.size === 0 && node.localAppPackRefsByRef.size === 0) {
+        return task;
+    }
+    const usesAssets = task.uses.assets.map((dependency) => {
+        const assetKey = node.localAppAssetKeysByRef.get(dependency.ref);
+        if (!assetKey) {
+            return dependency;
+        }
+        const uploaded = state.uploadedAssetsByKey.get(assetKey);
+        if (!uploaded) {
+            throw new Error(`Local asset dependency "${dependency.ref}" did not produce an uploaded asset ref.`);
+        }
+        return {
+            ...dependency,
+            ref: uploaded.ref,
+        };
+    });
+    const usesPacks = task.uses.packs.map((rawRef) => {
+        const normalized = normalizePackDependencyRef(rawRef);
+        if (!normalized) {
+            return rawRef;
+        }
+        return node.localAppPackRefsByRef.get(normalized) ?? normalized;
+    });
+    return {
+        ...task,
+        uses: {
+            assets: usesAssets,
+            packs: usesPacks,
+        },
+    };
+}
 function buildAppOverviewUrl(base, creator, task) {
     const typeSlug = (0, appUrls_1.getAppTypeSlug)(task.type ?? 'GAME');
     const encodedCreator = encodeURIComponent(creator);
@@ -233,6 +750,22 @@ function buildUploadErrorDetail(error) {
     if (error instanceof types_1.ApiError && error.code === 'tag_clear_confirmation_required') {
         return 'tag_clear_confirmation_required: This publish would remove existing live tags. Re-run with --clear-tags to confirm.';
     }
+    if (error instanceof types_1.ApiError) {
+        const ref = typeof error.details?.ref === 'string' ? error.details.ref.trim() : '';
+        const targetKind = typeof error.details?.targetKind === 'string' ? error.details.targetKind.trim() : '';
+        if (error.code === 'unknown_tag_ref' && ref) {
+            return `unknown_tag_ref:${ref}`;
+        }
+        if (error.code === 'invalid_tag_ref' && ref) {
+            return `invalid_tag_ref:${ref}`;
+        }
+        if (error.code === 'duplicate_tag_ref' && ref) {
+            return `duplicate_tag_ref:${ref}`;
+        }
+        if (error.code === 'tag_not_allowed_for_target_kind' && ref && targetKind) {
+            return `tag_not_allowed_for_target_kind:${ref}:${targetKind}`;
+        }
+    }
     const rawMessage = typeof error?.message === 'string' && error.message.trim()
         ? error.message.trim()
         : 'upload failed';
@@ -370,12 +903,12 @@ async function uploadStandaloneAssetTask(state, task, taskCreator, options) {
     appendOverviewLink(entry, task, state.portalBase, uploaded.creatorUsername);
     return entry;
 }
-async function uploadOwnedAssetTask(state, task, taskCreator) {
+async function uploadOwnedAssetTask(state, task, taskCreator, options) {
     const sourceApp = state.uploadedAppsByName.get(task.appName);
     if (!sourceApp) {
         throw new Error(`Owned 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);
+    const uploaded = await (0, upload_content_1.uploadAssetTask)(state.client, task, sourceApp.versionId, sourceApp.creatorUsername, { clearTags: options?.clearTags });
     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);
@@ -446,7 +979,10 @@ async function uploadPackTask(state, task, taskCreator, options) {
     appendOverviewLink(entry, task, state.portalBase, taskCreator);
     return entry;
 }
-async function processSingleUploadTask(state, task, taskCreator, options) {
+async function processSingleUploadTask(state, node, taskCreator, options) {
+    const task = node.task.kind === 'app'
+        ? resolveAppTaskLocalDependencies(node.task, node, state)
+        : node.task;
     if (task.kind === 'app') {
         return await uploadAppTask(state, task, taskCreator, options);
     }
@@ -457,7 +993,7 @@ async function processSingleUploadTask(state, task, taskCreator, options) {
         return { entry: await uploadStandaloneAssetTask(state, task, taskCreator, options), warnings: [] };
     }
     if (task.kind === 'owned-asset') {
-        return { entry: await uploadOwnedAssetTask(state, task, taskCreator), warnings: [] };
+        return { entry: await uploadOwnedAssetTask(state, task, taskCreator, options), warnings: [] };
     }
     if (task.kind === 'asset-pack') {
         return { entry: await uploadPackTask(state, task, taskCreator, options), warnings: [] };
@@ -484,17 +1020,21 @@ async function flushGraphState(client, graphState, results) {
         process.exitCode = process.exitCode || 1;
     }
 }
-async function processUploadTasks(client, tasks, owner, ownerUsername, currentUserRole, currentUser, token, warnings, apiBase, webBase, options) {
+async function processUploadTasks(client, tasks, owner, ownerUsername, currentUserRole, localTagGroups, currentUser, token, warnings, apiBase, webBase, options) {
     const portalBase = normalizePortalBase(webBase);
     const defaultCreator = normalizeCreatorUsername(ownerUsername) ?? owner;
     const results = [];
-    let aborted = false;
-    const sortedTasks = (0, taskUtils_1.sortTasks)(tasks);
+    const preflight = await buildUploadPreflight(client, tasks, defaultCreator, currentUserRole, localTagGroups);
+    const sortedTasks = preflight.nodes.map((node) => node.task);
     const packPlanning = (0, upload_content_1.buildAssetPackUploadPlans)(sortedTasks, defaultCreator, currentUserRole);
+    const taskStatusById = new Map(preflight.nodes.map((node) => [node.id, 'pending']));
+    preflight.initialEntries.forEach(({ taskId, entry }) => {
+        taskStatusById.set(taskId, entry.status);
+        pushLoggedEntry(results, entry);
+    });
     if (!packPlanning.ok) {
         const entry = buildPackPlanningFailureEntry(packPlanning.task, defaultCreator, currentUserRole, packPlanning.message);
         pushLoggedEntry(results, entry);
-        process.exitCode = process.exitCode || 1;
         return results;
     }
     const state = {
@@ -511,45 +1051,85 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
         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}`);
+    while (true) {
+        const pendingNodes = preflight.nodes.filter((node) => taskStatusById.get(node.id) === 'pending');
+        if (pendingNodes.length === 0) {
+            break;
         }
-        const entityId = buildTaskEntityId(task, creatorResult.taskCreator);
-        const taskCreator = creatorResult.taskCreator;
-        try {
-            if (creatorResult.creatorTargetError) {
-                throw new Error(creatorResult.creatorTargetError);
+        let madeProgress = false;
+        for (const node of preflight.nodes) {
+            if (taskStatusById.get(node.id) !== 'pending') {
+                continue;
             }
-            const outcome = await processSingleUploadTask(state, task, taskCreator, options);
-            outcome.warnings.forEach((warning) => warnings.add(warning));
-            pushLoggedEntry(results, outcome.entry);
-        }
-        catch (error) {
-            if (error instanceof http_1.CLIUnsupportedClientError) {
-                throw error;
+            const failedDependency = node.localDependencies.find((dependency) => {
+                const dependencyStatus = taskStatusById.get(dependency.taskId);
+                return dependencyStatus === 'error' || dependencyStatus === 'blocked';
+            });
+            if (failedDependency) {
+                const entry = buildTaskBlockedEntry(node.task, node.entityId, `local_dependency_failed:${failedDependency.ref}`);
+                taskStatusById.set(node.id, entry.status);
+                pushLoggedEntry(results, entry);
+                madeProgress = true;
+                continue;
             }
-            const entry = buildTaskErrorEntry(task, entityId, error);
-            pushLoggedEntry(results, entry);
-            process.exitCode = process.exitCode || 1;
-            aborted = true;
+            const waitingOnLocalDependency = node.localDependencies.some((dependency) => taskStatusById.get(dependency.taskId) === 'pending');
+            if (waitingOnLocalDependency) {
+                continue;
+            }
+            const creatorResult = (0, upload_content_1.getTaskCreatorResult)(node.task, defaultCreator, currentUserRole);
+            if (creatorResult.requestedTaskOwner && !creatorResult.creatorTargetError) {
+                console.log(`[Admin] Publishing ${node.task.name} as user: ${creatorResult.taskCreator}`);
+            }
+            try {
+                const outcome = await processSingleUploadTask(state, node, node.creator, options);
+                outcome.warnings.forEach((warning) => warnings.add(warning));
+                taskStatusById.set(node.id, outcome.entry.status);
+                pushLoggedEntry(results, outcome.entry);
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError) {
+                    throw error;
+                }
+                const entry = buildTaskErrorEntry(node.task, node.entityId, error);
+                taskStatusById.set(node.id, entry.status);
+                pushLoggedEntry(results, entry);
+            }
+            madeProgress = true;
             break;
         }
+        if (madeProgress) {
+            continue;
+        }
+        for (const node of pendingNodes) {
+            const entry = buildTaskDirectErrorEntry(node.task, node.entityId, 'dependency_cycle_detected');
+            taskStatusById.set(node.id, entry.status);
+            pushLoggedEntry(results, entry);
+        }
     }
-    if (!aborted) {
-        await flushGraphState(client, state.graphState, results);
-    }
+    await flushGraphState(client, state.graphState, results);
     return results;
 }
+function printResolvedUploadAccount(input) {
+    const username = typeof input.username === 'string' && input.username.trim().length > 0
+        ? input.username.trim()
+        : 'unknown';
+    console.log(`Resolved account: ${username} (${input.env})`);
+}
 async function upload(pathOrName, options) {
     const selection = (0, taskSelection_1.selectTasks)(pathOrName);
     const workspaceRoot = resolveUploadWorkspaceRoot(pathOrName, selection.resolution);
-    const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)('project publish', 'Publishing content', { workspacePath: workspaceRoot });
+    const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)('project publish', 'Publishing content', {
+        env: options?.env,
+        workspacePath: workspaceRoot,
+    });
     if (!ctx) {
         return;
     }
     const { client, env, envConfig } = ctx;
+    printResolvedUploadAccount({
+        env,
+        username: ctx.account?.username,
+    });
     let userInfo = { username: null, role: null, user: null };
     try {
         userInfo = await fetchCurrentUserInfo(client, envConfig.apiBase);
@@ -600,7 +1180,7 @@ async function upload(pathOrName, options) {
         taxonomyEntries.forEach((entry) => pushLoggedEntry(results, entry));
     }
     if (tasks.length > 0) {
-        const uploadEntries = await processUploadTasks(client, tasks, owner, userInfo.username, userInfo.role, userInfo.user, ctx.token, warnings, envConfig.apiBase, envConfig.webBase, options);
+        const uploadEntries = await processUploadTasks(client, tasks, owner, userInfo.username, userInfo.role, tagGroupLoad.groups, userInfo.user, ctx.token, warnings, envConfig.apiBase, envConfig.webBase, options);
         results.push(...uploadEntries);
     }
     (0, uploadLog_1.printTaskSummary)(results, warnings, { action: 'upload', environment: env });