@playdrop/playdrop-cli 0.17.5 → 0.17.14

package/dist/commands/source.js

@@ -3,25 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseExactSourceRef = parseExactSourceRef;
 exports.prepareDestination = prepareDestination;
 exports.extractArchive = extractArchive;
+exports.extractGitSource = extractGitSource;
 exports.showExactContentDetail = showExactContentDetail;
 exports.downloadContentSource = downloadContentSource;
 const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
+const game_source_git_1 = require("@playdrop/game-source-git");
+const types_1 = require("@playdrop/types");
 const fflate_1 = require("fflate");
 const commandContext_1 = require("../commandContext");
 const errors_1 = require("../errors");
 const output_1 = require("../output");
+const game_source_git_2 = require("./worker/game-source-git");
 function parseExactSourceRef(raw, expectedKind) {
-    const pattern = expectedKind === "asset"
-        ? /^asset:([a-z0-9]+(?:-[a-z0-9]+)*)\/([a-z0-9]+(?:-[a-z0-9]+)*)@(r[1-9][0-9]*)$/
-        : /^pack:([a-z0-9]+(?:-[a-z0-9]+)*)\/([a-z0-9]+(?:-[a-z0-9]+)*)@(\d+\.\d+\.\d+)$/;
-    const match = pattern.exec(raw.trim());
-    if (!match) {
+    const ref = (0, types_1.parseContentVersionRef)(raw);
+    if (!ref || ref.kind !== expectedKind) {
         throw new Error(expectedKind === "asset"
             ? "invalid_exact_asset_ref: expected asset:creator/name@rN"
-            : "invalid_exact_pack_ref: expected pack:creator/name@X.Y.Z");
+            : `invalid_exact_${expectedKind}_ref: expected ${expectedKind}:creator/name@X.Y.Z`);
     }
-    return { kind: expectedKind, creator: match[1], name: match[2], version: match[3] };
+    return {
+        kind: expectedKind,
+        creator: ref.creatorUsername,
+        name: ref.name,
+        version: ref.kind === "asset" ? `r${ref.revision}` : ref.version,
+    };
 }
 function prepareDestination(path) {
     const destination = (0, node_path_1.resolve)(path);
@@ -58,6 +66,36 @@ function extractArchive(bytes, destination) {
     }
     return fileCount;
 }
+async function extractGitSource(bytes, destination, options) {
+    if (!/^[0-9a-f]{40}$/.test(options.commitSha))
+        throw new Error("app_source_commit_missing");
+    const temporary = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "playdrop-app-source-"));
+    const git = (0, game_source_git_1.createGitRunner)();
+    try {
+        const bundle = (0, node_path_1.join)(temporary, "source.bundle");
+        await (0, promises_1.writeFile)(bundle, bytes);
+        await git.run(["init", "--initial-branch=main", destination]);
+        await git.run(["fetch", "--update-head-ok", bundle, "+refs/*:refs/*"], destination);
+        const tag = `refs/tags/v${options.version}`;
+        const taggedCommit = (await git.run(["rev-parse", "--verify", `${tag}^{commit}`], destination).catch(() => {
+            throw new Error(`app_source_version_missing:${options.version}: Git source is missing ${tag}`);
+        })).toString("utf8").trim();
+        if (taggedCommit !== options.commitSha)
+            throw new Error(`app_source_version_commit_mismatch:${options.version}`);
+        await git.run(["checkout", "--detach", options.commitSha], destination);
+        const lock = await (0, game_source_git_2.materializeCurrentLock)({
+            projectDir: destination,
+            workerHomeDir: options.workerHomeDir,
+            readFiles: options.readFiles,
+            cloneFile: promises_1.copyFile,
+        });
+        const trackedFiles = (await git.run(["ls-files", "-z"], destination)).toString("utf8").split("\0").filter(Boolean);
+        return new Set([...trackedFiles, ...Object.keys(lock.files)]).size;
+    }
+    finally {
+        await (0, promises_1.rm)(temporary, { recursive: true, force: true });
+    }
+}
 async function showExactContentDetail(kind, rawRef, options = {}) {
     const command = `${kind} detail`;
     await (0, commandContext_1.withPublicEnvironment)(command, async ({ client, envConfig }) => {
@@ -114,20 +152,48 @@ async function showExactContentDetail(kind, rawRef, options = {}) {
 }
 async function downloadContentSource(kind, rawRef, directory, options = {}) {
     const command = `${kind} source`;
-    await (0, commandContext_1.withPublicEnvironment)(command, async ({ client }) => {
+    await (0, commandContext_1.withPublicEnvironment)(command, async ({ client, workspaceAuth }) => {
         try {
             const ref = parseExactSourceRef(rawRef, kind);
-            const result = kind === "asset"
-                ? await client.downloadAssetSource(ref.creator, ref.name, ref.version)
-                : await client.downloadAssetPackSource(ref.creator, ref.name, ref.version);
-            const destination = prepareDestination(directory ?? ref.name);
-            const fileCount = extractArchive(new Uint8Array(await result.blob.arrayBuffer()), destination);
+            const result = kind === "app"
+                ? await client.downloadAppSource(ref.creator, ref.name, ref.version)
+                : kind === "asset"
+                    ? await client.downloadAssetSource(ref.creator, ref.name, ref.version)
+                    : await client.downloadAssetPackSource(ref.creator, ref.name, ref.version);
+            const bytes = new Uint8Array(await result.blob.arrayBuffer());
+            if (bytes.length !== result.metadata.sizeBytes) {
+                throw new Error(`source_download_incomplete:${rawRef}: expected ${result.metadata.sizeBytes} bytes, received ${bytes.length}`);
+            }
+            const metadata = result.metadata;
+            const isGit = "format" in metadata && metadata.format === "git-bundle";
+            const taskId = workspaceAuth?.config.taskId;
+            const workerHomeDir = process.env.PLAYDROP_WORKER_HOME?.trim();
+            if (isGit) {
+                if (process.env.PLAYDROP_WORKER_CONTEXT !== "1" || !taskId) {
+                    throw new Error("app_source_task_required: Cloud Git material downloads require an active Cloud task");
+                }
+                if (!workerHomeDir || !(0, node_path_1.isAbsolute)(workerHomeDir)) {
+                    throw new Error("app_source_worker_home_missing: the Cloud worker must provide its absolute PLAYDROP_WORKER_HOME cache directory");
+                }
+            }
+            const destination = directory === undefined && kind === "app"
+                ? await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "playdrop-app-source-"))
+                : prepareDestination(directory ?? ref.name);
+            const fileCount = isGit
+                ? await extractGitSource(bytes, destination, {
+                    version: ref.version,
+                    commitSha: "commitSha" in metadata && typeof metadata.commitSha === "string" ? metadata.commitSha : "",
+                    workerHomeDir: workerHomeDir,
+                    readFiles: (files) => client.workerReadGameSourceFiles(taskId, { files }),
+                })
+                : extractArchive(bytes, destination);
             const output = {
                 ref: rawRef,
                 destination,
                 filename: result.metadata.filename,
                 sizeBytes: result.metadata.sizeBytes,
                 files: fileCount,
+                format: isGit ? "git-bundle" : "zip",
             };
             if (options.json)
                 (0, output_1.printJson)(output);
@@ -135,7 +201,9 @@ async function downloadContentSource(kind, rawRef, directory, options = {}) {
                 console.log(`Downloaded ${rawRef} source to ${destination} (${fileCount} files).`);
         }
         catch (error) {
-            if (!(0, errors_1.handleCommandFailure)(error, command, "Source download"))
+            if (!(0, errors_1.handleCommandFailure)(error, command, "Source download", {
+                apiMessage: (apiError) => ({ problem: `Source download rejected for ${rawRef}: ${apiError.code ?? apiError.message} (HTTP ${apiError.status}).` }),
+            }))
                 throw error;
         }
     }, { env: options.env });

package/dist/commands/taskCaptureSession.d.ts

@@ -1,4 +1,4 @@
 import type { AppResponse } from "@playdrop/types";
 import type { TaskCaptureSession } from "../appUrls";
 import type { ResolvedWorkspaceAuthConfig } from "../workspaceAuth";
-export declare function resolveTaskCaptureSession(workspaceAuth: ResolvedWorkspaceAuthConfig | null, app: AppResponse): TaskCaptureSession | null;
+export declare function resolveTaskCaptureSession(workspaceAuth: ResolvedWorkspaceAuthConfig | null, app: AppResponse | null): TaskCaptureSession | null;

package/dist/commands/taskCaptureSession.js

@@ -10,7 +10,7 @@ function resolveTaskCaptureSession(workspaceAuth, app) {
     if (!Number.isInteger(taskId) || Number(taskId) <= 0 || !taskToken) {
         throw new Error("worker_capture_session_incomplete");
     }
-    if (!Number.isInteger(app.id) || Number(app.id) <= 0) {
+    if (!app || !Number.isInteger(app.id) || Number(app.id) <= 0) {
         throw new Error("registered_app_id_missing");
     }
     return {

package/dist/commands/upload-content.js

@@ -13,6 +13,7 @@ const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const assetSpecs_1 = require("../assetSpecs");
+const proceduralValidation_1 = require("../proceduralValidation");
 const EXTENSION_TO_FORMAT = {
     ".png": "PNG",
     ".jpg": "JPEG",
@@ -292,7 +293,8 @@ function validateAssetSubcategoryCompatibility(task, format) {
     }
     return subcategory;
 }
-async function prepareAssetTaskUploadData(task) {
+async function prepareAssetTaskUploadData(task, client) {
+    await (0, proceduralValidation_1.assertProceduralAssetIsValid)(task, { client, primaryContentType: resolveMimeType(task.filePaths.primary ?? "") });
     if ("assetSpec" in task && typeof task.assetSpec === "string" && task.assetSpec.trim().length > 0) {
         const uploadFiles = Object.entries(task.filePaths)
             .sort(([leftRole], [rightRole]) => leftRole.localeCompare(rightRole))
@@ -331,7 +333,7 @@ async function prepareAssetTaskUploadData(task) {
     };
 }
 async function uploadAssetTask(client, task, sourceAppVersionId, creatorUsername, options) {
-    const prepared = await prepareAssetTaskUploadData(task);
+    const prepared = await prepareAssetTaskUploadData(task, client);
     const visibility = task.visibility;
     const files = prepared.uploadFiles.map((entry) => ({
         file: entry.file,
@@ -485,20 +487,19 @@ function describeError(error) {
     }
     return String(error);
 }
-async function prepareLocalPackAssets(task, mutationCreatorUsername, localAssetTasks, uploadKeyByAssetKey) {
-    const preparedLocalAssets = new Map();
-    for (const localAssetTask of localAssetTasks) {
+async function prepareLocalPackAssets(client, task, mutationCreatorUsername, localAssetTasks, uploadKeyByAssetKey) {
+    const preparedLocalAssets = await Promise.all(localAssetTasks.map(async (localAssetTask) => {
         const assetKey = buildAssetKey(mutationCreatorUsername, localAssetTask.name);
         const uploadKey = uploadKeyByAssetKey.get(assetKey);
         if (!uploadKey) {
             throw new Error(`Asset pack "${task.name}@${task.version}" is missing upload key for local asset "${localAssetTask.name}".`);
         }
-        preparedLocalAssets.set(uploadKey, {
-            task: localAssetTask,
-            prepared: await prepareAssetTaskUploadData(localAssetTask),
-        });
-    }
-    return preparedLocalAssets;
+        return [uploadKey, {
+                task: localAssetTask,
+                prepared: await prepareAssetTaskUploadData(localAssetTask, client),
+            }];
+    }));
+    return new Map(preparedLocalAssets);
 }
 function buildLocalAssetManifestEntries(preparedLocalAssets) {
     const localAssets = [];
@@ -656,7 +657,7 @@ function buildUploadedPackInfo(creatorUsername, task, versionNodeId, versionAsse
 }
 async function uploadAssetPackTask(client, task, creatorUsername, uploadedAssets, localAssetTasks, uploadKeyByAssetKey, targetCreatorUsername, options) {
     const mutationCreatorUsername = resolveMutationCreatorUsername(task, creatorUsername, targetCreatorUsername);
-    const preparedLocalAssets = await prepareLocalPackAssets(task, mutationCreatorUsername, localAssetTasks, uploadKeyByAssetKey);
+    const preparedLocalAssets = await prepareLocalPackAssets(client, task, mutationCreatorUsername, localAssetTasks, uploadKeyByAssetKey);
     const ownedAssets = buildLocalAssetManifestEntries(preparedLocalAssets);
     const { existingAssets, members } = await buildPackMembersAndExistingAssets(client, task, mutationCreatorUsername, uploadedAssets, uploadKeyByAssetKey);
     const listingUploads = buildPackListingUploads(task);

package/dist/commands/upload.d.ts

@@ -1,5 +1,6 @@
 import type { ApiClient } from "@playdrop/api-client";
 import type { AgentExecutionTarget, AppSurface, FinalizeAppUploadRequest, UserResponse } from "@playdrop/types";
+import type { GameServerDevServices } from "./devGameServer";
 import { type AppTask } from "../catalogue";
 export type UploadCommandOptions = {
     env?: string;
@@ -28,6 +29,7 @@ export type WorkerAppPublishInput = {
     token: string;
     user: UserResponse;
     devRouterPort?: number;
+    gameServerDev?: GameServerDevServices;
     deterministicE2EFixture?: boolean;
     prepareGitTransition?: (input: {
         appId: number;
@@ -35,15 +37,6 @@ export type WorkerAppPublishInput = {
         version: string;
     }) => Promise<NonNullable<FinalizeAppUploadRequest["gitTransition"]>>;
 };
-export declare function resolveWorkerHostedValidationPolicy(input: {
-    kind: WorkerAppPublishInput["kind"];
-    deterministicE2EFixture?: boolean;
-}): {
-    runLocalLoadCheck: boolean;
-    runStagedUploadLoadCheck: boolean;
-    playtestSmokeCheckRequired: boolean;
-    skipReview: boolean;
-};
 export type WorkerAppPublishResult = {
     appId: number;
     appVersionId: number;

package/dist/commands/upload.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveUploadOwner = resolveUploadOwner;
 exports.resolveDefaultUploadCreator = resolveDefaultUploadCreator;
 exports.upload = upload;
-exports.resolveWorkerHostedValidationPolicy = resolveWorkerHostedValidationPolicy;
 exports.assertAgentPrimarySurfaceContract = assertAgentPrimarySurfaceContract;
 exports.assertAgentNewGamePlaytestContract = assertAgentNewGamePlaytestContract;
 exports.assertAgentNewGameListingIdentity = assertAgentNewGameListingIdentity;
@@ -1240,15 +1239,6 @@ async function upload(pathOrName, options) {
     (0, uploadLog_1.printTaskSummary)(results, warnings, { action: "upload", environment: env });
     (0, uploadLog_1.printPublishedAppNextSteps)(results);
 }
-function resolveWorkerHostedValidationPolicy(input) {
-    const browserChecksRequired = input.deterministicE2EFixture !== true;
-    return {
-        runLocalLoadCheck: browserChecksRequired,
-        runStagedUploadLoadCheck: browserChecksRequired,
-        playtestSmokeCheckRequired: browserChecksRequired && input.kind === "NEW_GAME",
-        skipReview: !browserChecksRequired,
-    };
-}
 function assertAgentPrimarySurfaceContract(task, kind) {
     if (!task.primarySurface) {
         throw new Error(`agent_task_primary_surface_required: ${kind} catalogue.json must declare primarySurface.`);
@@ -1365,9 +1355,9 @@ async function prepareWorkerAppProject(input) {
             throw new Error(`agent_task_remix_ref_mismatch:${catalogueRemixRef}:${expectedRemixRef}`);
         }
     }
-    await (0, apps_1.validateAppTask)(task);
+    await (0, apps_1.validateAppTask)(task, { apiBase: input.apiBase });
     const isExternal = task.hostingMode === "EXTERNAL" || Boolean(task.externalUrl);
-    const artifacts = isExternal ? null : await (0, apps_1.buildApp)(task, { includeSourceArchive: false });
+    const artifacts = isExternal ? null : await (0, apps_1.buildApp)(task, { includeSourceArchive: false, apiBase: input.apiBase });
     await assertWorkerAppLocalUploadPreflight({
         task,
         kind: input.kind,
@@ -1384,7 +1374,7 @@ async function prepareWorkerAppProject(input) {
 // succeed before the agent can complete the task.
 async function preflightWorkerAppProject(input) {
     const prepared = await prepareWorkerAppProject(input);
-    await (0, apps_1.prepareAppUploadFiles)(prepared.task, prepared.artifacts);
+    await (0, apps_1.prepareAppUploadFiles)(prepared.task, prepared.artifacts, { apiBase: input.apiBase, client: input.client });
     return {
         appName: prepared.task.name,
         creatorUsername: prepared.creatorUsername,
@@ -1409,7 +1399,6 @@ async function publishWorkerAppProject(input) {
             displayName: fixtureDisplayName,
         });
     }
-    const validationPolicy = resolveWorkerHostedValidationPolicy(input);
     const { app } = await (0, registration_1.ensureRegisteredHostedAppShell)({
         client: input.client,
         creatorUsername,
@@ -1434,13 +1423,11 @@ async function publishWorkerAppProject(input) {
         webBase: normalizePortalBase(input.webBase ?? undefined),
         token: input.token,
         user: input.user,
-        runLocalLoadCheck: validationPolicy.runLocalLoadCheck,
         devRouterPort: input.devRouterPort,
-        runStagedUploadLoadCheck: validationPolicy.runStagedUploadLoadCheck,
+        gameServerDev: input.gameServerDev,
         ensureRegisteredAppShell: true,
         agentTaskId: input.taskId,
-        playtestSmokeCheckRequired: validationPolicy.playtestSmokeCheckRequired,
-        skipReview: validationPolicy.skipReview,
+        skipReview: input.deterministicE2EFixture === true,
         captureSession,
         prepareGitTransition: input.prepareGitTransition,
         ...(artifacts ? { artifacts } : {}),
@@ -1528,12 +1515,9 @@ async function publishStaticHtmlProject(input) {
             webBase: normalizePortalBase(input.webBase ?? undefined),
             token: input.token,
             user: input.user,
-            runLocalLoadCheck: true,
             devRouterPort: input.devRouterPort,
-            runStagedUploadLoadCheck: true,
             ensureRegisteredAppShell: true,
             agentTaskId: input.taskId,
-            playtestSmokeCheckRequired: false,
             skipReview: input.skipReview,
             captureSession,
             prepareGitTransition: input.prepareGitTransition,

package/dist/commands/validate.js

@@ -215,7 +215,7 @@ async function validate(pathOrName, options = {}) {
                         kind: workerContext.kind,
                     });
                 }
-                await (0, apps_1.validateAppTask)(task);
+                await (0, apps_1.validateAppTask)(task, { environment: resolvedValidationContext?.envConfig });
                 (0, apps_1.collectAppValidationWarnings)(task, "source").forEach((warning) => warnings.add(warning));
             }
             else if (task.kind === "asset-spec") {

package/dist/commands/worker/game-server-infra.d.ts

@@ -78,3 +78,9 @@ export declare function provisionWorkerGameServerDevLease(input: {
     mongoAdminUrl: string;
     requireRedisAcl?: boolean;
 }): Promise<WorkerGameServerDevLease>;
+export declare function provisionPublishingGameServerDevLease(input: {
+    sessionId: string;
+    environment: string;
+    redisAdminUrl: string;
+    mongoAdminUrl: string;
+}): Promise<WorkerGameServerDevLease>;

package/dist/commands/worker/game-server-infra.js

@@ -13,6 +13,7 @@ exports.setupManagedWorkerGameServerInfrastructure = setupManagedWorkerGameServe
 exports.probeManagedWorkerGameServerInfrastructure = probeManagedWorkerGameServerInfrastructure;
 exports.cleanupStaleWorkerGameServerDevResources = cleanupStaleWorkerGameServerDevResources;
 exports.provisionWorkerGameServerDevLease = provisionWorkerGameServerDevLease;
+exports.provisionPublishingGameServerDevLease = provisionPublishingGameServerDevLease;
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
@@ -507,6 +508,15 @@ async function cleanupStaleWorkerGameServerDevResources(input) {
 }
 async function provisionWorkerGameServerDevLease(input) {
     const scope = normalizeTaskScope(input.taskId, input.attempt);
+    return provisionScopedGameServerDevLease({ ...input, scope });
+}
+async function provisionPublishingGameServerDevLease(input) {
+    if (!/^[a-zA-Z0-9-]{1,100}$/u.test(input.sessionId))
+        throw new Error("publishing_session_id_invalid");
+    return provisionScopedGameServerDevLease({ ...input, scope: `upload-${input.sessionId}`, requireRedisAcl: true });
+}
+async function provisionScopedGameServerDevLease(input) {
+    const scope = input.scope;
     const environment = input.environment.trim().toLowerCase().replace(/[^a-z0-9_-]/gu, "-");
     if (!environment)
         throw new Error("worker_game_server_dev_environment_invalid");

package/dist/commands/worker/game-source-git.d.ts

@@ -1,5 +1,6 @@
 import type { ApiClient } from "@playdrop/api-client";
-import type { WorkerGameSourceAssignmentV1, WorkerGameTaskAssignment } from "@playdrop/types";
+import { type GameSourceLockEntry, type GameSourceLockV1, type MaterializeLockOptions } from "@playdrop/game-source-git";
+import type { WorkerGameSourceAssignmentV1, WorkerGameTaskAssignment, WorkerReadGameSourceFilesResponse } from "@playdrop/types";
 export declare function emitGameSourceWorkerEvent(event: string, fields: Record<string, string | number | boolean | null>, write?: (line: string) => void): void;
 export type GameSourceWorkspace = {
     assignment: WorkerGameSourceAssignmentV1;
@@ -50,6 +51,12 @@ export type FinalizedGameSource = ReconciledGameSource & {
         commitSha: string;
     }>;
 };
+export declare function materializeCurrentLock(input: {
+    projectDir: string;
+    workerHomeDir: string;
+    readFiles: (files: GameSourceLockEntry[]) => Promise<WorkerReadGameSourceFilesResponse>;
+    cloneFile?: MaterializeLockOptions["cloneFile"];
+}): Promise<GameSourceLockV1>;
 export declare function setupGameSourceWorkspace(input: {
     assignment: WorkerGameTaskAssignment;
     workspaceDir: string;
@@ -58,6 +65,7 @@ export declare function setupGameSourceWorkspace(input: {
     workerKey: string;
     leaseToken: string;
 }): Promise<GameSourceWorkspace>;
+export declare function fingerprintGameSourcePublication(projectDir: string, includeServerOutput?: boolean): Promise<string>;
 export declare function checkpointFailedGameSourceWorkspace(input: {
     workspace: GameSourceWorkspace;
     taskId: number;

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

@@ -4,7 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitGameSourceWorkerEvent = emitGameSourceWorkerEvent;
+exports.materializeCurrentLock = materializeCurrentLock;
 exports.setupGameSourceWorkspace = setupGameSourceWorkspace;
+exports.fingerprintGameSourcePublication = fingerprintGameSourcePublication;
 exports.checkpointFailedGameSourceWorkspace = checkpointFailedGameSourceWorkspace;
 exports.reconcileGameSourceWorkspace = reconcileGameSourceWorkspace;
 exports.finalizeGameSourceRepository = finalizeGameSourceRepository;
@@ -222,36 +224,51 @@ async function reattachRetainedWorktree(input) {
     }
 }
 async function materializeCurrentLock(input) {
-    const lock = (0, game_source_git_1.parseGameSourceLock)(await (0, promises_1.readFile)(node_path_1.default.join(input.projectDir, ".playdrop", "files.lock")));
+    const lockPath = node_path_1.default.join(input.projectDir, game_source_git_1.GAME_SOURCE_LOCK_PATH);
+    const lock = (0, game_source_git_1.parseGameSourceLock)(await (0, promises_1.readFile)(lockPath).catch((error) => {
+        if (error.code === "ENOENT")
+            throw new Error(`game_source_material_lock_missing:${lockPath}`);
+        throw error;
+    }));
     const requestedByKey = new Map();
     for (const entry of Object.values(lock.files)) {
         const existing = requestedByKey.get(entry.key);
         if (existing && (existing.sha256 !== entry.sha256 || existing.bytes !== entry.bytes)) {
             throw new Error("game_source_material_lock_conflict");
         }
-        requestedByKey.set(entry.key, { sha256: entry.sha256, bytes: entry.bytes, key: entry.key });
+        requestedByKey.set(entry.key, entry);
     }
     const requested = [...requestedByKey.values()];
-    const response = requested.length > 0
-        ? await input.client.workerReadGameSourceFiles(input.taskId, {
-            workerKey: input.workerKey,
-            leaseToken: input.leaseToken,
-            files: requested,
-        })
-        : { files: [] };
-    const urlByKey = new Map(response.files.map((entry) => [entry.key, entry.downloadUrl]));
+    const urlByKey = new Map();
+    for (let offset = 0; offset < requested.length; offset += 100) {
+        const batch = requested.slice(offset, offset + 100);
+        const response = await input.readFiles(batch);
+        for (const expected of batch) {
+            const file = response.files.find((entry) => entry.key === expected.key);
+            if (!file || file.sha256 !== expected.sha256 || file.bytes !== expected.bytes || !file.downloadUrl) {
+                throw new Error(`game_source_material_url_missing:${expected.key}`);
+            }
+            urlByKey.set(expected.key, file.downloadUrl);
+        }
+    }
     await (0, game_source_git_1.materializeGameSourceLock)({
         rootDir: input.projectDir,
         blobCacheDir: blobCacheRoot(input.workerHomeDir),
         lock,
+        cloneFile: input.cloneFile,
         download: async (key) => {
-            const entry = Object.values(lock.files).find((candidate) => candidate.key === key);
             const url = urlByKey.get(key);
-            if (!entry || !url)
-                throw new Error("game_source_material_url_missing");
-            return await downloadBuffer(url, entry.bytes, entry.sha256);
+            if (!url)
+                throw new Error(`game_source_material_url_missing:${key}`);
+            try {
+                return await downloadBuffer(url);
+            }
+            catch (error) {
+                throw new Error(`game_source_material_download_failed:${key}: ${error instanceof Error ? error.message : String(error)}`);
+            }
         },
     });
+    return lock;
 }
 async function writeManagedGameSourceIgnore(projectDir) {
     const ignorePath = node_path_1.default.join(projectDir, ".gitignore");
@@ -329,7 +346,15 @@ async function setupGameSourceWorkspace(input) {
         });
     }
     if (taskBaseSha && !resumed) {
-        await materializeCurrentLock({ ...input, projectDir, taskId: input.assignment.task.id });
+        await materializeCurrentLock({
+            projectDir,
+            workerHomeDir: input.workerHomeDir,
+            readFiles: (files) => input.client.workerReadGameSourceFiles(input.assignment.task.id, {
+                workerKey: input.workerKey,
+                leaseToken: input.leaseToken,
+                files,
+            }),
+        });
     }
     if (source.listingSync && !resumed) {
         const listingFiles = new Map();
@@ -411,7 +436,7 @@ async function setupGameSourceWorkspace(input) {
         pendingMaterials,
     };
 }
-async function walkFiles(root, current = root) {
+async function walkFiles(root, current = root, includeBuildOutput = false) {
     const files = [];
     for (const entry of await (0, promises_1.readdir)(current, { withFileTypes: true })) {
         if (entry.name === ".git")
@@ -419,11 +444,15 @@ async function walkFiles(root, current = root) {
         const absolute = node_path_1.default.join(current, entry.name);
         const relative = normalizeRelativePath(root, absolute);
         if (entry.isDirectory()) {
-            if (["node_modules", "dist", "build", "coverage", ".next", ".playdrop-task-events"].includes(entry.name))
+            if (["node_modules", "coverage", ".next", ".playdrop-task-events"].includes(entry.name))
+                continue;
+            if (!includeBuildOutput && ["dist", "build"].includes(entry.name))
+                continue;
+            if (relative === ".playdrop" && !includeBuildOutput)
                 continue;
-            if (relative === ".playdrop" || relative.startsWith(".playdrop/"))
+            if (relative.startsWith(".playdrop/") && relative !== ".playdrop/server")
                 continue;
-            files.push(...await walkFiles(root, absolute));
+            files.push(...await walkFiles(root, absolute, includeBuildOutput));
         }
         else if (entry.isFile()) {
             files.push(absolute);
@@ -431,6 +460,23 @@ async function walkFiles(root, current = root) {
     }
     return files;
 }
+// Source reconciliation deliberately excludes generated builds. Publication
+// freshness must cover those bytes too, while ignoring task feedback/logs.
+async function fingerprintGameSourcePublication(projectDir, includeServerOutput = true) {
+    const files = [];
+    for (const absolute of await walkFiles(projectDir, projectDir, true)) {
+        const relative = normalizeRelativePath(projectDir, absolute);
+        const content = await (0, promises_1.readFile)(absolute);
+        const classification = (0, game_source_git_1.classifyGameSourceFile)(relative, content);
+        const buildOutput = relative.split("/").some((part) => ["dist", "build", "output"].includes(part));
+        const serverOutput = includeServerOutput && [".playdrop/server/bundle.mjs", ".playdrop/server/manifest.json"].includes(relative);
+        if (classification === "git" || classification === "material" || buildOutput || serverOutput || relative === "source.zip") {
+            files.push([relative, (0, game_source_git_1.sha256)(content)]);
+        }
+    }
+    files.sort(([left], [right]) => left.localeCompare(right));
+    return (0, game_source_git_1.sha256)(Buffer.from(JSON.stringify(files)));
+}
 async function gitCommit(repoPath, message) {
     await git.run([
         "-c", "user.name=Playdrop Game Source",

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

@@ -59,7 +59,9 @@ export declare function buildSandboxedCodexArgs(input: {
     outputPath: string;
     prompt: string;
     outputSchemaPath?: string;
+    persistSession?: boolean;
 }): string[];
+export declare function retainScreeningTranscript(codexHomeDir: string, taskId: number): 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;