@neocompose/cli 0.50.7 → 0.50.8

package/dist/neo.mjs

@@ -41,6 +41,31 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/performance.ts
+function startPerformanceSpan(phase, fields = {}) {
+  if (process.env.NEO_COMPOSE_TRACE_PERFORMANCE !== "1") return () => {
+  };
+  const started = performance.now();
+  return () => recordPerformance(phase, performance.now() - started, fields);
+}
+function recordPerformance(phase, durationMs, fields = {}) {
+  if (process.env.NEO_COMPOSE_TRACE_PERFORMANCE !== "1") return;
+  console.error(
+    JSON.stringify({
+      type: "neo-performance",
+      phase,
+      ...fields,
+      startedMs: Math.round(performance.now() - durationMs),
+      durationMs: Math.round(durationMs)
+    })
+  );
+}
+var init_performance = __esm({
+  "src/performance.ts"() {
+    "use strict";
+  }
+});
+
 // src/project-source/workspace-source-path.ts
 import { existsSync, lstatSync, realpathSync } from "node:fs";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
@@ -34757,7 +34782,9 @@ __export(token_store_exports, {
   keychainAccount: () => keychainAccount,
   loadCredential: () => loadCredential,
   loadToken: () => loadToken,
-  saveCredential: () => saveCredential
+  loadTrustedConvexSite: () => loadTrustedConvexSite,
+  saveCredential: () => saveCredential,
+  saveTrustedConvexSite: () => saveTrustedConvexSite
 });
 import {
   chmodSync,
@@ -34884,6 +34911,22 @@ function loadCredential(apiBaseUrl) {
   const file = readCredentialsFile();
   return file.credentials[apiBaseUrl] ?? null;
 }
+function loadTrustedConvexSite(apiBaseUrl) {
+  return readCredentialsFile().convexSites?.[apiBaseUrl] ?? null;
+}
+function saveTrustedConvexSite(apiBaseUrl, siteUrl) {
+  const file = readCredentialsFile();
+  file.convexSites ??= {};
+  file.convexSites[apiBaseUrl] = siteUrl;
+  mkdirSync2(credentialsDir(), { recursive: true, mode: 448 });
+  const path = credentialsPath();
+  writeFileSync2(path, `${JSON.stringify(file, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  chmodSync(path, 384);
+}
 function deleteCredential(apiBaseUrl) {
   const account = keychainAccount(apiBaseUrl);
   const fromKeychain = keychainGet(account);
@@ -34892,11 +34935,12 @@ function deleteCredential(apiBaseUrl) {
   const token = fromKeychain ?? (fileEntry !== void 0 && fileEntry.token !== "" ? fileEntry.token : null);
   const deletedKeychainEntry = keychainDelete(account);
   let deletedFileEntry = false;
-  if (fileEntry !== void 0) {
+  if (fileEntry !== void 0 || file.convexSites?.[apiBaseUrl] !== void 0) {
     delete file.credentials[apiBaseUrl];
-    deletedFileEntry = true;
+    if (file.convexSites !== void 0) delete file.convexSites[apiBaseUrl];
+    deletedFileEntry = fileEntry !== void 0;
     const path = credentialsPath();
-    if (Object.keys(file.credentials).length === 0) {
+    if (Object.keys(file.credentials).length === 0 && Object.keys(file.convexSites ?? {}).length === 0) {
       rmSync(path, { force: true });
     } else {
       writeFileSync2(path, `${JSON.stringify(file, null, 2)}
@@ -82365,25 +82409,66 @@ function resolvedStoredInstanceRows(args) {
   const rows = new Map(document.values.map((row) => [row.id, row]));
   const materializedIndex = buildVirtualInstanceMaterializedIndex({ document });
   const queue = [{ root: args.instanceRoot, member: args.rootMember }];
+  const visitedArguments = /* @__PURE__ */ new Set();
+  const argumentRoots = (row) => {
+    const roots = [];
+    const collectArgument = (valueId, type) => {
+      if (visitedArguments.has(valueId)) return;
+      const row2 = materializedIndex.rowsById.get(valueId);
+      if (row2 === void 0) return;
+      visitedArguments.add(valueId);
+      if (type.type === 7 /* Class */ || type.type === 22 /* Interface */) {
+        const classId = row2.classId ?? (type.type === 7 /* Class */ ? type.classId : void 0);
+        if (classId === void 0) return;
+        roots.push({
+          root: row2,
+          member: {
+            name: "Constructor argument",
+            kind: 7 /* Class */,
+            classId,
+            requirement: 1 /* Required */
+          }
+        });
+      } else if (type.type === 6 /* List */) {
+        const children = materializedIndex.unorderedEntryIdsByContainerId.get(valueId);
+        for (const childId of children ?? (Array.isArray(row2.value) ? row2.value : [])) {
+          if (typeof childId === "string")
+            collectArgument(childId, type.entryTypeInfo);
+        }
+      } else if (type.type === 5 /* Dictionary */) {
+        for (const childId of Object.values(stringRecord2(row2.value)))
+          collectArgument(childId, type.entryTypeInfo);
+      }
+    };
+    for (const edge of materializedIndex.graph.constructorEdges(row)) {
+      collectArgument(edge.targetValueId, edge.typeInfo);
+    }
+    return roots;
+  };
   const stored = indexExpansion({
     document,
     instanceRoot: args.instanceRoot,
     rootMember: args.rootMember,
     expandedRoot: rows.get(args.instanceRoot.id) ?? args.instanceRoot,
-    expandedRows: document.values
+    expandedRows: document.values,
+    additionalRoots: argumentRoots
   });
-  for (const node of stored.nodesByPath.values()) {
-    if (node.expandedRow.id === args.instanceRoot.id) continue;
-    if (!isMemberClassBase(node.member)) continue;
-    if (!isStoredClassResolutionRoot(node.expandedRow)) continue;
-    queue.push({ root: node.expandedRow, member: node.member });
-  }
+  const enqueueStoredRoots = (nodes) => {
+    for (const node of nodes) {
+      if (node.expandedRow.id === args.instanceRoot.id) continue;
+      if (!isMemberClassBase(node.member)) continue;
+      if (!isStoredClassResolutionRoot(node.expandedRow)) continue;
+      queue.push({ root: node.expandedRow, member: node.member });
+    }
+  };
+  enqueueStoredRoots(stored.nodesByPath.values());
   const resolvedRootIds = /* @__PURE__ */ new Set();
   const resolvedFrameByValueId = /* @__PURE__ */ new Map();
-  while (queue.length > 0) {
-    const next = queue.shift();
+  for (let index = 0; index < queue.length; index += 1) {
+    const next = queue[index];
     if (next === void 0 || resolvedRootIds.has(next.root.id)) continue;
     resolvedRootIds.add(next.root.id);
+    enqueueStoredRoots(stored.includeRoot(next.root, next.member));
     const expanded = expandStoredClassValue({
       evaluateInitializer: args.evaluateInitializer,
       document,
@@ -83263,6 +83348,7 @@ function indexExpansion(args) {
     if (paths === void 0) childPathsByParentPath.set(parentPath, [pathKey]);
     else paths.push(pathKey);
   };
+  let discoveredNodes = null;
   const visit = (rowId, rawMember, pathKey, parentPath, parentSegment, genericEnv) => {
     const row = rowsByExpandedId.get(rowId);
     if (row === void 0 || nodesByExpandedId.has(rowId)) return;
@@ -83297,6 +83383,7 @@ function indexExpansion(args) {
       virtualId
     };
     nodesByExpandedId.set(rowId, node);
+    discoveredNodes?.push(node);
     nodesByPath.set(pathKey, node);
     appendChildPath(parentPath, pathKey);
     const childEnv = row.genericBindings ? envFromStamp(row.genericBindings) : genericEnv;
@@ -83399,15 +83486,49 @@ function indexExpansion(args) {
       );
     }
   };
-  visit(
-    args.expandedRoot.id,
-    args.rootMember,
-    ROOT_PATH,
-    null,
-    null,
-    /* @__PURE__ */ new Map()
-  );
+  const includeRoot = (root, member, path = appendPath(ROOT_PATH, {
+    kind: "class",
+    schemaKey: `@stored:${root.id}`
+  })) => {
+    const added = [];
+    discoveredNodes = added;
+    visit(root.id, member, path, null, null, /* @__PURE__ */ new Map());
+    if (args.additionalRoots !== void 0) {
+      for (let index = 0; index < added.length; index += 1) {
+        for (const { root: root2, member: member2 } of args.additionalRoots(
+          added[index].expandedRow
+        )) {
+          visit(
+            root2.id,
+            member2,
+            appendPath(ROOT_PATH, {
+              kind: "class",
+              schemaKey: `@constructor:${root2.id}`
+            }),
+            null,
+            null,
+            /* @__PURE__ */ new Map()
+          );
+        }
+      }
+    }
+    discoveredNodes = null;
+    return added;
+  };
+  if (args.additionalRoots === void 0) {
+    visit(
+      args.expandedRoot.id,
+      args.rootMember,
+      ROOT_PATH,
+      null,
+      null,
+      /* @__PURE__ */ new Map()
+    );
+  } else {
+    includeRoot(args.expandedRoot, args.rootMember, ROOT_PATH);
+  }
   return {
+    includeRoot,
     nodesByExpandedId,
     nodesByPath,
     rowsByExpandedId,
@@ -109738,17 +109859,17 @@ function computeWorkspaceStatus(workspace, options) {
       useBuildCaches: options.useBuildCaches !== false
     })
   });
+  const compilationSources = projectSources.map((source) => ({
+    uri: source.uri,
+    kind: source.kind,
+    text: source.source
+  }));
   try {
     if (!baseManifest) {
       throw new Error(
         "Format-4 status requires a pulled schema base; run `neo pull --reset`."
       );
     }
-    const compilationSources = projectSources.map((source) => ({
-      uri: source.uri,
-      kind: source.kind,
-      text: source.source
-    }));
     const analysis = options.readProjectAnalysisCache?.(workspace.root, compilationSources) ?? options.compileProjectAnalysis?.(workspace.root, compilationSources) ?? compileNeoProjectSources(compilationSources);
     projectAnalysisV4 = analysis;
     for (const diagnostic of analysis.diagnostics) {
@@ -110451,6 +110572,12 @@ function computeWorkspaceStatus(workspace, options) {
   }
   reportPhase("initializer-materialization");
   return {
+    ...projectAnalysisV4 === null ? {} : {
+      sourceSnapshot: {
+        inputs: compilationSources,
+        analysis: projectAnalysisV4
+      }
+    },
     localValues: valueLowerRegistry.localValues?.placements(),
     changes,
     conflictedFiles,
@@ -123313,6 +123440,7 @@ function computeWorkspaceStatus2(workspace, options = {}) {
   }));
   return computeWorkspaceStatus(workspace, {
     ...options,
+    reportPhase: options.reportPhase ?? ((phase, milliseconds) => recordPerformance(`workspace-${phase}`, milliseconds)),
     virtualSourceFiles,
     writeProjectAnalysisCache: options.writeProjectAnalysisCache ?? writeProjectSourceAnalysisCacheV4,
     readProjectAnalysisCache: options.readProjectAnalysisCache ?? readProjectSourceAnalysisBuildCacheV4,
@@ -123329,6 +123457,7 @@ var init_workspace_status = __esm({
     "use strict";
     import_ignore = __toESM(require_ignore(), 1);
     init_src();
+    init_performance();
     init_project_document_cache();
     init_project_files();
     init_supplemental_records_file_system();
@@ -123465,6 +123594,164 @@ var init_status_output = __esm({
   }
 });
 
+// src/http.ts
+var NeoApiError, NeoApiClient;
+var init_http = __esm({
+  "src/http.ts"() {
+    "use strict";
+    init_performance();
+    init_token_store();
+    NeoApiError = class extends Error {
+      constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "NeoApiError";
+      }
+      status;
+      body;
+    };
+    NeoApiClient = class _NeoApiClient {
+      constructor(apiBaseUrl, token) {
+        this.apiBaseUrl = apiBaseUrl;
+        this.token = token;
+      }
+      apiBaseUrl;
+      token;
+      static forBaseUrl(apiBaseUrl) {
+        const token = loadToken(apiBaseUrl);
+        if (token === null) {
+          throw new Error(
+            `No credentials stored for "${apiBaseUrl}". Run "neo login" (or set NEO_COMPOSE_TOKEN).`
+          );
+        }
+        return new _NeoApiClient(apiBaseUrl, token);
+      }
+      async post(path, body, headers, options = {}) {
+        return await this.postBytes(
+          path,
+          body === void 0 ? void 0 : JSON.stringify(body),
+          headers,
+          options
+        );
+      }
+      async postBytes(path, body, headers, options = {}) {
+        const url = new URL(path, this.apiBaseUrl).toString();
+        const finish = startPerformanceSpan("http", {
+          method: "POST",
+          path: new URL(url).pathname
+        });
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${this.token}`,
+              "Content-Type": "application/json",
+              ...headers
+            },
+            body,
+            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(
+              `POST ${path} failed with status ${response.status}: ${detail}`,
+              response.status,
+              parsed
+            );
+          }
+          return parsed;
+        } finally {
+          finish();
+        }
+      }
+      async get(path, options = {}) {
+        const url = new URL(path, this.apiBaseUrl).toString();
+        const finish = startPerformanceSpan("http", {
+          method: "GET",
+          path: new URL(url).pathname
+        });
+        try {
+          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;
+        } finally {
+          finish();
+        }
+      }
+      async getBytes(path) {
+        const url = new URL(path, this.apiBaseUrl).toString();
+        const finish = startPerformanceSpan("http", {
+          method: "GET",
+          path: new URL(url).pathname
+        });
+        try {
+          const response = await fetch(url, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${this.token}` }
+          });
+          if (!response.ok) {
+            const detail = (await response.text()).slice(0, 300);
+            throw new NeoApiError(
+              `GET ${path} failed with status ${response.status}: ${detail}`,
+              response.status,
+              detail
+            );
+          }
+          return {
+            bytes: new Uint8Array(await response.arrayBuffer()),
+            contentSha256: response.headers.get("x-neo-content-sha256"),
+            contentType: response.headers.get("content-type")
+          };
+        } finally {
+          finish();
+        }
+      }
+    };
+  }
+});
+
+// ../src/common/schema-commit-transport.ts
+var SCHEMA_COMMIT_HTTP_MAX_BYTES, SCHEMA_COMMIT_HTTP_MAX_DECODED_BYTES, SCHEMA_COMMIT_HTTP_PATH, SCHEMA_COMMIT_V8_MAX_DECODED_BYTES;
+var init_schema_commit_transport = __esm({
+  "../src/common/schema-commit-transport.ts"() {
+    "use strict";
+    SCHEMA_COMMIT_HTTP_MAX_BYTES = 18 * 1024 * 1024;
+    SCHEMA_COMMIT_HTTP_MAX_DECODED_BYTES = 32 * 1024 * 1024;
+    SCHEMA_COMMIT_HTTP_PATH = "/schema-commit";
+    SCHEMA_COMMIT_V8_MAX_DECODED_BYTES = 1024 * 1024;
+  }
+});
+
 // ../convex/_generated/api.js
 var api_exports = {};
 __export(api_exports, {
@@ -123487,35 +123774,62 @@ var init_api = __esm({
 var convex_exports = {};
 __export(convex_exports, {
   api: () => api2,
+  convexHttpActionUrl: () => convexHttpActionUrl,
   createConvexClient: () => createConvexClient,
   createConvexClientForApi: () => createConvexClientForApi,
+  createConvexPushConnection: () => createConvexPushConnection,
   mintConvexJwt: () => mintConvexJwt,
   resolveConvexUrl: () => resolveConvexUrl
 });
-import { ConvexHttpClient } from "convex/browser";
+import { gzipSync } from "node:zlib";
+import { ConvexClient, ConvexHttpClient } from "convex/browser";
 import { Buffer as Buffer2 } from "node:buffer";
-async function mintConvexJwt(apiBaseUrl) {
-  const sessionToken = loadToken(apiBaseUrl);
-  if (sessionToken === null) {
-    throw new Error(
-      `No credentials stored for "${apiBaseUrl}". Run "neo login".`
-    );
-  }
-  const response = await fetch(new URL("/api/auth/convex/token", apiBaseUrl), {
-    headers: { Authorization: `Bearer ${sessionToken}` }
-  });
-  const body = await response.json();
-  if (!response.ok) {
-    throw new Error(
-      `Convex JWT mint failed with status ${response.status}: ${JSON.stringify(body).slice(0, 200)}`
+async function mintConvexJwt(apiBaseUrl, signal, convexSiteUrl) {
+  const finish = startPerformanceSpan("authentication");
+  try {
+    const sessionToken = loadToken(apiBaseUrl);
+    if (sessionToken === null) {
+      throw new Error(
+        `No credentials stored for "${apiBaseUrl}". Run "neo login".`
+      );
+    }
+    const pinnedSite = loadTrustedConvexSite(apiBaseUrl);
+    const direct = convexSiteUrl !== void 0 && pinnedSite === convexSiteUrl;
+    const response = await fetch(
+      new URL("/api/auth/convex/token", direct ? convexSiteUrl : apiBaseUrl),
+      {
+        headers: { Authorization: `Bearer ${sessionToken}` },
+        redirect: "error",
+        signal
+      }
     );
+    const body = await response.json();
+    if (!response.ok) {
+      throw new Error(
+        `Convex JWT mint failed with status ${response.status}: ${JSON.stringify(body).slice(0, 200)}`
+      );
+    }
+    if (typeof body !== "object" || body === null || !("token" in body) || typeof body.token !== "string")
+      throw new Error('Convex token response is missing a string "token".');
+    const payload = convexJwtPayload(body.token);
+    if (convexSiteUrl !== void 0) {
+      if (payload.iss !== convexSiteUrl)
+        throw new Error(
+          "The workspace Convex deployment does not match the authenticated API origin."
+        );
+      if (!direct) {
+        try {
+          saveTrustedConvexSite(apiBaseUrl, convexSiteUrl);
+        } catch {
+        }
+      }
+    }
+    return body.token;
+  } finally {
+    finish();
   }
-  if (typeof body !== "object" || body === null || typeof body.token !== "string") {
-    throw new Error('Convex token response is missing a string "token".');
-  }
-  return body.token;
 }
-async function resolveConvexUrl(workspace) {
+async function resolveConvexUrl(workspace, signal) {
   const fromEnv = process.env.NEXT_PUBLIC_CONVEX_URL;
   if (fromEnv !== void 0 && fromEnv.length > 0) return fromEnv;
   const persisted = workspace.config.convexUrl;
@@ -123533,7 +123847,8 @@ async function resolveConvexUrl(workspace) {
     ),
     {
       method: "POST",
-      headers: { Authorization: `Bearer ${sessionToken}` }
+      headers: { Authorization: `Bearer ${sessionToken}` },
+      signal
     }
   );
   const convexUrl = response.headers.get("x-neo-convex-url");
@@ -123549,11 +123864,12 @@ async function resolveConvexUrl(workspace) {
   writeWorkspaceConfig(workspace.root, workspace.config);
   return convexUrl;
 }
-async function createConvexClient(workspace) {
-  const convexUrl = await resolveConvexUrl(workspace);
+async function createConvexClient(workspace, options = {}) {
+  const convexUrl = await resolveConvexUrl(workspace, options.signal);
   return await createAuthenticatedConvexClient(
     convexUrl,
-    workspace.config.apiBaseUrl
+    workspace.config.apiBaseUrl,
+    options.signal
   );
 }
 async function createConvexClientForApi(apiBaseUrl) {
@@ -123574,22 +123890,35 @@ async function createConvexClientForApi(apiBaseUrl) {
   }
   return await createAuthenticatedConvexClient(convexUrl, apiBaseUrl);
 }
-async function createAuthenticatedConvexClient(convexUrl, apiBaseUrl) {
-  const tokenCache = new ConvexJwtCache(apiBaseUrl);
+async function createAuthenticatedConvexClient(convexUrl, apiBaseUrl, signal) {
+  const tokenCache = new ConvexJwtCache(
+    apiBaseUrl,
+    signal,
+    convexHttpActionUrl(convexUrl)
+  );
   const initialToken = await tokenCache.getToken();
   const authenticatedFetch = async (input, init) => {
     const headers = new Headers(
       init?.headers ?? (input instanceof Request ? input.headers : void 0)
     );
     headers.set("Authorization", `Bearer ${await tokenCache.getToken()}`);
-    return await fetch(input, { ...init, headers });
+    const finish = startPerformanceSpan("convex-response-headers");
+    try {
+      return await fetch(input, {
+        ...init,
+        headers,
+        ...signal === void 0 ? {} : { signal }
+      });
+    } finally {
+      finish();
+    }
   };
   return new ConvexHttpClient(convexUrl, {
     auth: initialToken,
     fetch: authenticatedFetch
   });
 }
-function convexJwtExpiration(token) {
+function convexJwtPayload(token) {
   const segments = token.split(".");
   if (segments.length !== 3) {
     throw new Error("Convex token response is not a three-segment JWT.");
@@ -123608,9 +123937,16 @@ function convexJwtExpiration(token) {
   } catch {
     throw new Error("Convex token response has an invalid JWT payload.");
   }
-  if (typeof payload !== "object" || payload === null) {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
     throw new Error("Convex token response has a non-object JWT payload.");
   }
+  return {
+    exp: "exp" in payload ? payload.exp : void 0,
+    iss: "iss" in payload ? payload.iss : void 0
+  };
+}
+function convexJwtExpiration(token) {
+  const payload = convexJwtPayload(token);
   if (!("exp" in payload)) {
     throw new Error('Convex token response JWT is missing an "exp" claim.');
   }
@@ -123642,10 +123978,93 @@ function missingProjectsConvexUrlError() {
     "Could not discover the Convex deployment URL (/api/projects supplied neither a non-empty x-neo-convex-url header nor a non-empty convexUrl JSON field)."
   );
 }
+function convexHttpActionUrl(convexUrl) {
+  const url = new URL(convexUrl);
+  if (url.protocol !== "https:" || url.port !== "" || url.username !== "" || url.password !== "" || !url.hostname.endsWith(".convex.cloud"))
+    throw new Error(
+      "Direct schema commits require a Convex cloud deployment URL."
+    );
+  url.hostname = url.hostname.slice(0, -".convex.cloud".length) + ".convex.site";
+  return url.origin;
+}
+async function createConvexPushConnection(workspace) {
+  const convexUrl = await resolveConvexUrl(workspace);
+  const siteUrl = convexHttpActionUrl(convexUrl);
+  const tokenCache = new ConvexJwtCache(
+    workspace.config.apiBaseUrl,
+    void 0,
+    siteUrl
+  );
+  return {
+    async submit(body, force) {
+      const json = JSON.stringify(body);
+      const bytes = Buffer2.from(json);
+      if (bytes.byteLength > SCHEMA_COMMIT_HTTP_MAX_DECODED_BYTES)
+        throw new NeoApiError(
+          "Schema commit requires the large-payload route.",
+          413,
+          { error: "schema-commit-route-required" }
+        );
+      const compressed = bytes.byteLength >= 1024 ? gzipSync(bytes) : bytes;
+      const gzip = compressed.byteLength < bytes.byteLength;
+      const payload = gzip ? compressed : bytes;
+      if (payload.byteLength > SCHEMA_COMMIT_HTTP_MAX_BYTES)
+        throw new NeoApiError(
+          "Schema commit exceeds the HTTP body limit.",
+          413,
+          { error: "schema-commit-route-required" }
+        );
+      const client = new NeoApiClient(siteUrl, await tokenCache.getToken());
+      const path = `${SCHEMA_COMMIT_HTTP_PATH}?${new URLSearchParams({ projectId: workspace.config.projectId, versionId: workspace.config.versionId })}`;
+      const finish = startPerformanceSpan("commit-transport", {
+        decodedBytes: bytes.byteLength,
+        encodedBytes: payload.byteLength,
+        compression: gzip ? "gzip" : "identity"
+      });
+      try {
+        return await client.postBytes(path, payload, {
+          "x-neo-decoded-content-length": String(bytes.byteLength),
+          ...process.env.NEO_COMPOSE_TRACE_PERFORMANCE === "1" ? { "x-neo-trace-performance": "1" } : {},
+          ...typeof body === "object" && body !== null && "stagedFiles" in body && Array.isArray(body.stagedFiles) && body.stagedFiles.length > 0 ? { "x-neo-commit-runtime": "node" } : {},
+          "Content-Type": gzip ? "application/gzip" : "application/json",
+          ...force ? { "x-neo-force-project-version-write": "true" } : {}
+        });
+      } finally {
+        finish();
+      }
+    },
+    async subscribe(signal, onError) {
+      await tokenCache.getToken(false, signal);
+      signal.throwIfAborted();
+      const client = new ConvexClient(convexUrl, {
+        initialAuthTokenReuse: true,
+        logger: false
+      });
+      client.setAuth(
+        async ({ forceRefreshToken }) => {
+          try {
+            return await tokenCache.getToken(forceRefreshToken, signal);
+          } catch (error) {
+            onError(error instanceof Error ? error : new Error(String(error)));
+            return null;
+          }
+        },
+        (authenticated) => {
+          if (!authenticated && !signal.aborted)
+            onError(new Error("Convex rejected the session authentication."));
+        }
+      );
+      return client;
+    }
+  };
+}
 var generatedApiModule, generatedApiValue, api2, CONVEX_JWT_REFRESH_LEEWAY_MS, ConvexJwtCache;
 var init_convex = __esm({
   "src/convex.ts"() {
     "use strict";
+    init_http();
+    init_schema_commit_transport();
+    init_performance();
     init_api();
     init_token_store();
     init_workspace();
@@ -123657,18 +124076,22 @@ var init_convex = __esm({
     api2 = generatedApiValue;
     CONVEX_JWT_REFRESH_LEEWAY_MS = 6e4;
     ConvexJwtCache = class {
-      constructor(apiBaseUrl) {
+      constructor(apiBaseUrl, signal, convexSiteUrl) {
         this.apiBaseUrl = apiBaseUrl;
+        this.signal = signal;
+        this.convexSiteUrl = convexSiteUrl;
       }
       apiBaseUrl;
+      signal;
+      convexSiteUrl;
       token = null;
       expiresAt = 0;
       refreshPromise = null;
-      async getToken() {
-        if (this.token !== null && Date.now() + CONVEX_JWT_REFRESH_LEEWAY_MS < this.expiresAt) {
+      async getToken(forceRefresh = false, signal = this.signal) {
+        if (!forceRefresh && this.token !== null && Date.now() + CONVEX_JWT_REFRESH_LEEWAY_MS < this.expiresAt) {
           return this.token;
         }
-        const pending = this.refreshPromise ?? this.refresh();
+        const pending = this.refreshPromise ?? this.refresh(signal);
         this.refreshPromise = pending;
         try {
           return await pending;
@@ -123676,8 +124099,12 @@ var init_convex = __esm({
           if (this.refreshPromise === pending) this.refreshPromise = null;
         }
       }
-      async refresh() {
-        const token = await mintConvexJwt(this.apiBaseUrl);
+      async refresh(signal) {
+        const token = await mintConvexJwt(
+          this.apiBaseUrl,
+          signal,
+          this.convexSiteUrl
+        );
         const expiresAt = convexJwtExpiration(token);
         if (expiresAt <= Date.now()) {
           throw new Error("Convex token response contains an expired JWT.");
@@ -124614,119 +125041,6 @@ var init_reset = __esm({
   }
 });
 
-// src/http.ts
-var NeoApiError, NeoApiClient;
-var init_http = __esm({
-  "src/http.ts"() {
-    "use strict";
-    init_token_store();
-    NeoApiError = class extends Error {
-      constructor(message, status, body) {
-        super(message);
-        this.status = status;
-        this.body = body;
-        this.name = "NeoApiError";
-      }
-      status;
-      body;
-    };
-    NeoApiClient = class _NeoApiClient {
-      constructor(apiBaseUrl, token) {
-        this.apiBaseUrl = apiBaseUrl;
-        this.token = token;
-      }
-      apiBaseUrl;
-      token;
-      static forBaseUrl(apiBaseUrl) {
-        const token = loadToken(apiBaseUrl);
-        if (token === null) {
-          throw new Error(
-            `No credentials stored for "${apiBaseUrl}". Run "neo login" (or set NEO_COMPOSE_TOKEN).`
-          );
-        }
-        return new _NeoApiClient(apiBaseUrl, token);
-      }
-      async post(path, body, headers, options = {}) {
-        const url = new URL(path, this.apiBaseUrl).toString();
-        const response = await fetch(url, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${this.token}`,
-            "Content-Type": "application/json",
-            ...headers
-          },
-          body: body === void 0 ? void 0 : JSON.stringify(body),
-          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(
-            `POST ${path} failed with status ${response.status}: ${detail}`,
-            response.status,
-            parsed
-          );
-        }
-        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, {
-          method: "GET",
-          headers: { Authorization: `Bearer ${this.token}` }
-        });
-        if (!response.ok) {
-          const detail = (await response.text()).slice(0, 300);
-          throw new NeoApiError(
-            `GET ${path} failed with status ${response.status}: ${detail}`,
-            response.status,
-            detail
-          );
-        }
-        return {
-          bytes: new Uint8Array(await response.arrayBuffer()),
-          contentSha256: response.headers.get("x-neo-content-sha256"),
-          contentType: response.headers.get("content-type")
-        };
-      }
-    };
-  }
-});
-
 // src/project-source/project-file-pull.ts
 import { existsSync as existsSync7, rmSync as rmSync4 } from "node:fs";
 import { join as join9 } from "node:path";
@@ -129163,6 +129477,78 @@ var init_script = __esm({
   }
 });
 
+// ../convex/convexValues.ts
+function decodeConvexOpaqueJson(value, context) {
+  if (typeof value !== "string") {
+    throw new Error(`${context} must be an encoded JSON string.`);
+  }
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${context} could not be parsed as JSON: ${message}`);
+  }
+}
+var CONVEX_DOCUMENT_WARNING_BYTES, CONVEX_DOCUMENT_MAX_BYTES;
+var init_convexValues = __esm({
+  "../convex/convexValues.ts"() {
+    "use strict";
+    CONVEX_DOCUMENT_WARNING_BYTES = 750 * 1024;
+    CONVEX_DOCUMENT_MAX_BYTES = 1024 * 1024;
+  }
+});
+
+// ../src/database/project-version-transaction-result.ts
+function decodeProjectVersionTransactionResultPage(page) {
+  const assignments = {};
+  const changedRecords = [];
+  for (const chunk of page.chunks) {
+    const chunkAssignments = decodeConvexOpaqueJson(
+      chunk.assignmentsJson,
+      `Project transaction "${page.transactionId}" result chunk ${chunk.chunkIndex} assignments`
+    );
+    if (!isRecord9(chunkAssignments)) {
+      throw new Error(
+        `Project transaction "${page.transactionId}" result chunk ${chunk.chunkIndex} assignments are not an object.`
+      );
+    }
+    for (const [pendingId2, assignedId] of Object.entries(chunkAssignments)) {
+      if (typeof assignedId !== "string") {
+        throw new Error(
+          `Project transaction "${page.transactionId}" result chunk ${chunk.chunkIndex} assignment ${JSON.stringify(pendingId2)} is not a string.`
+        );
+      }
+      assignments[pendingId2] = assignedId;
+    }
+    const chunkRecords = decodeConvexOpaqueJson(
+      chunk.changedRecordsJson,
+      `Project transaction "${page.transactionId}" result chunk ${chunk.chunkIndex} changed records`
+    );
+    if (!Array.isArray(chunkRecords)) {
+      throw new Error(
+        `Project transaction "${page.transactionId}" result chunk ${chunk.chunkIndex} changed records are not an array.`
+      );
+    }
+    for (const record4 of chunkRecords) changedRecords.push(record4);
+  }
+  return {
+    transactionId: page.transactionId,
+    assignments,
+    changedRecords,
+    continueCursor: page.continueCursor,
+    isDone: page.isDone
+  };
+}
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var init_project_version_transaction_result = __esm({
+  "../src/database/project-version-transaction-result.ts"() {
+    "use strict";
+    init_convexValues();
+  }
+});
+
 // src/project-source/identity-rewriter.ts
 function createIdentityRewriter(assignments) {
   if (assignments.size === 0) return (value) => value;
@@ -130278,6 +130664,7 @@ function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInit
   }
   const rewriteString = createIdentityRewriter(assigned);
   const rewrite = (value) => {
+    if (assigned.size === 0) return value;
     if (typeof value === "string") {
       return rewriteString(value);
     }
@@ -130348,7 +130735,7 @@ function assignPendingIds(changes, authoredValueSeeds, reconstructed3, localInit
       });
     }
   }
-  if (reconstructed3 !== void 0) {
+  if (reconstructed3 !== void 0 && assigned.size > 0) {
     const rewrittenRecords = /* @__PURE__ */ new Map();
     for (const record4 of reconstructed3.values()) {
       const rewrittenRecordId = rewrite(record4.recordId);
@@ -130471,6 +130858,10 @@ function readProjectVersionTransactionStatus(value, transactionId) {
   return {
     transactionId,
     commitStatus: value.commitStatus,
+    transactionHash: readNullableString(
+      value.transactionHash,
+      `Project transaction "${transactionId}" transactionHash`
+    ),
     totalChangeCount: readNullableCount(
       value.totalChangeCount,
       `Project transaction "${transactionId}" totalChangeCount`
@@ -130680,66 +131071,164 @@ function progressEventFromStatus(status) {
   };
 }
 async function waitForAcceptedProjectVersionTransaction(args) {
-  const { client, projectId, versionId, accepted, reporter } = args;
-  const transactionPath = `/api/projects/${projectId}/versions/${versionId}/schema/transactions/${accepted.transactionId}`;
+  const { workspace, accepted, reporter } = args;
+  const { projectId, versionId } = workspace.config;
   const controller = new AbortController();
-  let interrupted = false;
-  const interrupt = () => {
-    interrupted = true;
-    controller.abort();
-  };
+  const interrupt = () => controller.abort(
+    new ProjectTransactionInterruptedError(accepted.transactionId)
+  );
   process.once("SIGINT", interrupt);
   reporter.report(progressEventFromAccepted(accepted));
-  let pollIndex = 0;
+  const finishWait = startPerformanceSpan("transaction-wait");
+  let client;
+  let unsubscribe;
+  let progressTimer;
+  let settled = false;
   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") {
+    const connection = args.connection ?? await withTransactionAbort(
+      createConvexPushConnection(workspace),
+      controller.signal
+    );
+    let failed = () => void 0;
+    let updated = () => void 0;
+    let firstResultPage;
+    const terminal2 = new Promise(
+      (resolve5, reject) => {
+        failed = (error) => {
+          if (!settled) {
+            settled = true;
+            reject(error);
+          }
+        };
+        updated = (response) => {
+          if (settled) return;
+          if (response === null) return;
+          try {
+            const status = readProjectVersionTransactionStatus(
+              response,
+              accepted.transactionId
+            );
+            reporter.report(progressEventFromStatus(status));
+            if (status.commitStatus === "failed") {
+              failed(new ProjectTransactionFailedError(status));
+              return;
+            }
+            if (status.commitStatus === "committed") {
+              settled = true;
+              resolve5(status);
+            }
+          } catch (error) {
+            failed(error instanceof Error ? error : new Error(String(error)));
+          }
+        };
+      }
+    );
+    void terminal2.catch(() => void 0);
+    client = await connection.subscribe(controller.signal, (error) => {
+      controller.abort(error);
+      failed(error);
+    });
+    const progressClient = client;
+    const refreshProgress = async () => {
+      if (settled || controller.signal.aborted) return;
+      try {
+        const response = await withTransactionAbort(
+          progressClient.query(
+            api2.projectVersionTransactionJobs.getTransactionStatus,
+            {
+              projectId,
+              versionId,
+              transactionId: accepted.transactionId
+            }
+          ),
+          controller.signal
+        );
+        if (settled || controller.signal.aborted) return;
+        const status = readProjectVersionTransactionStatus(
+          response,
+          accepted.transactionId
+        );
+        if (status.commitStatus === "committed") return;
+        updated(status);
+        if (!settled)
+          progressTimer = setTimeout(() => void refreshProgress(), 5e3);
+      } catch (error) {
+        failed(error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+    const finishFirstStatus = startPerformanceSpan("transaction-first-status");
+    let firstStatus = true;
+    try {
+      unsubscribe = client.onUpdate(
+        api2.projectVersionTransactionJobs.getTransactionCompletion,
+        {
+          projectId,
+          versionId,
+          transactionId: accepted.transactionId,
+          includeResultPage: true
+        },
+        (response) => {
+          if (firstStatus) {
+            firstStatus = false;
+            finishFirstStatus();
+          }
+          if (settled) return;
+          firstResultPage = response?.resultPage;
+          updated(response);
+        },
+        failed
+      );
+      if (!settled)
+        progressTimer = setTimeout(() => void refreshProgress(), 5e3);
+      const status = await withTransactionAbort(terminal2, controller.signal);
+      unsubscribe();
+      unsubscribe = void 0;
+      const finishDownload = startPerformanceSpan("result-download");
+      try {
         return await downloadProjectVersionTransactionResult({
           client,
-          transactionPath,
+          projectId,
+          versionId,
           transactionId: accepted.transactionId,
           status,
+          firstResultPage,
           signal: controller.signal
         });
+      } finally {
+        finishDownload();
       }
-      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);
+    } finally {
+      if (firstStatus) finishFirstStatus();
     }
-    throw error;
   } finally {
+    settled = true;
+    clearTimeout(progressTimer);
+    unsubscribe?.();
+    controller.abort();
+    if (client !== void 0) await client.close();
+    finishWait();
     process.removeListener("SIGINT", interrupt);
   }
 }
-async function waitForPollDelay(delayMs, signal) {
-  if (signal.aborted) {
-    throw new Error("Project transaction polling was interrupted.");
-  }
-  await new Promise((resolve5, reject) => {
-    const aborted = () => {
-      clearTimeout(timer);
-      reject(new Error("Project transaction polling was interrupted."));
+async function withTransactionAbort(pending, signal) {
+  signal.throwIfAborted();
+  return await new Promise((resolve5, reject) => {
+    const abort = () => {
+      cleanup();
+      reject(signal.reason);
     };
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", aborted);
-      resolve5();
-    }, delayMs);
-    signal.addEventListener("abort", aborted, { once: true });
+    const cleanup = () => signal.removeEventListener("abort", abort);
+    signal.addEventListener("abort", abort, { once: true });
+    pending.then(
+      (value) => {
+        cleanup();
+        resolve5(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
   });
 }
 async function downloadProjectVersionTransactionResult(args) {
@@ -130754,11 +131243,20 @@ async function downloadProjectVersionTransactionResult(args) {
       );
     }
     seenCursors.add(cursor);
-    const query = new URLSearchParams({ cursor });
-    const rawPage = await args.client.get(
-      `${args.transactionPath}/results?${query.toString()}`,
-      { signal: args.signal }
+    args.signal.throwIfAborted();
+    const storedPage = cursor === "" && args.firstResultPage !== void 0 ? args.firstResultPage : await withTransactionAbort(
+      args.client.query(
+        api2.projectVersionTransactionJobs.getTransactionResultPage,
+        {
+          projectId: args.projectId,
+          versionId: args.versionId,
+          transactionId: args.transactionId,
+          paginationOpts: { cursor, numItems: 16 }
+        }
+      ),
+      args.signal
     );
+    const rawPage = storedPage === null ? null : decodeProjectVersionTransactionResultPage(storedPage);
     const page = readProjectVersionTransactionResultPage(
       rawPage,
       args.transactionId
@@ -130784,8 +131282,13 @@ async function downloadProjectVersionTransactionResult(args) {
           `Project transaction "${args.transactionId}" committed ${args.status.totalChangeCount} changes but its result download returned ${changedRecords.length}.`
         );
       }
+      if (args.status.transactionHash === null)
+        throw new Error(
+          `Committed project transaction "${args.transactionId}" has no transaction hash.`
+        );
       return {
         kind: "committed",
+        headTransactionHash: args.status.transactionHash,
         transactionId: args.transactionId,
         totalChangeCount: args.status.totalChangeCount,
         totalChunkCount: args.status.totalChunkCount ?? 0,
@@ -130900,6 +131403,7 @@ async function runPush(workspace, options, preparationOverride) {
   const verifiesConfiguredHook = options.noVerify !== true && configuredHook !== void 0;
   const preparedInputFingerprint = verifiesConfiguredHook ? fingerprintPushInputs(workspace) : void 0;
   const preparation = preparationOverride === void 0 ? process.stdout.isTTY === true && options.json !== true ? spinner("Preparing push\u2026") : null : preparationOverride;
+  const finishCandidate = startPerformanceSpan("local-candidate");
   let candidate;
   try {
     candidate = await prepareLocalCandidateV4(workspace, {
@@ -130922,6 +131426,8 @@ async function runPush(workspace, options, preparationOverride) {
     }
     preparation?.fail("Push preparation failed.");
     throw error;
+  } finally {
+    finishCandidate();
   }
   const status = candidate.status;
   const local = candidate.preparedLocal;
@@ -131102,7 +131608,12 @@ async function runPush(workspace, options, preparationOverride) {
   };
   let preparedPush;
   try {
-    preparedPush = await stagePreparedPush();
+    const finishUploads = startPerformanceSpan("file-uploads");
+    try {
+      preparedPush = await stagePreparedPush();
+    } finally {
+      finishUploads();
+    }
   } catch (error) {
     progress.stop();
     if (error instanceof ProjectFilePushCancelledError) {
@@ -131122,9 +131633,9 @@ async function runPush(workspace, options, preparationOverride) {
     stagedUploadSessionId
   } = preparedPush;
   const { stagedFiles } = preparedPush;
-  const commit = async (force) => await client.post(
-    `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/schema/commit`,
-    {
+  let pushConnection;
+  const commit = async (force) => {
+    const body = {
       operation: transactionOperation,
       changes: transportChanges,
       authoredValueSeeds: transportSeeds,
@@ -131139,9 +131650,20 @@ async function runPush(workspace, options, preparationOverride) {
       headTransactionHash: workspace.state.headTransactionHash ?? null,
       derivedEdgeExtractorVersion: PROJECT_SNAPSHOT_DERIVED_EDGE_EXTRACTOR_VERSION,
       forceRecompile: options.forceRecompile === true
-    },
-    force ? { "x-neo-force-project-version-write": "true" } : void 0
-  );
+    };
+    pushConnection ??= await createConvexPushConnection(workspace);
+    try {
+      return await pushConnection.submit(body, force);
+    } catch (error) {
+      if (!(error instanceof NeoApiError) || error.status !== 413 || !isObjectRecord2(error.body) || error.body.error !== "schema-commit-route-required")
+        throw error;
+    }
+    return await client.post(
+      `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/schema/commit`,
+      body,
+      force ? { "x-neo-force-project-version-write": "true" } : void 0
+    );
+  };
   const finishCommitResponse = async (response, reporter) => {
     let accepted;
     try {
@@ -131156,7 +131678,12 @@ async function runPush(workspace, options, preparationOverride) {
         if (!applyCommittedHeadTransactionHash(workspace, response)) {
           await recoverHeadTransactionHashFromSchemaSignal(workspace);
         }
-        applyPushResult(workspace, response, pendingAssignment.assigned);
+        applyPushResult(
+          workspace,
+          response,
+          pendingAssignment.assigned,
+          preparedLocal.submittedStatus
+        );
       } catch (error) {
         reporter.stop();
         throw error;
@@ -131184,11 +131711,10 @@ async function runPush(workspace, options, preparationOverride) {
     let completed;
     try {
       completed = await waitForAcceptedProjectVersionTransaction({
-        client,
-        projectId: workspace.config.projectId,
-        versionId: workspace.config.versionId,
+        workspace,
         accepted,
-        reporter
+        reporter,
+        connection: pushConnection
       });
     } catch (error) {
       if (error instanceof ProjectTransactionInterruptedError) {
@@ -131234,15 +131760,19 @@ async function runPush(workspace, options, preparationOverride) {
       throw error;
     }
     try {
-      if (!applyCommittedHeadTransactionHash(workspace, completed)) {
-        await recoverHeadTransactionHashFromSchemaSignal(workspace);
+      applyCommittedHeadTransactionHash(workspace, completed);
+      const finishApply = startPerformanceSpan("apply-result");
+      try {
+        applyCommittedProjectTransactionResult({
+          workspace,
+          result: completed,
+          submittedChanges: status.changes,
+          candidateAssignments: pendingAssignment.assigned,
+          submittedStatus: preparedLocal.submittedStatus
+        });
+      } finally {
+        finishApply();
       }
-      applyCommittedProjectTransactionResult({
-        workspace,
-        result: completed,
-        submittedChanges: status.changes,
-        candidateAssignments: pendingAssignment.assigned
-      });
     } catch (error) {
       reporter.stop();
       throw error;
@@ -131282,7 +131812,12 @@ async function runPush(workspace, options, preparationOverride) {
   }
   let result;
   try {
-    result = await commit(options.acceptBump);
+    const finishSubmit = startPerformanceSpan("submit");
+    try {
+      result = await commit(options.acceptBump);
+    } finally {
+      finishSubmit();
+    }
   } catch (error) {
     progress.stop();
     if (!(error instanceof NeoApiError)) throw error;
@@ -131362,12 +131897,19 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
   fullValidation: true,
   forceRecompile: false
 }) {
-  onPhase("Hashing canonical project source\u2026");
-  const source = createPendingProjectSourceIdentityV4(
+  const submittedStatus = {
+    status: cloneWorkspaceStatus(status),
+    records: workspace.state.records,
+    config: structuredClone(workspace.config),
+    root: workspace.root
+  };
+  onPhase("Hashing project source\u2026");
+  const source = projectSourceIdentityForStatus(status);
+  const verificationSource = options.fullValidation ? createPendingProjectSourceIdentityV4(
     workspace,
     status,
     status.authoredValueSeeds
-  );
+  ) : null;
   const pendingTransportChanges = transportChangesForStatus(status);
   const pendingTransportSeeds = [...status.authoredValueSeeds].map(
     ([memberId, seed]) => ({ memberId, ...seed })
@@ -131401,20 +131943,20 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
     localizedTextCreateEnvelopeConfig2(workspace, status.changes)
   );
   let preparedChanges = null;
-  if (options.fullValidation) {
+  if (verificationSource !== null) {
     onPhase("Verifying the assigned-id source rewrite\u2026");
     materializeAssignedSchemaIdsInAuthoredSource(
       workspace,
       pendingAssignment.assigned,
       status.pendingValueIdentitySites,
-      true
+      { sourceSnapshot: status.sourceSnapshot, validateResult: true }
     );
     onPhase("Verifying the complete source round trip\u2026");
     verifyProjectSourceCommitAgainstStateV4({
       projectId: workspace.config.projectId,
       versionId: workspace.config.versionId,
       stateRecords: workspace.state.records,
-      files: source.files,
+      files: verificationSource.files,
       changes: transportChanges,
       authoredValueSeeds: transportSeeds,
       initializerMaterialization: pendingAssignment.localInitializerMaterialization ?? { roots: [] },
@@ -131439,6 +131981,7 @@ async function prepareLocalPushArtifactsV4(workspace, status, onPhase = () => vo
   }
   return {
     source,
+    submittedStatus,
     pendingAssignment,
     transactionOperation,
     transportChanges,
@@ -131468,7 +132011,7 @@ async function prepareLocalCandidateV4(workspace, options = {}) {
   let documentStatus = status;
   if (status.changes.length > 0 || status.authoredValueSeeds.size > 0) {
     try {
-      documentStatus = pushOptions.dryRun ? cloneStatusForDryRun(status) : status;
+      documentStatus = pushOptions.dryRun ? cloneWorkspaceStatus(status) : status;
       if (options.refreshDerivedEdgeVersion === true) {
         const convex = await createConvexClient(workspace);
         const signal = await convex.query(api2.projectExportData.schemaSignal, {
@@ -131494,20 +132037,7 @@ async function prepareLocalCandidateV4(workspace, options = {}) {
     }
     sourceHash = preparedLocal.source.sourceHash;
   } else {
-    const files = listProjectSourceFilesV4(workspace.root).map(
-      (absolutePath) => {
-        const path = relative7(workspace.root, absolutePath).split(sep7).join("/");
-        const content = readFileSync16(absolutePath, "utf8");
-        const kind = neoProjectSourceKind(path, content);
-        if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
-          throw new Error(
-            `Listed workspace source ${JSON.stringify(path)} is not production Neo source.`
-          );
-        }
-        return { path, kind, content };
-      }
-    );
-    sourceHash = hashProjectSourceFiles(files);
+    sourceHash = projectSourceIdentityForStatus(status).sourceHash;
   }
   if (options.includeDocument === false) {
     return { status, document: null, sourceHash, preparedLocal };
@@ -131648,7 +132178,7 @@ function describeChangeOrigin(change) {
   if (parts.length === 0) return "";
   return ` (${parts.join(" in ")})`;
 }
-function cloneStatusForDryRun(status) {
+function cloneWorkspaceStatus(status) {
   return {
     ...status,
     changes: structuredClone(status.changes),
@@ -131700,6 +132230,19 @@ function reportDryRunFailure(error, json) {
   }
   console.error(`Dry run failed: ${message}`);
 }
+function projectSourceIdentityForStatus(status) {
+  if (status.sourceSnapshot === void 0) {
+    throw new Error(
+      "Push source identity requires the analyzed source snapshot."
+    );
+  }
+  const files = status.sourceSnapshot.inputs.map((input) => ({
+    path: input.uri,
+    kind: input.kind,
+    content: input.text
+  }));
+  return { files, sourceHash: hashProjectSourceFiles(files) };
+}
 function createPendingProjectSourceIdentityV4(workspace, status, authoredValueSeeds) {
   const records2 = /* @__PURE__ */ new Map();
   for (const [key, state] of Object.entries(workspace.state.records)) {
@@ -131981,7 +132524,7 @@ function reportAdditionalServerChanges(totalChangeCount, authoredChangeCount, js
 }
 function applyCommittedProjectTransactionResult(args) {
   const { workspace, result, submittedChanges, candidateAssignments } = args;
-  const localStatus = computeWorkspaceStatus2(workspace);
+  const localStatus = statusForPushResult(workspace, args.submittedStatus);
   const blockingErrors = localStatus.parseErrors.filter(
     isBlockingSchemaSourceError
   );
@@ -132003,7 +132546,8 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
   const preservedSourceFiles = materializeAssignedSchemaIdsInAuthoredSource(
     workspace,
     replacements.exact,
-    localStatus.pendingValueIdentitySites
+    localStatus.pendingValueIdentitySites,
+    { sourceSnapshot: localStatus.sourceSnapshot }
   );
   const localRecords = rewriteReconstructedRecords(
     localStatus.reconstructed,
@@ -132083,6 +132627,38 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     throw error;
   }
 }
+function statusForPushResult(workspace, submitted) {
+  if (submitted === void 0) return computeWorkspaceStatus2(workspace);
+  if (submitted.records !== workspace.state.records)
+    return computeWorkspaceStatus2(workspace);
+  if (submitted.root !== workspace.root)
+    return computeWorkspaceStatus2(workspace);
+  if (!canonicallyEqual(submitted.config, workspace.config))
+    return computeWorkspaceStatus2(workspace);
+  const submittedStatus = submitted.status;
+  const snapshot = submittedStatus?.sourceSnapshot;
+  if (snapshot === void 0 || submittedStatus?.binaryFiles === void 0)
+    return computeWorkspaceStatus2(workspace);
+  const paths = listProjectSourceFilesV4(workspace.root);
+  if (paths.length !== snapshot.inputs.length)
+    return computeWorkspaceStatus2(workspace);
+  for (let index = 0; index < paths.length; index += 1) {
+    const path = paths[index];
+    const input = snapshot.inputs[index];
+    if (input?.uri !== relative7(workspace.root, path).split(sep7).join("/"))
+      return computeWorkspaceStatus2(workspace);
+    if (input.text !== readFileSync16(path, "utf8"))
+      return computeWorkspaceStatus2(workspace);
+  }
+  const binaries = inspectProjectBinaryStatusV4(
+    workspace.root,
+    workspace.state.records,
+    snapshot.analysis
+  );
+  if (!canonicallyEqual(binaries, submittedStatus.binaryFiles))
+    return computeWorkspaceStatus2(workspace);
+  return submittedStatus;
+}
 function projectTransactionResultReplacements(candidateAssignments, resultAssignments) {
   const replacements = /* @__PURE__ */ new Map();
   for (const [pendingId2, assignedId] of Object.entries(resultAssignments)) {
@@ -132096,6 +132672,7 @@ function projectTransactionResultReplacements(candidateAssignments, resultAssign
   };
 }
 function rewriteReconstructedRecords(records2, replacements) {
+  if (replacements.exact.size === 0) return records2;
   const rewritten = /* @__PURE__ */ new Map();
   for (const record4 of records2.values()) {
     const recordId = rewriteAssignedString(record4.recordId, replacements);
@@ -132250,15 +132827,16 @@ function foldChangedRecords(previous, changedRecords) {
   }
   return records2;
 }
-function applyPushResult(workspace, result, pendingIdAssignments = /* @__PURE__ */ new Map()) {
+function applyPushResult(workspace, result, pendingIdAssignments = /* @__PURE__ */ new Map(), submittedStatus) {
   if (!isObjectRecord2(result) || !Array.isArray(result.changedRecords)) {
     throw new Error("Transaction response is missing changedRecords.");
   }
-  const localStatus = computeWorkspaceStatus2(workspace);
+  const localStatus = statusForPushResult(workspace, submittedStatus);
   const preservedSourceFiles = materializeAssignedSchemaIdsInAuthoredSource(
     workspace,
     pendingIdAssignments,
-    localStatus.pendingValueIdentitySites
+    localStatus.pendingValueIdentitySites,
+    { sourceSnapshot: localStatus.sourceSnapshot }
   );
   const replacements = {
     exact: pendingIdAssignments,
@@ -132378,19 +132956,20 @@ function rewriteFilesFromState(workspace, records2 = new Map(
       )
     };
   });
-  const finalAnalysis = compileNeoProjectSources(
-    files.map((file) => {
-      const kind = neoProjectSourceKind(file.path, file.content);
-      if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
-        throw new Error(
-          `Emitted project source ${JSON.stringify(file.path)} has an unsupported path.`
-        );
-      }
-      return { uri: file.path, kind, text: file.content };
-    })
-  );
+  const finalInputs = files.map((file) => {
+    const kind = neoProjectSourceKind(file.path, file.content);
+    if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
+      throw new Error(
+        `Emitted project source ${JSON.stringify(file.path)} has an unsupported path.`
+      );
+    }
+    return { uri: file.path, kind, text: file.content };
+  });
+  const finalAnalysis = files.every(
+    (file, index) => file.content === result.files[index]?.content
+  ) ? result.analysis : compileNeoProjectSources(finalInputs);
   assertAssignedIdSourceRewriteValid(finalAnalysis);
-  writeProjectSourceAnalysisCacheV4(workspace.root, finalAnalysis);
+  writeProjectSourceAnalysisCacheV4(workspace.root, finalAnalysis, finalInputs);
   const resolveSourcePath = createWorkspaceSourcePathResolver(workspace.root);
   const emittedPaths = new Set(files.map((file) => file.path));
   for (const recordState of Object.values(workspace.state.records)) {
@@ -132438,7 +133017,7 @@ ${finalErrors.map(
     );
   }
 }
-function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, pendingValueIdentitySites = /* @__PURE__ */ new Map(), validateResult = false) {
+function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, pendingValueIdentitySites = /* @__PURE__ */ new Map(), options = {}) {
   const pendingIdsByUri = /* @__PURE__ */ new Map();
   for (const pendingId2 of replacements.keys()) {
     if (!isPendingId(pendingId2)) continue;
@@ -132449,25 +133028,23 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, p
     pendingIdsByUri.set(uri, pendingIds);
   }
   if (pendingIdsByUri.size === 0) return /* @__PURE__ */ new Map();
-  const inputs = listProjectSourceFilesV4(workspace.root).map(
-    (absolutePath) => {
-      const uri = relative7(workspace.root, absolutePath).split(sep7).join("/");
-      const text = readFileSync16(absolutePath, "utf8");
-      const kind = neoProjectSourceKind(uri, text);
-      if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
-        throw new Error(
-          `Listed workspace source ${JSON.stringify(uri)} has an unsupported path.`
-        );
-      }
-      return {
-        uri,
-        kind,
-        text
-      };
+  const inputs = options.sourceSnapshot?.inputs ?? listProjectSourceFilesV4(workspace.root).map((absolutePath) => {
+    const uri = relative7(workspace.root, absolutePath).split(sep7).join("/");
+    const text = readFileSync16(absolutePath, "utf8");
+    const kind = neoProjectSourceKind(uri, text);
+    if (kind === null || !isNeoProjectProductionSourceKind(kind)) {
+      throw new Error(
+        `Listed workspace source ${JSON.stringify(uri)} has an unsupported path.`
+      );
     }
-  );
+    return {
+      uri,
+      kind,
+      text
+    };
+  });
   const inputByUri = new Map(inputs.map((input) => [input.uri, input.text]));
-  const analysis = compileNeoProjectSources(inputs);
+  const analysis = options.sourceSnapshot?.analysis ?? compileNeoProjectSources(inputs);
   if (analysis.diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
     return /* @__PURE__ */ new Map();
   }
@@ -132615,7 +133192,7 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements, p
     }
     preserved.set(uri, source);
   }
-  if (validateResult && preserved.size > 0) {
+  if (options.validateResult === true && preserved.size > 0) {
     assertAssignedIdSourceRewriteValid(
       compileNeoProjectSources(
         inputs.map((input) => ({
@@ -133181,10 +133758,12 @@ function compileMigrationAction(context, migrationData, locator) {
     locator
   );
 }
-var compileNSVoidBody2, compileNSFunction2, compileNSGetter2, compileNSSetter2, createNeoScriptCompilationProject2, ProjectTransactionInterruptedError, ProjectTransactionFailedError, PROJECT_TRANSACTION_POLL_DELAYS_MS, LocalCandidateArtifactError, SERVER_MINTED_PUSH_RECORD_KINDS;
+var compileNSVoidBody2, compileNSFunction2, compileNSGetter2, compileNSSetter2, createNeoScriptCompilationProject2, ProjectTransactionInterruptedError, ProjectTransactionFailedError, LocalCandidateArtifactError, SERVER_MINTED_PUSH_RECORD_KINDS;
 var init_push = __esm({
   "src/commands/push.ts"() {
     "use strict";
+    init_project_version_transaction_result();
+    init_performance();
     init_identity_rewriter();
     init_source_layout();
     init_src();
@@ -133200,6 +133779,7 @@ var init_push = __esm({
     init_push_hook();
     init_project_documents();
     init_project_document_cache();
+    init_project_files();
     init_workspace_status();
     init_lower_support();
     init_init_conversion();
@@ -133251,14 +133831,6 @@ var init_push = __esm({
       }
       status;
     };
-    PROJECT_TRANSACTION_POLL_DELAYS_MS = [
-      250,
-      500,
-      1e3,
-      2e3,
-      4e3,
-      5e3
-    ];
     LocalCandidateArtifactError = class extends Error {
       constructor(cause) {
         super(cause instanceof Error ? cause.message : String(cause));
@@ -133279,7 +133851,7 @@ var init_registry2 = __esm({
   "schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.50.7",
+      cliVersion: "0.50.8",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -134724,7 +135296,7 @@ import {
   sep as sep8
 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function expectation(actual, negated = false) {
@@ -134735,13 +135307,13 @@ function expectation(actual, negated = false) {
   return value;
 }
 function readExpectation(value) {
-  if (!isRecord9(value) || value.__neoExpectation !== true) {
+  if (!isRecord10(value) || value.__neoExpectation !== true) {
     throw new NeoTestAssertionError("Matcher receiver is not an expectation.");
   }
   return value;
 }
 function readMockHandle(value) {
-  if (!isRecord9(value) || value.__neoMockHandle !== true || typeof value.mockId !== "number") {
+  if (!isRecord10(value) || value.__neoMockHandle !== true || typeof value.mockId !== "number") {
     throw new NeoTestAssertionError(
       "Mock configuration receiver is not a mock handle."
     );
@@ -134852,13 +135424,13 @@ function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function findDelegateTargetMemberId(value) {
-  return isRecord9(value) && typeof value.memberId === "string" ? value.memberId : null;
+  return isRecord10(value) && typeof value.memberId === "string" ? value.memberId : null;
 }
 function sharedEvaluatorBase(rawDocument) {
   const cached = SHARED_EVALUATOR_BASES.get(rawDocument);
   if (cached !== void 0) return cached;
   const document = readDocumentArrays(rawDocument);
-  const constructors = Array.isArray(rawDocument.constructors) ? rawDocument.constructors.filter(isRecord9) : [];
+  const constructors = Array.isArray(rawDocument.constructors) ? rawDocument.constructors.filter(isRecord10) : [];
   const runtime = cliEvaluatorRuntime(
     { ...document, constructors },
     { includeValueGraphIndexes: true }
@@ -134927,7 +135499,7 @@ function preparedHookCandidate(workspace) {
     const parsed = JSON.parse(
       readFileSync17(join15(directory, "candidate.json"), "utf8")
     );
-    if (!isRecord9(parsed)) {
+    if (!isRecord10(parsed)) {
       throw new NeoTestPreparedCandidateError(
         "Configured push hook candidate manifest must be a JSON object."
       );
@@ -134947,7 +135519,7 @@ function preparedHookCandidate(workspace) {
         "Configured push hook candidate inputs no longer match the workspace."
       );
     }
-    if (!isRecord9(parsed.document)) {
+    if (!isRecord10(parsed.document)) {
       throw new NeoTestPreparedCandidateError(
         "Configured push hook candidate is missing its project document."
       );
@@ -134996,7 +135568,7 @@ function cachedTestCandidate(workspace, inputFingerprint) {
   try {
     const candidatePath = testCandidateCachePath(workspace, inputFingerprint);
     const parsed = JSON.parse(readFileSync17(candidatePath, "utf8"));
-    if (!isRecord9(parsed)) return null;
+    if (!isRecord10(parsed)) return null;
     if (parsed.version !== 1) return null;
     if (parsed.candidateRevision !== TEST_CANDIDATE_CACHE_REVISION) return null;
     if (parsed.cliVersion !== PROJECT_SCHEMA_CONTRACT.cliVersion) return null;
@@ -135014,7 +135586,7 @@ function cachedTestCandidate(workspace, inputFingerprint) {
       return null;
     }
     const document = JSON.parse(documentJson);
-    if (!isRecord9(document)) return null;
+    if (!isRecord10(document)) return null;
     return {
       document,
       sourceHash: parsed.sourceHash,
@@ -135058,7 +135630,7 @@ function compileSpec(workspace, document, absolutePath, projectCompilationHash2)
   );
   try {
     const cached = JSON.parse(readFileSync17(artifactPath, "utf8"));
-    if (isRecord9(cached) && cached.version === 1 && cached.compilerRevision === NEOSCRIPT_COMPILER_REVISION && cached.projectCompilationHash === projectCompilationHash2 && cached.sourceHash === sourceHash && isRecord9(cached.action) && typeof cached.artifactSha256 === "string" && createHash11("sha256").update(JSON.stringify(cached.action)).digest("hex") === cached.artifactSha256 && cached.action.compilerRevision === NEOSCRIPT_COMPILER_REVISION && Array.isArray(cached.action.parameters) && Array.isArray(cached.action.instructions) && isRecord9(cached.action.typeInfo)) {
+    if (isRecord10(cached) && cached.version === 1 && cached.compilerRevision === NEOSCRIPT_COMPILER_REVISION && cached.projectCompilationHash === projectCompilationHash2 && cached.sourceHash === sourceHash && isRecord10(cached.action) && typeof cached.artifactSha256 === "string" && createHash11("sha256").update(JSON.stringify(cached.action)).digest("hex") === cached.artifactSha256 && cached.action.compilerRevision === NEOSCRIPT_COMPILER_REVISION && Array.isArray(cached.action.parameters) && Array.isArray(cached.action.instructions) && isRecord10(cached.action.typeInfo)) {
       return {
         path,
         source,
@@ -135222,7 +135794,7 @@ function portableDelegate(value) {
   }
 }
 function callMemberId(value) {
-  if (!isRecord9(value) || value.type !== "callFunction") return null;
+  if (!isRecord10(value) || value.type !== "callFunction") return null;
   return typeof value.memberId === "string" ? value.memberId : null;
 }
 function assertNoNestedRegistration(value) {
@@ -135230,7 +135802,7 @@ function assertNoNestedRegistration(value) {
     for (const entry of value) assertNoNestedRegistration(entry);
     return;
   }
-  if (!isRecord9(value)) return;
+  if (!isRecord10(value)) return;
   const memberId = callMemberId(value);
   if (memberId !== null && REGISTRATION_IDS.has(memberId)) {
     throw new NeoTestRegistrationError(
@@ -135246,8 +135818,8 @@ function compiledDelegateActions(value) {
       for (const child of entry) visit(child);
       return;
     }
-    if (!isRecord9(entry)) return;
-    if (isRecord9(entry.action) && Array.isArray(entry.action.instructions) && Array.isArray(entry.action.parameters) && isRecord9(entry.action.typeInfo)) {
+    if (!isRecord10(entry)) return;
+    if (isRecord10(entry.action) && Array.isArray(entry.action.instructions) && Array.isArray(entry.action.parameters) && isRecord10(entry.action.typeInfo)) {
       actions.push(entry.action);
       return;
     }
@@ -135258,7 +135830,7 @@ function compiledDelegateActions(value) {
 }
 function validateRegistrationAction(action, allowRegistration) {
   for (const instruction of action.instructions) {
-    const record4 = isRecord9(instruction) ? instruction : null;
+    const record4 = isRecord10(instruction) ? instruction : null;
     const call = record4?.type === "functionCall" ? record4.call : null;
     const memberId = callMemberId(call);
     if (memberId !== null && REGISTRATION_IDS.has(memberId)) {
@@ -135391,8 +135963,8 @@ function mockResponse(environment, mock, selected, call) {
   };
 }
 function partialObjectMatch(actual, expected) {
-  if (!isRecord9(expected)) return isDeepStrictEqual(actual, expected);
-  if (!isRecord9(actual)) return false;
+  if (!isRecord10(expected)) return isDeepStrictEqual(actual, expected);
+  if (!isRecord10(actual)) return false;
   return Object.entries(expected).every(
     ([key, value]) => partialObjectMatch(actual[key], value)
   );
@@ -135584,7 +136156,7 @@ function interceptTestCallCore(environment, call) {
     const contains2 = typeof actual === "string" ? actual.includes(String(call.args[0])) : Array.isArray(actual) && actual.some((entry) => isDeepStrictEqual(entry, call.args[0]));
     assertMatcher(contains2, expectationValue, "toContain", call.args[0]);
   } else if (call.memberId === NEO_TEST_IDS.toHaveLength) {
-    const length = typeof actual === "string" || Array.isArray(actual) ? actual.length : isRecord9(actual) ? Object.keys(actual).length : -1;
+    const length = typeof actual === "string" || Array.isArray(actual) ? actual.length : isRecord10(actual) ? Object.keys(actual).length : -1;
     assertMatcher(
       length === call.args[0],
       expectationValue,
@@ -135675,11 +136247,11 @@ function snapshotEnvironmentDocument(environment) {
   const values = [...baseValues];
   const byId = /* @__PURE__ */ new Map();
   values.forEach((value, index) => {
-    if (isRecord9(value) && typeof value.id === "string")
+    if (isRecord10(value) && typeof value.id === "string")
       byId.set(value.id, index);
   });
   const mergeRow = (row) => {
-    if (!isRecord9(row) || typeof row.id !== "string") return;
+    if (!isRecord10(row) || typeof row.id !== "string") return;
     const cloned = structuredClone(row);
     const index = byId.get(row.id);
     if (index === void 0) {
@@ -135695,7 +136267,7 @@ function snapshotEnvironmentDocument(environment) {
   if (bindings.size > 0) {
     const baseMembers = Array.isArray(snapshot.members) ? snapshot.members : [];
     snapshot.members = baseMembers.map((member) => {
-      if (!isRecord9(member) || typeof member.id !== "string" || !bindings.has(member.id)) {
+      if (!isRecord10(member) || typeof member.id !== "string" || !bindings.has(member.id)) {
         return member;
       }
       return { ...member, valueId: bindings.get(member.id) ?? null };
@@ -139980,7 +140552,7 @@ __export(dev_exports, {
 import { watch } from "node:fs";
 import { join as join20 } from "node:path";
 import { emitKeypressEvents } from "node:readline";
-import { ConvexClient } from "convex/browser";
+import { ConvexClient as ConvexClient2 } from "convex/browser";
 function isSchemaSignal(value) {
   if (typeof value !== "object" || value === null) return false;
   return typeof value.transactionHash === "string";
@@ -140055,8 +140627,14 @@ async function runDev(workspace, options) {
       busy = false;
     }
   };
-  const convex = new ConvexClient(convexUrl);
-  convex.setAuth(async () => await mintConvexJwt(workspace.config.apiBaseUrl));
+  const convex = new ConvexClient2(convexUrl, { initialAuthTokenReuse: true });
+  convex.setAuth(
+    async () => await mintConvexJwt(
+      workspace.config.apiBaseUrl,
+      void 0,
+      convexHttpActionUrl(convexUrl)
+    )
+  );
   convex.onUpdate(
     api2.projectExportData.schemaSignal,
     {
@@ -140495,7 +141073,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.50.7");
+    console.log("0.50.8");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {
@@ -140899,12 +141477,15 @@ async function main() {
       return;
     }
     case "push": {
+      const finishPush = startPerformanceSpan("push");
+      const finishWorkspace = startPerformanceSpan("workspace");
       const json = boolFlag(args, "json");
       const preparation = process.stdout.isTTY === true && json !== true ? spinner("Preparing push\u2026") : null;
       let handedOffPreparation = false;
       try {
         const workspace = loadWorkspaceForCommand(args);
         const { runPush: runPush2 } = await Promise.resolve().then(() => (init_push(), push_exports));
+        finishWorkspace();
         handedOffPreparation = true;
         await runPush2(
           workspace,
@@ -140923,6 +141504,8 @@ async function main() {
           preparation?.fail("Push preparation failed.");
         }
         throw error;
+      } finally {
+        finishPush();
       }
       return;
     }
@@ -141022,6 +141605,7 @@ var DEFAULT_API_BASE_URL;
 var init_main = __esm({
   "src/main.ts"() {
     "use strict";
+    init_performance();
     init_auth_api_base_url();
     init_login();
     init_args();