@neocompose/cli 0.6.0 → 0.6.2

package/dist/neo.mjs

@@ -26173,6 +26173,9 @@ var init_merge = __esm({
 });
 
 // src/project-manifest/merge.ts
+function isSchemaDocumentRecordKind(recordKind) {
+  return Object.hasOwn(SCHEMA_DOCUMENT_FIELD_CONTRACTS, recordKind);
+}
 function schemaDocumentSemanticallyEqual(recordKind, left, right) {
   return canonicallyEqual(
     normalizeDocumentForComparison(recordKind, left, "left"),
@@ -28256,29 +28259,38 @@ function genericConstraint(context, type) {
   };
 }
 function inheritedMemberId(context, ownerClass, name) {
-  const baseType = ownerClass.baseTypes.find(
+  const directBase = ownerClass.baseTypes.find(
     (entry) => context.classIdsByName.has(entry.name)
   );
-  if (!baseType) return null;
-  const baseClass = context.baseClasses.get(
-    requiredName(context.classIdsByName, baseType.name, "class")
-  );
-  if (baseClass !== void 0) return baseClass.schema[name] ?? null;
-  const baseClassId = requiredName(
-    context.classIdsByName,
-    baseType.name,
-    "class"
-  );
-  const sourceBase = context.sourceClasses.get(baseClassId);
-  if (sourceBase === void 0) return null;
-  const sourceMember = sourceBase.members.find(
-    (member) => member.name === name
-  );
-  return sourceMember === void 0 ? null : materializedId(
-    sourceMember,
-    "member",
-    `${sourceBase.name}.${sourceMember.name}`
-  );
+  let classId = directBase ? requiredName(context.classIdsByName, directBase.name, "class") : null;
+  const visited = /* @__PURE__ */ new Set();
+  while (classId !== null && !visited.has(classId)) {
+    visited.add(classId);
+    const sourceClass = context.sourceClasses.get(classId);
+    if (sourceClass !== void 0) {
+      const sourceMember = sourceClass.members.find(
+        (member) => member.name === name
+      );
+      if (sourceMember !== void 0) {
+        return materializedId(
+          sourceMember,
+          "member",
+          `${sourceClass.name}.${sourceMember.name}`
+        );
+      }
+      const sourceBase = sourceClass.baseTypes.find(
+        (entry) => context.classIdsByName.has(entry.name)
+      );
+      classId = sourceBase ? requiredName(context.classIdsByName, sourceBase.name, "class") : null;
+      continue;
+    }
+    const pulledClass = context.baseClasses.get(classId);
+    if (pulledClass === void 0) return null;
+    const memberId = pulledClass.schema[name];
+    if (memberId !== void 0) return memberId;
+    classId = pulledClass.extendsClassId;
+  }
+  return null;
 }
 function resolveQualifiedMemberId(context, expression) {
   const match = /^([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(
@@ -39728,6 +39740,7 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest) {
     if (record3.recordKind === "value") pulledValueIds.add(record3.recordId);
   }
   const memberDefaultValues = /* @__PURE__ */ new Map();
+  const seeds = /* @__PURE__ */ new Map();
   for (const sourceClass of analysis.schema.classes) {
     for (const declaration of sourceClass.members) {
       if (declaration.kind !== "field" || declaration.initializer === null) {
@@ -39736,13 +39749,6 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest) {
       if (declaration.modifiers.includes("static")) continue;
       const label = `${sourceClass.name}.${declaration.name}`;
       const memberId = sourceIdentityId(declaration, "member", label);
-      const baseData3 = stateData(context, "member", memberId);
-      if (baseData3 === null) continue;
-      const backed = rowBackedDefaultBody(
-        baseData3,
-        (id2) => pulledValueIds.has(id2)
-      );
-      if (backed === null) continue;
       const member = context.members.get(memberId);
       if (member === void 0) continue;
       const binding = {
@@ -39751,17 +39757,52 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest) {
         source: declaration.source,
         label
       };
-      memberDefaultValues.set(
-        memberId,
-        lowerRowBackedDefault(context, member, backed, baseData3, binding)
+      const baseData3 = stateData(context, "member", memberId);
+      const backed = baseData3 === null ? null : rowBackedDefaultBody(baseData3, (id2) => pulledValueIds.has(id2));
+      if (backed !== null && baseData3 !== null) {
+        memberDefaultValues.set(
+          memberId,
+          lowerRowBackedDefault(context, member, backed, baseData3, binding)
+        );
+        continue;
+      }
+      const expression = parseCachedInitializer(
+        context.parsedInitializers,
+        declaration.initializer
+      );
+      if (!defaultRequiresOwnedRows(member, expression)) continue;
+      const rootValueId = pendingValueId(binding, `${label}.default`);
+      const seed = lowerStaticSeed(
+        context,
+        member,
+        expression,
+        binding,
+        rootValueId
       );
+      seeds.set(memberId, { ...seed, valueId: rootValueId });
+      memberDefaultValues.set(memberId, {
+        value: seed.value,
+        classId: seed.classId
+      });
     }
   }
   return {
     records: [...context.reconstructed.values()],
-    memberDefaultValues
+    memberDefaultValues,
+    seeds
   };
 }
+function defaultRequiresOwnedRows(member, sourceExpression) {
+  const expression = annotatedValue(sourceExpression).expression;
+  if (member.kind === "class") return expression.kind === "new";
+  if (member.kind === "list") {
+    return expression.kind === "litList" && expression.elements.length > 0;
+  }
+  if (member.kind === "dictionary") {
+    return expression.kind === "litDict" && expression.entries.length > 0;
+  }
+  return false;
+}
 function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
   const baseDefault = isObjectRecord2(baseData3.defaultValue) ? baseData3.defaultValue : {};
   const storedClassId = stringOrNull(baseDefault.classId);
@@ -43737,7 +43778,8 @@ function computeWorkspaceStatus(workspace, options = {}) {
   let staticMemberValueIds = /* @__PURE__ */ new Map();
   let memberDefaults = {
     records: [],
-    memberDefaultValues: /* @__PURE__ */ new Map()
+    memberDefaultValues: /* @__PURE__ */ new Map(),
+    seeds: /* @__PURE__ */ new Map()
   };
   let projectAnalysisV4 = null;
   try {
@@ -43887,7 +43929,7 @@ function computeWorkspaceStatus(workspace, options = {}) {
     projectAnalysisV4,
     manifest
   );
-  staticValueSeeds = staticValues.seeds;
+  staticValueSeeds = new Map([...staticValues.seeds, ...memberDefaults.seeds]);
   staticMemberValueIds = staticValues.memberValueIds;
   const rootRecords = lowerProjectRootSourceV4(
     workspace.state.records,
@@ -45434,6 +45476,7 @@ __export(project_document_read_exports, {
   readOptionalArrayField: () => readOptionalArrayField,
   readProjectDocument: () => readProjectDocument,
   readProjectDocumentContentHashHeads: () => readProjectDocumentContentHashHeads,
+  readProjectDocumentManifestPageRecords: () => readProjectDocumentManifestPageRecords,
   readProjectDocumentManifestRecords: () => readProjectDocumentManifestRecords,
   readProjectDocumentRevisionMarker: () => readProjectDocumentRevisionMarker
 });
@@ -45639,6 +45682,12 @@ function readProjectDocumentManifestRecords(value) {
     };
   });
 }
+function readProjectDocumentManifestPageRecords(value) {
+  if (!isObject3(value)) {
+    throw new Error("Convex project document manifest page must be an object.");
+  }
+  return readProjectDocumentManifestRecords(value.records);
+}
 async function fetchProjectDocumentSnapshots(fetchBatch, snapshotIds) {
   const chunks = [];
   for (let offset = 0; offset < snapshotIds.length; offset += DOCUMENT_SNAPSHOT_FETCH_CHUNK_SIZE) {
@@ -46600,6 +46649,32 @@ var init_http = __esm({
         }
         return parsed;
       }
+      async get(path, options = {}) {
+        const url = new URL(path, this.apiBaseUrl).toString();
+        const response = await fetch(url, {
+          method: "GET",
+          headers: { Authorization: `Bearer ${this.token}` },
+          signal: options.signal
+        });
+        const text = await response.text();
+        let parsed = null;
+        if (text.length > 0) {
+          try {
+            parsed = JSON.parse(text);
+          } catch {
+            parsed = text;
+          }
+        }
+        if (!response.ok) {
+          const detail = typeof parsed === "object" && parsed !== null && "error" in parsed && typeof parsed.error === "string" ? parsed.error : text.slice(0, 300);
+          throw new NeoApiError(
+            `GET ${path} failed with status ${response.status}: ${detail}`,
+            response.status,
+            parsed
+          );
+        }
+        return parsed;
+      }
       async getBytes(path) {
         const url = new URL(path, this.apiBaseUrl).toString();
         const response = await fetch(url, {
@@ -59024,11 +59099,32 @@ async function runMerge(workspace, sourceRef, dryRun, runMigrations = false) {
     }
   }
   try {
-    const result = await client.post(mergePath, {
+    let result = await client.post(mergePath, {
       sourceVersionId: source.id,
       dryRun,
       resolutions: resolutions.length > 0 ? resolutions : void 0
     });
+    const accepted = readAcceptedMergeTransaction(result);
+    if (accepted !== null) {
+      const progress = spinner("Preparing merge\u2026");
+      try {
+        await waitForMergeTransaction({
+          client,
+          projectId: workspace.config.projectId,
+          versionId: workspace.config.versionId,
+          accepted,
+          update: (label) => progress.update(label)
+        });
+        progress.succeed("Merge transaction committed.");
+      } catch (error) {
+        progress.fail("Merge transaction failed.");
+        throw error;
+      }
+      result = { ...result, commitStatus: "committed" };
+      if (result.sourceArchivePending === true) {
+        console.log("Source branch archival is finishing in the background.");
+      }
+    }
     const merged = typeof result.merged === "number" ? result.merged : 0;
     if (dryRun) {
       console.log(`Merge dry-run: ${merged} record(s) would merge cleanly.`);
@@ -59096,6 +59192,104 @@ async function runMerge(workspace, sourceRef, dryRun, runMigrations = false) {
     throw error;
   }
 }
+function readAcceptedMergeTransaction(value) {
+  if (!isObjectRecord2(value)) {
+    throw new Error("Merge response must be an object.");
+  }
+  if (value.kind !== "accepted") return null;
+  if (typeof value.transactionId !== "string") {
+    throw new Error("Accepted merge is missing transactionId.");
+  }
+  if (!isMergeTransactionStatus(value.commitStatus)) {
+    throw new Error("Accepted merge has an invalid commitStatus.");
+  }
+  const totalChangeCount = value.totalChangeCount === null ? null : readMergeProgressCount(value.totalChangeCount, "totalChangeCount");
+  const appliedChangeCount = readMergeProgressCount(
+    value.appliedChangeCount,
+    "appliedChangeCount"
+  );
+  return {
+    transactionId: value.transactionId,
+    commitStatus: value.commitStatus,
+    totalChangeCount,
+    appliedChangeCount
+  };
+}
+async function waitForMergeTransaction(args) {
+  const transactionPath = `/api/projects/${encodeURIComponent(args.projectId)}/versions/${encodeURIComponent(args.versionId)}/schema/transactions/${encodeURIComponent(args.accepted.transactionId)}`;
+  let status = args.accepted;
+  let delayMs = 250;
+  for (; ; ) {
+    args.update(mergeTransactionProgressLabel(status));
+    if (status.commitStatus === "committed") return;
+    if (status.commitStatus === "failed") {
+      throw new Error(
+        `Merge transaction "${status.transactionId}" failed after rollback.`
+      );
+    }
+    const response = await args.client.get(transactionPath);
+    status = readMergeTransactionStatus(response, status.transactionId);
+    if (status.commitStatus === "committed") continue;
+    if (status.commitStatus === "failed") continue;
+    await new Promise((resolve4) => setTimeout(resolve4, delayMs));
+    delayMs = Math.min(delayMs * 2, 5e3);
+  }
+}
+function readMergeTransactionStatus(value, transactionId) {
+  if (!isObjectRecord2(value)) {
+    throw new Error(
+      `Merge transaction "${transactionId}" status must be an object.`
+    );
+  }
+  if (value.transactionId !== transactionId) {
+    throw new Error(
+      `Merge transaction status expected "${transactionId}", received ${JSON.stringify(value.transactionId)}.`
+    );
+  }
+  if (!isMergeTransactionStatus(value.commitStatus)) {
+    throw new Error(
+      `Merge transaction "${transactionId}" has an invalid commitStatus.`
+    );
+  }
+  const totalChangeCount = value.totalChangeCount === null ? null : readMergeProgressCount(value.totalChangeCount, "totalChangeCount");
+  const appliedChangeCount = readMergeProgressCount(
+    value.appliedChangeCount,
+    "appliedChangeCount"
+  );
+  return {
+    transactionId,
+    commitStatus: value.commitStatus,
+    totalChangeCount,
+    appliedChangeCount
+  };
+}
+function readMergeProgressCount(value, field) {
+  if (typeof value !== "number") {
+    throw new Error(`Merge transaction ${field} must be a number.`);
+  }
+  if (!Number.isSafeInteger(value)) {
+    throw new Error(`Merge transaction ${field} must be a safe integer.`);
+  }
+  if (value < 0) {
+    throw new Error(`Merge transaction ${field} must not be negative.`);
+  }
+  return value;
+}
+function isMergeTransactionStatus(value) {
+  return value === "preparing" || value === "waiting" || value === "queued" || value === "applying" || value === "reverting" || value === "committed" || value === "failed";
+}
+function mergeTransactionProgressLabel(status) {
+  if (status.commitStatus === "preparing") return "Preparing merge\u2026";
+  if (status.commitStatus === "waiting") return "Waiting to apply merge\u2026";
+  if (status.commitStatus === "queued") return "Queueing merge\u2026";
+  if (status.commitStatus === "reverting") return "Reverting merge\u2026";
+  if (status.commitStatus === "committed") return "Merge committed.";
+  if (status.commitStatus === "failed") return "Merge failed.";
+  if (status.totalChangeCount !== null) {
+    return `Applying merge\u2026 ${status.appliedChangeCount.toLocaleString("en-US")}/${status.totalChangeCount.toLocaleString("en-US")} changes`;
+  }
+  return "Applying merge\u2026";
+}
 async function runRefresh(workspace, dryRun) {
   const { versions } = await loadVersionMetadata(workspace);
   const current = versions.find(
@@ -61687,6 +61881,345 @@ function assignPendingIds(changes, staticValueSeeds, reconstructed3) {
   }
   return { assigned, staticValueSeeds: rewrittenSeeds };
 }
+function readAcceptedProjectVersionCommitResponse(value) {
+  if (!isObjectRecord2(value) || value.kind !== "accepted") return null;
+  if (typeof value.transactionId !== "string") {
+    throw new Error("Accepted project transaction is missing transactionId.");
+  }
+  const rawStatus = value.commitStatus ?? value.status;
+  if (rawStatus !== "preparing" && rawStatus !== "waiting" && rawStatus !== "queued" && rawStatus !== "applying" && rawStatus !== "reverting" && rawStatus !== "committed" && rawStatus !== "failed") {
+    throw new Error(
+      `Accepted project transaction "${value.transactionId}" has invalid commitStatus ${JSON.stringify(rawStatus)}.`
+    );
+  }
+  const totalChangeCount = readNullableCount(
+    value.totalChangeCount,
+    "accepted totalChangeCount"
+  );
+  const appliedChangeCount = readCount(
+    value.appliedChangeCount,
+    "accepted appliedChangeCount"
+  );
+  const totalChunkCount = readNullableCount(
+    value.totalChunkCount,
+    "accepted totalChunkCount"
+  );
+  const appliedChunkCount = readCount(
+    value.appliedChunkCount,
+    "accepted appliedChunkCount"
+  );
+  return {
+    kind: "accepted",
+    transactionId: value.transactionId,
+    commitStatus: rawStatus,
+    totalChangeCount,
+    appliedChangeCount,
+    totalChunkCount,
+    appliedChunkCount
+  };
+}
+function readProjectVersionTransactionStatus(value, transactionId) {
+  if (!isObjectRecord2(value)) {
+    throw new Error(
+      `Project transaction "${transactionId}" status response must be an object.`
+    );
+  }
+  if (value.transactionId !== transactionId) {
+    throw new Error(
+      `Project transaction status response expected transactionId "${transactionId}"; received ${JSON.stringify(value.transactionId)}.`
+    );
+  }
+  if (!isProjectVersionTransactionCommitStatus(value.commitStatus)) {
+    throw new Error(
+      `Project transaction "${transactionId}" has invalid commitStatus ${JSON.stringify(value.commitStatus)}.`
+    );
+  }
+  const errorCode = readNullableString(
+    value.errorCode,
+    `Project transaction "${transactionId}" errorCode`
+  );
+  const errorMessage3 = readNullableString(
+    value.errorMessage,
+    `Project transaction "${transactionId}" errorMessage`
+  );
+  const resultCursor = readNullableString(
+    value.resultCursor,
+    `Project transaction "${transactionId}" resultCursor`
+  );
+  return {
+    transactionId,
+    commitStatus: value.commitStatus,
+    totalChangeCount: readNullableCount(
+      value.totalChangeCount,
+      `Project transaction "${transactionId}" totalChangeCount`
+    ),
+    appliedChangeCount: readCount(
+      value.appliedChangeCount,
+      `Project transaction "${transactionId}" appliedChangeCount`
+    ),
+    totalChunkCount: readNullableCount(
+      value.totalChunkCount,
+      `Project transaction "${transactionId}" totalChunkCount`
+    ),
+    appliedChunkCount: readCount(
+      value.appliedChunkCount,
+      `Project transaction "${transactionId}" appliedChunkCount`
+    ),
+    errorCode,
+    errorMessage: errorMessage3,
+    resultCursor
+  };
+}
+function readProjectVersionTransactionResultPage(value, transactionId) {
+  if (!isObjectRecord2(value)) {
+    throw new Error(
+      `Project transaction "${transactionId}" result page must be an object.`
+    );
+  }
+  if (value.transactionId !== transactionId) {
+    throw new Error(
+      `Project transaction result page expected transactionId "${transactionId}"; received ${JSON.stringify(value.transactionId)}.`
+    );
+  }
+  if (!isObjectRecord2(value.assignments)) {
+    throw new Error(
+      `Project transaction "${transactionId}" result page assignments must be an object.`
+    );
+  }
+  const assignments = {};
+  for (const [pendingId2, assignedId] of Object.entries(value.assignments)) {
+    if (typeof assignedId !== "string") {
+      throw new Error(
+        `Project transaction "${transactionId}" result assignment ${JSON.stringify(pendingId2)} must be a string.`
+      );
+    }
+    assignments[pendingId2] = assignedId;
+  }
+  if (!Array.isArray(value.changedRecords)) {
+    throw new Error(
+      `Project transaction "${transactionId}" result page changedRecords must be an array.`
+    );
+  }
+  const continueCursor = readNullableString(
+    value.continueCursor,
+    `Project transaction "${transactionId}" result page continueCursor`
+  );
+  if (typeof value.isDone !== "boolean") {
+    throw new Error(
+      `Project transaction "${transactionId}" result page isDone must be a boolean.`
+    );
+  }
+  return {
+    transactionId,
+    assignments,
+    changedRecords: value.changedRecords,
+    continueCursor,
+    isDone: value.isDone
+  };
+}
+function readCount(value, field) {
+  if (typeof value !== "number") {
+    throw new Error(`${field} must be a number.`);
+  }
+  if (!Number.isSafeInteger(value)) {
+    throw new Error(`${field} must be a safe integer.`);
+  }
+  if (value < 0) {
+    throw new Error(`${field} must not be negative.`);
+  }
+  return value;
+}
+function readNullableCount(value, field) {
+  if (value === null) return null;
+  return readCount(value, field);
+}
+function readNullableString(value, field) {
+  if (value === null) return null;
+  if (typeof value !== "string") {
+    throw new Error(`${field} must be a string or null.`);
+  }
+  return value;
+}
+function isProjectVersionTransactionCommitStatus(value) {
+  return value === "preparing" || value === "waiting" || value === "queued" || value === "applying" || value === "reverting" || value === "committed" || value === "failed";
+}
+function createPushProgressReporter(json) {
+  const animated = process.stdout.isTTY === true && !json;
+  const indicator = animated ? spinner("Pushing\u2026") : null;
+  let lastStructuredEvent = "";
+  return {
+    report(event) {
+      if (indicator !== null) {
+        indicator.update(projectTransactionProgressLabel(event));
+        return;
+      }
+      const encoded = JSON.stringify(event);
+      if (encoded === lastStructuredEvent) return;
+      lastStructuredEvent = encoded;
+      console.log(encoded);
+    },
+    stop() {
+      indicator?.stop();
+    }
+  };
+}
+function projectTransactionProgressLabel(event) {
+  if (event.phase === "submitting") return "Pushing\u2026";
+  if (event.phase === "preparing") return "Preparing push\u2026";
+  if (event.phase === "waiting") return "Waiting to apply project transaction\u2026";
+  if (event.phase === "reverting") return "Reverting project transaction\u2026";
+  if (event.phase === "finalizing") return "Finalizing project transaction\u2026";
+  if (event.phase === "committed") return "Push complete.";
+  if (event.phase === "failed") return "Project transaction failed.";
+  if (event.phase === "interrupted")
+    return "Project transaction still running.";
+  if (event.totalChangeCount !== null && event.appliedChangeCount < event.totalChangeCount) {
+    return `Applying project transaction\u2026 ${event.appliedChangeCount.toLocaleString("en-US")}/${event.totalChangeCount.toLocaleString("en-US")} changes`;
+  }
+  if (event.totalChunkCount !== null && event.appliedChunkCount < event.totalChunkCount) {
+    return `Applying project transaction\u2026 ${event.appliedChunkCount.toLocaleString("en-US")}/${event.totalChunkCount.toLocaleString("en-US")} chunks`;
+  }
+  return "Finalizing project transaction\u2026";
+}
+function progressEventFromAccepted(accepted) {
+  return {
+    type: "project-transaction-progress",
+    transactionId: accepted.transactionId,
+    phase: accepted.commitStatus,
+    totalChangeCount: accepted.totalChangeCount,
+    appliedChangeCount: accepted.appliedChangeCount,
+    totalChunkCount: accepted.totalChunkCount,
+    appliedChunkCount: accepted.appliedChunkCount,
+    errorCode: null,
+    errorMessage: null
+  };
+}
+function progressEventFromStatus(status) {
+  const phase = status.commitStatus === "committed" || status.commitStatus === "applying" && status.totalChunkCount !== null && status.appliedChunkCount === status.totalChunkCount ? "finalizing" : status.commitStatus;
+  return {
+    type: "project-transaction-progress",
+    transactionId: status.transactionId,
+    phase,
+    totalChangeCount: status.totalChangeCount,
+    appliedChangeCount: status.appliedChangeCount,
+    totalChunkCount: status.totalChunkCount,
+    appliedChunkCount: status.appliedChunkCount,
+    errorCode: status.errorCode,
+    errorMessage: status.errorMessage
+  };
+}
+async function waitForAcceptedProjectVersionTransaction(args) {
+  const { client, projectId, versionId, accepted, reporter } = args;
+  const transactionPath = `/api/projects/${projectId}/versions/${versionId}/schema/transactions/${accepted.transactionId}`;
+  const controller = new AbortController();
+  let interrupted = false;
+  const interrupt = () => {
+    interrupted = true;
+    controller.abort();
+  };
+  process.once("SIGINT", interrupt);
+  reporter.report(progressEventFromAccepted(accepted));
+  let pollIndex = 0;
+  try {
+    for (; ; ) {
+      const rawStatus = await client.get(transactionPath, {
+        signal: controller.signal
+      });
+      const status = readProjectVersionTransactionStatus(
+        rawStatus,
+        accepted.transactionId
+      );
+      reporter.report(progressEventFromStatus(status));
+      if (status.commitStatus === "committed") {
+        return await downloadProjectVersionTransactionResult({
+          client,
+          transactionPath,
+          transactionId: accepted.transactionId,
+          status,
+          signal: controller.signal
+        });
+      }
+      if (status.commitStatus === "failed") {
+        throw new ProjectTransactionFailedError(status);
+      }
+      const delay = PROJECT_TRANSACTION_POLL_DELAYS_MS[Math.min(pollIndex, PROJECT_TRANSACTION_POLL_DELAYS_MS.length - 1)];
+      pollIndex += 1;
+      await waitForPollDelay(delay, controller.signal);
+    }
+  } catch (error) {
+    if (interrupted) {
+      throw new ProjectTransactionInterruptedError(accepted.transactionId);
+    }
+    throw error;
+  } finally {
+    process.removeListener("SIGINT", interrupt);
+  }
+}
+async function waitForPollDelay(delayMs, signal) {
+  if (signal.aborted) {
+    throw new Error("Project transaction polling was interrupted.");
+  }
+  await new Promise((resolve4, reject) => {
+    const aborted = () => {
+      clearTimeout(timer);
+      reject(new Error("Project transaction polling was interrupted."));
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", aborted);
+      resolve4();
+    }, delayMs);
+    signal.addEventListener("abort", aborted, { once: true });
+  });
+}
+async function downloadProjectVersionTransactionResult(args) {
+  const assignments = {};
+  const changedRecords = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor = args.status.resultCursor ?? "";
+  for (; ; ) {
+    if (seenCursors.has(cursor)) {
+      throw new Error(
+        `Project transaction "${args.transactionId}" result pagination repeated cursor ${JSON.stringify(cursor)}.`
+      );
+    }
+    seenCursors.add(cursor);
+    const query = new URLSearchParams({ cursor });
+    const rawPage = await args.client.get(
+      `${args.transactionPath}/results?${query.toString()}`,
+      { signal: args.signal }
+    );
+    const page = readProjectVersionTransactionResultPage(
+      rawPage,
+      args.transactionId
+    );
+    for (const [pendingId2, assignedId] of Object.entries(page.assignments)) {
+      const existing = assignments[pendingId2];
+      if (existing !== void 0 && existing !== assignedId) {
+        throw new Error(
+          `Project transaction "${args.transactionId}" returned conflicting assignments for ${JSON.stringify(pendingId2)}.`
+        );
+      }
+      assignments[pendingId2] = assignedId;
+    }
+    changedRecords.push(...page.changedRecords);
+    if (page.isDone) {
+      return {
+        kind: "committed",
+        transactionId: args.transactionId,
+        totalChangeCount: args.status.totalChangeCount ?? changedRecords.length,
+        totalChunkCount: args.status.totalChunkCount ?? 0,
+        assignments,
+        changedRecords
+      };
+    }
+    if (page.continueCursor === null) {
+      throw new Error(
+        `Project transaction "${args.transactionId}" result page is not done but has no continueCursor.`
+      );
+    }
+    cursor = page.continueCursor;
+  }
+}
 async function runPush(workspace, options) {
   const status = computeWorkspaceStatus(workspace);
   if (status.conflictedFiles.length > 0) {
@@ -61717,7 +62250,19 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     binaryChanges: status.binaryChanges ?? []
   });
   if (status.changes.length === 0) {
-    console.log("Nothing to push \u2014 working copy is clean.");
+    if (options.json === true) {
+      console.log(
+        JSON.stringify({
+          type: "push-plan",
+          dryRun: options.dryRun,
+          changeCount: 0,
+          staticValueSeedCount: 0,
+          changes: []
+        })
+      );
+    } else {
+      console.log("Nothing to push \u2014 working copy is clean.");
+    }
     return;
   }
   prepareNSPropertySetterChanges(workspace, status);
@@ -61763,23 +62308,42 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
       change.nextData = { ...change.nextData, updatedAt: now };
     }
   }
-  console.log(
-    `${options.dryRun ? "Would push" : "Pushing"} ${color.bold(String(status.changes.length))} change(s):`
-  );
-  for (const change of status.changes) {
+  if (options.json === true) {
     console.log(
-      `  ${paintChangeKind(change.kind)} ${describeChange(change).replace(`${change.kind} `, "")}`
+      JSON.stringify({
+        type: "push-plan",
+        dryRun: options.dryRun,
+        changeCount: status.changes.length,
+        staticValueSeedCount: status.staticValueSeeds.size,
+        changes: status.changes.map((change) => ({
+          kind: change.kind,
+          recordKind: change.recordKind,
+          recordId: change.recordId
+        }))
+      })
     );
-    if (change.kind === "update") {
-      for (const line of summarizeFieldDiff(change.baseData, change.nextData)) {
-        console.log(color.dim(`  ${line}`));
-      }
-    }
-  }
-  if (status.staticValueSeeds.size > 0) {
+  } else {
     console.log(
-      `  ${color.dim(`create ${status.staticValueSeeds.size} static value seed(s)`)}`
+      `${options.dryRun ? "Would push" : "Pushing"} ${color.bold(String(status.changes.length))} change(s):`
     );
+    for (const change of status.changes) {
+      console.log(
+        `  ${paintChangeKind(change.kind)} ${describeChange(change).replace(`${change.kind} `, "")}`
+      );
+      if (change.kind === "update") {
+        for (const line of summarizeFieldDiff(
+          change.baseData,
+          change.nextData
+        )) {
+          console.log(color.dim(`  ${line}`));
+        }
+      }
+    }
+    if (status.staticValueSeeds.size > 0) {
+      console.log(
+        `  ${color.dim(`create ${status.staticValueSeeds.size} member value seed(s)`)}`
+      );
+    }
   }
   if (options.dryRun) return;
   if (isInteractive() && !await promptConfirm({
@@ -61843,12 +62407,131 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     },
     force ? { "x-neo-force-project-version-write": "true" } : void 0
   );
-  const pushing = spinner("Pushing\u2026");
+  const finishCommitResponse = async (response, reporter) => {
+    let accepted;
+    try {
+      accepted = readAcceptedProjectVersionCommitResponse(response);
+    } catch (error) {
+      reporter.stop();
+      throw error;
+    }
+    if (accepted === null) {
+      try {
+        applyPushResult(workspace, response);
+      } catch (error) {
+        reporter.stop();
+        throw error;
+      }
+      reporter.report({
+        type: "project-transaction-progress",
+        transactionId: immediateTransactionId(response),
+        phase: "committed",
+        totalChangeCount: status.changes.length,
+        appliedChangeCount: status.changes.length,
+        totalChunkCount: null,
+        appliedChunkCount: 0,
+        errorCode: null,
+        errorMessage: null
+      });
+      reporter.stop();
+      if (options.json !== true) success("Push complete.");
+      return true;
+    }
+    let completed;
+    try {
+      completed = await waitForAcceptedProjectVersionTransaction({
+        client,
+        projectId: workspace.config.projectId,
+        versionId: workspace.config.versionId,
+        accepted,
+        reporter
+      });
+    } catch (error) {
+      if (error instanceof ProjectTransactionInterruptedError) {
+        reporter.report({
+          type: "project-transaction-progress",
+          transactionId: error.transactionId,
+          phase: "interrupted",
+          totalChangeCount: accepted.totalChangeCount,
+          appliedChangeCount: accepted.appliedChangeCount,
+          totalChunkCount: accepted.totalChunkCount,
+          appliedChunkCount: accepted.appliedChunkCount,
+          errorCode: null,
+          errorMessage: error.message
+        });
+        reporter.stop();
+        if (options.json !== true) console.error(error.message);
+        process.exitCode = 130;
+        return false;
+      }
+      if (error instanceof ProjectTransactionFailedError) {
+        const failed = error.status;
+        reporter.report({
+          type: "project-transaction-progress",
+          transactionId: failed.transactionId,
+          phase: "failed",
+          totalChangeCount: failed.totalChangeCount,
+          appliedChangeCount: failed.appliedChangeCount,
+          totalChunkCount: failed.totalChunkCount,
+          appliedChunkCount: failed.appliedChunkCount,
+          errorCode: failed.errorCode,
+          errorMessage: error.message
+        });
+        reporter.stop();
+        if (options.json !== true) {
+          console.error(
+            `Push failed (${failed.errorCode ?? "project-transaction-failed"}, transaction ${failed.transactionId}): ${error.message}`
+          );
+        }
+        process.exitCode = 1;
+        return false;
+      }
+      reporter.stop();
+      throw error;
+    }
+    try {
+      applyCommittedProjectTransactionResult({
+        workspace,
+        result: completed,
+        submittedChanges: status.changes,
+        candidateAssignments: pendingAssignment.assigned
+      });
+    } catch (error) {
+      reporter.stop();
+      throw error;
+    }
+    reporter.report({
+      type: "project-transaction-progress",
+      transactionId: completed.transactionId,
+      phase: "committed",
+      totalChangeCount: completed.totalChangeCount,
+      appliedChangeCount: completed.totalChangeCount,
+      totalChunkCount: completed.totalChunkCount,
+      appliedChunkCount: completed.totalChunkCount,
+      errorCode: null,
+      errorMessage: null
+    });
+    reporter.stop();
+    if (options.json !== true) success("Push complete.");
+    return true;
+  };
+  let progress = createPushProgressReporter(options.json === true);
+  progress.report({
+    type: "project-transaction-progress",
+    transactionId: null,
+    phase: "submitting",
+    totalChangeCount: status.changes.length,
+    appliedChangeCount: 0,
+    totalChunkCount: null,
+    appliedChunkCount: 0,
+    errorCode: null,
+    errorMessage: null
+  });
   let result;
   try {
     result = await commit(options.acceptBump);
   } catch (error) {
-    pushing.stop();
+    progress.stop();
     if (!(error instanceof NeoApiError)) throw error;
     const rejection = error.body;
     if (isInteractive() && !options.acceptBump && isObjectRecord2(rejection) && rejection.error === "version-bump-required") {
@@ -61864,7 +62547,18 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
         message: "Accept the bump and push?",
         fallback: false
       })) {
-        const retrying = spinner("Pushing (bump accepted)\u2026");
+        progress = createPushProgressReporter(options.json === true);
+        progress.report({
+          type: "project-transaction-progress",
+          transactionId: null,
+          phase: "submitting",
+          totalChangeCount: status.changes.length,
+          appliedChangeCount: 0,
+          totalChunkCount: null,
+          appliedChunkCount: 0,
+          errorCode: null,
+          errorMessage: null
+        });
         try {
           stagedFiles = await stageProjectFilePushesV4({
             workspace,
@@ -61875,7 +62569,7 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
           });
           result = await commit(true);
         } catch (retryError) {
-          retrying.stop();
+          progress.stop();
           if (retryError instanceof NeoApiError) {
             reportPushRejection(retryError.body);
             process.exitCode = 1;
@@ -61883,9 +62577,7 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
           }
           throw retryError;
         }
-        retrying.stop();
-        applyPushResult(workspace, result);
-        success("Push complete.");
+        await finishCommitResponse(result, progress);
         return;
       }
       console.log("Push cancelled.");
@@ -61896,9 +62588,7 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     process.exitCode = 1;
     return;
   }
-  pushing.stop();
-  applyPushResult(workspace, result);
-  success("Push complete.");
+  await finishCommitResponse(result, progress);
 }
 async function createPendingProjectSourceBundleV4(workspace, status, staticValueSeeds) {
   const records2 = /* @__PURE__ */ new Map();
@@ -62045,52 +62735,298 @@ function reportPushRejection(body) {
   }
   console.error(`Push rejected (409): ${JSON.stringify(body)}`);
 }
-function applyPushResult(workspace, result) {
-  if (!isObjectRecord2(result) || !Array.isArray(result.changedRecords)) {
-    throw new Error("Transaction response is missing changedRecords.");
+function immediateTransactionId(result) {
+  if (!isObjectRecord2(result)) return null;
+  if (typeof result.transactionId === "string") return result.transactionId;
+  if (!isObjectRecord2(result.transaction)) return null;
+  return typeof result.transaction.id === "string" ? result.transaction.id : null;
+}
+function applyCommittedProjectTransactionResult(args) {
+  const { workspace, result, submittedChanges, candidateAssignments } = args;
+  const localStatus = computeWorkspaceStatus(workspace);
+  const blockingErrors = localStatus.parseErrors.filter(
+    isBlockingSchemaSourceError
+  );
+  if (blockingErrors.length > 0) {
+    throw new Error(
+      `Project transaction "${result.transactionId}" committed, but its result cannot be applied while the working copy has parse errors. Fix the source and run the same neo push again:
+${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
+    );
+  }
+  if (localStatus.conflictedFiles.length > 0) {
+    throw new Error(
+      `Project transaction "${result.transactionId}" committed, but its result cannot be applied while conflict markers remain in ${localStatus.conflictedFiles.join(", ")}. Resolve them and run the same neo push again.`
+    );
+  }
+  const replacements = projectTransactionResultReplacements(
+    candidateAssignments,
+    result.assignments
+  );
+  const localRecords = rewriteReconstructedRecords(
+    localStatus.reconstructed,
+    replacements
+  );
+  const submittedByKey = /* @__PURE__ */ new Map();
+  for (const change of submittedChanges) {
+    if (change.nextData === void 0) continue;
+    const recordId = rewriteAssignedString(change.recordId, replacements);
+    const nextData = rewriteAssignedValue(change.nextData, replacements);
+    if (!isObjectRecord2(nextData)) {
+      throw new Error(
+        `Submitted ${change.recordKind} "${recordId}" did not rewrite to an object.`
+      );
+    }
+    submittedByKey.set(recordStateKey(change.recordKind, recordId), nextData);
   }
+  const previousRecords = workspace.state.records;
+  const nextRecords = foldChangedRecords(
+    previousRecords,
+    result.changedRecords
+  );
+  const changedKeys = /* @__PURE__ */ new Set();
   for (const changed of result.changedRecords) {
-    if (!isObjectRecord2(changed)) {
-      throw new Error("Transaction changedRecords entries must be objects.");
+    const identity2 = readChangedRecordIdentity(changed);
+    changedKeys.add(recordStateKey(identity2.recordKind, identity2.recordId));
+  }
+  const emitRecords = /* @__PURE__ */ new Map();
+  for (const [key, state] of Object.entries(nextRecords)) {
+    const prior = previousRecords[key];
+    const local = localRecords.get(key);
+    if (local === void 0 && prior?.file !== void 0) continue;
+    const submitted = submittedByKey.get(key);
+    const emitData = local === void 0 ? state.data : changedKeys.has(key) && submitted !== void 0 ? mergeCommittedRecordWithLaterLocalEdits(
+      state.recordKind,
+      submitted,
+      state.data,
+      local.fullData
+    ) : local.fullData;
+    emitRecords.set(key, {
+      recordKind: state.recordKind,
+      recordId: state.recordId,
+      contentHash: state.contentHash,
+      deleted: false,
+      data: emitData
+    });
+  }
+  for (const [key, local] of localRecords) {
+    if (emitRecords.has(key)) continue;
+    if (changedKeys.has(key)) continue;
+    emitRecords.set(key, {
+      recordKind: local.recordKind,
+      recordId: local.recordId,
+      contentHash: "",
+      deleted: false,
+      data: local.fullData
+    });
+  }
+  const previousState = workspace.state;
+  workspace.state = { ...previousState, records: nextRecords };
+  try {
+    rewriteFilesFromState(workspace, emitRecords);
+    writeWorkspaceState(workspace.root, workspace.state);
+  } catch (error) {
+    workspace.state = previousState;
+    throw error;
+  }
+}
+function projectTransactionResultReplacements(candidateAssignments, resultAssignments) {
+  const replacements = /* @__PURE__ */ new Map();
+  for (const [pendingId2, assignedId] of Object.entries(resultAssignments)) {
+    replacements.set(pendingId2, assignedId);
+    const candidateId = candidateAssignments.get(pendingId2);
+    if (candidateId !== void 0) replacements.set(candidateId, assignedId);
+  }
+  return {
+    exact: replacements,
+    embedded: [...replacements].sort(
+      ([left], [right]) => right.length - left.length
+    )
+  };
+}
+function rewriteReconstructedRecords(records2, replacements) {
+  const rewritten = /* @__PURE__ */ new Map();
+  for (const record3 of records2.values()) {
+    const recordId = rewriteAssignedString(record3.recordId, replacements);
+    const fileFields = rewriteAssignedValue(record3.fileFields, replacements);
+    if (!isObjectRecord2(fileFields)) {
+      throw new Error(
+        `Local ${record3.recordKind} "${recordId}" file fields did not rewrite to an object.`
+      );
+    }
+    const fullData = rewriteAssignedValue(record3.fullData, replacements);
+    if (!isObjectRecord2(fullData)) {
+      throw new Error(
+        `Local ${record3.recordKind} "${recordId}" full data did not rewrite to an object.`
+      );
+    }
+    const key = recordStateKey(record3.recordKind, recordId);
+    if (rewritten.has(key)) {
+      throw new Error(
+        `Project transaction assignments collapse multiple local records onto "${key}".`
+      );
+    }
+    rewritten.set(key, { ...record3, recordId, fileFields, fullData });
+  }
+  return rewritten;
+}
+function rewriteAssignedString(value, replacements) {
+  const exact = replacements.exact.get(value);
+  if (exact !== void 0) return exact;
+  let result = value;
+  for (const [source, target] of replacements.embedded) {
+    if (result.includes(source)) result = result.replaceAll(source, target);
+  }
+  return result;
+}
+function rewriteAssignedValue(value, replacements) {
+  if (typeof value === "string") {
+    return rewriteAssignedString(value, replacements);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => rewriteAssignedValue(entry, replacements));
+  }
+  if (!isObjectRecord2(value)) return value;
+  const rewritten = {};
+  for (const [key, entry] of Object.entries(value)) {
+    rewritten[rewriteAssignedString(key, replacements)] = rewriteAssignedValue(
+      entry,
+      replacements
+    );
+  }
+  return rewritten;
+}
+function mergeCommittedRecordWithLaterLocalEdits(recordKind, submitted, committed, local) {
+  if (!isObjectRecord2(committed)) return local;
+  if (isSchemaDocumentRecordKind(recordKind)) {
+    if (schemaDocumentAuthoredSemanticallyEqual(recordKind, submitted, local)) {
+      return committed;
     }
-    const recordKind = changed.recordKind;
-    const recordId = changed.recordId;
-    if (typeof recordKind !== "string" || typeof recordId !== "string") {
-      throw new Error("Changed record is missing recordKind/recordId.");
+    const merged2 = mergeSchemaDocumentRecord(
+      recordKind,
+      submitted,
+      committed,
+      local
+    );
+    return merged2.conflictFields.length === 0 ? merged2.merged : local;
+  }
+  const comparison = {
+    base: sourceComparableRecordForPush(recordKind, submitted),
+    server: sourceComparableRecordForPush(recordKind, committed),
+    local: sourceComparableRecordForPush(recordKind, local)
+  };
+  if (canonicallyEqual(comparison.base, comparison.local)) return committed;
+  const merged = threeWayMergeRecord(submitted, committed, local, {
+    comparison,
+    serverWinsFields: /* @__PURE__ */ new Set([
+      "projectId",
+      "createdAt",
+      "updatedAt",
+      "getter",
+      "setter",
+      "action",
+      "layout"
+    ]),
+    recursive: true
+  });
+  return merged.conflictFields.length === 0 ? merged.merged : local;
+}
+function sourceComparableRecordForPush(recordKind, value) {
+  const result = {};
+  const hasAuthoredCode = typeof value.code === "string" || typeof value.setterCode === "string";
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "projectId" || key === "createdAt" || key === "updatedAt") {
+      continue;
     }
+    if (recordKind === "dialogue-node" && key === "layout") continue;
+    if (hasAuthoredCode && (key === "getter" || key === "setter" || key === "action")) {
+      continue;
+    }
+    result[key] = sourceComparableValueForPush(recordKind, entry);
+  }
+  return result;
+}
+function sourceComparableValueForPush(recordKind, value) {
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => sourceComparableValueForPush(recordKind, entry)
+    );
+  }
+  if (!isObjectRecord2(value)) return value;
+  return sourceComparableRecordForPush(recordKind, value);
+}
+function readChangedRecordIdentity(changed) {
+  if (!isObjectRecord2(changed)) {
+    throw new Error("Transaction changedRecords entries must be objects.");
+  }
+  if (typeof changed.recordKind !== "string") {
+    throw new Error(
+      "Changed record is missing recordKind/recordId: recordKind is not a string."
+    );
+  }
+  if (typeof changed.recordId !== "string") {
+    throw new Error(
+      "Changed record is missing recordKind/recordId: recordId is not a string."
+    );
+  }
+  return { recordKind: changed.recordKind, recordId: changed.recordId };
+}
+function foldChangedRecords(previous, changedRecords) {
+  const records2 = { ...previous };
+  for (const changed of changedRecords) {
+    const { recordKind, recordId } = readChangedRecordIdentity(changed);
     const key = recordStateKey(recordKind, recordId);
+    if (!isObjectRecord2(changed)) {
+      throw new Error(`Changed record "${key}" must be an object.`);
+    }
     if (changed.deleted === true) {
-      delete workspace.state.records[key];
+      delete records2[key];
       continue;
     }
     const snapshot = changed.snapshot;
-    if (!isObjectRecord2(snapshot) || typeof snapshot.contentHash !== "string") {
+    if (!isObjectRecord2(snapshot)) {
+      throw new Error(
+        `Changed record "${key}" response is missing its snapshot.`
+      );
+    }
+    if (typeof snapshot.contentHash !== "string") {
       throw new Error(
         `Changed record "${key}" response is missing its snapshot content hash.`
       );
     }
-    workspace.state.records[key] = {
+    records2[key] = {
       recordKind,
       recordId,
       contentHash: snapshot.contentHash,
       data: changed.data,
-      file: workspace.state.records[key]?.file
+      file: records2[key]?.file,
+      projectBinary: records2[key]?.projectBinary
     };
   }
+  return records2;
+}
+function applyPushResult(workspace, result) {
+  if (!isObjectRecord2(result) || !Array.isArray(result.changedRecords)) {
+    throw new Error("Transaction response is missing changedRecords.");
+  }
+  workspace.state.records = foldChangedRecords(
+    workspace.state.records,
+    result.changedRecords
+  );
   rewriteFilesFromState(workspace);
   writeWorkspaceState(workspace.root, workspace.state);
 }
-function rewriteFilesFromState(workspace) {
-  const records2 = /* @__PURE__ */ new Map();
-  for (const [key, recordState] of Object.entries(workspace.state.records)) {
-    records2.set(key, {
+function rewriteFilesFromState(workspace, records2 = new Map(
+  Object.entries(workspace.state.records).map(([key, recordState]) => [
+    key,
+    {
       recordKind: recordState.recordKind,
       recordId: recordState.recordId,
       contentHash: recordState.contentHash,
       deleted: false,
       data: recordState.data
-    });
-  }
+    }
+  ])
+)) {
   const result = emitProjectDocumentFilesV4(records2);
   writeProjectSourceAnalysisCacheV4(workspace.root, result.analysis);
   const emittedPaths = new Set(result.files.map((file) => file.path));
@@ -62571,7 +63507,7 @@ function compileMigrationAction(schema, migrationData) {
     migrationContext: true
   });
 }
-var compileNSAction2, compileNSFunction2, compileNSGetter2, compileNSSetter2, createProjectVersionIntent2, isKnownProjectVersionIntentType2;
+var compileNSAction2, compileNSFunction2, compileNSGetter2, compileNSSetter2, createProjectVersionIntent2, isKnownProjectVersionIntentType2, ProjectTransactionInterruptedError, ProjectTransactionFailedError, PROJECT_TRANSACTION_POLL_DELAYS_MS;
 var init_push = __esm({
   "src/commands/push.ts"() {
     "use strict";
@@ -62588,8 +63524,38 @@ var init_push = __esm({
     init_source_diagnostics();
     init_projection();
     init_project_file_push();
+    init_project_manifest();
+    init_merge();
     ({ compileNSAction: compileNSAction2, compileNSFunction: compileNSFunction2, compileNSGetter: compileNSGetter2, compileNSSetter: compileNSSetter2 } = compiler_adapter_exports);
     ({ createProjectVersionIntent: createProjectVersionIntent2, isKnownProjectVersionIntentType: isKnownProjectVersionIntentType2 } = project_version_intents_exports);
+    ProjectTransactionInterruptedError = class extends Error {
+      constructor(transactionId) {
+        super(
+          `Project transaction "${transactionId}" is still running. Run the same neo push again to reconnect.`
+        );
+        this.transactionId = transactionId;
+        this.name = "ProjectTransactionInterruptedError";
+      }
+      transactionId;
+    };
+    ProjectTransactionFailedError = class extends Error {
+      constructor(status) {
+        super(
+          status.errorMessage ?? `Project transaction "${status.transactionId}" failed after rollback.`
+        );
+        this.status = status;
+        this.name = "ProjectTransactionFailedError";
+      }
+      status;
+    };
+    PROJECT_TRANSACTION_POLL_DELAYS_MS = [
+      250,
+      500,
+      1e3,
+      2e3,
+      4e3,
+      5e3
+    ];
   }
 });
 
@@ -63329,7 +64295,7 @@ ${h("Start")}
   whoami    ${d("[--api <url>]")}
 
 ${h("Working copy")}
-  pull      ${d("[--force|--reset] [--regenerate-source-names]")}  push ${d("[--dry-run] [--summary <text>] [--accept-bump]")}
+  pull      ${d("[--force|--reset] [--regenerate-source-names]")}  push ${d("[--dry-run] [--summary <text>] [--accept-bump] [--json]")}
   status    ${d("[--json]")}                  diff    ${d("[--json]")}
   dev       ${d("[--push]")}                  resolve ${d("[--mine|--theirs]")}
   doctor    ${d("[--json]")}                  ${d("validate format/compiler/editor/source/file contracts")}
@@ -63379,16 +64345,18 @@ and tracked project binary from the authoritative server records.
     return `${h("neo push")} \u2014 commit the working copy to the server
 
 ${h("Usage")}
-  neo push ${d("[--dry-run] [--summary <text>] [--accept-bump]")}
+  neo push ${d("[--dry-run] [--summary <text>] [--accept-bump] [--json]")}
 
 ${h("Flags")}
   --dry-run         ${d("Preview the change set; commit nothing.")}
   --summary <text>  ${d("Attach a summary message to the transaction.")}
   --accept-bump     ${d("Accept a server-required version bump instead of aborting.")}
+  --json            ${d("Emit machine-readable plan and transaction progress events.")}
 
-Push sends the ${h("entire")} working copy as one atomic compare-and-swap
-transaction. Run ${h("neo status")} / ${h("neo diff")} first \u2014 local-ahead changes
-you did not make this session ride along too.
+Push sends the ${h("entire")} working copy as one compare-and-swap logical
+transaction. Large pushes continue as a durable server job; rerun the identical
+push to reconnect if the terminal closes. Run ${h("neo status")} / ${h("neo diff")}
+first \u2014 local-ahead changes you did not make this session ride along too.
 `;
   }
   if (command === "script") {
@@ -63880,7 +64848,8 @@ async function main() {
       await runPush2(workspace, {
         dryRun: boolFlag(args, "dry-run"),
         summary: stringFlag(args, "summary"),
-        acceptBump: boolFlag(args, "accept-bump")
+        acceptBump: boolFlag(args, "accept-bump"),
+        json: boolFlag(args, "json")
       });
       return;
     }