veryfront 0.1.1237 → 0.1.1239

package/esm/cli/commands/push/command.js

@@ -16,7 +16,7 @@ import { createApiClient, resolveConfigWithAuthDetails, } from "../../shared/con
 import { canPersistAlternativeSlug, getErrorStatus, projectApiReference, ProjectReferenceNotFoundError, resolveOrCreateProject, shouldPersistProjectLink, slugConflictAction, } from "../../shared/project-resolution.js";
 import { ProjectSlugConflictError, reserveProjectSlug } from "../../shared/reserve-slug.js";
 import { isVerbose, logInfo, logSuccess } from "../../utils/index.js";
-import { INVALID_ARGUMENT, PREVIEW_HOSTNAME_TOO_LONG } from "../../../src/errors/index.js";
+import { INVALID_ARGUMENT, PREVIEW_HOSTNAME_TOO_LONG, PUSH_CONFLICT, VeryfrontError, } from "../../../src/errors/index.js";
 import { brand, createNoopSpinner, createSpinner, formatDuration } from "../../ui/index.js";
 import { withSpan } from "../../../src/observability/tracing/otlp-setup.js";
 import { createIgnoreChecker, loadIgnorePatterns } from "../../sync/ignore.js";
@@ -26,6 +26,8 @@ import { isNotFoundError, lstat } from "../../../src/fs/index.js";
 import { areSourceFilesTracked, clearPushReceipt, computeSourceDigest, getProjectTarget, normalizeControlPlane, resolveGitSource, writePushReceipt, } from "../../shared/deployment-provenance.js";
 import { buildStudioUrl } from "../studio/command.js";
 import { isJsonMode, streamJsonLine } from "../../shared/json-output.js";
+import { planPushChanges } from "./plan.js";
+import { computeContentDigest, preflightSyncState, readSyncTarget, writeSyncTarget, } from "../../sync/state.js";
 const PREVIEW_BRANCH_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
 const BRANCH_SUFFIX_LENGTH = 6;
 const PREVIEW_BRANCH_ERROR = "Preview branches must use 1-63 lowercase letters, numbers, or hyphens.";
@@ -36,7 +38,7 @@ export const getPushArgsSchema = defineSchema((v) => v.object({
     projectSlug: v.string().optional(),
     projectDir: v.string().optional(),
     branch: v.string().regex(PREVIEW_BRANCH_PATTERN, PREVIEW_BRANCH_ERROR).default("main"),
-    /** Deprecated compatibility flag; invoking push already authorizes the operation. */
+    /** Intentionally overwrite remote changes and bypass concurrency guards. */
     force: v.boolean().default(false),
     prune: v.boolean().default(false),
     dryRun: v.boolean().default(false),
@@ -274,27 +276,29 @@ async function getBranchByName(client, projectSlug, branchName) {
 }
 export async function ensureBranch(client, projectSlug, branchName) {
     try {
-        return await createBranch(client, projectSlug, branchName);
+        return { ...await createBranch(client, projectSlug, branchName), created: true };
     }
     catch (error) {
         if (getErrorStatus(error) !== 409)
             throw error;
         const existingBranch = await getBranchByName(client, projectSlug, branchName);
         if (existingBranch)
-            return existingBranch;
+            return { ...existingBranch, created: false };
         throw error;
     }
 }
 export async function resolvePushRemoteFiles(client, projectSlug, branchName, mainFiles) {
     const mainSource = { type: "main" };
-    if (branchName === "main")
-        return { branchId: null, remoteFiles: mainFiles, source: mainSource };
+    if (branchName === "main") {
+        return { branchId: null, remoteFiles: mainFiles, source: mainSource, branchExists: true };
+    }
     const existingBranch = await getBranchByName(client, projectSlug, branchName);
-    if (!existingBranch)
-        return { branchId: null, remoteFiles: mainFiles, source: mainSource };
+    if (!existingBranch) {
+        return { branchId: null, remoteFiles: mainFiles, source: mainSource, branchExists: false };
+    }
     const branchSource = { type: "branch", name: branchName };
     const remoteFiles = await listAllFiles(client, projectSlug, branchSource);
-    return { branchId: existingBranch.id, remoteFiles, source: branchSource };
+    return { branchId: existingBranch.id, remoteFiles, source: branchSource, branchExists: true };
 }
 function buildFileUrl(projectSlug, path, branchId) {
     const encodedPath = encodeURIComponent(path);
@@ -304,6 +308,8 @@ function buildFileUrl(projectSlug, path, branchId) {
 export async function uploadFiles(client, projectSlug, branchId, ops, dryRun) {
     let uploaded = 0;
     let failed = 0;
+    const conflicts = [];
+    const applied = [];
     for (const op of ops) {
         if (dryRun) {
             if (!isJsonMode())
@@ -312,36 +318,81 @@ export async function uploadFiles(client, projectSlug, branchId, ops, dryRun) {
             continue;
         }
         try {
-            await client.put(buildFileUrl(projectSlug, op.path, branchId), { content: op.content });
+            await client.put(buildFileUrl(projectSlug, op.path, branchId), {
+                content: op.content,
+                ...(op.expectedVersionId ? { expected_version_id: op.expectedVersionId } : {}),
+                ...(op.expectedAbsent ? { expected_absent: true } : {}),
+            }, op.expectedVersionId || op.expectedAbsent ? { retryPolicy: "none" } : undefined);
             uploaded++;
+            applied.push(op.path);
         }
         catch (error) {
+            if (getErrorStatus(error) === 409) {
+                conflicts.push(op.path);
+                break;
+            }
             cliLogger.error(`Failed to upload ${op.path}:`, error);
             failed++;
         }
     }
-    return { uploaded, failed };
+    return { uploaded, failed, conflicts, applied };
 }
-export async function deleteFiles(client, projectSlug, branchId, paths, dryRun) {
+export async function deleteFiles(client, projectSlug, branchId, ops, dryRun) {
     let deleted = 0;
     let failed = 0;
-    for (const path of paths) {
+    const conflicts = [];
+    const applied = [];
+    for (const op of ops) {
         if (dryRun) {
             if (!isJsonMode())
-                cliLogger.info(`  Would delete: ${path}`);
+                cliLogger.info(`  Would delete: ${op.path}`);
             deleted++;
             continue;
         }
         try {
-            await client.delete(buildFileUrl(projectSlug, path, branchId));
+            const url = new URL(buildFileUrl(projectSlug, op.path, branchId), "https://veryfront.invalid");
+            if (op.expectedVersionId) {
+                url.searchParams.set("expected_version_id", op.expectedVersionId);
+            }
+            await client.delete(`${url.pathname}${url.search}`);
             deleted++;
+            applied.push(op.path);
         }
         catch (error) {
-            cliLogger.error(`Failed to delete ${path}:`, error);
+            if (getErrorStatus(error) === 409) {
+                conflicts.push(op.path);
+                break;
+            }
+            cliLogger.error(`Failed to delete ${op.path}:`, error);
             failed++;
         }
     }
-    return { deleted, failed };
+    return { deleted, failed, conflicts, applied };
+}
+async function deleteForcedPruneRemoteOnlyFiles(client, projectSlug, branchId, remoteFiles, ignoreChecker, plannedFiles) {
+    const plannedPaths = new Set(Object.keys(plannedFiles));
+    const remoteOnlyDeletes = remoteFiles
+        .filter((file) => ignoreChecker.isSupportedExtension(file.path) &&
+        !ignoreChecker.isIgnored(file.path) &&
+        !plannedPaths.has(file.path))
+        .map((file) => ({ path: file.path }));
+    if (remoteOnlyDeletes.length === 0) {
+        return { deleted: 0, failed: 0, conflicts: [], applied: [] };
+    }
+    return await deleteFiles(client, projectSlug, branchId, remoteOnlyDeletes, false);
+}
+async function uploadForcedPlannedFiles(client, projectSlug, branchId, remoteFiles, ignoreChecker, uploads) {
+    const remoteSnapshot = await buildManagedRemoteSnapshot(remoteFiles, ignoreChecker, false);
+    const restoreUploads = [];
+    for (const upload of uploads) {
+        if (remoteSnapshot.get(upload.path)?.digest !== await computeContentDigest(upload.content)) {
+            restoreUploads.push(upload);
+        }
+    }
+    if (restoreUploads.length === 0) {
+        return { uploaded: 0, failed: 0, conflicts: [], applied: [] };
+    }
+    return await uploadFiles(client, projectSlug, branchId, restoreUploads, false);
 }
 function formatParts(parts) {
     return parts.join(", ");
@@ -360,6 +411,96 @@ function buildSummaryParts(ops, toDelete) {
 function buildConfirmParts(ops, toDelete) {
     return buildOpParts(ops, toDelete, (count) => `upload ${count}`, (count) => `delete ${count}`);
 }
+function pushConflictError(paths) {
+    const files = paths.map((path) => `"${path}"`).join(", ");
+    return PUSH_CONFLICT.create({
+        detail: `Push rejected because remote files changed since your last pull or push: ${files}. ` +
+            "Commit or stash local changes, run veryfront pull, reconcile the changes with Git, then push again. " +
+            "Use veryfront push --force only to intentionally overwrite remote changes.",
+        context: { paths: [...paths] },
+    });
+}
+function requireRemoteContent(file) {
+    if (typeof file.content === "string")
+        return file.content;
+    throw new Error(`Veryfront returned invalid content for remote file "${file.path}". No files were pushed.`);
+}
+async function buildManagedRemoteSnapshot(files, ignoreChecker, includeVersion = true) {
+    const snapshot = new Map();
+    for (const file of files) {
+        if (!ignoreChecker.isSupportedExtension(file.path) || ignoreChecker.isIgnored(file.path)) {
+            continue;
+        }
+        snapshot.set(file.path, {
+            digest: await computeContentDigest(requireRemoteContent(file)),
+            ...(includeVersion && file.version_id ? { versionId: file.version_id } : {}),
+        });
+    }
+    return snapshot;
+}
+function findRemoteSnapshotChanges(expected, actual) {
+    const paths = new Set([...expected.keys(), ...actual.keys()]);
+    const changed = [];
+    for (const path of paths) {
+        const expectedFile = expected.get(path);
+        const actualFile = actual.get(path);
+        if (!expectedFile ||
+            !actualFile ||
+            expectedFile.digest !== actualFile.digest ||
+            expectedFile.versionId !== actualFile.versionId) {
+            changed.push(path);
+        }
+    }
+    return changed.sort();
+}
+function buildSyncFileDigestSnapshot(files) {
+    return new Map(Object.entries(files)
+        .map(([path, file]) => [path, { digest: file.digest }]));
+}
+async function filterAppliedChangesStillMatchingRemote(latestRemoteSnapshot, appliedUploads, appliedDeletes) {
+    const uploads = [];
+    for (const upload of appliedUploads) {
+        if (latestRemoteSnapshot.get(upload.path)?.digest === await computeContentDigest(upload.content)) {
+            uploads.push(upload);
+        }
+    }
+    const deletes = appliedDeletes.filter((deletion) => !latestRemoteSnapshot.has(deletion.path));
+    return { uploads, deletes };
+}
+async function buildSyncFilesAfterAppliedChanges(remoteFiles, appliedUploads, appliedDeletes) {
+    const files = {};
+    for (const file of remoteFiles) {
+        files[file.path] = {
+            digest: await computeContentDigest(requireRemoteContent(file)),
+            ...(file.version_id ? { versionId: file.version_id } : {}),
+        };
+    }
+    for (const upload of appliedUploads) {
+        files[upload.path] = { digest: await computeContentDigest(upload.content) };
+    }
+    for (const deletion of appliedDeletes) {
+        delete files[deletion.path];
+    }
+    return files;
+}
+async function computePushedSourceDigest(localFiles, remoteFiles) {
+    const localPaths = new Set(localFiles.map((file) => file.path));
+    const preservedRemoteFiles = remoteFiles
+        .filter((file) => !localPaths.has(file.path))
+        .map((file) => ({ path: file.path, content: requireRemoteContent(file) }));
+    return await computeSourceDigest([...localFiles, ...preservedRemoteFiles]);
+}
+async function writeAppliedSyncTarget(projectDir, config, project, branch, remoteFiles, appliedUploads, appliedDeletes) {
+    if (!project || (appliedUploads.length === 0 && appliedDeletes.length === 0))
+        return;
+    await writeSyncTarget(projectDir, {
+        controlPlane: config.apiUrl,
+        projectId: project.id,
+        projectSlug: project.slug,
+        branch,
+        files: await buildSyncFilesAfterAppliedChanges(remoteFiles, appliedUploads, appliedDeletes),
+    });
+}
 export async function recordPushReceipt(client, config, projectDir, branch, snapshot, ignoreChecker, pushedSourceDigest = snapshot.sourceDigest) {
     const project = await getProjectTarget(client, projectApiReference(config));
     let currentSnapshot;
@@ -384,7 +525,7 @@ export async function recordPushReceipt(client, config, projectDir, branch, snap
 }
 export function pushCommand(options = {}) {
     return withSpan("cli.command.push", async () => {
-        const { projectSlug: slugOverride, projectDir = cwd(), branch = "main", dryRun = false, quiet = false, } = options;
+        const { projectSlug: slugOverride, projectDir = cwd(), branch = "main", force = false, dryRun = false, quiet = false, } = options;
         const pruneRemoteMissing = options.prune ?? false;
         assertPreviewBranchName(branch);
         const jsonOutput = isJsonMode();
@@ -408,6 +549,7 @@ export function pushCommand(options = {}) {
             config = { ...config, projectSlug: slugOverride };
             projectReferenceSource = { kind: "argument", name: "--project" };
         }
+        await preflightSyncState(projectDir);
         spinner.update("Loading ignore patterns...");
         const ignorePatterns = await loadIgnorePatterns(projectDir);
         const ignoreChecker = createIgnoreChecker(ignorePatterns);
@@ -493,13 +635,43 @@ export function pushCommand(options = {}) {
         }
         const ops = sourceSnapshot.files;
         const localPaths = new Set(ops.map((op) => op.path));
-        const target = projectExists
+        let target = projectExists
             ? await resolvePushRemoteFiles(client, projectApiReference(config), branchName, mainFiles)
             : {
                 branchId: null,
                 remoteFiles: mainFiles,
                 source: { type: "main" },
+                branchExists: isMainBranch,
             };
+        let remoteFilesAreBaseline = !isMainBranch && !target.branchExists;
+        if (!dryRun && !isMainBranch && !target.branchId) {
+            spinner.update(`Creating branch "${branchName}"...`);
+            try {
+                const preparedBranch = await ensureBranch(client, projectApiReference(config), branchName);
+                const branchSource = { type: "branch", name: branchName };
+                const branchRemoteFiles = await listAllFiles(client, projectApiReference(config), branchSource);
+                if (preparedBranch.created && !force) {
+                    const conflicts = findRemoteSnapshotChanges(await buildManagedRemoteSnapshot(mainFiles, ignoreChecker, false), await buildManagedRemoteSnapshot(branchRemoteFiles, ignoreChecker, false));
+                    if (conflicts.length > 0) {
+                        throw pushConflictError(conflicts);
+                    }
+                }
+                target = {
+                    branchId: preparedBranch.id,
+                    remoteFiles: branchRemoteFiles,
+                    source: branchSource,
+                    branchExists: true,
+                };
+                remoteFilesAreBaseline = preparedBranch.created;
+            }
+            catch (error) {
+                spinner.stop();
+                if (error instanceof VeryfrontError)
+                    throw error;
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to prepare branch "${branchName}": ${message}`);
+            }
+        }
         const remoteFilesMissingLocally = target.remoteFiles
             .map((file) => file.path)
             .filter((path) => ignoreChecker.isSupportedExtension(path) &&
@@ -515,15 +687,100 @@ export function pushCommand(options = {}) {
             }
             return { path: file.path, content: file.content };
         });
-        const pushedSourceDigest = preservedRemoteFiles.length === 0
+        let pushedSourceDigest = preservedRemoteFiles.length === 0
             ? sourceSnapshot.sourceDigest
             : await computeSourceDigest([...ops, ...preservedRemoteFiles]);
-        if (ops.length === 0 && toDelete.length === 0) {
+        const project = outcome.kind === "planned-create" ? null : outcome.project;
+        const baseline = project
+            ? await readSyncTarget(projectDir, {
+                controlPlane: config.apiUrl,
+                projectId: project.id,
+                branch: branchName,
+            })
+            : null;
+        const managedRemoteFiles = target.remoteFiles.filter((file) => ignoreChecker.isSupportedExtension(file.path) && !ignoreChecker.isIgnored(file.path));
+        const plan = await planPushChanges({
+            localFiles: ops,
+            remoteFiles: managedRemoteFiles,
+            baselineFiles: baseline?.files ?? {},
+            deletePaths: toDelete,
+            force,
+            remoteFilesAreBaseline,
+        });
+        if (plan.conflicts.length > 0) {
+            spinner.stop();
+            throw pushConflictError(plan.conflicts);
+        }
+        const uploadOps = plan.uploads;
+        const deleteOps = plan.deletes;
+        const branchId = target.branchId;
+        let pushedSyncFiles = plan.nextFiles;
+        if (!dryRun && !force) {
+            spinner = quiet || jsonOutput
+                ? createNoopSpinner()
+                : createSpinner("Checking remote files...");
+            try {
+                const latestRemoteFiles = await listAllFiles(client, projectApiReference(config), target.source);
+                const conflicts = findRemoteSnapshotChanges(await buildManagedRemoteSnapshot(managedRemoteFiles, ignoreChecker), await buildManagedRemoteSnapshot(latestRemoteFiles, ignoreChecker));
+                if (conflicts.length > 0) {
+                    throw pushConflictError(conflicts);
+                }
+            }
+            finally {
+                spinner.stop();
+            }
+        }
+        if (uploadOps.length === 0 && deleteOps.length === 0) {
+            let forcedPruneDeleteCount = 0;
             try {
                 if (!dryRun) {
+                    if (!force) {
+                        spinner.update("Checking remote files...");
+                        const latestRemoteFiles = await listAllFiles(client, projectApiReference(config), target.source);
+                        const conflicts = findRemoteSnapshotChanges(await buildManagedRemoteSnapshot(managedRemoteFiles, ignoreChecker), await buildManagedRemoteSnapshot(latestRemoteFiles, ignoreChecker));
+                        if (conflicts.length > 0) {
+                            throw pushConflictError(conflicts);
+                        }
+                        pushedSourceDigest = await computePushedSourceDigest(ops, latestRemoteFiles);
+                    }
+                    else if (pruneRemoteMissing) {
+                        spinner.update("Verifying push target...");
+                        let latestRemoteFiles = await listAllFiles(client, projectApiReference(config), target.source);
+                        const lateDeleteResult = await deleteForcedPruneRemoteOnlyFiles(client, projectApiReference(config), branchId, latestRemoteFiles, ignoreChecker, plan.nextFiles);
+                        forcedPruneDeleteCount = lateDeleteResult.deleted;
+                        if (lateDeleteResult.conflicts.length > 0) {
+                            throw pushConflictError(lateDeleteResult.conflicts);
+                        }
+                        if (lateDeleteResult.failed > 0) {
+                            throw new Error(`Push failed for ${lateDeleteResult.failed} file${lateDeleteResult.failed === 1 ? "" : "s"} during forced prune reconciliation`);
+                        }
+                        if (lateDeleteResult.deleted > 0) {
+                            latestRemoteFiles = await listAllFiles(client, projectApiReference(config), target.source);
+                        }
+                        const conflicts = findRemoteSnapshotChanges(buildSyncFileDigestSnapshot(plan.nextFiles), await buildManagedRemoteSnapshot(latestRemoteFiles, ignoreChecker, false));
+                        if (conflicts.length > 0) {
+                            throw pushConflictError(conflicts);
+                        }
+                        pushedSourceDigest = await computePushedSourceDigest(ops, latestRemoteFiles);
+                    }
+                    else {
+                        const latestRemoteFiles = await listAllFiles(client, projectApiReference(config), target.source);
+                        pushedSourceDigest = await computePushedSourceDigest(ops, latestRemoteFiles);
+                        pushedSyncFiles = await buildSyncFilesAfterAppliedChanges(latestRemoteFiles.filter((file) => ignoreChecker.isSupportedExtension(file.path) &&
+                            !ignoreChecker.isIgnored(file.path)), [], []);
+                    }
                     await clearPushReceipt(projectDir);
                     spinner.update("Verifying push target...");
                     await recordPushReceipt(client, config, projectDir, branchName, sourceSnapshot, ignoreChecker, pushedSourceDigest);
+                    if (project) {
+                        await writeSyncTarget(projectDir, {
+                            controlPlane: config.apiUrl,
+                            projectId: project.id,
+                            projectSlug: project.slug,
+                            branch: branchName,
+                            files: pushedSyncFiles,
+                        });
+                    }
                 }
             }
             finally {
@@ -537,72 +794,232 @@ export function pushCommand(options = {}) {
                     logInfo("Dry run complete. No files would change.");
                 }
                 else {
-                    outputPushResult(config.projectSlug, branchName, 0, 0, Date.now() - startTime);
+                    outputPushResult(config.projectSlug, branchName, 0, forcedPruneDeleteCount, Date.now() - startTime);
                 }
             }
             return;
         }
         spinner.stop();
         if (!quiet && !jsonOutput && (dryRun || isVerbose())) {
-            const parts = buildSummaryParts(ops, toDelete);
+            const parts = buildSummaryParts(uploadOps, deleteOps.map((op) => op.path));
             cliLogger.info(`\nFound ${formatParts(parts)} for ${isMainBranch ? "main" : `branch "${branchName}"`}.`);
         }
         if (dryRun) {
-            if (ops.length > 0) {
-                await uploadFiles(client, projectApiReference(config), target.branchId, ops, true);
+            if (uploadOps.length > 0) {
+                await uploadFiles(client, projectApiReference(config), target.branchId, uploadOps, true);
             }
-            if (toDelete.length > 0) {
-                await deleteFiles(client, projectApiReference(config), target.branchId, toDelete, true);
+            if (deleteOps.length > 0) {
+                await deleteFiles(client, projectApiReference(config), target.branchId, deleteOps, true);
             }
             if (jsonOutput && !quiet) {
-                outputPushDryRunResult(config.projectSlug, branchName, projectExists, ops.length, toDelete.length);
+                outputPushDryRunResult(config.projectSlug, branchName, projectExists, uploadOps.length, deleteOps.length);
             }
             else if (!quiet) {
-                const parts = buildConfirmParts(ops, toDelete);
+                const parts = buildConfirmParts(uploadOps, deleteOps.map((op) => op.path));
                 logInfo(`Dry run complete. Would ${parts.join(" and ")} files.`);
             }
             return;
         }
         await clearPushReceipt(projectDir);
-        let branchId = target.branchId;
         const uploadMsg = isMainBranch
             ? "Pushing to main..."
             : branchId
                 ? `Pushing to branch "${branchName}"...`
                 : `Creating branch "${branchName}"...`;
         spinner = quiet || jsonOutput ? createNoopSpinner() : createSpinner(uploadMsg);
-        if (!isMainBranch && !branchId) {
+        let uploadResult = {
+            uploaded: 0,
+            failed: 0,
+            conflicts: [],
+            applied: [],
+        };
+        let deleteResult = {
+            deleted: 0,
+            failed: 0,
+            conflicts: [],
+            applied: [],
+        };
+        const writeConfirmedAppliedSyncTarget = async () => {
+            const appliedUploads = new Set(uploadResult.applied);
+            const appliedDeletes = [...new Set(deleteResult.applied)]
+                .map((path) => ({ path }));
+            await writeAppliedSyncTarget(projectDir, config, project, branchName, managedRemoteFiles, uploadOps.filter((op) => appliedUploads.has(op.path)), appliedDeletes);
+        };
+        const listAllFilesForVerification = async () => {
             try {
-                const preparedBranch = await ensureBranch(client, projectApiReference(config), branchName);
-                branchId = preparedBranch.id;
+                return await listAllFiles(client, projectApiReference(config), target.source);
             }
             catch (error) {
-                spinner.stop();
-                const message = error instanceof Error ? error.message : String(error);
-                throw new Error(`Failed to prepare branch "${branchName}": ${message}`);
+                await writeConfirmedAppliedSyncTarget();
+                throw error;
             }
-        }
-        let uploadResult = { uploaded: 0, failed: 0 };
-        let deleteResult = { deleted: 0, failed: 0 };
-        if (ops.length > 0) {
+        };
+        const writeVerifiedAppliedSyncTarget = async (knownRemoteFiles) => {
+            const latestRemoteFiles = knownRemoteFiles ?? await listAllFilesForVerification();
+            const latestRemoteSnapshot = await buildManagedRemoteSnapshot(latestRemoteFiles, ignoreChecker, false);
+            const appliedUploads = new Set(uploadResult.applied);
+            const appliedDeletes = [...new Set(deleteResult.applied)]
+                .map((path) => ({ path }));
+            const stillApplied = await filterAppliedChangesStillMatchingRemote(latestRemoteSnapshot, uploadOps.filter((op) => appliedUploads.has(op.path)), appliedDeletes);
+            await writeAppliedSyncTarget(projectDir, config, project, branchName, managedRemoteFiles, stillApplied.uploads, stillApplied.deletes);
+        };
+        if (uploadOps.length > 0) {
             spinner.update("Uploading files...");
-            uploadResult = await uploadFiles(client, projectApiReference(config), branchId, ops, false);
+            uploadResult = await uploadFiles(client, projectApiReference(config), branchId, uploadOps, false);
+        }
+        if (uploadResult.conflicts.length > 0) {
+            spinner.stop();
+            const appliedUploads = new Set(uploadResult.applied);
+            await writeAppliedSyncTarget(projectDir, config, project, branchName, managedRemoteFiles, uploadOps.filter((op) => appliedUploads.has(op.path)), []);
+            throw pushConflictError(uploadResult.conflicts);
         }
         if (uploadResult.failed > 0) {
             spinner.stop();
+            const appliedUploads = new Set(uploadResult.applied);
+            await writeAppliedSyncTarget(projectDir, config, project, branchName, managedRemoteFiles, uploadOps.filter((op) => appliedUploads.has(op.path)), []);
             throw new Error(`Push failed for ${uploadResult.failed} file${uploadResult.failed === 1 ? "" : "s"}. Remote files were not deleted.`);
         }
-        if (toDelete.length > 0) {
+        if (deleteOps.length > 0) {
             spinner.update("Deleting removed files...");
-            deleteResult = await deleteFiles(client, projectApiReference(config), branchId, toDelete, false);
+            deleteResult = await deleteFiles(client, projectApiReference(config), branchId, deleteOps, false);
+        }
+        if (deleteResult.conflicts.length > 0) {
+            spinner.stop();
+            const appliedUploads = new Set(uploadResult.applied);
+            const appliedDeletes = new Set(deleteResult.applied);
+            await writeAppliedSyncTarget(projectDir, config, project, branchName, managedRemoteFiles, uploadOps.filter((op) => appliedUploads.has(op.path)), deleteOps.filter((op) => appliedDeletes.has(op.path)));
+            throw pushConflictError(deleteResult.conflicts);
         }
         if (deleteResult.failed > 0) {
             spinner.stop();
+            await writeVerifiedAppliedSyncTarget();
             throw new Error(`Push failed for ${deleteResult.failed} file${deleteResult.failed === 1 ? "" : "s"} during deletion`);
         }
         spinner.update("Verifying push target...");
         try {
-            await recordPushReceipt(client, config, projectDir, branchName, sourceSnapshot, ignoreChecker, pushedSourceDigest);
+            if (!force) {
+                const latestRemoteFiles = await listAllFilesForVerification();
+                const latestRemoteSnapshot = await buildManagedRemoteSnapshot(latestRemoteFiles, ignoreChecker, false);
+                const conflicts = findRemoteSnapshotChanges(buildSyncFileDigestSnapshot(plan.nextFiles), latestRemoteSnapshot);
+                if (conflicts.length > 0) {
+                    const appliedUploads = new Set(uploadResult.applied);
+                    const appliedDeletes = new Set(deleteResult.applied);
+                    const stillApplied = await filterAppliedChangesStillMatchingRemote(latestRemoteSnapshot, uploadOps.filter((op) => appliedUploads.has(op.path)), deleteOps.filter((op) => appliedDeletes.has(op.path)));
+                    await writeAppliedSyncTarget(projectDir, config, project, branchName, managedRemoteFiles, stillApplied.uploads, stillApplied.deletes);
+                    throw pushConflictError(conflicts);
+                }
+                pushedSourceDigest = await computePushedSourceDigest(ops, latestRemoteFiles);
+            }
+            else if (pruneRemoteMissing) {
+                const latestRemoteFiles = await listAllFilesForVerification();
+                let repaired = false;
+                const lateUploadResult = await uploadForcedPlannedFiles(client, projectApiReference(config), branchId, latestRemoteFiles, ignoreChecker, uploadOps);
+                if (lateUploadResult.uploaded > 0 ||
+                    lateUploadResult.failed > 0 ||
+                    lateUploadResult.conflicts.length > 0) {
+                    repaired = true;
+                    uploadResult = {
+                        uploaded: uploadResult.uploaded + lateUploadResult.uploaded,
+                        failed: uploadResult.failed + lateUploadResult.failed,
+                        conflicts: [...uploadResult.conflicts, ...lateUploadResult.conflicts],
+                        applied: [...uploadResult.applied, ...lateUploadResult.applied],
+                    };
+                    if (lateUploadResult.conflicts.length > 0) {
+                        await writeVerifiedAppliedSyncTarget();
+                        throw pushConflictError(lateUploadResult.conflicts);
+                    }
+                    if (lateUploadResult.failed > 0) {
+                        await writeVerifiedAppliedSyncTarget();
+                        throw new Error(`Push failed for ${lateUploadResult.failed} file${lateUploadResult.failed === 1 ? "" : "s"} during forced prune reconciliation`);
+                    }
+                }
+                const lateDeleteResult = await deleteForcedPruneRemoteOnlyFiles(client, projectApiReference(config), branchId, latestRemoteFiles, ignoreChecker, plan.nextFiles);
+                if (lateDeleteResult.deleted > 0 ||
+                    lateDeleteResult.failed > 0 ||
+                    lateDeleteResult.conflicts.length > 0) {
+                    repaired = true;
+                    deleteResult = {
+                        deleted: deleteResult.deleted + lateDeleteResult.deleted,
+                        failed: deleteResult.failed + lateDeleteResult.failed,
+                        conflicts: [...deleteResult.conflicts, ...lateDeleteResult.conflicts],
+                        applied: [...deleteResult.applied, ...lateDeleteResult.applied],
+                    };
+                    if (lateDeleteResult.conflicts.length > 0) {
+                        await writeVerifiedAppliedSyncTarget();
+                        throw pushConflictError(lateDeleteResult.conflicts);
+                    }
+                    if (lateDeleteResult.failed > 0) {
+                        await writeVerifiedAppliedSyncTarget();
+                        throw new Error(`Push failed for ${lateDeleteResult.failed} file${lateDeleteResult.failed === 1 ? "" : "s"} during forced prune reconciliation`);
+                    }
+                }
+                if (repaired) {
+                    const repairedRemoteFiles = await listAllFilesForVerification();
+                    const repairedConflicts = findRemoteSnapshotChanges(buildSyncFileDigestSnapshot(plan.nextFiles), await buildManagedRemoteSnapshot(repairedRemoteFiles, ignoreChecker, false));
+                    if (repairedConflicts.length > 0) {
+                        await writeVerifiedAppliedSyncTarget(repairedRemoteFiles);
+                        throw pushConflictError(repairedConflicts);
+                    }
+                    pushedSourceDigest = await computePushedSourceDigest(ops, repairedRemoteFiles);
+                }
+                else {
+                    pushedSourceDigest = await computePushedSourceDigest(ops, latestRemoteFiles);
+                }
+            }
+            else {
+                let latestRemoteFiles = await listAllFilesForVerification();
+                const repairUploadResult = await uploadForcedPlannedFiles(client, projectApiReference(config), branchId, latestRemoteFiles, ignoreChecker, uploadOps);
+                uploadResult = {
+                    uploaded: uploadResult.uploaded + repairUploadResult.uploaded,
+                    failed: uploadResult.failed + repairUploadResult.failed,
+                    conflicts: [...uploadResult.conflicts, ...repairUploadResult.conflicts],
+                    applied: [...uploadResult.applied, ...repairUploadResult.applied],
+                };
+                if (repairUploadResult.conflicts.length > 0) {
+                    await writeVerifiedAppliedSyncTarget();
+                    throw pushConflictError(repairUploadResult.conflicts);
+                }
+                if (repairUploadResult.failed > 0) {
+                    await writeVerifiedAppliedSyncTarget();
+                    throw new Error(`Push failed for ${repairUploadResult.failed} file${repairUploadResult.failed === 1 ? "" : "s"} during forced push verification`);
+                }
+                if (repairUploadResult.uploaded > 0) {
+                    latestRemoteFiles = await listAllFilesForVerification();
+                }
+                const latestRemoteSnapshot = await buildManagedRemoteSnapshot(latestRemoteFiles, ignoreChecker, false);
+                const uploadPaths = new Set(uploadOps.map((upload) => upload.path));
+                const expectedUploadSnapshot = new Map([...buildSyncFileDigestSnapshot(plan.nextFiles)]
+                    .filter(([path]) => uploadPaths.has(path)));
+                const actualUploadSnapshot = new Map([...latestRemoteSnapshot]
+                    .filter(([path]) => uploadPaths.has(path)));
+                const conflicts = findRemoteSnapshotChanges(expectedUploadSnapshot, actualUploadSnapshot);
+                if (conflicts.length > 0) {
+                    await writeVerifiedAppliedSyncTarget(latestRemoteFiles);
+                    throw pushConflictError(conflicts);
+                }
+                pushedSourceDigest = await computePushedSourceDigest(ops, latestRemoteFiles);
+                pushedSyncFiles = await buildSyncFilesAfterAppliedChanges(latestRemoteFiles.filter((file) => ignoreChecker.isSupportedExtension(file.path) &&
+                    !ignoreChecker.isIgnored(file.path)), [], []);
+            }
+            const writePlannedSyncTarget = async () => {
+                if (!project)
+                    return;
+                await writeSyncTarget(projectDir, {
+                    controlPlane: config.apiUrl,
+                    projectId: project.id,
+                    projectSlug: project.slug,
+                    branch: branchName,
+                    files: pushedSyncFiles,
+                });
+            };
+            try {
+                await recordPushReceipt(client, config, projectDir, branchName, sourceSnapshot, ignoreChecker, pushedSourceDigest);
+            }
+            catch (error) {
+                await writePlannedSyncTarget();
+                throw error;
+            }
+            await writePlannedSyncTarget();
         }
         finally {
             spinner.stop();