@playdrop/playdrop-cli 0.18.8 → 0.19.0

package/dist/catalogue.js

@@ -9,7 +9,11 @@ exports.resolveWorkspaceApp = resolveWorkspaceApp;
 exports.formatMetadataWarnings = formatMetadataWarnings;
 exports.formatMissingMetadataWarnings = formatMissingMetadataWarnings;
 exports.findAppTaskByFile = findAppTaskByFile;
+exports.catalogueListingContent = catalogueListingContent;
+exports.calculateCatalogueListingSourceHash = calculateCatalogueListingSourceHash;
+const node_crypto_1 = require("node:crypto");
 const types_1 = require("@playdrop/types");
+const types_2 = require("@playdrop/types");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const assetSpecs_1 = require("./assetSpecs");
@@ -17,7 +21,7 @@ const catalogue_utils_1 = require("./catalogue-utils");
 const HEX_COLOR_REGEX = /^#?(?:[0-9a-fA-F]{6})$/;
 const SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
 const LEGACY_CATALOGUE_VERSION_KEY = ["schema", "Version"].join("");
-const ASSET_CATEGORY_SET = new Set(types_1.ASSET_CATEGORY_VALUES);
+const ASSET_CATEGORY_SET = new Set(types_2.ASSET_CATEGORY_VALUES);
 const LISTING_IMAGE_EXTENSIONS = new Set([".png"]);
 const LISTING_VIDEO_EXTENSIONS = new Set([".mp4"]);
 exports.APP_DESCRIPTION_RECOMMENDED_MIN_CHARACTERS = 120;
@@ -26,7 +30,7 @@ exports.APP_RELEASE_NOTES_MAX_CHARACTERS = 240;
 const MAX_CONTENT_TAGS_PER_ITEM = 20;
 const APP_ALLOWED_LICENSES = new Set(["CLOSED", "PLAYDROP", "MIT"]);
 const ASSET_ALLOWED_LICENSES = new Set(["CLOSED", "PLAYDROP", "MIT", "CC0"]);
-const ASSET_SUBCATEGORY_SET_BY_CATEGORY = types_1.ASSET_SUBCATEGORY_DEFINITIONS.reduce((acc, definition) => {
+const ASSET_SUBCATEGORY_SET_BY_CATEGORY = types_2.ASSET_SUBCATEGORY_DEFINITIONS.reduce((acc, definition) => {
     if (!acc[definition.category]) {
         acc[definition.category] = new Set();
     }
@@ -240,7 +244,7 @@ function normalizeCatalogueRemixRef(value, expectedKind, errors, context) {
         errors.push(`${context} remix must be a canonical ${expectedKind} version ref string.`);
         return undefined;
     }
-    const parsed = (0, types_1.parseContentVersionRef)(trimmed);
+    const parsed = (0, types_2.parseContentVersionRef)(trimmed);
     if (!parsed) {
         errors.push(`${context} remix must use canonical version ref format.`);
         return undefined;
@@ -249,7 +253,7 @@ function normalizeCatalogueRemixRef(value, expectedKind, errors, context) {
         errors.push(`${context} remix must point to a ${expectedKind} version.`);
         return undefined;
     }
-    return (0, types_1.formatContentVersionRef)(parsed);
+    return (0, types_2.formatContentVersionRef)(parsed);
 }
 function normalizeCatalogueRelations(value, errors, context) {
     if (!Array.isArray(value)) {
@@ -291,12 +295,12 @@ function normalizeCatalogueAppDependencyAssets(value, errors, context) {
             errors.push(`${context} uses.assets[${index}] must be a non-empty asset ref string or { ref, runtimeKey } object.`);
             continue;
         }
-        const parsed = (0, types_1.parseContentVersionRef)(ref);
+        const parsed = (0, types_2.parseContentVersionRef)(ref);
         if (!parsed || parsed.kind !== "asset") {
             errors.push(`${context} uses.assets[${index}] must be a canonical asset version ref.`);
             continue;
         }
-        const normalizedRef = (0, types_1.formatContentVersionRef)(parsed);
+        const normalizedRef = (0, types_2.formatContentVersionRef)(parsed);
         if (seenRefs.has(normalizedRef)) {
             errors.push(`${context} uses.assets contains duplicate ref "${normalizedRef}".`);
             continue;
@@ -335,12 +339,12 @@ function normalizeCatalogueAppDependencyPacks(value, errors, context) {
             errors.push(`${context} uses.packs[${index}] must be a non-empty pack version ref string. Use "pack:playdrop/name@version", not { ref, runtimeKey }.`);
             continue;
         }
-        const parsed = (0, types_1.parseContentVersionRef)(entry.trim());
+        const parsed = (0, types_2.parseContentVersionRef)(entry.trim());
         if (!parsed || parsed.kind !== "pack") {
             errors.push(`${context} uses.packs[${index}] must be a canonical pack version ref.`);
             continue;
         }
-        const normalizedRef = (0, types_1.formatContentVersionRef)(parsed);
+        const normalizedRef = (0, types_2.formatContentVersionRef)(parsed);
         if (seenRefs.has(normalizedRef)) {
             errors.push(`${context} uses.packs contains duplicate ref "${normalizedRef}".`);
             continue;
@@ -375,7 +379,7 @@ function normalizeCatalogueTags(value, errors, context) {
         }
         let normalizedRef = "";
         try {
-            normalizedRef = (0, types_1.normalizeTagRef)(entry);
+            normalizedRef = (0, types_2.normalizeTagRef)(entry);
         }
         catch {
             errors.push(`${context} tags[${index}] must use group-slug/tag-slug format.`);
@@ -406,8 +410,8 @@ function normalizeCatalogueAllowedTargetKinds(value, errors, context) {
     for (let index = 0; index < value.length; index += 1) {
         const entry = value[index];
         const normalizedKind = typeof entry === "string" ? entry.trim().toUpperCase() : "";
-        if (!types_1.SAVED_ITEM_KIND_VALUES.includes(normalizedKind)) {
-            errors.push(`${context} allowedTargetKinds[${index}] must be one of ${types_1.SAVED_ITEM_KIND_VALUES.join(", ")}.`);
+        if (!types_2.SAVED_ITEM_KIND_VALUES.includes(normalizedKind)) {
+            errors.push(`${context} allowedTargetKinds[${index}] must be one of ${types_2.SAVED_ITEM_KIND_VALUES.join(", ")}.`);
             continue;
         }
         const savedItemKind = normalizedKind;
@@ -626,11 +630,11 @@ function normalizeAssetVisibilityValue(raw, errors, label) {
     }
     return normalized;
 }
-function normalizeContentLicenseValue(raw, errors, label, allowedValues, defaultValue = types_1.DEFAULT_CONTENT_LICENSE) {
+function normalizeContentLicenseValue(raw, errors, label, allowedValues, defaultValue = types_2.DEFAULT_CONTENT_LICENSE) {
     if (raw === undefined || raw === null || (typeof raw === "string" && raw.trim().length === 0)) {
         return defaultValue;
     }
-    const parsed = (0, types_1.parseContentLicense)(raw);
+    const parsed = (0, types_2.parseContentLicense)(raw);
     if (!parsed || !allowedValues.has(parsed)) {
         errors.push(`[${label}] license must be one of ${Array.from(allowedValues).join(", ")}.`);
         return null;
@@ -670,8 +674,8 @@ function normalizeAssetSubcategoryValue(raw, category, errors, label) {
         errors.push(`${label} must define subcategory.`);
         return null;
     }
-    const normalized = (0, types_1.normalizeAssetSubcategory)(raw);
-    if (!(0, types_1.isValidAssetSubcategorySlug)(normalized)) {
+    const normalized = (0, types_2.normalizeAssetSubcategory)(raw);
+    if (!(0, types_2.isValidAssetSubcategorySlug)(normalized)) {
         errors.push(`${label} uses invalid subcategory "${raw}".`);
         return null;
     }
@@ -740,7 +744,7 @@ function validateAchievementDefinitions(value, catalogueDir, errors) {
             return;
         }
         const key = typeof entry.key === "string" ? entry.key.trim() : "";
-        if (!(0, types_1.isPlayerMetaKey)(key)) {
+        if (!(0, types_2.isPlayerMetaKey)(key)) {
             errors.push(`achievements[${index}].key must match the player meta key format`);
             return;
         }
@@ -759,15 +763,15 @@ function validateAchievementDefinitions(value, catalogueDir, errors) {
             errors.push(`achievements[${index}].description must be a non-empty string`);
             return;
         }
-        const kind = (0, types_1.parseAppAchievementKind)(entry.kind);
+        const kind = (0, types_2.parseAppAchievementKind)(entry.kind);
         if (!kind) {
-            errors.push(`achievements[${index}].kind must be one of ${types_1.APP_ACHIEVEMENT_KIND_VALUES.join(", ")}`);
+            errors.push(`achievements[${index}].kind must be one of ${types_2.APP_ACHIEVEMENT_KIND_VALUES.join(", ")}`);
             return;
         }
         const hidden = Boolean(entry.hidden);
-        const status = (0, types_1.parsePlayerMetaDefinitionStatus)(entry.status ?? "ACTIVE");
+        const status = (0, types_2.parsePlayerMetaDefinitionStatus)(entry.status ?? "ACTIVE");
         if (!status) {
-            errors.push(`achievements[${index}].status must be one of ${types_1.PLAYER_META_DEFINITION_STATUS_VALUES.join(", ")}`);
+            errors.push(`achievements[${index}].status must be one of ${types_2.PLAYER_META_DEFINITION_STATUS_VALUES.join(", ")}`);
             return;
         }
         const icon = typeof entry.icon === "string" ? entry.icon.trim() : "";
@@ -828,7 +832,7 @@ function validateLeaderboardDefinitions(value, errors) {
             return;
         }
         const key = typeof entry.key === "string" ? entry.key.trim() : "";
-        if (!(0, types_1.isPlayerMetaKey)(key)) {
+        if (!(0, types_2.isPlayerMetaKey)(key)) {
             errors.push(`leaderboards[${index}].key must match the player meta key format`);
             return;
         }
@@ -847,23 +851,23 @@ function validateLeaderboardDefinitions(value, errors) {
             errors.push(`leaderboards[${index}].description must be a non-empty string`);
             return;
         }
-        const scoreType = (0, types_1.parseAppLeaderboardScoreType)(entry.scoreType);
+        const scoreType = (0, types_2.parseAppLeaderboardScoreType)(entry.scoreType);
         if (!scoreType) {
-            errors.push(`leaderboards[${index}].scoreType must be one of ${types_1.APP_LEADERBOARD_SCORE_TYPE_VALUES.join(", ")}`);
+            errors.push(`leaderboards[${index}].scoreType must be one of ${types_2.APP_LEADERBOARD_SCORE_TYPE_VALUES.join(", ")}`);
             return;
         }
-        const sort = (0, types_1.parseAppLeaderboardSort)(entry.sort);
+        const sort = (0, types_2.parseAppLeaderboardSort)(entry.sort);
         if (!sort) {
-            errors.push(`leaderboards[${index}].sort must be one of ${types_1.APP_LEADERBOARD_SORT_VALUES.join(", ")}`);
+            errors.push(`leaderboards[${index}].sort must be one of ${types_2.APP_LEADERBOARD_SORT_VALUES.join(", ")}`);
             return;
         }
-        if (!(0, types_1.isValidLeaderboardDefinitionCombination)(scoreType, sort)) {
+        if (!(0, types_2.isValidLeaderboardDefinitionCombination)(scoreType, sort)) {
             errors.push(`leaderboards[${index}] must use INTEGER + DESC or TIME_MS + ASC`);
             return;
         }
-        const status = (0, types_1.parsePlayerMetaDefinitionStatus)(entry.status ?? "ACTIVE");
+        const status = (0, types_2.parsePlayerMetaDefinitionStatus)(entry.status ?? "ACTIVE");
         if (!status) {
-            errors.push(`leaderboards[${index}].status must be one of ${types_1.PLAYER_META_DEFINITION_STATUS_VALUES.join(", ")}`);
+            errors.push(`leaderboards[${index}].status must be one of ${types_2.PLAYER_META_DEFINITION_STATUS_VALUES.join(", ")}`);
             return;
         }
         const unitLabel = typeof entry.unitLabel === "string" && entry.unitLabel.trim().length > 0
@@ -892,9 +896,9 @@ function validateAppMetadata(entry) {
     const color = validateOptionalColor(entry.color, Object.prototype.hasOwnProperty.call(entry, "color"), errors);
     let type;
     if (typeof entry.type === "string" && entry.type.trim()) {
-        const parsedType = (0, types_1.parseAppType)(entry.type.trim());
+        const parsedType = (0, types_2.parseAppType)(entry.type.trim());
         if (!parsedType) {
-            errors.push(`type must be one of ${types_1.APP_TYPE_VALUES.join(", ")}`);
+            errors.push(`type must be one of ${types_2.APP_TYPE_VALUES.join(", ")}`);
         }
         else {
             type = parsedType;
@@ -909,8 +913,8 @@ function validateAppMetadata(entry) {
         if (typeof entry.subtitle !== "string" || entry.subtitle.trim().length === 0) {
             errors.push("subtitle must be a non-empty string when provided");
         }
-        else if (entry.subtitle.trim().length > types_1.APP_SUBTITLE_MAX_LENGTH) {
-            errors.push(`subtitle must be ${types_1.APP_SUBTITLE_MAX_LENGTH} characters or fewer`);
+        else if (entry.subtitle.trim().length > types_2.APP_SUBTITLE_MAX_LENGTH) {
+            errors.push(`subtitle must be ${types_2.APP_SUBTITLE_MAX_LENGTH} characters or fewer`);
         }
         else {
             subtitle = entry.subtitle.trim();
@@ -951,7 +955,7 @@ function validateAppMetadata(entry) {
     }
     let primarySurface;
     if (Object.prototype.hasOwnProperty.call(entry, "primarySurface")) {
-        primarySurface = (0, types_1.parseAppSurface)(entry.primarySurface) ?? undefined;
+        primarySurface = (0, types_2.parseAppSurface)(entry.primarySurface) ?? undefined;
         if (!primarySurface) {
             errors.push("primarySurface must be DESKTOP, MOBILE_LANDSCAPE, or MOBILE_PORTRAIT");
         }
@@ -961,7 +965,7 @@ function validateAppMetadata(entry) {
     }
     let playtestTapes;
     if (Object.prototype.hasOwnProperty.call(entry, "playtestTapes")) {
-        const normalized = (0, types_1.normalizeAppPlaytestTapes)(entry.playtestTapes, {
+        const normalized = (0, types_2.normalizeAppPlaytestTapes)(entry.playtestTapes, {
             surfaceTargets: surfaceTargetsList,
             requireComplete: true,
         });
@@ -1168,8 +1172,8 @@ function buildAppTasks(rootDir, catalogues, options) {
             let versionVisibility;
             const rawVisibility = typeof entry.visibility === "string" ? entry.visibility.trim().toUpperCase() : "";
             if (rawVisibility) {
-                if (!types_1.APP_VERSION_VISIBILITY_VALUES.includes(rawVisibility)) {
-                    errors.push(`[${label}] Skipping ${rawName}: visibility must be one of ${types_1.APP_VERSION_VISIBILITY_VALUES.join(", ")}.`);
+                if (!types_2.APP_VERSION_VISIBILITY_VALUES.includes(rawVisibility)) {
+                    errors.push(`[${label}] Skipping ${rawName}: visibility must be one of ${types_2.APP_VERSION_VISIBILITY_VALUES.join(", ")}.`);
                     continue;
                 }
                 versionVisibility = rawVisibility;
@@ -1177,8 +1181,8 @@ function buildAppTasks(rootDir, catalogues, options) {
             let hostingMode;
             const rawHostingMode = typeof entry.hostingMode === "string" ? entry.hostingMode.trim().toUpperCase() : "";
             if (rawHostingMode) {
-                if (!types_1.APP_HOSTING_MODE_VALUES.includes(rawHostingMode)) {
-                    errors.push(`[${label}] Skipping ${rawName}: hostingMode must be one of ${types_1.APP_HOSTING_MODE_VALUES.join(", ")}.`);
+                if (!types_2.APP_HOSTING_MODE_VALUES.includes(rawHostingMode)) {
+                    errors.push(`[${label}] Skipping ${rawName}: hostingMode must be one of ${types_2.APP_HOSTING_MODE_VALUES.join(", ")}.`);
                     continue;
                 }
                 hostingMode = rawHostingMode;
@@ -1186,8 +1190,8 @@ function buildAppTasks(rootDir, catalogues, options) {
             let authMode;
             const rawAuthMode = typeof entry.authMode === "string" ? entry.authMode.trim().toUpperCase() : "";
             if (rawAuthMode) {
-                if (!types_1.APP_AUTH_MODE_VALUES.includes(rawAuthMode)) {
-                    errors.push(`[${label}] Skipping ${rawName}: authMode must be one of ${types_1.APP_AUTH_MODE_VALUES.join(", ")}.`);
+                if (!types_2.APP_AUTH_MODE_VALUES.includes(rawAuthMode)) {
+                    errors.push(`[${label}] Skipping ${rawName}: authMode must be one of ${types_2.APP_AUTH_MODE_VALUES.join(", ")}.`);
                     continue;
                 }
                 authMode = rawAuthMode;
@@ -1245,8 +1249,8 @@ function buildAppTasks(rootDir, catalogues, options) {
             let controllerMode;
             const rawControllerMode = typeof entry.controllerMode === "string" ? entry.controllerMode.trim().toUpperCase() : "";
             if (rawControllerMode) {
-                if (!types_1.APP_CONTROLLER_MODE_VALUES.includes(rawControllerMode)) {
-                    errors.push(`[${label}] Skipping ${rawName}: controllerMode must be one of ${types_1.APP_CONTROLLER_MODE_VALUES.join(", ")}.`);
+                if (!types_2.APP_CONTROLLER_MODE_VALUES.includes(rawControllerMode)) {
+                    errors.push(`[${label}] Skipping ${rawName}: controllerMode must be one of ${types_2.APP_CONTROLLER_MODE_VALUES.join(", ")}.`);
                     continue;
                 }
                 controllerMode = rawControllerMode;
@@ -1293,7 +1297,7 @@ function buildAppTasks(rootDir, catalogues, options) {
                 errors.push(`[${label}] Skipping ${rawName}: editorSupported can only be true for HOSTED apps.`);
                 continue;
             }
-            const defaultLicense = (hostingMode ?? "HOSTED") === "EXTERNAL" ? "CLOSED" : types_1.DEFAULT_CONTENT_LICENSE;
+            const defaultLicense = (hostingMode ?? "HOSTED") === "EXTERNAL" ? "CLOSED" : types_2.DEFAULT_CONTENT_LICENSE;
             const license = normalizeContentLicenseValue(entry.license, errors, `${label} app "${rawName}"`, APP_ALLOWED_LICENSES, defaultLicense);
             if (!license) {
                 continue;
@@ -1382,6 +1386,22 @@ function buildAppTasks(rootDir, catalogues, options) {
                         }
                     }
                 }
+                if (rawListing.socialLandscape !== undefined) {
+                    const socialPath = rawListing.socialLandscape;
+                    if (typeof socialPath !== "string" || !socialPath.trim()) {
+                        errors.push(`[${label}] invalid listing.socialLandscape`);
+                        listingValidationFailed = true;
+                    }
+                    else {
+                        const failure = ([".jpg", ".jpeg"].includes((0, node_path_1.extname)(socialPath).toLowerCase()) ? undefined : validateListingAssetExtension(socialPath, "listing.socialLandscape", "image")) ?? validateListingAssetPath(file.directory, socialPath, "listing.socialLandscape");
+                        if (failure) {
+                            errors.push(failure);
+                            listingValidationFailed = true;
+                        }
+                        else
+                            resolvedListing.socialLandscapePath = resolveListingAssetPath(file.directory, socialPath);
+                    }
+                }
                 for (const mediaField of [
                     {
                         value: rawListing.screenshotsPortrait,
@@ -1461,7 +1481,7 @@ function buildAppTasks(rootDir, catalogues, options) {
             }
             let design;
             if (Object.prototype.hasOwnProperty.call(entry, "design")) {
-                const parsedDesign = (0, types_1.normalizeAppVersionDesign)(entry.design);
+                const parsedDesign = (0, types_2.normalizeAppVersionDesign)(entry.design);
                 if (!parsedDesign.ok) {
                     errors.push(`[${label}] App "${rawName}" ${parsedDesign.error}`);
                     continue;
@@ -1470,7 +1490,7 @@ function buildAppTasks(rootDir, catalogues, options) {
             }
             let players;
             if (Object.prototype.hasOwnProperty.call(entry, "players")) {
-                const parsedPlayers = (0, types_1.normalizeAppPlayers)(entry.players);
+                const parsedPlayers = (0, types_2.normalizeAppPlayers)(entry.players);
                 if (!parsedPlayers.ok) {
                     errors.push(`[${label}] App "${rawName}" ${parsedPlayers.error}`);
                     continue;
@@ -1496,7 +1516,7 @@ function buildAppTasks(rootDir, catalogues, options) {
             }
             let creation;
             if (Object.prototype.hasOwnProperty.call(entry, "creation")) {
-                const parsedCreation = (0, types_1.normalizeAppCreationMetadata)(entry.creation);
+                const parsedCreation = (0, types_2.normalizeAppCreationMetadata)(entry.creation);
                 if (!parsedCreation.ok) {
                     errors.push(`[${label}] App "${rawName}" ${parsedCreation.error}`);
                     continue;
@@ -1524,7 +1544,7 @@ function buildAppTasks(rootDir, catalogues, options) {
             }
             let tweaks;
             if (Object.prototype.hasOwnProperty.call(entry, "tweaks")) {
-                const parsedTweaks = (0, types_1.normalizeAppTweaks)(entry.tweaks);
+                const parsedTweaks = (0, types_2.normalizeAppTweaks)(entry.tweaks);
                 if (!parsedTweaks.ok) {
                     errors.push(`[${label}] App "${rawName}" ${parsedTweaks.error}`);
                     continue;
@@ -1695,8 +1715,89 @@ function buildAppTasks(rootDir, catalogues, options) {
             if (errors.length > runtimeValidationErrorCount) {
                 continue;
             }
+            let listingLocalizations = [];
+            let sourceLocale = null;
+            let listingSourceHash;
+            try {
+                sourceLocale = (0, types_1.normalizeAppListingSourceLocale)(entry.sourceLocale);
+                const rawLocalizations = entry.listingLocalizations;
+                if (rawLocalizations !== undefined && (!rawLocalizations || typeof rawLocalizations !== "object" || Array.isArray(rawLocalizations)))
+                    throw new Error("invalid_listing_localizations");
+                for (const [locale, value] of Object.entries(rawLocalizations ?? {})) {
+                    if (!value || typeof value !== "object" || Array.isArray(value))
+                        throw new Error("invalid_listing_localization");
+                    const localized = value;
+                    const allowedFields = new Set(["displayName", "subtitle", "description", "controls", "makingOf", "releaseNotes", "sourceHash", "listing"]);
+                    const unsupported = Object.keys(localized).filter((key) => !allowedFields.has(key));
+                    if (unsupported.length)
+                        throw new Error(`unsupported_listing_localization_fields:${locale}:${unsupported.join(",")}`);
+                    (0, types_1.normalizeAppListingLocalizations)([{ ...localized, locale }], sourceLocale);
+                    const media = localized.listing ?? {};
+                    if (!media || typeof media !== "object" || Array.isArray(media))
+                        throw new Error("invalid_listing_media");
+                    const allowedMedia = new Set([...types_1.APP_LISTING_PATH_FIELDS.map((field) => field.replace(/Path$/, "")), ...types_1.APP_LISTING_ARRAY_FIELDS]);
+                    const unsupportedMedia = Object.keys(media).filter((key) => !allowedMedia.has(key));
+                    if (unsupportedMedia.length)
+                        throw new Error(`unsupported_listing_localization_media_fields:${locale}:${unsupportedMedia.join(",")}`);
+                    for (const field of types_1.APP_LISTING_ARRAY_FIELDS) {
+                        const entries = media[field];
+                        if (entries === undefined)
+                            continue;
+                        if (!Array.isArray(entries))
+                            throw new Error(`invalid_listing_${field}`);
+                        for (const entry of entries) {
+                            if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+                                const unsupported = Object.keys(entry).filter((key) => !["path", "slug", "title", "alt", "caption", "description"].includes(key));
+                                if (unsupported.length)
+                                    throw new Error(`unsupported_listing_localization_media_fields:${locale}:${field}:${unsupported.join(",")}`);
+                            }
+                        }
+                    }
+                }
+                if (options.listingAssets !== "ignore") {
+                    listingLocalizations = (0, types_1.normalizeAppListingLocalizations)(Object.entries(rawLocalizations ?? {}).map(([locale, value]) => {
+                        if (!value || typeof value !== "object" || Array.isArray(value))
+                            throw new Error("invalid_listing_localization");
+                        const localized = value;
+                        const media = localized.listing ?? {};
+                        if (!media || typeof media !== "object" || Array.isArray(media))
+                            throw new Error("invalid_listing_media");
+                        const paths = {};
+                        const metadata = [];
+                        for (const field of types_1.APP_LISTING_PATH_FIELDS) {
+                            const key = field.replace(/Path$/, "");
+                            const value = media[key];
+                            if (value === undefined || value === null)
+                                continue;
+                            if (typeof value !== "string" || !value.trim())
+                                throw new Error(`invalid_listing_${key}`);
+                            const failure = (field === "socialLandscapePath" && [".jpg", ".jpeg"].includes((0, node_path_1.extname)(value).toLowerCase()) ? undefined : validateListingAssetExtension(value, `${locale}.listing.${key}`, "image")) ?? validateListingAssetPath(file.directory, value, `${locale}.listing.${key}`);
+                            if (failure)
+                                throw new Error(failure);
+                            paths[field] = resolveListingAssetPath(file.directory, value);
+                        }
+                        for (const field of types_1.APP_LISTING_ARRAY_FIELDS) {
+                            const resolved = resolveListingMediaEntries({ value: media[field], baseDir: file.directory, fieldName: `${locale}.listing.${field}`, kind: field.startsWith("videos") ? "video" : "image", fileKeyPrefix: field });
+                            if (resolved.error)
+                                throw new Error(resolved.error);
+                            paths[field] = resolved.paths;
+                            metadata.push(...resolved.metadata);
+                        }
+                        return { ...localized, ...paths, listingMedia: metadata, locale };
+                    }), sourceLocale);
+                    if (sourceLocale)
+                        listingSourceHash = calculateCatalogueListingSourceHash({ ...metadata, sourceLocale, listing, controls, makingOf, releaseNotes });
+                }
+            }
+            catch (error) {
+                errors.push(`[${label}] ${rawName}: ${error instanceof Error ? error.message : String(error)}`);
+                continue;
+            }
             tasks.push({
                 kind: "app",
+                sourceLocale,
+                listingSourceHash,
+                listingLocalizations,
                 name: rawName,
                 cataloguePath: label,
                 catalogueAbsolutePath: file.absolutePath,
@@ -1820,8 +1921,8 @@ function buildAssetSpecTasks(catalogues) {
             let validationKind = loadedContract.validationKind;
             if (typeof entry.validationKind === "string" && entry.validationKind.trim().length > 0) {
                 const normalizedValidationKind = entry.validationKind.trim().toUpperCase();
-                if (!types_1.ASSET_SPEC_VALIDATION_KIND_VALUES.includes(normalizedValidationKind)) {
-                    errors.push(`[${label}] Asset spec "${name}@${version}" validationKind must be one of ${types_1.ASSET_SPEC_VALIDATION_KIND_VALUES.join(", ")}.`);
+                if (!types_2.ASSET_SPEC_VALIDATION_KIND_VALUES.includes(normalizedValidationKind)) {
+                    errors.push(`[${label}] Asset spec "${name}@${version}" validationKind must be one of ${types_2.ASSET_SPEC_VALIDATION_KIND_VALUES.join(", ")}.`);
                     continue;
                 }
                 if (normalizedValidationKind !== loadedContract.validationKind) {
@@ -1833,8 +1934,8 @@ function buildAssetSpecTasks(catalogues) {
             let status = "ACTIVE";
             if (typeof entry.status === "string" && entry.status.trim().length > 0) {
                 const normalizedStatus = entry.status.trim().toUpperCase();
-                if (!types_1.ASSET_SPEC_STATUS_VALUES.includes(normalizedStatus)) {
-                    errors.push(`[${label}] Asset spec "${name}@${version}" status must be one of ${types_1.ASSET_SPEC_STATUS_VALUES.join(", ")}.`);
+                if (!types_2.ASSET_SPEC_STATUS_VALUES.includes(normalizedStatus)) {
+                    errors.push(`[${label}] Asset spec "${name}@${version}" status must be one of ${types_2.ASSET_SPEC_STATUS_VALUES.join(", ")}.`);
                     continue;
                 }
                 status = normalizedStatus;
@@ -2012,7 +2113,7 @@ function buildAssetTasks(catalogues, assetSpecTasks) {
                     assetSpecContract = directAssetSpecTask.contract;
                 }
                 else {
-                    const parsedAssetSpec = (0, types_1.parseAssetSpecVersionRef)(assetSpec);
+                    const parsedAssetSpec = (0, types_2.parseAssetSpecVersionRef)(assetSpec);
                     if (parsedAssetSpec) {
                         const fallbackAssetSpecTask = uniqueAssetSpecTaskByNameVersion.get(`${parsedAssetSpec.name}@${parsedAssetSpec.version}`);
                         if (fallbackAssetSpecTask) {
@@ -2194,8 +2295,8 @@ function buildAssetPackTasks(catalogues) {
             let hostingMode;
             const rawHostingMode = typeof entry.hostingMode === "string" ? entry.hostingMode.trim().toUpperCase() : "";
             if (rawHostingMode) {
-                if (!types_1.APP_HOSTING_MODE_VALUES.includes(rawHostingMode)) {
-                    errors.push(`[${label}] Asset pack "${name}" hostingMode must be one of ${types_1.APP_HOSTING_MODE_VALUES.join(", ")}.`);
+                if (!types_2.APP_HOSTING_MODE_VALUES.includes(rawHostingMode)) {
+                    errors.push(`[${label}] Asset pack "${name}" hostingMode must be one of ${types_2.APP_HOSTING_MODE_VALUES.join(", ")}.`);
                     continue;
                 }
                 hostingMode = rawHostingMode;
@@ -2440,7 +2541,7 @@ function resolveCatalogueTagGroups(rootDir) {
                 continue;
             }
             const slug = typeof entry.slug === "string" ? entry.slug.trim().toLowerCase() : "";
-            if (!slug || !(0, types_1.isValidTagSlug)(slug)) {
+            if (!slug || !(0, types_2.isValidTagSlug)(slug)) {
                 errors.push(`[${label}] tagGroups[${index}] slug must use lowercase slug format.`);
                 continue;
             }
@@ -2468,7 +2569,7 @@ function resolveCatalogueTagGroups(rootDir) {
                     continue;
                 }
                 const tagSlug = typeof rawTag.slug === "string" ? rawTag.slug.trim().toLowerCase() : "";
-                if (!tagSlug || !(0, types_1.isValidTagSlug)(tagSlug)) {
+                if (!tagSlug || !(0, types_2.isValidTagSlug)(tagSlug)) {
                     errors.push(`[${label}] Tag group "${slug}" tags[${tagIndex}] slug must use lowercase slug format.`);
                     continue;
                 }
@@ -2705,3 +2806,17 @@ function findAppTaskByFile(htmlPath, options = {}) {
     }
     return { task: undefined, warnings: [], errors: [] };
 }
+function catalogueListingContent(task) {
+    const listing = task.listing;
+    return (0, types_1.normalizeAppListingContent)({ ...task,
+        iconPath: listing?.iconPath, heroPortraitPath: listing?.heroPortraitPath, heroLandscapePath: listing?.heroLandscapePath, socialLandscapePath: listing?.socialLandscapePath,
+        screenshotsPortrait: listing?.screenshotPortraitPaths, screenshotsLandscape: listing?.screenshotLandscapePaths,
+        videosPortrait: listing?.videoPortraitPaths, videosLandscape: listing?.videoLandscapePaths, listingMedia: listing?.mediaMetadata,
+    });
+}
+function calculateCatalogueListingSourceHash(task) {
+    const content = catalogueListingContent(task);
+    const paths = [...types_1.APP_LISTING_PATH_FIELDS.flatMap((field) => content[field] ? [content[field]] : []), ...types_1.APP_LISTING_ARRAY_FIELDS.flatMap((field) => content[field])];
+    const hashes = new Map(paths.map((file) => [file, (0, node_crypto_1.createHash)("sha256").update((0, node_fs_1.readFileSync)(file)).digest("hex")]));
+    return (0, node_crypto_1.createHash)("sha256").update((0, types_1.canonicalAppListingSource)(content, task.sourceLocale ?? null, hashes)).digest("hex");
+}

package/dist/commands/devServer.js

@@ -545,6 +545,9 @@ async function ensureDevRouterRunning(port = exports.DEV_ROUTER_PORT) {
         }
         throw new Error(`dev_router_incompatible:port_${port}`);
     }
+    if (process.env.PLAYDROP_WORKER_CONTEXT === "1") {
+        throw new Error(`worker_dev_router_missing:port_${port}`);
+    }
     await startOwnedDevRouter(port);
 }
 // Managed Mac workers call this with their reserved slots before advertising

package/dist/commands/validate.js

@@ -259,6 +259,7 @@ async function validate(pathOrName, options = {}) {
                 entityType: task.kind,
                 entityId,
                 catalogue: task.cataloguePath,
+                ...(task.kind === "app" && task.listingSourceHash ? { detail: `listingSourceHash=${task.listingSourceHash}` } : {}),
             };
             results.push(entry);
             console.log((0, uploadLog_1.formatTaskLogLine)(entry));

package/dist/commands/worker/game-source-git.js

@@ -366,6 +366,13 @@ async function setupGameSourceWorkspace(input) {
             repoPath: projectDir,
             listing: {
                 version: source.listingSync.version,
+                sourceLocale: source.listingSync.sourceLocale,
+                listingSourceHash: source.listingSync.listingSourceHash,
+                listingLocalizations: source.listingSync.listingLocalizations,
+                listingMedia: source.listingSync.listingMedia,
+                controls: source.listingSync.controls,
+                makingOf: source.listingSync.makingOf,
+                releaseNotes: source.listingSync.releaseNotes,
                 displayName: source.listingSync.displayName,
                 subtitle: source.listingSync.subtitle,
                 description: source.listingSync.description,

package/dist/commands/worker/generation.d.ts

@@ -55,13 +55,28 @@ export declare function triggerGenerationWorkerFailpoint(input: {
 }): Promise<boolean>;
 export declare function configureFalCredential(workerHomeDir: string): Promise<void>;
 export declare function buildSandboxedCodexArgs(input: {
-    sandbox: "read-only" | "workspace-write";
+    sandbox: "read-only" | "workspace-write" | "danger-full-access";
     outputPath: string;
     prompt: string;
     outputSchemaPath?: string;
     persistSession?: boolean;
+    model?: string;
+    reasoningEffort?: string;
+    imagePaths?: string[];
 }): string[];
 export declare function retainScreeningTranscript(codexHomeDir: string, taskId: number): Promise<void>;
+export declare function runCodex(input: {
+    cwd: string;
+    prompt: string;
+    sandbox: "read-only" | "workspace-write" | "danger-full-access";
+    outputPath: string;
+    outputSchema?: Record<string, unknown>;
+    signal: AbortSignal;
+    screeningTaskId?: number;
+    model?: string;
+    reasoningEffort?: string;
+    imagePaths?: string[];
+}): Promise<void>;
 export declare function falInput(request: CreateAiGenerationTaskRequest, resolvedInputs: Map<string, string>): Record<string, unknown>;
 export declare function selectFalOutputs(kind: CreateAiGenerationTaskRequest["kind"], value: Record<string, unknown>): {
     primary: FalFile;

package/dist/commands/worker/generation.js

@@ -49,6 +49,7 @@ exports.triggerGenerationWorkerFailpoint = triggerGenerationWorkerFailpoint;
 exports.configureFalCredential = configureFalCredential;
 exports.buildSandboxedCodexArgs = buildSandboxedCodexArgs;
 exports.retainScreeningTranscript = retainScreeningTranscript;
+exports.runCodex = runCodex;
 exports.falInput = falInput;
 exports.selectFalOutputs = selectFalOutputs;
 exports.validatePrimary = validatePrimary;
@@ -400,10 +401,12 @@ function buildSandboxedCodexArgs(input) {
         "--sandbox",
         input.sandbox,
         "--model",
-        CODEX_MODEL,
+        input.model ?? CODEX_MODEL,
         "-c",
-        'model_reasoning_effort="high"',
+        `model_reasoning_effort="${input.reasoningEffort ?? 'high'}"`,
     ];
+    for (const imagePath of input.imagePaths ?? [])
+        args.push('--image', imagePath);
     if (input.outputSchemaPath)
         args.push("--output-schema", input.outputSchemaPath);
     args.push("-o", input.outputPath, input.prompt);
@@ -448,6 +451,9 @@ async function runCodex(input) {
         prompt: input.prompt,
         persistSession: input.screeningTaskId !== undefined,
         ...(outputSchemaPath ? { outputSchemaPath } : {}),
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}),
+        ...(input.imagePaths ? { imagePaths: input.imagePaths } : {}),
     });
     const runtime = await prepareGenerationCodexRuntime();
     try {

package/dist/commands/worker/ugc-processing.d.ts

@@ -0,0 +1,13 @@
+import type { ApiClient } from '@playdrop/api-client';
+import { type UgcProcessingResult, type WorkerUgcTaskAssignmentV5 } from '@playdrop/types';
+export declare const UGC_PROCESSING_PROMPT: string;
+export declare function normalizeWorkerUgcAssignment(value: unknown): WorkerUgcTaskAssignmentV5;
+export declare function parseUgcModelOutput(text: string, claudeEnvelope?: boolean): {
+    results: UgcProcessingResult[];
+};
+export declare function runWorkerUgcTask(input: {
+    client: ApiClient;
+    assignment: WorkerUgcTaskAssignmentV5;
+    workerKey: string;
+    leaseToken: string;
+}): Promise<void>;