@playdrop/playdrop-cli 0.16.5 → 0.16.12

package/dist/commands/upload.js

@@ -50,7 +50,7 @@ function resolveCatalogueWorkspaceRoot(startPath) {
         if (parentDir === currentDir) {
             return currentDir;
         }
-        const parentCataloguePath = (0, node_path_1.join)(parentDir, 'catalogue.json');
+        const parentCataloguePath = (0, node_path_1.join)(parentDir, "catalogue.json");
         if (!(0, node_fs_1.existsSync)(parentCataloguePath)) {
             return currentDir;
         }
@@ -58,28 +58,28 @@ function resolveCatalogueWorkspaceRoot(startPath) {
     }
 }
 function resolveUploadWorkspaceRoot(pathOrName, resolution) {
-    if (resolution === 'name') {
+    if (resolution === "name") {
         return resolveCatalogueWorkspaceRoot(process.cwd());
     }
     return resolveCatalogueWorkspaceRoot(pathOrName);
 }
 function buildTagGroupLogEntry(status, entityId, detail) {
     return {
-        action: 'upload',
+        action: "upload",
         status,
-        entityType: 'tag-group',
+        entityType: "tag-group",
         entityId,
-        catalogue: 'catalogue:tag-groups',
+        catalogue: "catalogue:tag-groups",
         detail,
     };
 }
 function buildTagLogEntry(status, entityId, detail) {
     return {
-        action: 'upload',
+        action: "upload",
         status,
-        entityType: 'tag',
+        entityType: "tag",
         entityId,
-        catalogue: 'catalogue:tag-groups',
+        catalogue: "catalogue:tag-groups",
         detail,
     };
 }
@@ -103,10 +103,10 @@ async function syncTagGroupsFromCatalogue(client, groups) {
                 tags: [],
             };
             liveGroupsBySlug.set(liveGroup.slug, liveGroup);
-            entries.push(buildTagGroupLogEntry('success', liveGroup.slug, `created "${liveGroup.displayName}"`));
+            entries.push(buildTagGroupLogEntry("success", liveGroup.slug, `created "${liveGroup.displayName}"`));
         }
-        else if (liveGroup.displayName !== groupDefinition.displayName
-            || !sameSavedItemKinds(liveGroup.allowedTargetKinds, groupDefinition.allowedTargetKinds)) {
+        else if (liveGroup.displayName !== groupDefinition.displayName ||
+            !sameSavedItemKinds(liveGroup.allowedTargetKinds, groupDefinition.allowedTargetKinds)) {
             const updated = await client.updateAdminTagGroup(groupDefinition.slug, {
                 displayName: groupDefinition.displayName,
                 allowedTargetKinds: normalizeSavedItemKinds(groupDefinition.allowedTargetKinds),
@@ -116,7 +116,7 @@ async function syncTagGroupsFromCatalogue(client, groups) {
                 tags: liveGroup.tags,
             };
             liveGroupsBySlug.set(liveGroup.slug, liveGroup);
-            entries.push(buildTagGroupLogEntry('success', liveGroup.slug, `updated "${liveGroup.displayName}"`));
+            entries.push(buildTagGroupLogEntry("success", liveGroup.slug, `updated "${liveGroup.displayName}"`));
         }
         if (!liveGroup) {
             throw new Error(`tag_group_sync_failed:${groupDefinition.slug}`);
@@ -131,7 +131,7 @@ async function syncTagGroupsFromCatalogue(client, groups) {
                     displayName: tagDefinition.displayName,
                 });
                 liveTagsBySlug.set(created.tag.slug, created.tag);
-                entries.push(buildTagLogEntry('success', tagRef, `created "${created.tag.displayName}"`));
+                entries.push(buildTagLogEntry("success", tagRef, `created "${created.tag.displayName}"`));
                 continue;
             }
             if (liveTag.displayName !== tagDefinition.displayName) {
@@ -139,25 +139,25 @@ async function syncTagGroupsFromCatalogue(client, groups) {
                     displayName: tagDefinition.displayName,
                 });
                 liveTagsBySlug.set(updated.tag.slug, updated.tag);
-                entries.push(buildTagLogEntry('success', tagRef, `updated "${updated.tag.displayName}"`));
+                entries.push(buildTagLogEntry("success", tagRef, `updated "${updated.tag.displayName}"`));
             }
         }
     }
     return entries;
 }
 function buildApiUnavailableMessage(apiBase) {
-    if (apiBase && typeof apiBase === 'string') {
+    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.';
+    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') {
+    if (error instanceof TypeError || networkCode === "ECONNREFUSED") {
         return true;
     }
     const aggregateErrors = error?.cause?.errors;
-    return Array.isArray(aggregateErrors) && aggregateErrors.some((entry) => entry?.code === 'ECONNREFUSED');
+    return Array.isArray(aggregateErrors) && aggregateErrors.some((entry) => entry?.code === "ECONNREFUSED");
 }
 async function fetchCurrentUserInfo(client, apiBase) {
     try {
@@ -170,7 +170,7 @@ async function fetchCurrentUserInfo(client, apiBase) {
     }
     catch (error) {
         if (error instanceof types_1.UnsupportedClientError) {
-            (0, http_1.handleUnsupportedError)(error, 'Upload');
+            (0, http_1.handleUnsupportedError)(error, "Upload");
             return { username: null, role: null, user: null };
         }
         if (error instanceof http_1.CLIUnsupportedClientError) {
@@ -192,23 +192,21 @@ function normalizeCreatorUsername(username) {
     if (!username)
         return null;
     const trimmed = username.trim();
-    if (!trimmed || trimmed.toLowerCase() === 'unknown') {
+    if (!trimmed || trimmed.toLowerCase() === "unknown") {
         return null;
     }
     return trimmed;
 }
 function resolveUploadOwner(actorUsername, workspaceOwnerUsername) {
-    const workspaceOwner = workspaceOwnerUsername?.trim() ?? '';
+    const workspaceOwner = workspaceOwnerUsername?.trim() ?? "";
     if (workspaceOwner) {
         return workspaceOwner;
     }
-    const actor = actorUsername?.trim() ?? '';
-    return actor || 'unknown';
+    const actor = actorUsername?.trim() ?? "";
+    return actor || "unknown";
 }
 function resolveDefaultUploadCreator(owner, actorUsername) {
-    return normalizeCreatorUsername(owner ?? null)
-        ?? normalizeCreatorUsername(actorUsername ?? null)
-        ?? 'unknown';
+    return normalizeCreatorUsername(owner ?? null) ?? normalizeCreatorUsername(actorUsername ?? null) ?? "unknown";
 }
 function isNotFoundApiError(error) {
     return error instanceof types_1.ApiError && error.status === 404;
@@ -222,20 +220,20 @@ function createRemoteDependencyCache() {
     };
 }
 function createTaskExecutionId(task, creator, index) {
-    if (task.kind === 'asset-spec') {
+    if (task.kind === "asset-spec") {
         return `${index}:${task.kind}:${creator}/${task.name}@${task.version}`;
     }
-    if (task.kind === 'asset-pack') {
+    if (task.kind === "asset-pack") {
         return `${index}:${task.kind}:${creator}/${task.name}@${task.version}`;
     }
-    if (task.kind === 'owned-asset') {
+    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',
+        action: "upload",
         status,
         entityType: task.kind,
         entityId,
@@ -244,10 +242,10 @@ function buildTaskDetailEntry(task, entityId, status, detail) {
     };
 }
 function buildTaskDirectErrorEntry(task, entityId, detail) {
-    return buildTaskDetailEntry(task, entityId, 'error', detail.startsWith('upload failed:') ? detail : `upload failed: ${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);
+    return buildTaskDetailEntry(task, entityId, "blocked", detail);
 }
 function buildAssetSpecFamilyKey(creatorUsername, name) {
     return `${creatorUsername}/${name}`;
@@ -279,7 +277,7 @@ 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)));
+    const matching = candidates.filter((candidate) => candidate.task.kind === "asset-spec" && (0, semver_1.satisfies)(candidate.task.version, versionRange));
     if (matching.length === 0) {
         return null;
     }
@@ -337,7 +335,7 @@ async function validateRemoteAssetVersionExists(client, rawRef, cache) {
         return cache.assetVersionExists.get(rawRef);
     }
     const parsed = (0, types_1.parseContentVersionRef)(rawRef);
-    if (!parsed || parsed.kind !== 'asset') {
+    if (!parsed || parsed.kind !== "asset") {
         cache.assetVersionExists.set(rawRef, false);
         return false;
     }
@@ -365,7 +363,7 @@ async function validateRemotePackVersionExists(client, rawRef, cache) {
         return cache.packVersionExists.get(rawRef);
     }
     const parsed = (0, types_1.parseContentVersionRef)(rawRef);
-    if (!parsed || parsed.kind !== 'pack') {
+    if (!parsed || parsed.kind !== "pack") {
         cache.packVersionExists.set(rawRef, false);
         return false;
     }
@@ -396,7 +394,7 @@ function addLocalDependency(node, dependencyTaskId, ref) {
 }
 function normalizePackDependencyRef(rawRef) {
     const parsed = (0, types_1.parseContentVersionRef)(rawRef);
-    if (!parsed || parsed.kind !== 'pack') {
+    if (!parsed || parsed.kind !== "pack") {
         return null;
     }
     return (0, types_1.formatContentVersionRef)(parsed);
@@ -437,7 +435,7 @@ async function buildRemoteTagRegistry(client) {
             let offset = 0;
             while (offset < tagCount || (tagCount === 0 && offset === 0)) {
                 const response = await client.fetchTagGroup(groupSlug, {
-                    sort: 'alpha',
+                    sort: "alpha",
                     limit: 200,
                     ...(offset > 0 ? { offset } : {}),
                 });
@@ -475,14 +473,14 @@ async function buildUploadTagRegistry(client, localGroups) {
 }
 function validateTagRefsForTarget(tagRegistry, target) {
     for (const rawTagRef of target.tags) {
-        let normalizedRef = '';
+        let normalizedRef = "";
         try {
             normalizedRef = (0, types_1.normalizeTagRef)(rawTagRef);
         }
         catch {
-            return `invalid_tag_ref:${String(rawTagRef ?? '').trim() || String(rawTagRef ?? '')}`;
+            return `invalid_tag_ref:${String(rawTagRef ?? "").trim() || String(rawTagRef ?? "")}`;
         }
-        const [groupSlug, tagSlug] = normalizedRef.split('/');
+        const [groupSlug, tagSlug] = normalizedRef.split("/");
         if (!groupSlug || !tagSlug) {
             return `invalid_tag_ref:${normalizedRef}`;
         }
@@ -490,38 +488,37 @@ function validateTagRefsForTarget(tagRegistry, target) {
         if (!registryEntry || !registryEntry.tags.has(tagSlug)) {
             return `unknown_tag_ref:${normalizedRef}`;
         }
-        if (registryEntry.allowedTargetKinds.length > 0
-            && !registryEntry.allowedTargetKinds.includes(target.targetKind)) {
+        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') {
+    if (task.kind === "app") {
         return [
             {
                 tags: Array.from(new Set([...task.tags, ...Object.values(task.design ?? {})])),
-                targetKind: 'APP',
+                targetKind: "APP",
             },
             ...task.ownedAssets.map((ownedAsset) => ({
                 tags: ownedAsset.tags,
-                targetKind: 'ASSET',
+                targetKind: "ASSET",
             })),
         ];
     }
-    if (task.kind === 'asset') {
-        return [{ tags: task.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 === "owned-asset") {
+        return [{ tags: task.tags, targetKind: "ASSET" }];
     }
-    if (task.kind === 'asset-pack') {
+    if (task.kind === "asset-pack") {
         return [
-            { tags: task.tags, targetKind: 'PACK' },
+            { tags: task.tags, targetKind: "PACK" },
             ...task.ownedAssets.map((ownedAsset) => ({
                 tags: ownedAsset.tags,
-                targetKind: 'ASSET',
+                targetKind: "ASSET",
             })),
         ];
     }
@@ -559,23 +556,21 @@ async function buildUploadPreflight(client, tasks, defaultCreator, currentUserRo
     const assetTasksByKey = new Map();
     const packTasksByKey = new Map();
     for (const { node } of nodes) {
-        if (node.task.kind === 'asset-spec') {
+        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') {
+        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') {
+        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 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)) {
@@ -590,7 +585,7 @@ async function buildUploadPreflight(client, tasks, defaultCreator, currentUserRo
                 }
             }
         }
-        if (!blockedDetail && node.task.kind === 'asset' && node.task.assetSpec) {
+        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}`;
@@ -609,7 +604,7 @@ async function buildUploadPreflight(client, tasks, defaultCreator, currentUserRo
                 }
             }
         }
-        if (!blockedDetail && node.task.kind === 'app') {
+        if (!blockedDetail && node.task.kind === "app") {
             for (const support of node.task.assetSpecSupport) {
                 const parsedFamily = (0, types_1.parseAssetSpecFamilyRef)(support.assetSpec);
                 if (!parsedFamily) {
@@ -629,10 +624,10 @@ async function buildUploadPreflight(client, tasks, defaultCreator, currentUserRo
                 }
             }
         }
-        if (!blockedDetail && node.task.kind === 'app') {
+        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') {
+                if (!parsedAsset || parsedAsset.kind !== "asset") {
                     blockedDetail = `dependency_invalid:${assetDependency.ref}`;
                     break;
                 }
@@ -654,7 +649,7 @@ async function buildUploadPreflight(client, tasks, defaultCreator, currentUserRo
                 }
             }
         }
-        if (!blockedDetail && node.task.kind === 'app') {
+        if (!blockedDetail && node.task.kind === "app") {
             for (const rawPackRef of node.task.uses.packs) {
                 const normalizedPackRef = normalizePackDependencyRef(rawPackRef);
                 if (!normalizedPackRef) {
@@ -662,7 +657,7 @@ async function buildUploadPreflight(client, tasks, defaultCreator, currentUserRo
                     break;
                 }
                 const parsedPack = (0, types_1.parseContentVersionRef)(normalizedPackRef);
-                if (!parsedPack || parsedPack.kind !== 'pack') {
+                if (!parsedPack || parsedPack.kind !== "pack") {
                     blockedDetail = `dependency_invalid:${normalizedPackRef}`;
                     break;
                 }
@@ -673,7 +668,7 @@ async function buildUploadPreflight(client, tasks, defaultCreator, currentUserRo
                 }
                 if (localDependency.node) {
                     addLocalDependency(node, localDependency.node.id, normalizedPackRef);
-                    if (localDependency.node.task.kind === 'asset-pack') {
+                    if (localDependency.node.task.kind === "asset-pack") {
                         node.localAppPackRefsByRef.set(normalizedPackRef, `pack:${localDependency.node.creator}/${localDependency.node.task.name}@${localDependency.node.task.version}`);
                     }
                     continue;
@@ -730,7 +725,7 @@ function resolveAppTaskLocalDependencies(task, node, state) {
     };
 }
 function buildAppOverviewUrl(base, creator, task) {
-    const typeSlug = (0, appUrls_1.getAppTypeSlug)(task.type ?? 'GAME');
+    const typeSlug = (0, appUrls_1.getAppTypeSlug)(task.type ?? "GAME");
     const encodedCreator = encodeURIComponent(creator);
     const encodedName = encodeURIComponent(task.name);
     return `${base}/creators/${encodedCreator}/apps/${typeSlug}/${encodedName}/overview`;
@@ -746,20 +741,20 @@ function buildAssetPackOverviewUrl(base, creator, name) {
     return `${base}/creators/${encodedCreator}/asset-packs/${encodedName}/overview`;
 }
 function appendOverviewLink(entry, task, portalBase, creator) {
-    if (!portalBase || !creator || entry.status === 'error') {
+    if (!portalBase || !creator || entry.status === "error") {
         return;
     }
     let url = null;
-    if (task.kind === 'app') {
+    if (task.kind === "app") {
         url = buildAppOverviewUrl(portalBase, creator, task);
     }
-    else if (task.kind === 'asset-spec') {
+    else if (task.kind === "asset-spec") {
         url = null;
     }
-    else if (task.kind === 'asset' || task.kind === 'owned-asset') {
+    else if (task.kind === "asset" || task.kind === "owned-asset") {
         url = buildAssetOverviewUrl(portalBase, creator, task.name);
     }
-    else if (task.kind === 'asset-pack') {
+    else if (task.kind === "asset-pack") {
         url = buildAssetPackOverviewUrl(portalBase, creator, task.name);
     }
     if (!url) {
@@ -768,7 +763,7 @@ function appendOverviewLink(entry, task, portalBase, creator) {
     entry.detail = entry.detail ? `${entry.detail} | view: ${url}` : `view: ${url}`;
 }
 function buildTaskEntityId(task, creatorUsername) {
-    return task.kind === 'owned-asset'
+    return task.kind === "owned-asset"
         ? `${creatorUsername}/${task.appName}:${task.name}`
         : `${creatorUsername}/${task.name}`;
 }
@@ -777,44 +772,44 @@ function pushLoggedEntry(results, entry) {
     console.log((0, uploadLog_1.formatTaskLogLine)(entry));
 }
 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 && 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) {
+        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) {
+        if (error.code === "invalid_tag_ref" && ref) {
             return `invalid_tag_ref:${ref}`;
         }
-        if (error.code === 'duplicate_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) {
+        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()
+    const rawMessage = typeof error?.message === "string" && error.message.trim()
         ? error.message.trim()
-        : 'upload failed';
-    const message = rawMessage.replace(/^Upload failed for [^:]+:\s*/i, '');
+        : "upload failed";
+    const message = rawMessage.replace(/^Upload failed for [^:]+:\s*/i, "");
     if (/^[a-z0-9_]+:\s+/i.test(message)) {
         return message;
     }
     if (/status\s+413/i.test(message)) {
-        return 'upload_too_large: Upload exceeded the Playdrop HTTP 413 limit. Reduce the size of your bundle, source archive, or listing media and try again.';
+        return "upload_too_large: Upload exceeded the Playdrop HTTP 413 limit. Reduce the size of your bundle, source archive, or listing media and try again.";
     }
-    if (!message.startsWith('upload failed')) {
+    if (!message.startsWith("upload failed")) {
         return `upload failed: ${message}`;
     }
     return message;
 }
 function buildTaskErrorEntry(task, entityId, error) {
     return {
-        action: 'upload',
-        status: 'error',
+        action: "upload",
+        status: "error",
         entityType: task.kind,
         entityId,
         catalogue: task.cataloguePath,
@@ -824,8 +819,8 @@ function buildTaskErrorEntry(task, entityId, error) {
 function buildPackPlanningFailureEntry(task, defaultCreator, currentUserRole, message) {
     const creator = (0, upload_content_1.getTaskCreatorResult)(task, defaultCreator, currentUserRole);
     return {
-        action: 'upload',
-        status: 'error',
+        action: "upload",
+        status: "error",
         entityType: task.kind,
         entityId: buildTaskEntityId(task, creator.taskCreator),
         catalogue: task.cataloguePath,
@@ -834,7 +829,7 @@ function buildPackPlanningFailureEntry(task, defaultCreator, currentUserRole, me
 }
 function appendTaskRelations(graphState, fromNodeId, relations, contextLabel) {
     (relations ?? []).forEach((relation, index) => {
-        if (relation.type === 'REMIXES') {
+        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}]`);
@@ -854,10 +849,10 @@ async function uploadAppTask(state, task, taskCreator, options) {
     if (!upload.versionCreated || !upload.version) {
         throw new Error(`App "${task.name}" upload did not return a created version.`);
     }
-    if (typeof upload.versionId !== 'number') {
+    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) {
+    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}`;
@@ -874,16 +869,16 @@ async function uploadAppTask(state, task, taskCreator, options) {
     (0, upload_graph_1.registerLocalRef)(state.graphState.localAppNodeByName, state.graphState.ambiguousAppNames, task.name, uploadedApp.versionNodeId);
     appendTaskRelations(state.graphState, uploadedApp.versionNodeId, task.graph.relations, `[${task.cataloguePath}] app "${task.name}"`);
     const entry = {
-        action: 'upload',
-        status: 'success',
-        entityType: 'app',
+        action: "upload",
+        status: "success",
+        entityType: "app",
         entityId: buildTaskEntityId(task, taskCreator),
         catalogue: task.cataloguePath,
         detail: `version ${upload.version} created`,
         playUrl: (0, appUrls_1.buildPlatformPlayUrl)(state.portalBase, {
             creatorUsername: taskCreator,
             appName: task.name,
-            appType: task.type ?? 'GAME',
+            appType: task.type ?? "GAME",
         }),
     };
     appendOverviewLink(entry, task, state.portalBase, taskCreator);
@@ -892,9 +887,9 @@ async function uploadAppTask(state, task, taskCreator, options) {
 async function uploadAssetSpecDefinitionTask(state, task, taskCreator) {
     const uploaded = await (0, upload_content_1.uploadAssetSpecTask)(state.client, task, taskCreator);
     return {
-        action: 'upload',
-        status: 'success',
-        entityType: 'asset-spec',
+        action: "upload",
+        status: "success",
+        entityType: "asset-spec",
         entityId: buildTaskEntityId(task, taskCreator),
         catalogue: task.cataloguePath,
         detail: `asset-spec:${uploaded.creatorUsername}/${uploaded.name}@${uploaded.version}`,
@@ -904,9 +899,9 @@ async function uploadStandaloneAssetTask(state, task, taskCreator, options) {
     const ownedPack = state.packPlanning.ownedPackByAssetKey.get((0, upload_content_1.buildAssetKey)(taskCreator, task.name));
     if (ownedPack) {
         return {
-            action: 'upload',
-            status: 'success',
-            entityType: 'asset',
+            action: "upload",
+            status: "success",
+            entityType: "asset",
             entityId: buildTaskEntityId(task, taskCreator),
             catalogue: task.cataloguePath,
             detail: `staged with asset pack ${ownedPack.packTask.name}@${ownedPack.packTask.version}`,
@@ -920,9 +915,9 @@ async function uploadStandaloneAssetTask(state, task, taskCreator, options) {
     (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',
+        action: "upload",
+        status: "success",
+        entityType: "asset",
         entityId: buildTaskEntityId(task, taskCreator),
         catalogue: task.cataloguePath,
         detail: uploaded.ref,
@@ -935,14 +930,16 @@ async function uploadOwnedAssetTask(state, task, taskCreator, options) {
     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, { clearTags: options?.clearTags });
+    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);
     const entry = {
-        action: 'upload',
-        status: 'success',
-        entityType: 'owned-asset',
+        action: "upload",
+        status: "success",
+        entityType: "owned-asset",
         entityId: buildTaskEntityId(task, taskCreator),
         catalogue: task.cataloguePath,
         detail: `${uploaded.ref} (source app version ${sourceApp.versionId})`,
@@ -987,18 +984,16 @@ function registerUploadedLocalPackAssets(state, task, taskCreator, packPlan, loc
 }
 async function uploadPackTask(state, task, taskCreator, options) {
     const { packPlan, localAssetTasks } = collectPackLocalAssetTasks(state, task, taskCreator);
-    const mutationTargetCreator = typeof task.username === 'string' && task.username.trim().length > 0
-        ? taskCreator
-        : undefined;
+    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, { clearTags: options?.clearTags });
     (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',
+        action: "upload",
+        status: "success",
+        entityType: "asset-pack",
         entityId: buildTaskEntityId(task, taskCreator),
         catalogue: task.cataloguePath,
         detail: `version ${task.version} created (${uploadedPack.assetRefs.length} assets)`,
@@ -1007,22 +1002,20 @@ async function uploadPackTask(state, task, taskCreator, options) {
     return entry;
 }
 async function processSingleUploadTask(state, node, taskCreator, options) {
-    const task = node.task.kind === 'app'
-        ? resolveAppTaskLocalDependencies(node.task, node, state)
-        : node.task;
-    if (task.kind === 'app') {
+    const task = node.task.kind === "app" ? resolveAppTaskLocalDependencies(node.task, node, state) : node.task;
+    if (task.kind === "app") {
         return await uploadAppTask(state, task, taskCreator, options);
     }
-    if (task.kind === 'asset-spec') {
+    if (task.kind === "asset-spec") {
         return { entry: await uploadAssetSpecDefinitionTask(state, task, taskCreator), warnings: [] };
     }
-    if (task.kind === 'asset') {
+    if (task.kind === "asset") {
         return { entry: await uploadStandaloneAssetTask(state, task, taskCreator, options), warnings: [] };
     }
-    if (task.kind === 'owned-asset') {
+    if (task.kind === "owned-asset") {
         return { entry: await uploadOwnedAssetTask(state, task, taskCreator, options), warnings: [] };
     }
-    if (task.kind === 'asset-pack') {
+    if (task.kind === "asset-pack") {
         return { entry: await uploadPackTask(state, task, taskCreator, options), warnings: [] };
     }
     throw new Error(`Unsupported task kind "${task.kind}".`);
@@ -1032,15 +1025,15 @@ async function flushGraphState(client, graphState, results) {
         await (0, upload_graph_1.applyGraphOperations)(client, graphState);
     }
     catch (error) {
-        const message = typeof error?.message === 'string' && error.message.trim().length > 0
+        const message = typeof error?.message === "string" && error.message.trim().length > 0
             ? error.message.trim()
-            : 'graph batch upload failed';
+            : "graph batch upload failed";
         const entry = {
-            action: 'upload',
-            status: 'error',
-            entityType: 'app',
-            entityId: 'graph',
-            catalogue: 'graph:batch',
+            action: "upload",
+            status: "error",
+            entityType: "app",
+            entityId: "graph",
+            catalogue: "graph:batch",
             detail: `upload failed: ${message}`,
         };
         pushLoggedEntry(results, entry);
@@ -1054,7 +1047,7 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
     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']));
+    const taskStatusById = new Map(preflight.nodes.map((node) => [node.id, "pending"]));
     preflight.initialEntries.forEach(({ taskId, entry }) => {
         taskStatusById.set(taskId, entry.status);
         pushLoggedEntry(results, entry);
@@ -1079,18 +1072,18 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
         packPlanning,
     };
     while (true) {
-        const pendingNodes = preflight.nodes.filter((node) => taskStatusById.get(node.id) === 'pending');
+        const pendingNodes = preflight.nodes.filter((node) => taskStatusById.get(node.id) === "pending");
         if (pendingNodes.length === 0) {
             break;
         }
         let madeProgress = false;
         for (const node of preflight.nodes) {
-            if (taskStatusById.get(node.id) !== 'pending') {
+            if (taskStatusById.get(node.id) !== "pending") {
                 continue;
             }
             const failedDependency = node.localDependencies.find((dependency) => {
                 const dependencyStatus = taskStatusById.get(dependency.taskId);
-                return dependencyStatus === 'error' || dependencyStatus === 'blocked';
+                return dependencyStatus === "error" || dependencyStatus === "blocked";
             });
             if (failedDependency) {
                 const entry = buildTaskBlockedEntry(node.task, node.entityId, `local_dependency_failed:${failedDependency.ref}`);
@@ -1099,7 +1092,7 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
                 madeProgress = true;
                 continue;
             }
-            const waitingOnLocalDependency = node.localDependencies.some((dependency) => taskStatusById.get(dependency.taskId) === 'pending');
+            const waitingOnLocalDependency = node.localDependencies.some((dependency) => taskStatusById.get(dependency.taskId) === "pending");
             if (waitingOnLocalDependency) {
                 continue;
             }
@@ -1128,7 +1121,7 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
             continue;
         }
         for (const node of pendingNodes) {
-            const entry = buildTaskDirectErrorEntry(node.task, node.entityId, 'dependency_cycle_detected');
+            const entry = buildTaskDirectErrorEntry(node.task, node.entityId, "dependency_cycle_detected");
             taskStatusById.set(node.id, entry.status);
             pushLoggedEntry(results, entry);
         }
@@ -1137,19 +1130,17 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
     return results;
 }
 function printResolvedUploadAccount(input) {
-    const username = typeof input.username === 'string' && input.username.trim().length > 0
-        ? input.username.trim()
-        : 'unknown';
+    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 directEntryPath = (0, node_path_1.resolve)(pathOrName);
-    const directStaticHtml = (0, node_fs_1.existsSync)(directEntryPath)
-        && (0, node_fs_1.statSync)(directEntryPath).isFile()
-        && (0, node_path_1.basename)(directEntryPath).toLowerCase() === 'index.html';
+    const directStaticHtml = (0, node_fs_1.existsSync)(directEntryPath) &&
+        (0, node_fs_1.statSync)(directEntryPath).isFile() &&
+        (0, node_path_1.basename)(directEntryPath).toLowerCase() === "index.html";
     const selection = (0, taskSelection_1.selectTasks)(pathOrName);
     const workspaceRoot = resolveUploadWorkspaceRoot(pathOrName, selection.resolution);
-    const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)('project publish', 'Publishing content', {
+    const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)("project publish", "Publishing content", {
         env: options?.env,
         workspacePath: workspaceRoot,
     });
@@ -1176,16 +1167,16 @@ async function upload(pathOrName, options) {
     const owner = resolveUploadOwner(userInfo.username, ctx.workspaceAuth?.config.ownerUsername);
     if (directStaticHtml) {
         if (!userInfo.username || !userInfo.user) {
-            throw new Error('static_game_publish_authenticated_user_missing');
+            throw new Error("static_game_publish_authenticated_user_missing");
         }
         if (!envConfig.cdnBase) {
-            throw new Error('static_game_publish_cdn_base_missing');
+            throw new Error("static_game_publish_cdn_base_missing");
         }
         const result = await publishStaticHtmlProject({
             client,
             projectDir: (0, node_path_1.dirname)(directEntryPath),
             creatorUsername: userInfo.username,
-            primarySurface: 'DESKTOP',
+            primarySurface: "DESKTOP",
             apiBase: envConfig.apiBase,
             webBase: envConfig.webBase,
             cdnBase: envConfig.cdnBase,
@@ -1205,31 +1196,31 @@ async function upload(pathOrName, options) {
     const tagGroupLoad = (0, catalogue_1.resolveCatalogueTagGroups)(workspaceRoot);
     if (tagGroupLoad.errors.length > 0) {
         (0, taskSelection_1.reportTaskErrors)(tagGroupLoad.errors.map((message) => ({
-            type: 'invalid-catalogue',
+            type: "invalid-catalogue",
             message,
-            help: ['Update the tagGroups entries noted above, then retry the publish.'],
-        })), 'project publish');
+            help: ["Update the tagGroups entries noted above, then retry the publish."],
+        })), "project publish");
         process.exitCode = 1;
         return;
     }
     if (selection.errors.length > 0) {
-        const canPublishTagGroupsOnly = selection.errors.every((error) => error.type === 'no-tasks') && tagGroupLoad.groups.length > 0;
+        const canPublishTagGroupsOnly = selection.errors.every((error) => error.type === "no-tasks") && tagGroupLoad.groups.length > 0;
         if (canPublishTagGroupsOnly) {
             selection.errors.length = 0;
         }
     }
     if (selection.errors.length > 0) {
-        (0, taskSelection_1.reportTaskErrors)(selection.errors, 'project publish');
+        (0, taskSelection_1.reportTaskErrors)(selection.errors, "project publish");
         process.exitCode = 1;
         return;
     }
     const warnings = selection.warnings;
     const tasks = selection.tasks;
-    if (tagGroupLoad.groups.length > 0 && userInfo.role !== 'ADMIN') {
-        (0, messages_1.printErrorWithHelp)('Publishing tagGroups requires an admin account.', [
-            'Log in as an admin before publishing taxonomy changes.',
-            'Remove tagGroups from catalogue.json if this publish should only upload content.',
-        ], { command: 'project publish' });
+    if (tagGroupLoad.groups.length > 0 && userInfo.role !== "ADMIN") {
+        (0, messages_1.printErrorWithHelp)("Publishing tagGroups requires an admin account.", [
+            "Log in as an admin before publishing taxonomy changes.",
+            "Remove tagGroups from catalogue.json if this publish should only upload content.",
+        ], { command: "project publish" });
         process.exitCode = 1;
         return;
     }
@@ -1242,7 +1233,7 @@ async function upload(pathOrName, 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 });
+    (0, uploadLog_1.printTaskSummary)(results, warnings, { action: "upload", environment: env });
     (0, uploadLog_1.printPublishedAppNextSteps)(results);
 }
 function assertAgentPrimarySurfaceContract(task, kind) {
@@ -1254,9 +1245,9 @@ function assertAgentPrimarySurfaceContract(task, kind) {
     }
 }
 function assertAgentNewGamePlaytestContract(task) {
-    assertAgentPrimarySurfaceContract(task, 'NEW_GAME');
+    assertAgentPrimarySurfaceContract(task, "NEW_GAME");
     if (!task.playtestTapes) {
-        throw new Error('agent_task_playtest_tapes_required: NEW_GAME catalogue.json must declare one playtest tape per supported surface.');
+        throw new Error("agent_task_playtest_tapes_required: NEW_GAME catalogue.json must declare one playtest tape per supported surface.");
     }
     for (const surface of task.surfaceTargets) {
         const tape = task.playtestTapes[surface];
@@ -1268,13 +1259,13 @@ function assertAgentNewGamePlaytestContract(task) {
 function assertAgentNewGameListingIdentity(task) {
     const missing = [];
     if (!task.listing?.iconPath)
-        missing.push('listing.icon');
+        missing.push("listing.icon");
     if (!task.listing?.heroPortraitPath)
-        missing.push('listing.hero.portrait');
+        missing.push("listing.hero.portrait");
     if (!task.listing?.heroLandscapePath)
-        missing.push('listing.hero.landscape');
+        missing.push("listing.hero.landscape");
     if (missing.length > 0) {
-        throw new Error(`agent_task_listing_identity_required: NEW_GAME catalogue.json must provide ${missing.join(', ')}.`);
+        throw new Error(`agent_task_listing_identity_required: NEW_GAME catalogue.json must provide ${missing.join(", ")}.`);
     }
 }
 async function collectUploadPreflightErrors(checks) {
@@ -1290,25 +1281,13 @@ async function collectUploadPreflightErrors(checks) {
     return errors;
 }
 function assertAgentTaskReleaseNotes(task) {
-    const releaseNotes = task.releaseNotes?.trim() ?? '';
-    if (!releaseNotes) {
-        throw new Error('agent_task_release_notes_missing: catalogue releaseNotes must contain one line with 1..240 characters.');
-    }
-    if (/[\r\n]/.test(releaseNotes)) {
-        throw new Error(`agent_task_release_notes_multiline: releaseNotes has ${releaseNotes.split(/\r?\n/).length} lines; expected one line with 1..240 characters.`);
-    }
-    if (releaseNotes.length > 240) {
-        throw new Error(`agent_task_release_notes_too_long: releaseNotes length=${releaseNotes.length}; expected 1..240 characters on one line.`);
-    }
+    (0, catalogue_1.normalizeAppReleaseNotes)(task.releaseNotes, { required: true });
 }
 async function assertWorkerAppLocalUploadPreflight(input) {
     const errors = await collectUploadPreflightErrors([
         () => assertAgentTaskReleaseNotes(input.task),
-        ...(input.kind === 'NEW_GAME'
-            ? [
-                () => assertAgentNewGamePlaytestContract(input.task),
-                () => assertAgentNewGameListingIdentity(input.task),
-            ]
+        ...(input.kind === "NEW_GAME"
+            ? [() => assertAgentNewGamePlaytestContract(input.task), () => assertAgentNewGameListingIdentity(input.task)]
             : [() => assertAgentPrimarySurfaceContract(input.task, input.kind)]),
         () => (0, ownedRuntimeImageValidation_1.assertOwnedRuntimeImagesAreValid)(input.task),
     ]);
@@ -1316,51 +1295,51 @@ async function assertWorkerAppLocalUploadPreflight(input) {
         throw new Error(errors[0]);
     }
     if (errors.length > 1) {
-        throw new Error(`agent_task_upload_preflight_failed:\n${errors.map((error, index) => `${index + 1}. ${error}`).join('\n')}`);
+        throw new Error(`agent_task_upload_preflight_failed:\n${errors.map((error, index) => `${index + 1}. ${error}`).join("\n")}`);
     }
 }
 async function prepareWorkerAppProject(input) {
     const creatorUsername = input.creatorUsername.trim();
     if (!creatorUsername) {
-        throw new Error('agent_task_creator_username_missing');
+        throw new Error("agent_task_creator_username_missing");
     }
-    if (input.user.username !== creatorUsername && input.user.role !== 'ADMIN') {
+    if (input.user.username !== creatorUsername && input.user.role !== "ADMIN") {
         throw new Error(`worker_publish_on_behalf_requires_admin: the worker session user "${input.user.username}" cannot publish for "${creatorUsername}".`);
     }
     const selection = (0, taskSelection_1.selectTasks)(input.projectDir);
     if (selection.errors.length > 0) {
-        throw new Error(`agent_task_project_invalid: ${selection.errors.map((error) => error.message).join('; ')}`);
+        throw new Error(`agent_task_project_invalid: ${selection.errors.map((error) => error.message).join("; ")}`);
     }
-    const appTask = selection.tasks.find((task) => task.kind === 'app');
+    const appTask = selection.tasks.find((task) => task.kind === "app");
     if (!appTask || selection.tasks.length !== 1) {
-        const found = selection.tasks.map((task) => `${task.kind}:${task.name}`).join(', ') || 'none';
+        const found = selection.tasks.map((task) => `${task.kind}:${task.name}`).join(", ") || "none";
         throw new Error(`agent_task_project_requires_single_app: expected exactly one app task in ${input.projectDir}, found ${found}.`);
     }
-    const expectedAppName = input.expectedAppName?.trim() ?? '';
+    const expectedAppName = input.expectedAppName?.trim() ?? "";
     if (expectedAppName && appTask.name !== expectedAppName) {
         throw new Error(`agent_task_output_app_name_mismatch: expected catalogue app "${expectedAppName}", found "${appTask.name}".`);
     }
-    const expectedDisplayName = input.expectedDisplayName?.trim() ?? '';
+    const expectedDisplayName = input.expectedDisplayName?.trim() ?? "";
     if (expectedDisplayName && appTask.displayName !== expectedDisplayName) {
-        throw new Error(`agent_task_output_display_name_mismatch: expected "${expectedDisplayName}", found "${appTask.displayName ?? ''}".`);
+        throw new Error(`agent_task_output_display_name_mismatch: expected "${expectedDisplayName}", found "${appTask.displayName ?? ""}".`);
     }
-    const expectedSubtitle = input.expectedSubtitle?.trim() ?? '';
+    const expectedSubtitle = input.expectedSubtitle?.trim() ?? "";
     if (expectedSubtitle && appTask.subtitle !== expectedSubtitle) {
-        throw new Error(`agent_task_output_subtitle_mismatch: expected "${expectedSubtitle}", found "${appTask.subtitle ?? ''}".`);
+        throw new Error(`agent_task_output_subtitle_mismatch: expected "${expectedSubtitle}", found "${appTask.subtitle ?? ""}".`);
     }
     if (input.expectedPrimarySurface && appTask.primarySurface !== input.expectedPrimarySurface) {
-        throw new Error(`agent_task_output_primary_surface_mismatch: expected "${input.expectedPrimarySurface}", found "${appTask.primarySurface ?? ''}".`);
+        throw new Error(`agent_task_output_primary_surface_mismatch: expected "${input.expectedPrimarySurface}", found "${appTask.primarySurface ?? ""}".`);
     }
-    if ((input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') && (appTask.type ?? 'GAME') !== 'GAME') {
-        throw new Error(`agent_task_game_type_invalid:${appTask.type ?? 'missing'}`);
+    if ((input.kind === "NEW_GAME" || input.kind === "REMIX_GAME") && (appTask.type ?? "GAME") !== "GAME") {
+        throw new Error(`agent_task_game_type_invalid:${appTask.type ?? "missing"}`);
     }
     const task = (0, workerAppProject_1.prepareWorkerAppTask)(appTask);
-    if (input.kind === 'REMIX_GAME') {
-        const expectedRemixRef = input.remixSourceRef?.trim() ?? '';
+    if (input.kind === "REMIX_GAME") {
+        const expectedRemixRef = input.remixSourceRef?.trim() ?? "";
         if (!expectedRemixRef) {
-            throw new Error('agent_task_remix_source_ref_missing');
+            throw new Error("agent_task_remix_source_ref_missing");
         }
-        const catalogueRemixRef = task.remix?.trim() ?? '';
+        const catalogueRemixRef = task.remix?.trim() ?? "";
         if (!catalogueRemixRef) {
             throw new Error(`agent_task_remix_ref_missing:${expectedRemixRef}`);
         }
@@ -1369,7 +1348,7 @@ async function prepareWorkerAppProject(input) {
         }
     }
     await (0, apps_1.validateAppTask)(task);
-    const isExternal = task.hostingMode === 'EXTERNAL' || Boolean(task.externalUrl);
+    const isExternal = task.hostingMode === "EXTERNAL" || Boolean(task.externalUrl);
     const artifacts = isExternal ? null : await (0, apps_1.buildApp)(task);
     await assertWorkerAppLocalUploadPreflight({
         task,
@@ -1406,12 +1385,12 @@ async function publishWorkerAppProject(input) {
         task,
         agentTaskId: input.taskId,
     });
-    if (typeof app.id !== 'number' || !Number.isInteger(app.id) || app.id <= 0) {
+    if (typeof app.id !== "number" || !Number.isInteger(app.id) || app.id <= 0) {
         throw new Error(`App "${task.name}" registration did not return an app id.`);
     }
     const taskToken = input.taskToken.trim();
     if (!taskToken) {
-        throw new Error('agent_task_token_missing');
+        throw new Error("agent_task_token_missing");
     }
     const captureSession = {
         appId: app.id,
@@ -1428,17 +1407,17 @@ async function publishWorkerAppProject(input) {
         runStagedUploadLoadCheck: true,
         ensureRegisteredAppShell: true,
         agentTaskId: input.taskId,
-        playtestSmokeCheckRequired: input.kind === 'NEW_GAME',
+        playtestSmokeCheckRequired: input.kind === "NEW_GAME",
         captureSession,
         ...(artifacts ? { artifacts } : {}),
     });
     if (!uploadResult.versionCreated || !uploadResult.version) {
         throw new Error(`App "${task.name}" upload did not return a created version.`);
     }
-    if (typeof uploadResult.versionId !== 'number') {
+    if (typeof uploadResult.versionId !== "number") {
         throw new Error(`App "${task.name}" upload did not return version ID.`);
     }
-    if (typeof uploadResult.versionNodeId !== 'string' || uploadResult.versionNodeId.trim().length === 0) {
+    if (typeof uploadResult.versionNodeId !== "string" || uploadResult.versionNodeId.trim().length === 0) {
         throw new Error(`App "${task.name}" upload did not return versionNodeId.`);
     }
     return {
@@ -1454,9 +1433,9 @@ async function publishWorkerAppProject(input) {
 async function publishStaticHtmlProject(input) {
     const creatorUsername = input.creatorUsername.trim();
     if (!creatorUsername) {
-        throw new Error('static_game_publish_creator_username_missing');
+        throw new Error("static_game_publish_creator_username_missing");
     }
-    if (input.user.username !== creatorUsername && input.user.role !== 'ADMIN') {
+    if (input.user.username !== creatorUsername && input.user.role !== "ADMIN") {
         throw new Error(`static_game_publish_on_behalf_requires_admin:${input.user.username}:${creatorUsername}`);
     }
     const prepared = await (0, staticHtml_1.prepareStaticHtmlProject)({
@@ -1468,17 +1447,17 @@ async function publishStaticHtmlProject(input) {
     });
     try {
         if (input.taskId !== undefined && !input.claimedAppName?.trim()) {
-            const subtitle = prepared.metadata.description?.trim() ?? '';
+            const subtitle = prepared.metadata.description?.trim() ?? "";
             if (!subtitle) {
-                throw new Error('static_game_subtitle_required');
+                throw new Error("static_game_subtitle_required");
             }
             const primarySurface = prepared.runtimeTask.primarySurface;
             if (!primarySurface) {
-                throw new Error('static_game_primary_surface_required');
+                throw new Error("static_game_primary_surface_required");
             }
-            const taskToken = input.taskToken?.trim() ?? '';
+            const taskToken = input.taskToken?.trim() ?? "";
             if (!taskToken) {
-                throw new Error('static_game_publish_task_token_missing');
+                throw new Error("static_game_publish_task_token_missing");
             }
             const claimed = await input.client.workerClaimAgentTaskSlug(input.taskId, {
                 appName: prepared.runtimeTask.name,
@@ -1486,10 +1465,10 @@ async function publishStaticHtmlProject(input) {
                 subtitle,
                 primarySurface,
             });
-            if (claimed.appName !== prepared.runtimeTask.name
-                || claimed.displayName !== prepared.metadata.title
-                || claimed.subtitle !== subtitle
-                || claimed.primarySurface !== primarySurface) {
+            if (claimed.appName !== prepared.runtimeTask.name ||
+                claimed.displayName !== prepared.metadata.title ||
+                claimed.subtitle !== subtitle ||
+                claimed.primarySurface !== primarySurface) {
                 throw new Error(`static_game_publish_identity_claim_mismatch:${claimed.appName}:${prepared.runtimeTask.name}`);
             }
         }
@@ -1499,8 +1478,8 @@ async function publishStaticHtmlProject(input) {
             task: prepared.runtimeTask,
             agentTaskId: input.taskId,
         });
-        if (typeof app.id !== 'number' || !Number.isInteger(app.id) || app.id <= 0) {
-            throw new Error('static_game_publish_app_registration_failed');
+        if (typeof app.id !== "number" || !Number.isInteger(app.id) || app.id <= 0) {
+            throw new Error("static_game_publish_app_registration_failed");
         }
         const appId = app.id;
         const captureSession = input.taskId !== undefined && input.taskToken?.trim()
@@ -1523,7 +1502,7 @@ async function publishStaticHtmlProject(input) {
             artifacts: prepared.artifacts,
         });
         if (!upload.version || !Number.isInteger(upload.versionId) || !upload.versionNodeId?.trim()) {
-            throw new Error('static_game_publish_version_result_missing');
+            throw new Error("static_game_publish_version_result_missing");
         }
         return {
             appId,
@@ -1541,7 +1520,7 @@ async function publishStaticHtmlProject(input) {
             playUrl: (0, appUrls_1.buildPlatformPrivateDraftPlayUrl)(input.webBase, {
                 creatorUsername,
                 appName: prepared.runtimeTask.name,
-                appType: 'GAME',
+                appType: "GAME",
                 version: upload.version,
             }),
         };