@playdrop/playdrop-cli 0.16.12 → 0.17.0

package/dist/apps/serverBuild.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GAME_SERVER_BUNDLE_MAX_BYTES = exports.GAME_SERVER_RUNTIME_VERSION = void 0;
+exports.verifyGameServerDependencies = verifyGameServerDependencies;
+exports.buildGameServer = buildGameServer;
+exports.formatServerBuildPath = formatServerBuildPath;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const esbuild_1 = require("esbuild");
+exports.GAME_SERVER_RUNTIME_VERSION = "colyseus-0.17-v1";
+exports.GAME_SERVER_BUNDLE_MAX_BYTES = 2 * 1024 * 1024;
+const REQUIRED_PACKAGE_VERSIONS = Object.freeze({
+    colyseus: "0.17.10",
+    "@colyseus/core": "0.17.50",
+    "@colyseus/schema": "4.0.30",
+    mongodb: "7.5.0",
+    "@playdrop/server": "0.1.0",
+    typescript: "5.9.3",
+});
+const CREATOR_IMPORTS = new Set([
+    "colyseus",
+    "@colyseus/core",
+    "@colyseus/schema",
+    "mongodb",
+    "@playdrop/server",
+]);
+function resolveInstalledPackageVersion(projectPackageJsonPath, packageName) {
+    let current = (0, node_path_1.dirname)(projectPackageJsonPath);
+    while (true) {
+        const packageJsonPath = (0, node_path_1.join)(current, "node_modules", ...packageName.split("/"), "package.json");
+        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+            const manifest = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
+            if (manifest.name === packageName && typeof manifest.version === "string") {
+                return manifest.version;
+            }
+        }
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    throw new Error(`server_dependency_missing:${packageName}`);
+}
+function verifyGameServerDependencies(task) {
+    if (!task.server)
+        return;
+    if (!task.packageJsonPath)
+        throw new Error("server_package_json_required");
+    for (const [packageName, expected] of Object.entries(REQUIRED_PACKAGE_VERSIONS)) {
+        const actual = resolveInstalledPackageVersion(task.packageJsonPath, packageName);
+        if (actual !== expected) {
+            throw new Error(`server_dependency_version_mismatch:${packageName}:expected=${expected}:actual=${actual}`);
+        }
+    }
+}
+function allowedImportsPlugin(projectDir) {
+    const normalizedProjectDir = `${(0, node_fs_1.realpathSync)(projectDir)}${node_path_1.sep}`;
+    return {
+        name: "playdrop-server-import-policy",
+        setup(builder) {
+            builder.onResolve({ filter: /.*/ }, (args) => {
+                if (args.kind === "entry-point")
+                    return null;
+                if (CREATOR_IMPORTS.has(args.path)) {
+                    return { path: args.path, external: true };
+                }
+                if (args.path.startsWith(".") || args.path.startsWith("/")) {
+                    const candidate = (0, node_path_1.resolve)(args.resolveDir, args.path);
+                    let resolvedPath = candidate;
+                    try {
+                        resolvedPath = (0, node_fs_1.realpathSync)(candidate);
+                    }
+                    catch {
+                        // esbuild reports the more precise missing-module error.
+                    }
+                    if (`${resolvedPath}${node_path_1.sep}`.startsWith(normalizedProjectDir) || resolvedPath.startsWith(normalizedProjectDir)) {
+                        return null;
+                    }
+                    return { errors: [{ text: `server_import_outside_project:${args.path}` }] };
+                }
+                return { errors: [{ text: `server_import_not_allowed:${args.path}` }] };
+            });
+        },
+    };
+}
+async function validateRoomExports(task, bundlePath) {
+    if (!task.server)
+        return;
+    const moduleUrl = `${(0, node_url_1.pathToFileURL)(bundlePath).href}?validation=${Date.now()}`;
+    let imported;
+    try {
+        const importEsm = new Function("specifier", "return import(specifier)");
+        imported = await importEsm(moduleUrl);
+    }
+    catch (error) {
+        throw new Error(`server_bundle_load_failed:${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!imported.rooms || typeof imported.rooms !== "object" || Array.isArray(imported.rooms)) {
+        throw new Error("server_rooms_export_missing");
+    }
+    const exportedRoomNames = Object.keys(imported.rooms).sort();
+    const declaredRoomNames = [...task.server.rooms].sort();
+    if (JSON.stringify(exportedRoomNames) !== JSON.stringify(declaredRoomNames)) {
+        throw new Error(`server_rooms_mismatch:declared=${declaredRoomNames.join(",")}:exported=${exportedRoomNames.join(",")}`);
+    }
+    for (const roomName of exportedRoomNames) {
+        const handler = imported.rooms[roomName];
+        if (!handler || typeof handler.klass !== "function")
+            throw new Error(`server_room_invalid:${roomName}`);
+    }
+}
+async function buildGameServer(task) {
+    if (!task.server)
+        return null;
+    verifyGameServerDependencies(task);
+    const outputDir = (0, node_path_1.join)(task.projectDir, ".playdrop", "server");
+    const bundlePath = (0, node_path_1.join)(outputDir, "bundle.mjs");
+    const manifestPath = (0, node_path_1.join)(outputDir, "manifest.json");
+    (0, node_fs_1.mkdirSync)(outputDir, { recursive: true });
+    await (0, esbuild_1.build)({
+        entryPoints: [task.server.entryPath],
+        outfile: bundlePath,
+        absWorkingDir: task.projectDir,
+        bundle: true,
+        format: "esm",
+        platform: "node",
+        target: "node22",
+        packages: "bundle",
+        sourcemap: false,
+        legalComments: "none",
+        treeShaking: true,
+        metafile: true,
+        logLevel: "silent",
+        plugins: [allowedImportsPlugin(task.projectDir)],
+    });
+    const size = (0, node_fs_1.statSync)(bundlePath).size;
+    if (size > exports.GAME_SERVER_BUNDLE_MAX_BYTES) {
+        throw new Error(`server_bundle_too_large:max=${exports.GAME_SERVER_BUNDLE_MAX_BYTES}:actual=${size}`);
+    }
+    await validateRoomExports(task, bundlePath);
+    const sha256 = (0, node_crypto_1.createHash)("sha256").update((0, node_fs_1.readFileSync)(bundlePath)).digest("hex");
+    const manifest = {
+        runtimeVersion: exports.GAME_SERVER_RUNTIME_VERSION,
+        rooms: [...task.server.rooms],
+        size,
+        sha256,
+    };
+    (0, node_fs_1.writeFileSync)(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    return { bundlePath, manifestPath, manifest };
+}
+function formatServerBuildPath(task, absolutePath) {
+    return (0, node_path_1.relative)(task.projectDir, absolutePath).split(node_path_1.sep).join("/");
+}

package/dist/apps/staticHtml.d.ts

@@ -25,5 +25,6 @@ export declare function prepareStaticHtmlProject(input: {
     appName?: string;
     primarySurface: AppSurface;
     cdnBase: string;
+    gameSourceGit?: boolean;
 }): Promise<PreparedStaticHtmlProject>;
 export declare function sha256File(filePath: string): string;

package/dist/apps/staticHtml.js

@@ -12,7 +12,18 @@ const node_path_1 = require("node:path");
 const parse5_1 = require("parse5");
 const build_1 = require("./build");
 const STATIC_GAME_SURFACES = ["DESKTOP", "MOBILE_LANDSCAPE", "MOBILE_PORTRAIT"];
-const STATIC_SOURCE_EXCLUDES = ["AGENTS.md", "CLAUDE.md", ".playdrop/", "bin/playdrop"];
+const STATIC_SOURCE_EXCLUDES = ["AGENTS.md", "CLAUDE.md", ".playdrop/", "bin/playdrop", "tasks/"];
+const STATIC_GAME_SOURCE_GIT_EXCLUDES = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    ".DS_Store",
+    ".playdrop.json",
+    "bin/playdrop",
+    "next-steps.json",
+    "player-feedback.md",
+    "platform-feedback.md",
+    "source.zip",
+];
 const STATIC_BUNDLE_EXCLUDES = [...STATIC_SOURCE_EXCLUDES];
 function attribute(node, name) {
     return node.attrs?.find((entry) => entry.name.toLowerCase() === name)?.value.trim() ?? null;
@@ -246,7 +257,8 @@ function buildStaticAppTask(input) {
         version: "1.0.0",
         releaseNotes: "Initial static game upload",
         versionVisibility: "PRIVATE",
-        sourceArchiveExcludeRelativeFiles: STATIC_SOURCE_EXCLUDES,
+        sourceArchiveExcludeRelativeFiles: input.gameSourceGit ? STATIC_GAME_SOURCE_GIT_EXCLUDES : STATIC_SOURCE_EXCLUDES,
+        sourceArchiveGameSourceGit: input.gameSourceGit === true,
         bundleArchiveExcludeRelativeFiles: STATIC_BUNDLE_EXCLUDES,
         license: "CLOSED",
         tags: [],
@@ -302,8 +314,9 @@ async function prepareStaticHtmlProject(input) {
         name,
         metadata,
         primarySurface: input.primarySurface,
+        gameSourceGit: input.gameSourceGit,
     });
-    const sourceArtifacts = await (0, build_1.buildApp)(sourceTask);
+    const sourceArtifacts = await (0, build_1.buildApp)(sourceTask, { includeSourceArchive: false });
     const runtimeDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), `playdrop-static-${name}-`));
     try {
         await (0, promises_1.cp)(sourceRoot, runtimeDir, {
@@ -328,17 +341,13 @@ async function prepareStaticHtmlProject(input) {
             },
             primarySurface: input.primarySurface,
         });
-        const runtimeArtifacts = await (0, build_1.buildApp)(runtimeTask);
-        const artifacts = {
-            ...runtimeArtifacts,
-            sourceFile: sourceArtifacts.sourceFile,
-            sourceHash: sourceArtifacts.sourceHash,
-        };
+        const runtimeArtifacts = await (0, build_1.buildApp)(runtimeTask, { includeSourceArchive: false });
+        const artifacts = runtimeArtifacts;
         return {
             sourceTask,
             runtimeTask,
             artifacts,
-            sourceHash: sourceArtifacts.sourceHash,
+            sourceHash: sourceArtifacts.bundleHash,
             runtimeHash: runtimeArtifacts.bundleHash,
             metadata,
             runtimeDir,

package/dist/apps/upload.d.ts

@@ -1,5 +1,5 @@
 import type { ApiClient } from "@playdrop/api-client";
-import type { AgentTaskPlaytestProof, UserResponse } from "@playdrop/types";
+import type { AgentTaskPlaytestProof, FinalizeAppUploadRequest, UserResponse } from "@playdrop/types";
 import type { AppTask } from "../catalogue";
 import type { TaskCaptureSession } from "../appUrls";
 import type { AppBuildArtifacts } from "./build";
@@ -24,14 +24,22 @@ export type AppUploadOptions = {
     playtestProof?: AgentTaskPlaytestProof;
     playtestSmokeCheckRequired?: boolean;
     captureSession?: TaskCaptureSession | null;
+    prepareGitTransition?: (input: {
+        appId: number;
+        sessionId: string;
+        version: string;
+    }) => Promise<NonNullable<FinalizeAppUploadRequest["gitTransition"]>>;
 };
 type PreparedSessionFile = {
-    fileKey: string;
+    id: string;
+    role: "RUNTIME" | "LISTING" | "SERVER" | "SOURCE" | "OWNED_ASSET";
+    relativePath: string;
     file: File;
     filename: string;
     contentType: string;
     sizeBytes: number;
     sha256: string;
+    md5Base64: string;
 };
 type PreparedOwnedAssetUpload = {
     uploadKey: string;
@@ -49,12 +57,14 @@ type PreparedOwnedAssetUpload = {
     shopListed?: boolean;
     shopPriceCredits?: number;
     files: Array<{
+        objectId: string;
         role: string;
         file: File;
         filename: string;
         contentType: string;
         sizeBytes: number;
         sha256: string;
+        md5Base64: string;
     }>;
 };
 type PreparedAppUploadFiles = {

package/dist/apps/upload.js

@@ -8,6 +8,7 @@ const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const http_1 = require("../http");
+const serverBuild_1 = require("./serverBuild");
 const loadCheck_1 = require("./loadCheck");
 const EXTENSION_TO_MIME = {
     ".png": "image/png",
@@ -20,7 +21,18 @@ const EXTENSION_TO_MIME = {
     ".mp3": "audio/mpeg",
     ".wav": "audio/wav",
     ".ogg": "audio/ogg",
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".js": "application/javascript",
+    ".mjs": "application/javascript",
+    ".css": "text/css",
+    ".txt": "text/plain",
+    ".svg": "image/svg+xml",
+    ".wasm": "application/wasm",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
     ".json": "application/json",
+    ".zip": "application/zip",
     ".gltf": "model/gltf+json",
     ".glb": "model/gltf-binary",
     ".vox": "application/octet-stream",
@@ -75,19 +87,26 @@ async function bufferFromFile(file) {
 function computeSha256Hex(buffer) {
     return (0, node_crypto_1.createHash)("sha256").update(buffer).digest("hex");
 }
+function computeMd5Base64(buffer) {
+    return (0, node_crypto_1.createHash)("md5").update(buffer).digest("base64");
+}
 function resolveMimeType(filename, fallback = "application/octet-stream") {
     const type = EXTENSION_TO_MIME[(0, node_path_1.extname)(filename).toLowerCase()];
     return type ?? fallback;
 }
-async function buildPreparedSessionFile(fileKey, file) {
+async function buildPreparedSessionFile(role, relativePath, file) {
     const buffer = await bufferFromFile(file);
+    const sha256 = computeSha256Hex(buffer);
     return {
-        fileKey,
+        id: `o-${computeSha256Hex(Buffer.from(`${role}\0${relativePath}\0${sha256}`)).slice(0, 40)}`,
+        role,
+        relativePath,
         file,
         filename: file.name,
         contentType: file.type || resolveMimeType(file.name),
         sizeBytes: buffer.length,
-        sha256: computeSha256Hex(buffer),
+        sha256,
+        md5Base64: computeMd5Base64(buffer),
     };
 }
 function createGenericFileFromPath(filePath) {
@@ -100,12 +119,14 @@ async function prepareOwnedAssetUpload(task) {
         const file = createGenericFileFromPath(filePath);
         const buffer = await bufferFromFile(file);
         return {
+            objectId: `o-${computeSha256Hex(Buffer.from(`OWNED_ASSET\0owned-assets/${task.name}/${role}/${file.name}\0${computeSha256Hex(buffer)}`)).slice(0, 40)}`,
             role,
             file,
             filename: file.name,
             contentType: file.type || resolveMimeType(file.name),
             sizeBytes: buffer.length,
             sha256: computeSha256Hex(buffer),
+            md5Base64: computeMd5Base64(buffer),
         };
     }));
     return {
@@ -153,6 +174,41 @@ function pushPreparedArtifact(task, currentTotal, file, maxBytes, code, label) {
     const bytes = ensurePreparedArtifactSize(file, maxBytes, code, label);
     return accumulateUploadBytes(task.name, currentTotal, bytes);
 }
+async function uploadSignedObject(client, creatorUsername, appName, sessionId, file) {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const signed = await client.signAppUploadObjects(creatorUsername, appName, sessionId, {
+            objectIds: [file.id],
+        });
+        const descriptor = signed.uploads.find((entry) => entry.id === file.id);
+        if (!descriptor) {
+            throw new Error(`app_upload_signed_object_missing:${file.id}`);
+        }
+        const response = await fetch(descriptor.url, {
+            method: descriptor.method,
+            headers: descriptor.headers,
+            body: file.file,
+        });
+        if (response.ok) {
+            return;
+        }
+        if ((response.status === 401 || response.status === 403) && attempt === 0) {
+            continue;
+        }
+        const detail = (await response.text()).trim();
+        throw new Error(`direct_object_upload_failed:${file.id}:${response.status}${detail ? `:${detail.slice(0, 300)}` : ""}`);
+    }
+}
+async function uploadSignedObjects(client, creatorUsername, appName, sessionId, files) {
+    let cursor = 0;
+    const workers = Array.from({ length: Math.min(8, files.length) }, async () => {
+        while (cursor < files.length) {
+            const index = cursor;
+            cursor += 1;
+            await uploadSignedObject(client, creatorUsername, appName, sessionId, files[index]);
+        }
+    });
+    await Promise.all(workers);
+}
 async function prepareAppUploadFiles(task, artifacts) {
     let totalUploadBytes = 0;
     const listing = task.listing;
@@ -166,55 +222,72 @@ async function prepareAppUploadFiles(task, artifacts) {
     for (const definition of task.achievements ?? []) {
         const prepared = createFileFromPath(definition.iconPath, "image/png", config_1.MAX_VERSION_ICON_BYTES, "achievement_icon_too_large", "invalid_achievement_icon_content_type", `Achievement icon "${definition.key}"`, isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        sessionFiles.push(await buildPreparedSessionFile(`achievementIcon:${definition.key}`, prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile("LISTING", `listing/achievements/${definition.key}.png`, prepared.file));
     }
     if (task.hostingMode === "EXTERNAL") {
         // no hosted files
     }
     else if (artifacts) {
-        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.bundleFile, config_1.MAX_VERSION_BUNDLE_BYTES, "bundle_too_large", "Bundle");
-        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.sourceFile, config_1.MAX_APP_SOURCE_BYTES, "source_too_large", "Source archive");
-        sessionFiles.push(await buildPreparedSessionFile("bundle", artifacts.bundleFile));
-        sessionFiles.push(await buildPreparedSessionFile("source", artifacts.sourceFile));
+        const runtimeBytes = artifacts.runtimeFiles.reduce((total, entry) => total + entry.sizeBytes, 0);
+        if (runtimeBytes > config_1.MAX_VERSION_BUNDLE_BYTES) {
+            throw createUploadValidationError("bundle_too_large", `Runtime files for "${task.name}" exceed ${formatLimitBytes(config_1.MAX_VERSION_BUNDLE_BYTES)}. Received ${runtimeBytes} bytes.`);
+        }
+        for (const runtime of artifacts.runtimeFiles) {
+            totalUploadBytes = accumulateUploadBytes(task.name, totalUploadBytes, runtime.sizeBytes);
+            sessionFiles.push(await buildPreparedSessionFile("RUNTIME", runtime.relativePath, createGenericFileFromPath(runtime.absolutePath)));
+        }
+        if (artifacts.sourceFile) {
+            totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.sourceFile, config_1.MAX_APP_SOURCE_BYTES, "source_too_large", "Source archive");
+            sessionFiles.push(await buildPreparedSessionFile("SOURCE", "source.zip", artifacts.sourceFile));
+        }
+    }
+    const gameServer = await (0, serverBuild_1.buildGameServer)(task);
+    if (gameServer) {
+        const bundle = createFileFromPath(gameServer.bundlePath, "application/javascript", serverBuild_1.GAME_SERVER_BUNDLE_MAX_BYTES, "server_bundle_too_large", "invalid_server_bundle", "Game server bundle");
+        const manifest = createFileFromPath(gameServer.manifestPath, "application/json", 16 * 1024, "server_manifest_too_large", "invalid_server_manifest", "Game server manifest");
+        totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, bundle);
+        totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, manifest);
+        sessionFiles.push(await buildPreparedSessionFile("SERVER", "server/bundle.mjs", bundle.file));
+        sessionFiles.push(await buildPreparedSessionFile("SERVER", "server/manifest.json", manifest.file));
     }
     if (listing?.iconPath) {
         const prepared = createFileFromPath(listing.iconPath, "image/png", config_1.MAX_VERSION_ICON_BYTES, "icon_too_large", "invalid_icon_content_type", "Icon", isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        sessionFiles.push(await buildPreparedSessionFile("icon", prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile("LISTING", "listing/icon.png", prepared.file));
     }
     if (listing?.heroPortraitPath) {
         const prepared = createFileFromPath(listing.heroPortraitPath, "image/png", config_1.MAX_VERSION_HERO_BYTES, "hero_portrait_too_large", "invalid_hero_portrait_content_type", "Hero portrait", isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        sessionFiles.push(await buildPreparedSessionFile("heroPortrait", prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile("LISTING", "listing/hero-portrait.png", prepared.file));
     }
     if (listing?.heroLandscapePath) {
         const prepared = createFileFromPath(listing.heroLandscapePath, "image/png", config_1.MAX_VERSION_HERO_BYTES, "hero_landscape_too_large", "invalid_hero_landscape_content_type", "Hero landscape", isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        sessionFiles.push(await buildPreparedSessionFile("heroLandscape", prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile("LISTING", "listing/hero-landscape.png", prepared.file));
     }
     for (let index = 0; index < (listing?.screenshotPortraitPaths ?? []).length; index += 1) {
         const filePath = listing.screenshotPortraitPaths[index];
         const prepared = createFileFromPath(filePath, "image/png", config_1.MAX_VERSION_SCREENSHOT_BYTES, "screenshot_portrait_too_large", "invalid_screenshot_portrait_content_type", `Portrait screenshot ${index + 1}`, isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        sessionFiles.push(await buildPreparedSessionFile(`screenshotsPortrait:${index}`, prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile("LISTING", `listing/screenshots/portrait/${index}.png`, prepared.file));
     }
     for (let index = 0; index < (listing?.screenshotLandscapePaths ?? []).length; index += 1) {
         const filePath = listing.screenshotLandscapePaths[index];
         const prepared = createFileFromPath(filePath, "image/png", config_1.MAX_VERSION_SCREENSHOT_BYTES, "screenshot_landscape_too_large", "invalid_screenshot_landscape_content_type", `Landscape screenshot ${index + 1}`, isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        sessionFiles.push(await buildPreparedSessionFile(`screenshotsLandscape:${index}`, prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile("LISTING", `listing/screenshots/landscape/${index}.png`, prepared.file));
     }
     for (let index = 0; index < (listing?.videoPortraitPaths ?? []).length; index += 1) {
         const filePath = listing.videoPortraitPaths[index];
         const prepared = createFileFromPath(filePath, "video/mp4", config_1.MAX_VERSION_VIDEO_BYTES, "video_portrait_too_large", "invalid_video_portrait_content_type", `Portrait video ${index + 1}`, isMp4Signature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        sessionFiles.push(await buildPreparedSessionFile(`videosPortrait:${index}`, prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile("LISTING", `listing/videos/portrait/${index}.mp4`, prepared.file));
     }
     for (let index = 0; index < (listing?.videoLandscapePaths ?? []).length; index += 1) {
         const filePath = listing.videoLandscapePaths[index];
         const prepared = createFileFromPath(filePath, "video/mp4", config_1.MAX_VERSION_VIDEO_BYTES, "video_landscape_too_large", "invalid_video_landscape_content_type", `Landscape video ${index + 1}`, isMp4Signature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        sessionFiles.push(await buildPreparedSessionFile(`videosLandscape:${index}`, prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile("LISTING", `listing/videos/landscape/${index}.mp4`, prepared.file));
     }
     return { sessionFiles, ownedAssets };
 }
@@ -238,6 +311,18 @@ async function uploadAppVersion(client, task, artifacts, options) {
     const leaderboards = task.leaderboards ?? [];
     const listing = task.listing;
     const { sessionFiles: preparedSessionFiles, ownedAssets: preparedOwnedAssets } = await prepareAppUploadFiles(task, artifacts);
+    const preparedOwnedAssetFiles = preparedOwnedAssets.flatMap((ownedAsset) => ownedAsset.files.map((file) => ({
+        id: file.objectId,
+        role: "OWNED_ASSET",
+        relativePath: `owned-assets/${ownedAsset.uploadKey}/${file.role}/${file.filename}`,
+        file: file.file,
+        filename: file.filename,
+        contentType: file.contentType,
+        sizeBytes: file.sizeBytes,
+        sha256: file.sha256,
+        md5Base64: file.md5Base64,
+    })));
+    const preparedObjects = [...preparedSessionFiles, ...preparedOwnedAssetFiles];
     const initializeRequest = {
         version: task.version,
         agentTaskId: options?.agentTaskId,
@@ -254,6 +339,11 @@ async function uploadAppVersion(client, task, artifacts, options) {
         usesPacks: task.uses.packs,
         tags: task.tags,
         design: task.design,
+        players: task.players,
+        makingOf: task.makingOf,
+        controls: task.controls,
+        creation: task.creation,
+        sourceRepository: task.sourceRepository,
         tweaks: task.tweaks,
         clearTags: options?.clearTags,
         surfaceTargets: task.surfaceTargets,
@@ -297,12 +387,20 @@ async function uploadAppVersion(client, task, artifacts, options) {
         })),
         externalUrl: task.hostingMode === "EXTERNAL" ? task.externalUrl : undefined,
         listingMedia: listing?.mediaMetadata,
-        files: preparedSessionFiles.map((file) => ({
-            fileKey: file.fileKey,
-            filename: file.filename,
+        server: task.server
+            ? {
+                entry: task.server.entry,
+                rooms: task.server.rooms,
+            }
+            : undefined,
+        objects: preparedObjects.map((file) => ({
+            id: file.id,
+            role: file.role,
+            relativePath: file.relativePath,
             contentType: file.contentType,
             sizeBytes: file.sizeBytes,
             sha256: file.sha256,
+            md5Base64: file.md5Base64,
         })),
         ownedAssets: preparedOwnedAssets.map((ownedAsset) => ({
             uploadKey: ownedAsset.uploadKey,
@@ -320,11 +418,8 @@ async function uploadAppVersion(client, task, artifacts, options) {
             shopListed: ownedAsset.shopListed,
             shopPriceCredits: ownedAsset.shopPriceCredits,
             files: ownedAsset.files.map((file) => ({
+                objectId: file.objectId,
                 role: file.role,
-                filename: file.filename,
-                contentType: file.contentType,
-                sizeBytes: file.sizeBytes,
-                sha256: file.sha256,
             })),
         })),
     };
@@ -333,29 +428,8 @@ async function uploadAppVersion(client, task, artifacts, options) {
         const initialized = await client.initializeAppUpload(creatorUsername, task.name, initializeRequest);
         sessionId = initialized.session.id;
         if (initialized.status !== "finalized") {
-            const uploadedFileKeys = new Set(initialized.session.uploadedFileKeys);
-            const uploadedOwnedAssetKeys = new Set(initialized.session.uploadedOwnedAssetKeys);
-            for (const file of preparedSessionFiles) {
-                if (uploadedFileKeys.has(file.fileKey)) {
-                    continue;
-                }
-                await client.uploadAppSessionFile(creatorUsername, task.name, sessionId, file.fileKey, {
-                    file: file.file,
-                    filename: file.filename,
-                });
-            }
-            for (const ownedAsset of preparedOwnedAssets) {
-                if (uploadedOwnedAssetKeys.has(ownedAsset.uploadKey)) {
-                    continue;
-                }
-                await client.uploadAppSessionOwnedAsset(creatorUsername, task.name, sessionId, ownedAsset.uploadKey, {
-                    files: ownedAsset.files.map((file) => ({
-                        fieldName: file.role,
-                        file: file.file,
-                        filename: file.filename,
-                    })),
-                });
-            }
+            const missingIds = new Set(initialized.missingObjectIds);
+            await uploadSignedObjects(client, creatorUsername, task.name, sessionId, preparedObjects.filter((file) => missingIds.has(file.id)));
             if (task.hostingMode !== "EXTERNAL" && !task.externalUrl && options?.playtestSmokeCheckRequired) {
                 await (0, loadCheck_1.runUploadedHostedPlaytestSmokeCheck)({
                     client,
@@ -401,9 +475,16 @@ async function uploadAppVersion(client, task, artifacts, options) {
                 }
             }
         }
+        const gitTransition = !options?.prepareGitTransition
+            ? undefined
+            : await options.prepareGitTransition({
+                appId: initialized.session.appId,
+                sessionId,
+                version: task.version,
+            });
         const finalized = initialized.status === "finalized"
             ? initialized.finalized
-            : await client.finalizeAppUpload(creatorUsername, task.name, sessionId);
+            : await client.finalizeAppUpload(creatorUsername, task.name, sessionId, gitTransition ? { gitTransition } : undefined);
         if (!finalized) {
             throw new Error(`Upload failed for ${task.name}: missing finalized app upload payload`);
         }

package/dist/catalogue.d.ts

@@ -1,4 +1,4 @@
-import { type AppAchievementCatalogueDefinition, type AppAuthMode, type AppControllerMode, type AppHostingMode, type AppLeaderboardCatalogueDefinition, type AppListingMediaMetadata, type AppMetadataAssetSpecSupport, type AppPlaytestTapes, type AppSurface, type AppType, type AppTweaksDeclaration, type AppVersionDesign, type AppVersionVisibility, type AssetSpecContract, type AssetSpecStatus, type AssetSpecValidationKind, type CatalogueTagGroupDefinition, type ContentLicense, type PlayerMetaDefinitionStatus } from "@playdrop/types";
+import { type AppAchievementCatalogueDefinition, type AppAuthMode, type AppControllerMode, type AppCreationMetadata, type AppHostingMode, type AppLeaderboardCatalogueDefinition, type AppListingMediaMetadata, type AppMetadataAssetSpecSupport, type AppPlaytestTapes, type AppPlayersConfig, type AppSurface, type AppType, type AppTweaksDeclaration, type AppVersionDesign, type AppVersionVisibility, type AssetSpecContract, type AssetSpecStatus, type AssetSpecValidationKind, type CatalogueTagGroupDefinition, type ContentLicense, type PlayerMetaDefinitionStatus } from "@playdrop/types";
 import { type AssetSpecSupportDeclaration } from "./assetSpecs";
 export type CatalogueJson = {
     apps?: Array<Record<string, unknown>>;
@@ -58,6 +58,11 @@ export type AppCatalogueEntry = {
     primarySurface?: string | null;
     playtestTapes?: unknown;
     design?: unknown;
+    players?: unknown;
+    makingOf?: string;
+    controls?: string;
+    creation?: unknown;
+    sourceRepository?: string;
     tweaks?: unknown;
     version?: string;
     releaseNotes?: string;
@@ -68,6 +73,10 @@ export type AppCatalogueEntry = {
     controllerMode?: string;
     previewable?: boolean;
     editorSupported?: boolean;
+    server?: {
+        entry?: string;
+        rooms?: unknown;
+    };
     externalUrl?: string;
     listing?: AppListingConfig;
     username?: string;
@@ -179,6 +188,11 @@ export type AppDependencyAssetRef = {
     ref: string;
     runtimeKey?: string;
 };
+export type AppServerTask = {
+    entry: string;
+    entryPath: string;
+    rooms: string[];
+};
 export type AppTask = {
     kind: "app";
     name: string;
@@ -202,12 +216,18 @@ export type AppTask = {
     primarySurface?: AppSurface;
     playtestTapes?: AppPlaytestTapes;
     design?: AppVersionDesign;
+    players?: AppPlayersConfig;
+    makingOf?: string;
+    controls?: string;
+    creation?: AppCreationMetadata;
+    sourceRepository?: string;
     tweaks?: AppTweaksDeclaration;
     missingMetadata: string[];
     version?: string;
     releaseNotes?: string;
     versionVisibility?: AppVersionVisibility;
     sourceArchiveExcludeRelativeFiles?: string[];
+    sourceArchiveGameSourceGit?: boolean;
     bundleArchiveExcludeRelativeFiles?: string[];
     license: ContentLicense;
     tags: string[];
@@ -216,6 +236,7 @@ export type AppTask = {
     controllerMode?: AppControllerMode;
     previewable?: boolean;
     editorSupported?: boolean;
+    server?: AppServerTask | null;
     externalUrl?: string;
     listing?: ResolvedListingAssets;
     username?: string;
@@ -335,6 +356,7 @@ export type AssetPackTask = {
     visibility?: string;
     license: ContentLicense;
     releaseNotes?: string;
+    sourcePath?: string;
     listing?: ResolvedListingAssets;
     relations?: Array<{
         type: string;