convex 1.45.0 → 1.46.0

package/dist/cli.bundle.cjs

@@ -15222,7 +15222,7 @@ var require_context = __commonJS({
       };
     });
     var nodeContextIntegration = core.defineIntegration(_nodeContextIntegration);
-    var Context12 = core.convertIntegrationFnToClass(INTEGRATION_NAME, nodeContextIntegration);
+    var Context11 = core.convertIntegrationFnToClass(INTEGRATION_NAME, nodeContextIntegration);
     function _updateContext(contexts) {
       if (_optionalChain([contexts, "optionalAccess", (_11) => _11.app, "optionalAccess", (_12) => _12.app_memory])) {
         contexts.app.app_memory = process.memoryUsage().rss;
@@ -15432,7 +15432,7 @@ var require_context = __commonJS({
         return void 0;
       }
     }
-    exports2.Context = Context12;
+    exports2.Context = Context11;
     exports2.getDeviceContext = getDeviceContext;
     exports2.nodeContextIntegration = nodeContextIntegration;
     exports2.readDirAsync = readDirAsync;
@@ -47456,7 +47456,7 @@ var version;
 var init_index = __esm({
   "src/index.ts"() {
     "use strict";
-    version = "1.45.0";
+    version = "1.46.0";
   }
 });
 
@@ -50783,6 +50783,9 @@ function printLocalDeploymentWelcomeMessage() {
     )
   );
 }
+function releaseDate(version4) {
+  return /^precompiled-(\d{4}-\d{2}-\d{2})-/.exec(version4)?.[1] ?? null;
+}
 var LOCAL_BACKEND_INSTANCE_SECRET;
 var init_utils2 = __esm({
   "src/cli/lib/localDeployment/utils.ts"() {
@@ -53834,6 +53837,16 @@ var init_download = __esm({
 });
 
 // src/cli/lib/localDeployment/run.ts
+function _backendSupportsControlPlaneAuth(version4) {
+  if (version4 === FIRST_CONTROL_PLANE_AUTH_BACKEND_VERSION) {
+    return true;
+  }
+  const backendDate = releaseDate(version4);
+  const firstSupportedDate = releaseDate(
+    FIRST_CONTROL_PLANE_AUTH_BACKEND_VERSION
+  );
+  return backendDate !== null && firstSupportedDate !== null && backendDate > firstSupportedDate;
+}
 async function parseStartupTimeoutSecs(ctx) {
   const raw = process.env.CONVEX_LOCAL_BACKEND_STARTUP_TIMEOUT_SECS;
   if (raw === void 0) {
@@ -53921,7 +53934,22 @@ async function runLocalBackend(ctx, args) {
       errForSentry: new LocalDeploymentError(message)
     });
   }
-  const commandStr = `${args.binaryPath} ${commandArgs.join(" ")}`;
+  const supportsControlPlane = _backendSupportsControlPlaneAuth(
+    args.backendVersion
+  );
+  if (supportsControlPlane && provisionHost !== productionProvisionHost) {
+    commandArgs.push("--control-plane-url", provisionHost);
+  }
+  const auth2 = ctx.bigBrainAuth();
+  if (supportsControlPlane && args.deploymentKind === "local" && auth2?.kind === "accessToken") {
+    commandArgs.push("--control-plane-access-token", auth2.accessToken);
+  }
+  const displayArgs = commandArgs.map(
+    (arg, index) => index > 0 && ["--instance-secret", "--control-plane-access-token"].includes(
+      commandArgs[index - 1]
+    ) ? "[REDACTED]" : arg
+  );
+  const commandStr = `${args.binaryPath} ${displayArgs.join(" ")}`;
   logVerbose(`Starting local backend: \`${commandStr}\``);
   const p = import_child_process2.default.spawn(args.binaryPath, commandArgs, {
     stdio: "ignore",
@@ -54125,6 +54153,7 @@ Run \`npx convex dev\` first.`
   const instanceSecret = config3.instanceSecret ?? LOCAL_BACKEND_INSTANCE_SECRET;
   const { cleanupHandle } = await runLocalBackend(ctx, {
     binaryPath,
+    backendVersion: config3.backendVersion,
     ports: config3.ports,
     deploymentKind,
     deploymentName: args.deploymentName,
@@ -54140,7 +54169,7 @@ Run \`npx convex dev\` first.`
     }
   };
 }
-var import_path6, import_child_process2, import_crypto3, DEFAULT_STARTUP_TIMEOUT_SECS;
+var import_path6, import_child_process2, import_crypto3, DEFAULT_STARTUP_TIMEOUT_SECS, FIRST_CONTROL_PLANE_AUTH_BACKEND_VERSION;
 var init_run = __esm({
   "src/cli/lib/localDeployment/run.ts"() {
     "use strict";
@@ -54154,7 +54183,9 @@ var init_run = __esm({
     import_crypto3 = require("crypto");
     init_errors3();
     init_utils2();
+    init_config();
     DEFAULT_STARTUP_TIMEOUT_SECS = 30;
+    FIRST_CONTROL_PLANE_AUTH_BACKEND_VERSION = "precompiled-2026-09-15-4e9b83a";
   }
 });
 
@@ -64238,23 +64269,19 @@ function waitUntilCalled() {
   return [waitPromise, () => onCalled(null)];
 }
 function formatSize(n) {
-  if (n === 0) {
-    return "0 bytes";
+  let value = n;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < BYTE_UNITS.length - 1) {
+    value /= 1024;
+    unitIndex++;
   }
-  for (const [unitSize, unitName] of BYTE_UNITS) {
-    if (n < unitSize) {
-      continue;
-    }
-    if (n % unitSize === 0) {
-      return `${n / unitSize} ${unitName}`;
-    }
-    if (n * 10 % unitSize === 0) {
-      const whole = Math.floor(n / unitSize);
-      const frac = Math.floor(n * 10 / unitSize) % 10;
-      return `${whole}.${frac} ${unitName}`;
-    }
+  const roundedValue = Number(value.toFixed(1));
+  if (roundedValue >= 1024 && unitIndex < BYTE_UNITS.length - 1) {
+    value /= 1024;
+    unitIndex++;
   }
-  return `${n} bytes`;
+  const formatted = value.toFixed(1).replace(/\.0$/, "");
+  return `${formatted} ${BYTE_UNITS[unitIndex]}`;
 }
 function formatDuration(ms) {
   const twoDigits = (n, unit) => `${n.toLocaleString("en-US", { maximumFractionDigits: 2 })}${unit}`;
@@ -64371,8 +64398,8 @@ function retryDelay(attempt, _error, _response) {
   const randomSum = delay * 0.2 * Math.random();
   return delay + randomSum;
 }
-function deploymentFetchRetryOn(onError, method) {
-  const shouldRetry = function(_attempt, error3, response) {
+function deploymentFetchRetryOn(onError, method, maxRetries = MAX_RETRIES, shouldRetryOverride) {
+  const defaultShouldRetry = function(_attempt, error3, response) {
     if (error3 !== null) {
       return { kind: "retry", error: error3 };
     }
@@ -64418,12 +64445,18 @@ function deploymentFetchRetryOn(onError, method) {
     }
     return { kind: "stop" };
   };
+  const shouldRetry = shouldRetryOverride ? function(_attempt, error3, response) {
+    return shouldRetryOverride(error3, response) ? {
+      kind: "retry",
+      error: error3 ?? `Received response with status ${response?.status}`
+    } : { kind: "stop" };
+  } : defaultShouldRetry;
   return function(attempt, error3, response) {
     const result = shouldRetry(attempt, error3, response);
     if (result.kind === "retry") {
       onError?.(result.error, attempt);
     }
-    if (attempt >= MAX_RETRIES) {
+    if (attempt >= maxRetries) {
       return false;
     }
     return result.kind === "retry";
@@ -64452,13 +64485,19 @@ function bareDeploymentFetch(_ctx, options) {
   };
 }
 function deploymentFetch(_ctx, options) {
-  const { deploymentUrl, adminKey, onError } = options;
+  const {
+    deploymentUrl,
+    adminKey,
+    onError,
+    maxRetries = MAX_RETRIES,
+    shouldRetry
+  } = options;
   const onErrorWithAttempt = (err, attempt) => {
     onError?.(err);
     if (attempt >= RETRY_LOG_THRESHOLD) {
       logMessage(
         chalkStderr.gray(
-          `Retrying request (attempt ${attempt}/${MAX_RETRIES})...`
+          `Retrying request (attempt ${attempt}/${maxRetries})...`
         )
       );
     }
@@ -64477,7 +64516,12 @@ function deploymentFetch(_ctx, options) {
     }
     const func = throwingFetch(url2, {
       retryDelay,
-      retryOn: deploymentFetchRetryOn(onErrorWithAttempt, options2?.method),
+      retryOn: deploymentFetchRetryOn(
+        onErrorWithAttempt,
+        options2?.method,
+        maxRetries,
+        shouldRetry
+      ),
       ...options2,
       headers
     });
@@ -64611,14 +64655,7 @@ ${advice}`;
       PLATFORM_MANAGEMENT_API_URL,
       bigBrainFetch
     );
-    BYTE_UNITS = [
-      [1 << 30, "GiB"],
-      [1e9, "GB"],
-      [1 << 20, "MiB"],
-      [1e6, "MB"],
-      [1 << 10, "KiB"],
-      [1e3, "KB"]
-    ];
+    BYTE_UNITS = ["bytes", "KiB", "MiB", "GiB", "TiB", "PiB"];
     IDEMPOTENT_METHODS = ["GET", "HEAD", "PUT", "DELETE", "OPTIONS", "TRACE"];
   }
 });
@@ -110146,6 +110183,7 @@ init_run();
 init_log();
 init_filePaths();
 init_run();
+init_utils2();
 init_prompts();
 init_download();
 
@@ -110236,6 +110274,7 @@ async function handlePotentialUpgradeAndStart(ctx, args) {
     );
     const { cleanupHandle: cleanupHandle2 } = await runLocalBackend(ctx, {
       binaryPath: args.newBinaryPath,
+      backendVersion: args.newVersion,
       deploymentKind: args.deploymentKind,
       deploymentName: args.deploymentName,
       ports: args.ports,
@@ -110265,6 +110304,7 @@ async function handlePotentialUpgradeAndStart(ctx, args) {
     });
     const { cleanupHandle: cleanupHandle2 } = await runLocalBackend(ctx, {
       binaryPath: oldBinaryPath,
+      backendVersion: args.oldVersion,
       ports: args.ports,
       deploymentKind: args.deploymentKind,
       deploymentName: args.deploymentName,
@@ -110296,6 +110336,7 @@ async function handleUpgrade(ctx, args) {
   logVerbose(`Running backend on new version ${args.newVersion}`);
   const { cleanupHandle } = await runLocalBackend(ctx, {
     binaryPath: args.newBinaryPath,
+    backendVersion: args.newVersion,
     ports: args.ports,
     deploymentKind: args.deploymentKind,
     deploymentName: args.deploymentName,
@@ -110319,9 +110360,6 @@ function _isDowngrade(oldVersion, newVersion) {
   const newDate = releaseDate(newVersion);
   return oldDate !== null && newDate !== null && newDate < oldDate;
 }
-function releaseDate(version4) {
-  return /^precompiled-(\d{4}-\d{2}-\d{2})-/.exec(version4)?.[1] ?? null;
-}
 
 // src/cli/lib/localDeployment/localDeployment.ts
 init_errors3();
@@ -114593,7 +114631,7 @@ var startPushRequest = looseObject({
 var schemaChange = looseObject({
   allocatedComponentIds: external_exports.any(),
   schemaIds: external_exports.any(),
-  indexDiffs: external_exports.record(componentDefinitionPath, indexDiff).optional()
+  indexDiffs: external_exports.record(componentPath, indexDiff).optional()
 });
 var startPushResponse = looseObject({
   environmentVariables: external_exports.record(external_exports.string(), external_exports.string()),
@@ -114631,6 +114669,49 @@ var schemaStatus = external_exports.union([
   })
 ]);
 
+// src/cli/lib/deployApi/evaluateSchema.ts
+init_zod();
+var tableValidationOutcome = external_exports.enum([
+  "notValidated",
+  "supersetOfEnforced",
+  "supersetOfShape",
+  "mustWalk"
+]);
+var indexChangePrediction = external_exports.enum([
+  "added",
+  "identical",
+  "enabled",
+  "disabled",
+  "dropped"
+]);
+var tablePrediction = looseObject({
+  name: external_exports.string(),
+  outcome: tableValidationOutcome,
+  numDocs: external_exports.number(),
+  sizeBytes: external_exports.number()
+});
+var indexPrediction = external_exports.intersection(
+  developerIndexConfig,
+  looseObject({
+    change: indexChangePrediction,
+    needsBackfill: external_exports.boolean(),
+    numDocs: external_exports.number()
+  })
+);
+var componentSchemaPrediction = looseObject({
+  definitionPath: external_exports.string(),
+  schemaValidation: external_exports.boolean(),
+  tables: external_exports.array(tablePrediction),
+  indexes: external_exports.array(indexPrediction)
+});
+var evaluateSchemaResponse = looseObject({
+  componentSchemaEvaluations: external_exports.record(
+    componentPath,
+    componentSchemaPrediction
+  ),
+  newComponentDefinitions: external_exports.array(componentDefinitionPath)
+});
+
 // src/cli/lib/deploy2.ts
 init_source();
 var import_node_util9 = require("node:util");
@@ -115710,7 +115791,19 @@ async function evaluatePush(ctx, span, request, options) {
   );
   return evaluatePushResponse.parse(response);
 }
-async function pushCode(ctx, span, request, options, endpoint) {
+async function evaluateSchema(ctx, span, request, options, bestEffort) {
+  const response = await pushCode(
+    ctx,
+    span,
+    request,
+    options,
+    "/api/deploy2/evaluate_schema",
+    bestEffort
+  );
+  return evaluateSchemaResponse.parse(response);
+}
+var BEST_EFFORT_RETRIES = 5;
+async function pushCode(ctx, span, request, options, endpoint, bestEffort) {
   const unchangedModuleCount = request.appDefinition?.unchangedModuleHashes?.length ?? 0;
   const changedModuleCount = request.appDefinition?.changedModules?.length ?? 0;
   const requestSummary = {
@@ -115730,7 +115823,16 @@ async function pushCode(ctx, span, request, options, endpoint) {
   const fetch2 = deploymentFetch(ctx, {
     deploymentUrl: options.url,
     adminKey: request.adminKey,
-    onError
+    onError,
+    // Best-effort callers tolerate failure, so retry only plausibly
+    // transient conditions — network errors and 5xx responses (e.g. table
+    // summaries still bootstrapping) — and fail fast on everything else,
+    // like a 404 from a deployment whose backend doesn't yet expose the
+    // endpoint.
+    ...bestEffort ? {
+      maxRetries: BEST_EFFORT_RETRIES,
+      shouldRetry: (error3, response) => error3 !== null || response !== null && response.status >= 500
+    } : {}
   });
   try {
     const response = await fetch2(endpoint, {
@@ -115744,6 +115846,9 @@ async function pushCode(ctx, span, request, options, endpoint) {
     });
     return await response.json();
   } catch (error3) {
+    if (bestEffort) {
+      throw error3;
+    }
     return await handlePushConfigError(
       ctx,
       error3,
@@ -115956,6 +116061,7 @@ async function deployToDeployment(ctx, credentials, options) {
     liveComponentSources: !!options.liveComponentSources,
     pushAllModules: !!options.pushAllModules,
     largeIndexDeletionCheck: options.allowDeletingLargeIndexes ? "has confirmation" : "ask for confirmation",
+    warnOnSlowSchemaValidation: true,
     message: options.message
   };
   showSpinner(`Deploying to ${url2}...${options.dryRun ? " [dry run]" : ""}`);
@@ -119641,71 +119747,28 @@ async function checkForLargeIndexDeletion({
   askForConfirmation
 }) {
   changeSpinner("Verifying that the push isn\u2019t deleting large indexes...");
-  const { schemaChange: schemaChange2 } = await evaluatePush(ctx, span, request, options);
-  const indexDiffs = schemaChange2.indexDiffs ?? {};
-  const deletedIndexes = Object.entries(indexDiffs).flatMap(
-    ([componentDefinitionPath2, indexDiff2]) => indexDiff2.removed_indexes.map((index) => ({
-      componentDefinitionPath: componentDefinitionPath2,
-      index
-    }))
-  );
+  const deletedIndexes = await deletedIndexesFromSchemaEvaluation({
+    ctx,
+    span,
+    request,
+    options
+  }) ?? await deletedIndexesFromTableSizes({ ctx, span, request, options });
   if (deletedIndexes.length === 0) {
     logFinishedStep("No indexes are deleted by this push");
     return;
   }
-  const tablesWithDeletedIndexes = [
-    ...new Set(
-      deletedIndexes.map(
-        ({ componentDefinitionPath: componentDefinitionPath2, index }) => `${componentDefinitionPath2}:${getTableName(index)}`
-      )
-    )
-  ].map((str) => {
-    const [componentDefinitionPath2, table] = str.split(":");
-    return { componentDefinitionPath: componentDefinitionPath2, table };
-  });
-  changeSpinner("Checking whether the deleted indexes are on large tables...");
-  const documentCounts = await Promise.all(
-    tablesWithDeletedIndexes.map(
-      async ({ componentDefinitionPath: componentDefinitionPath2, table }) => ({
-        componentDefinitionPath: componentDefinitionPath2,
-        table,
-        count: await runSystemQuery(ctx, {
-          deploymentUrl: options.url,
-          adminKey: options.adminKey,
-          functionName: "_system/cli/tableSize:default",
-          componentPath: componentDefinitionPath2,
-          args: { tableName: table }
-        })
-      })
-    )
-  );
-  const deletedIndexesWithDocumentsCount = deletedIndexes.map(
-    ({ componentDefinitionPath: componentDefinitionPath2, index }) => ({
-      componentDefinitionPath: componentDefinitionPath2,
-      index,
-      count: documentCounts.find(
-        (count) => count.table === getTableName(index) && count.componentDefinitionPath === componentDefinitionPath2
-      ).count
-    })
-  );
   const minDocumentsForWarning = minDocumentsForIndexDeleteWarning();
-  if (!deletedIndexesWithDocumentsCount.some(
-    ({ count }) => count >= minDocumentsForWarning
+  if (!deletedIndexes.some(
+    ({ documentsCount }) => documentsCount >= minDocumentsForWarning
   )) {
     logFinishedStep("No large indexes are deleted by this push");
     return;
   }
-  logMessage(`\u26A0\uFE0F  This code push will ${chalkStderr.bold("delete")} the following ${deletedIndexesWithDocumentsCount.length === 1 ? "index" : "indexes"}
+  logMessage(`\u26A0\uFE0F  This code push will ${chalkStderr.bold("delete")} the following ${deletedIndexes.length === 1 ? "index" : "indexes"}
 from your production deployment (${options.url}):
 
-${deletedIndexesWithDocumentsCount.map(
-    ({ componentDefinitionPath: componentDefinitionPath2, index, count }) => formatDeletedIndex({
-      componentDefinitionPath: componentDefinitionPath2,
-      index,
-      indexDiff: indexDiffs[componentDefinitionPath2],
-      documentsCount: count,
-      minDocumentsForWarning
-    })
+${deletedIndexes.map(
+    (deletedIndex) => formatDeletedIndex({ ...deletedIndex, minDocumentsForWarning })
   ).join("\n")}
 
 The documents that are in the index won\u2019t be deleted, but the index will need
@@ -119728,7 +119791,7 @@ to be backfilled again if you want to restore it later.
   }
   stopSpinner();
   if (!await promptYesNo(ctx, {
-    message: `Delete ${deletedIndexesWithDocumentsCount.length === 1 ? "this index" : "these indexes"}?`,
+    message: `Delete ${deletedIndexes.length === 1 ? "this index" : "these indexes"}?`,
     default: false
   })) {
     return ctx.crash({
@@ -119739,16 +119802,98 @@ to be backfilled again if you want to restore it later.
   }
   logFinishedStep("Proceeding with push.");
 }
+async function deletedIndexesFromSchemaEvaluation({
+  ctx,
+  span,
+  request,
+  options
+}) {
+  try {
+    const response = await evaluateSchema(
+      ctx,
+      span,
+      request,
+      options,
+      /* bestEffort */
+      true
+    );
+    return Object.entries(response.componentSchemaEvaluations).flatMap(
+      ([componentPath2, prediction]) => prediction.indexes.filter((index) => index.change === "dropped").map((index) => ({
+        componentPath: componentPath2,
+        index,
+        documentsCount: index.numDocs,
+        replacedBy: prediction.indexes.find(
+          (other) => other.change === "added" && other.name === index.name
+        ) ?? null
+      }))
+    );
+  } catch (error3) {
+    logVerbose(
+      `Schema evaluation unavailable, sizing deleted indexes per table: ${error3 instanceof Error ? error3.message : String(error3)}`
+    );
+    return null;
+  }
+}
+async function deletedIndexesFromTableSizes({
+  ctx,
+  span,
+  request,
+  options
+}) {
+  const { schemaChange: schemaChange2 } = await evaluatePush(ctx, span, request, options);
+  const indexDiffs = schemaChange2.indexDiffs ?? {};
+  const deletedIndexes = Object.entries(indexDiffs).flatMap(
+    ([componentPath2, indexDiff2]) => indexDiff2.removed_indexes.map((index) => ({
+      componentPath: componentPath2,
+      index,
+      replacedBy: indexDiff2.added_indexes.find((other) => other.name === index.name) ?? null
+    }))
+  );
+  if (deletedIndexes.length === 0) {
+    return [];
+  }
+  const tablesWithDeletedIndexes = [
+    ...new Set(
+      deletedIndexes.map(
+        ({ componentPath: componentPath2, index }) => `${componentPath2}:${getTableName(index)}`
+      )
+    )
+  ].map((str) => {
+    const [componentPath2, table] = str.split(":");
+    return { componentPath: componentPath2, table };
+  });
+  changeSpinner("Checking whether the deleted indexes are on large tables...");
+  const documentCounts = await Promise.all(
+    tablesWithDeletedIndexes.map(async ({ componentPath: componentPath2, table }) => ({
+      componentPath: componentPath2,
+      table,
+      count: await runSystemQuery(ctx, {
+        deploymentUrl: options.url,
+        adminKey: options.adminKey,
+        functionName: "_system/cli/tableSize:default",
+        componentPath: componentPath2,
+        args: { tableName: table }
+      })
+    }))
+  );
+  return deletedIndexes.map(({ componentPath: componentPath2, index, replacedBy }) => ({
+    componentPath: componentPath2,
+    index,
+    replacedBy,
+    documentsCount: documentCounts.find(
+      (count) => count.table === getTableName(index) && count.componentPath === componentPath2
+    ).count
+  }));
+}
 function formatDeletedIndex({
-  componentDefinitionPath: componentDefinitionPath2,
+  componentPath: componentPath2,
   index,
-  indexDiff: indexDiff2,
   documentsCount,
+  replacedBy,
   minDocumentsForWarning
 }) {
-  const componentNameFormatted = componentDefinitionPath2 !== "" ? `${chalkStderr.gray(componentDefinitionPath2)}:` : "";
+  const componentNameFormatted = componentPath2 !== "" ? `${chalkStderr.gray(componentPath2)}:` : "";
   const documentsCountFormatted = documentsCount >= minDocumentsForWarning ? `  ${chalkStderr.yellowBright(`\u26A0\uFE0F  ${documentsCount.toLocaleString()} documents`)}` : `  ${documentsCount.toLocaleString()} ${documentsCount === 1 ? "document" : "documents"}`;
-  const replacedBy = indexDiff2.added_indexes.find((i) => i.name === index.name);
   const replacedByFormatted = replacedBy ? `
    ${chalkStderr.green("\u2192 replaced by:")} ${formatIndex(replacedBy)}` : "";
   return "\u26D4 " + componentNameFormatted + formatIndex(index) + documentsCountFormatted + replacedByFormatted;
@@ -119768,6 +119913,90 @@ function minDocumentsForIndexDeleteWarning() {
   return MIN_DOCUMENTS_FOR_INDEX_DELETE_WARNING;
 }
 
+// src/cli/lib/checkForSlowSchemaValidation.ts
+init_source();
+init_log();
+init_utils3();
+var MIN_BYTES_FOR_SCHEMA_WALK_WARNING = 1 << 27;
+async function checkForSlowSchemaValidation({
+  ctx,
+  span,
+  request,
+  options
+}) {
+  const response = await evaluateSchemaBestEffort({
+    ctx,
+    span,
+    request,
+    options
+  });
+  if (response === null) {
+    return;
+  }
+  const walkedTables = Object.entries(
+    response.componentSchemaEvaluations
+  ).flatMap(
+    ([componentPath2, prediction]) => prediction.tables.filter((table) => table.outcome === "mustWalk").map((table) => ({ componentPath: componentPath2, table }))
+  );
+  if (walkedTables.length === 0) {
+    return;
+  }
+  const totalBytes = walkedTables.reduce(
+    (sum, { table }) => sum + table.sizeBytes,
+    0
+  );
+  if (totalBytes < minBytesForSchemaWalkWarning()) {
+    return;
+  }
+  logMessage(`\u26A0\uFE0F  This schema change requires checking every document in the following ${walkedTables.length === 1 ? "table" : "tables"} against your new schema, totaling ${chalkStderr.yellowBright(formatSize(totalBytes))}. This deploy may take a while:
+
+${walkedTables.map(
+    ({ componentPath: componentPath2, table }) => formatWalkedTable({ componentPath: componentPath2, table })
+  ).join("\n")}
+`);
+}
+async function evaluateSchemaBestEffort({
+  ctx,
+  span,
+  request,
+  options
+}) {
+  try {
+    return await evaluateSchema(
+      ctx,
+      span,
+      request,
+      options,
+      /* bestEffort */
+      true
+    );
+  } catch (error3) {
+    logVerbose(
+      `Skipping slow schema validation check: ${error3 instanceof Error ? error3.message : String(error3)}`
+    );
+    return null;
+  }
+}
+function formatWalkedTable({
+  componentPath: componentPath2,
+  table
+}) {
+  const componentPrefix = componentPath2 !== "" ? `${chalkStderr.gray(componentPath2)}: ` : "";
+  const docsFormatted = `${table.numDocs.toLocaleString()} documents, `;
+  const sizeFormatted = formatSize(table.sizeBytes);
+  return `  ${componentPrefix}${table.name} (${docsFormatted}${sizeFormatted})`;
+}
+function minBytesForSchemaWalkWarning() {
+  const envValue = process.env.CONVEX_MIN_BYTES_FOR_SCHEMA_WALK_WARNING;
+  if (envValue !== void 0) {
+    const parsed = parseInt(envValue, 10);
+    if (!isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return MIN_BYTES_FOR_SCHEMA_WALK_WARNING;
+}
+
 // src/cli/lib/components.ts
 var import_crypto6 = require("crypto");
 async function runCodegen(ctx, credentials, options) {
@@ -120041,6 +120270,17 @@ async function startComponentsPushAndCodegen(ctx, parentSpan, projectConfig, con
       })
     );
   }
+  if (options.dryRun && options.warnOnSlowSchemaValidation) {
+    await parentSpan.enterAsync(
+      "checkForSlowSchemaValidation",
+      (span) => checkForSlowSchemaValidation({
+        ctx,
+        span,
+        request: startPushRequest2,
+        options
+      })
+    );
+  }
   changeSpinner("Uploading functions to Convex...");
   const startPushResponse2 = await parentSpan.enterAsync(
     "startPush",
@@ -120569,6 +120809,7 @@ async function devAgainstDeployment(ctx, credentials, devOptions) {
         // Pass logManager to control logs during deploy
         largeIndexDeletionCheck: "no verification",
         // `convex dev` can’t push to prod
+        warnOnSlowSchemaValidation: true,
         message: null
       },
       devOptions
@@ -121311,6 +121552,7 @@ async function pushToDeployment(ctx, args) {
       pushAllModules: false,
       largeIndexDeletionCheck: "no verification",
       // `convex run` can’t push to prod
+      warnOnSlowSchemaValidation: true,
       message: null
     },
     {
@@ -124991,6 +125233,8 @@ var codegen = new Command2("codegen").summary("Generate backend type definitions
     systemUdfs: !!options.systemUdfs,
     largeIndexDeletionCheck: "no verification",
     // `codegen` is a read-only operation
+    warnOnSlowSchemaValidation: false,
+    // ditto: a codegen dry run never deploys
     codegenOnlyThisComponent: options.componentDir
   };
   if (options.systemUdfs) {
@@ -127385,6 +127629,7 @@ async function deployToNewPreviewDeployment(ctx, deploymentSelection, options) {
     pushAllModules: !!options.pushAllModules,
     largeIndexDeletionCheck: "no verification",
     // fine for preview deployments
+    warnOnSlowSchemaValidation: true,
     message: options.message
   };
   showSpinner(`Deploying to ${previewUrl}...`);
@@ -130679,42 +130924,11 @@ var dev = new Command2("dev").summary("Develop against a dev deployment, watchin
 // src/cli/docs.ts
 init_source();
 init_log();
-init_utils3();
 var docs = new Command2("docs").description("Open the docs in the browser").allowExcessArguments(false).option("--no-open", "Print docs URL instead of opening it in your browser").action(async (options) => {
-  const ctx = await oneoffContext({
-    url: void 0,
-    adminKey: void 0,
-    envFile: void 0
-  });
-  const deploymentSelection = await getDeploymentSelection(ctx, {
-    url: void 0,
-    adminKey: void 0,
-    envFile: void 0
-  });
-  const configuredDeployment = deploymentNameFromSelection(deploymentSelection);
-  if (configuredDeployment === null) {
-    await openDocs(ctx, options.open);
-    return;
-  }
-  const getCookieUrl = new URL(
-    `get_cookie/${configuredDeployment}`,
-    BIG_BRAIN_URL
-  );
-  const fetch2 = bigBrainFetch(ctx);
-  try {
-    const res = await fetch2(getCookieUrl);
-    deprecationCheckWarning(ctx, res);
-    const { cookie } = await res.json();
-    await openDocs(ctx, options.open, cookie);
-  } catch {
-    await openDocs(ctx, options.open);
-  }
+  await openDocs(options.open);
 });
-async function openDocs(ctx, toOpen, cookie) {
-  let docsUrl = "https://docs.convex.dev";
-  if (cookie !== void 0) {
-    docsUrl += "/?t=" + cookie;
-  }
+async function openDocs(toOpen) {
+  const docsUrl = "https://docs.convex.dev/?utm_source=convex-cli";
   if (toOpen) {
     await open_default(docsUrl);
     logMessage(chalkStderr.green("Docs have launched! Check your browser."));