convex 1.45.0-alpha.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-alpha.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");
@@ -114645,7 +114726,7 @@ function addProgressLinkIfSlow(msg, deploymentName, start) {
   if (Date.now() - start > 1e4) {
     const dashboardUrl2 = deploymentDashboardUrlPage(
       deploymentName,
-      `/data?showSchema=true`
+      `/schema?showSchema=true`
     );
     msg = msg.concat(`
 See progress here: ${dashboardUrl2}`);
@@ -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."));
@@ -131886,6 +132100,9 @@ var logs = new Command2("logs").summary("Watch logs from your deployment").descr
   });
 });
 
+// src/cli/mcp.ts
+init_log();
+
 // ../node_modules/.pnpm/@modelcontextprotocol+server@2.0.0/node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
 var __create2 = Object.create;
 var __defProp2 = Object.defineProperty;
@@ -138681,6 +138898,7 @@ function missingClientCapabilities(required2, declared) {
   return Object.keys(missing).length > 0 ? missing : void 0;
 }
 var FIRST_MODERN_PROTOCOL_VERSION = "2026-07-28";
+var SUPPORTED_MODERN_PROTOCOL_VERSIONS = [FIRST_MODERN_PROTOCOL_VERSION];
 function isModernProtocolVersion(version4) {
   return version4 >= FIRST_MODERN_PROTOCOL_VERSION;
 }
@@ -141239,6 +141457,25 @@ function isSpecNotificationMethod(method) {
   return ALL_CODECS.some((codec) => codec.hasNotificationMethod(method));
 }
 var ALL_CODECS = [rev2025Codec, rev2026Codec];
+function isPlainObject$3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requestMetaOf(params) {
+  if (!isPlainObject$3(params)) return void 0;
+  const meta2 = params["_meta"];
+  return isPlainObject$3(meta2) ? meta2 : void 0;
+}
+function hasEnvelopeClaim(params) {
+  const meta2 = requestMetaOf(params);
+  return meta2 !== void 0 && PROTOCOL_VERSION_META_KEY in meta2;
+}
+function envelopeClaimVersion(params) {
+  const value = requestMetaOf(params)?.[PROTOCOL_VERSION_META_KEY];
+  return typeof value === "string" ? value : void 0;
+}
+function validateEnvelopeMeta(meta2) {
+  return codecForVersion(MODERN_WIRE_REVISION).validateEnvelopeMeta(meta2);
+}
 var schemas_exports2 = /* @__PURE__ */ __exportAll({
   AnnotationsSchema: () => AnnotationsSchema,
   AudioContentSchema: () => AudioContentSchema,
@@ -141412,6 +141649,96 @@ var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value
 var isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success;
 var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
 var isInputRequiredResult = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && value.resultType === "input_required";
+function assertCompleteRequestPrompt(request) {
+  if (request.params.ref.type !== "ref/prompt") throw new TypeError(`Expected CompleteRequestPrompt, but got ${request.params.ref.type}`);
+}
+function assertCompleteRequestResourceTemplate(request) {
+  if (request.params.ref.type !== "ref/resource") throw new TypeError(`Expected CompleteRequestResourceTemplate, but got ${request.params.ref.type}`);
+}
+var X_MCP_HEADER_KEY = "x-mcp-header";
+var RFC9110_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var PERMITTED_X_MCP_HEADER_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "integer",
+  "boolean",
+  "number"
+]);
+function scanXMcpHeaderDeclarations(inputSchema9) {
+  const declarations = [];
+  const seenLower = /* @__PURE__ */ new Map();
+  const visit = (node, path38, reachable) => {
+    if (node === null || typeof node !== "object") return void 0;
+    const schema2 = node;
+    if (X_MCP_HEADER_KEY in schema2) {
+      if (!reachable || path38.length === 0) return `${pathName(path38)}: x-mcp-header is only permitted on properties statically reachable via a chain of 'properties' keys (not under items, additionalProperties, oneOf/anyOf/allOf/not, if/then/else, or $ref)`;
+      const raw = schema2[X_MCP_HEADER_KEY];
+      if (typeof raw !== "string" || raw.length === 0) return `${pathName(path38)}: x-mcp-header MUST be a non-empty string`;
+      if (!RFC9110_TOKEN.test(raw)) return `${pathName(path38)}: x-mcp-header '${raw}' is not a valid RFC 9110 token (no spaces, control characters or HTTP delimiters)`;
+      const type = typeof schema2.type === "string" ? schema2.type : void 0;
+      if (type === void 0 || !PERMITTED_X_MCP_HEADER_TYPES.has(type)) return `${pathName(path38)}: x-mcp-header is only permitted on primitive-typed properties (string, integer, boolean); got ${type ?? "<none>"}`;
+      const lower = raw.toLowerCase();
+      const prior = seenLower.get(lower);
+      if (prior !== void 0) return `x-mcp-header '${raw}' is not case-insensitively unique (also declared as '${prior}')`;
+      seenLower.set(lower, raw);
+      declarations.push({
+        path: path38,
+        headerName: raw,
+        type
+      });
+    }
+    const properties = schema2.properties;
+    if (properties !== null && typeof properties === "object") for (const [key, child] of Object.entries(properties)) {
+      const fault$1 = visit(child, [...path38, key], reachable);
+      if (fault$1 !== void 0) return fault$1;
+    }
+    for (const k of NON_REACHABLE_SUBSCHEMA_KEYWORDS) {
+      const sub = schema2[k];
+      if (sub === void 0) continue;
+      const branches = Array.isArray(sub) ? sub : sub !== null && typeof sub === "object" && OBJECT_VALUED_SUBSCHEMA_KEYWORDS.has(k) ? Object.values(sub) : [sub];
+      for (const branch of branches) {
+        const fault$1 = visit(branch, [...path38, `<${k}>`], false);
+        if (fault$1 !== void 0) return fault$1;
+      }
+    }
+  };
+  const fault = visit(inputSchema9, [], true);
+  return fault === void 0 ? {
+    valid: true,
+    declarations
+  } : {
+    valid: false,
+    reason: fault
+  };
+}
+var NON_REACHABLE_SUBSCHEMA_KEYWORDS = [
+  "items",
+  "prefixItems",
+  "contains",
+  "additionalProperties",
+  "unevaluatedProperties",
+  "unevaluatedItems",
+  "propertyNames",
+  "patternProperties",
+  "dependentSchemas",
+  "oneOf",
+  "anyOf",
+  "allOf",
+  "not",
+  "if",
+  "then",
+  "else",
+  "$defs",
+  "definitions"
+];
+var OBJECT_VALUED_SUBSCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+  "patternProperties",
+  "dependentSchemas",
+  "$defs",
+  "definitions"
+]);
+function pathName(path38) {
+  return path38.length === 0 ? "<root>" : path38.join(".");
+}
 var HEADER_MISMATCH_ERROR_CODE = -32020;
 var INBOUND_VALIDATION_LADDER = [
   {
@@ -141499,6 +141826,45 @@ var LADDER_ERROR_HTTP_STATUS = {
   [ProtocolErrorCode.MissingRequiredClientCapability]: 400,
   [HEADER_MISMATCH_ERROR_CODE]: 400
 };
+function rejection(rung, cell, httpStatus, error3, settled) {
+  return {
+    kind: "reject",
+    rung,
+    cell,
+    httpStatus,
+    code: error3.code,
+    message: error3.message,
+    ...error3.data !== void 0 && { data: error3.data },
+    settled
+  };
+}
+function carriesValidModernEnvelopeClaim(params) {
+  if (!hasEnvelopeClaim(params)) return false;
+  const claimedVersion = envelopeClaimVersion(params);
+  if (claimedVersion === void 0 || !isModernProtocolVersion(claimedVersion)) return false;
+  const meta2 = requestMetaOf(params);
+  return meta2 !== void 0 && validateEnvelopeMeta(meta2).length === 0;
+}
+function modernOnlyStrictRejection(route, supportedVersions) {
+  switch (route.reason) {
+    case "http-method":
+      return rejection("http-method", "modern-only-method-not-allowed", 405, new ProtocolError(-32e3, "Method not allowed."), true);
+    case "batch":
+      return rejection("jsonrpc-shape", "modern-only-batch-not-supported", 400, new ProtocolError(ProtocolErrorCode.InvalidRequest, "Bad Request: JSON-RPC batches are not supported by this endpoint"), true);
+    case "response":
+      return rejection("jsonrpc-shape", "modern-only-response-post", 400, new ProtocolError(ProtocolErrorCode.InvalidRequest, "Bad Request: JSON-RPC responses cannot be posted to this endpoint"), true);
+    case "notification":
+      return;
+    case "initialize":
+    case "no-claim": {
+      const requested = route.requestedVersion;
+      return rejection("era-classification", "modern-only-missing-envelope", 400, requested === void 0 ? new ProtocolError(ProtocolErrorCode.UnsupportedProtocolVersion, "Unsupported protocol version: the request did not name a protocol version", { supported: [...supportedVersions] }) : new UnsupportedProtocolVersionError({
+        supported: [...supportedVersions],
+        requested
+      }), true);
+    }
+  }
+}
 function parseSchema(schema2, data2) {
   return safeParse2(schema2, data2);
 }
@@ -141613,6 +141979,16 @@ function isLibraryFormatPattern(format5, pattern, vendor) {
   if (vendor !== "zod") return true;
   return referencePatternsForFormat(format5, pattern).has(pattern);
 }
+function promptArgumentsFromStandardSchema(schema2) {
+  const jsonSchema = standardSchemaToJsonSchema(schema2, "input");
+  const properties = jsonSchema.properties || {};
+  const required2 = jsonSchema.required || [];
+  return Object.entries(properties).map(([name, prop]) => ({
+    name,
+    description: prop?.description,
+    required: required2.includes(name)
+  }));
+}
 function isJsonObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -142050,6 +142426,9 @@ function withRequestStateValue(ctx, value) {
   };
 }
 var writeNegotiatedProtocolVersion;
+function setNegotiatedProtocolVersion(instance, version4) {
+  writeNegotiatedProtocolVersion(instance, version4);
+}
 var Protocol = class {
   _transport;
   _requestMessageId = 0;
@@ -142908,6 +143287,68 @@ function deserializeMessage(line) {
 function serializeMessage(message) {
   return JSON.stringify(message) + "\n";
 }
+var TOOL_NAME_REGEX = /^[A-Za-z0-9._-]{1,128}$/;
+function validateToolName(name) {
+  const warnings = [];
+  if (name.length === 0) return {
+    isValid: false,
+    warnings: ["Tool name cannot be empty"]
+  };
+  if (name.length > 128) return {
+    isValid: false,
+    warnings: [`Tool name exceeds maximum length of 128 characters (current: ${name.length})`]
+  };
+  if (name.includes(" ")) warnings.push("Tool name contains spaces, which may cause parsing issues");
+  if (name.includes(",")) warnings.push("Tool name contains commas, which may cause parsing issues");
+  if (name.startsWith("-") || name.endsWith("-")) warnings.push("Tool name starts or ends with a dash, which may cause parsing issues in some contexts");
+  if (name.startsWith(".") || name.endsWith(".")) warnings.push("Tool name starts or ends with a dot, which may cause parsing issues in some contexts");
+  if (!TOOL_NAME_REGEX.test(name)) {
+    const invalidChars = [...name].filter((char) => !/[A-Za-z0-9._-]/.test(char)).filter((char, index, arr) => arr.indexOf(char) === index);
+    warnings.push(`Tool name contains invalid characters: ${invalidChars.map((c) => `"${c}"`).join(", ")}`, "Allowed characters are: A-Z, a-z, 0-9, underscore (_), dash (-), and dot (.)");
+    return {
+      isValid: false,
+      warnings
+    };
+  }
+  return {
+    isValid: true,
+    warnings
+  };
+}
+function issueToolNameWarning(name, warnings) {
+  if (warnings.length > 0) {
+    console.warn(`Tool name validation warning for "${name}":`);
+    for (const warning2 of warnings) console.warn(`  - ${warning2}`);
+    console.warn("Tool registration will proceed, but this may cause compatibility issues.");
+    console.warn("Consider updating the tool name to conform to the MCP tool naming standard.");
+    console.warn("See SEP: Specify Format for Tool Names (https://github.com/modelcontextprotocol/modelcontextprotocol/issues/986) for more details.");
+  }
+}
+function validateAndWarnToolName(name) {
+  const result = validateToolName(name);
+  issueToolNameWarning(name, result.warnings);
+  return result.isValid;
+}
+function isZodV4Schema(v) {
+  return typeof v === "object" && v !== null && "_zod" in v;
+}
+function looksLikeZodV3(v) {
+  return typeof v === "object" && v !== null && !("_zod" in v) && "_def" in v && typeof v._def?.typeName === "string";
+}
+function isZodRawShape(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  if (isStandardSchema(obj)) return false;
+  const proto2 = Object.getPrototypeOf(obj);
+  if (proto2 !== Object.prototype && proto2 !== null) return false;
+  return Object.values(obj).every((v) => isZodV4Schema(v));
+}
+function normalizeRawShapeSchema(schema2) {
+  if (schema2 === void 0) return void 0;
+  if (isZodRawShape(schema2)) return object(schema2);
+  if (typeof schema2 === "object" && schema2 !== null && !isStandardSchema(schema2) && Object.values(schema2).some((v) => looksLikeZodV3(v))) throw new TypeError("Raw-shape inputSchema/outputSchema/argsSchema fields must be Zod v4 schemas. Got a Zod v3 field schema. Import from `zod/v4` (or upgrade your zod import), or wrap with `z.object({...})` yourself.");
+  if (!isStandardSchema(schema2)) throw new TypeError("inputSchema/outputSchema/argsSchema must be a Standard Schema (e.g. z.object({...})) or a raw Zod shape ({ field: z.string() }).");
+  return schema2;
+}
 
 // ../node_modules/.pnpm/@modelcontextprotocol+server@2.0.0/node_modules/@modelcontextprotocol/server/dist/ajvProvider-CEoC__sr.mjs
 var require_code$1 = /* @__PURE__ */ __commonJSMin(((exports2) => {
@@ -149924,7 +150365,197 @@ var import_node_process16 = __toESM(require("node:process"), 1);
 
 // ../node_modules/.pnpm/@modelcontextprotocol+server@2.0.0/node_modules/@modelcontextprotocol/server/dist/mcp-DXXb3Vv3.mjs
 var COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
+function isCompletable(schema2) {
+  return !!schema2 && typeof schema2 === "object" && COMPLETABLE_SYMBOL in schema2;
+}
+function getCompleter(schema2) {
+  return schema2[COMPLETABLE_SYMBOL]?.complete;
+}
 var MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
+function listenFilterAccepts(filter, event) {
+  switch (event.kind) {
+    case "tools_list_changed":
+      return filter.toolsListChanged === true;
+    case "prompts_list_changed":
+      return filter.promptsListChanged === true;
+    case "resources_list_changed":
+      return filter.resourcesListChanged === true;
+    case "resource_updated":
+      return filter.resourceSubscriptions !== void 0 && filter.resourceSubscriptions.includes(event.uri);
+  }
+}
+function honoredSubset(requested, capabilities) {
+  const honored = {};
+  const allow = (bit) => capabilities === void 0 || bit === true;
+  if (requested.toolsListChanged === true && allow(capabilities?.tools?.listChanged)) honored.toolsListChanged = true;
+  if (requested.promptsListChanged === true && allow(capabilities?.prompts?.listChanged)) honored.promptsListChanged = true;
+  if (requested.resourcesListChanged === true && allow(capabilities?.resources?.listChanged)) honored.resourcesListChanged = true;
+  if (requested.resourceSubscriptions !== void 0 && requested.resourceSubscriptions.length > 0 && allow(capabilities?.resources?.subscribe)) honored.resourceSubscriptions = [...requested.resourceSubscriptions];
+  return honored;
+}
+var DEFAULT_MAX_SUBSCRIPTIONS = 1024;
+function stampSubscriptionId(notification, subscriptionId) {
+  return {
+    method: notification.method,
+    params: {
+      ...notification.params,
+      _meta: {
+        ...notification.params?._meta,
+        [SUBSCRIPTION_ID_META_KEY]: subscriptionId
+      }
+    }
+  };
+}
+function parseListenFilter(message) {
+  const outcome = codecForVersion(MODERN_WIRE_REVISION).validateRequest("subscriptions/listen", message);
+  return outcome.ok ? outcome.value.params?.notifications : void 0;
+}
+var CHANGE_NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
+  "notifications/tools/list_changed",
+  "notifications/prompts/list_changed",
+  "notifications/resources/list_changed",
+  "notifications/resources/updated"
+]);
+var StdioListenRouter = class {
+  /** Active subscriptions, keyed by the listen request's JSON-RPC id verbatim. */
+  _subs = /* @__PURE__ */ new Map();
+  /**
+  * The serving instance's declared capabilities. Filled in by the entry
+  * once the modern instance is constructed (the router is created before
+  * the instance exists), so the acknowledged filter is narrowed against
+  * what the server can actually deliver.
+  */
+  _serverCapabilities;
+  /**
+  * The serving instance's identity, stamped onto the graceful-close
+  * results' `_meta` (the spec's `SubscriptionsListenResultMeta` extends
+  * `ResultMetaObject`). Handed over together with the capabilities.
+  */
+  _serverInfo;
+  constructor(_maxSubscriptions = DEFAULT_MAX_SUBSCRIPTIONS, serverCapabilities, serverInfo) {
+    this._maxSubscriptions = _maxSubscriptions;
+    this._serverCapabilities = serverCapabilities;
+    this._serverInfo = serverInfo;
+  }
+  /**
+  * Record the serving instance's declared capabilities and identity once
+  * it has been constructed. Called by `serveStdio`'s connect path;
+  * subsequent `serve()` calls narrow the honored filter against the
+  * capabilities, and `teardownAll()` stamps the identity.
+  */
+  setServerCapabilities(capabilities, serverInfo) {
+    this._serverCapabilities = capabilities;
+    if (serverInfo !== void 0) this._serverInfo = serverInfo;
+  }
+  /** Whether `id` is an active listen subscription on this connection. */
+  has(id) {
+    return this._subs.has(id);
+  }
+  /**
+  * Serve one inbound `subscriptions/listen` request: registers the
+  * subscription and returns the stamped acknowledged notification (or, on
+  * capacity / params rejection, the in-band JSON-RPC error response).
+  *
+  * @throws when called before {@linkcode setServerCapabilities} (or the
+  * constructor) has supplied the serving instance's capabilities. Honoring a
+  * filter without knowing the server's advertised capabilities would fail
+  * open (deliver unadvertised types); the entry guarantees capabilities are
+  * set before any listen request is routed here.
+  */
+  serve(message) {
+    if (this._serverCapabilities === void 0) throw new Error("StdioListenRouter.serve() called before setServerCapabilities(); refusing to honor a filter without capabilities");
+    if (this._subs.size >= this._maxSubscriptions) return {
+      jsonrpc: "2.0",
+      id: message.id,
+      error: {
+        code: -32603,
+        message: "Subscription limit reached"
+      }
+    };
+    const filter = parseListenFilter(message);
+    if (filter === void 0) return {
+      jsonrpc: "2.0",
+      id: message.id,
+      error: {
+        code: -32602,
+        message: "Invalid params: 'notifications' is required and must be a valid SubscriptionFilter"
+      }
+    };
+    const honored = honoredSubset(filter, this._serverCapabilities);
+    this._subs.set(message.id, honored);
+    return stampSubscriptionId({
+      method: "notifications/subscriptions/acknowledged",
+      params: { notifications: honored }
+    }, message.id);
+  }
+  /**
+  * Tear down one subscription (inbound `notifications/cancelled`). Returns
+  * `true` when a subscription was removed. After this call NOTHING further
+  * is delivered for that subscription id (the post-cancel hardening).
+  */
+  cancel(id) {
+    return this._subs.delete(id);
+  }
+  /**
+  * Route an outbound notification through the active subscriptions.
+  *
+  * - For a subscription-gated change notification, returns one stamped copy
+  *   per subscription that opted in to it (an empty array means it is
+  *   dropped — the modern era never delivers an un-requested change type).
+  * - For any other outbound message, returns `'passthrough'` (the entry
+  *   forwards it as-is).
+  */
+  routeOutbound(message) {
+    if (!CHANGE_NOTIFICATION_METHODS.has(message.method)) return "passthrough";
+    const uriParam = message.params?.["uri"];
+    const uri = typeof uriParam === "string" ? uriParam : void 0;
+    const event = notificationToServerEvent(message.method, uri);
+    const out = [];
+    for (const [subscriptionId, filter] of this._subs) if (listenFilterAccepts(filter, event)) out.push(stampSubscriptionId({
+      method: message.method,
+      params: message.params ?? {}
+    }, subscriptionId));
+    return out;
+  }
+  /**
+  * Server-side graceful teardown of every active subscription: returns the
+  * empty `subscriptions/listen` JSON-RPC result for each subscription id —
+  * the spec's graceful-close signal, `_meta` carrying the subscription id
+  * and the serving instance's identity — for the entry to emit before
+  * closing the wire. Clears the set so nothing further is delivered.
+  */
+  teardownAll() {
+    const out = [];
+    for (const id of this._subs.keys()) out.push({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        resultType: "complete",
+        _meta: {
+          [SUBSCRIPTION_ID_META_KEY]: id,
+          ...this._serverInfo !== void 0 && { [SERVER_INFO_META_KEY]: this._serverInfo }
+        }
+      }
+    });
+    this._subs.clear();
+    return out;
+  }
+};
+function notificationToServerEvent(method, uri) {
+  switch (method) {
+    case "notifications/tools/list_changed":
+      return { kind: "tools_list_changed" };
+    case "notifications/prompts/list_changed":
+      return { kind: "prompts_list_changed" };
+    case "notifications/resources/list_changed":
+      return { kind: "resources_list_changed" };
+    default:
+      return {
+        kind: "resource_updated",
+        uri: uri ?? ""
+      };
+  }
+}
 var DEFAULT_LEGACY_SHIM_MAX_ROUNDS = 8;
 var DEFAULT_LEGACY_SHIM_ROUND_TIMEOUT_MS = 6e5;
 function resolveLegacyShimOptions(options) {
@@ -150062,6 +150693,12 @@ var INPUT_REQUIRED_CAPABLE_METHODS = /* @__PURE__ */ new Set([
 var writeClientIdentity;
 var installDiscoverHandler;
 var readServerIdentity;
+function installModernOnlyHandlers(server, servedModernVersions) {
+  installDiscoverHandler(server, servedModernVersions);
+}
+function serverIdentityOf(server) {
+  return readServerIdentity(server);
+}
 var Server = class extends Protocol {
   _clientCapabilities;
   _clientVersion;
@@ -150673,6 +151310,579 @@ var Server = class extends Protocol {
 function discoverAdvertisedCapabilities(capabilities) {
   return { ...capabilities };
 }
+var McpServer = class {
+  /**
+  * The underlying {@linkcode Server} instance, useful for advanced operations like sending notifications.
+  */
+  server;
+  _registeredResources = {};
+  _registeredResourceTemplates = {};
+  _registeredTools = {};
+  _registeredPrompts = {};
+  /**
+  * Per-tool JSON-converted `inputSchema`, memoized so the SEP-2243
+  * registration-time scan and the pre-dispatch validation step share one
+  * conversion instead of paying it twice per request under the
+  * per-request-factory `createMcpHandler` model.
+  */
+  _toolInputSchemaJson = {};
+  /**
+  * The JSON-serialized `inputSchema` of a registered tool, or `undefined`
+  * when no such tool is registered. Used by the HTTP entry's pre-dispatch
+  * SEP-2243 `Mcp-Param-*` validation step (which needs the same JSON Schema
+  * `tools/list` would emit, before dispatch reaches the handler).
+  *
+  * @internal
+  */
+  toolInputSchemaJson(name) {
+    const tool = this._registeredTools[name];
+    if (tool === void 0 || !tool.enabled) return void 0;
+    if (Object.hasOwn(this._toolInputSchemaJson, name)) return this._toolInputSchemaJson[name];
+    if (tool.inputSchema === void 0) return EMPTY_OBJECT_JSON_SCHEMA;
+    try {
+      const json = standardSchemaToJsonSchema(tool.inputSchema, "input");
+      this._toolInputSchemaJson[name] = json;
+      return json;
+    } catch {
+      return;
+    }
+  }
+  constructor(serverInfo, options) {
+    this.server = new Server(serverInfo, options);
+    if (options?.capabilities?.tools) this.setToolRequestHandlers();
+    if (options?.capabilities?.resources) this.setResourceRequestHandlers();
+    if (options?.capabilities?.prompts) this.setPromptRequestHandlers();
+  }
+  /**
+  * Attaches to the given transport, starts it, and starts listening for messages.
+  *
+  * The `server` object assumes ownership of the {@linkcode Transport}, replacing any callbacks that have already been set, and expects that it is the only user of the {@linkcode Transport} instance going forward.
+  *
+  * @example
+  * ```ts source="./mcp.examples.ts#McpServer_connect_stdio"
+  * const server = new McpServer({ name: 'my-server', version: '1.0.0' });
+  * const transport = new StdioServerTransport();
+  * await server.connect(transport);
+  * ```
+  */
+  async connect(transport) {
+    return await this.server.connect(transport);
+  }
+  /**
+  * Closes the connection.
+  */
+  async close() {
+    await this.server.close();
+  }
+  _toolHandlersInitialized = false;
+  setToolRequestHandlers() {
+    if (this._toolHandlersInitialized) return;
+    this.server.assertCanSetRequestHandler("tools/list");
+    this.server.assertCanSetRequestHandler("tools/call");
+    this.server.registerCapabilities({ tools: { listChanged: this.server.getCapabilities().tools?.listChanged ?? true } });
+    this.server.setRequestHandler("tools/list", () => ({ tools: Object.entries(this._registeredTools).filter(([, tool]) => tool.enabled).map(([name, tool]) => {
+      const toolDefinition = {
+        name,
+        title: tool.title,
+        description: tool.description,
+        inputSchema: tool.inputSchema ? standardSchemaToJsonSchema(tool.inputSchema, "input") : EMPTY_OBJECT_JSON_SCHEMA,
+        annotations: tool.annotations,
+        icons: tool.icons,
+        execution: tool.execution,
+        _meta: tool._meta
+      };
+      if (tool.outputSchema) toolDefinition.outputSchema = standardSchemaToJsonSchema(tool.outputSchema, "output");
+      return toolDefinition;
+    }) }));
+    this.server.setRequestHandler("tools/call", async (request, ctx) => {
+      const tool = this._registeredTools[request.params.name];
+      if (!tool) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
+      if (!tool.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
+      try {
+        const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
+        const result = await this.executeToolHandler(tool, args, ctx);
+        await this.validateToolOutput(tool, result, request.params.name);
+        if (isInputRequiredResult(result)) return result;
+        return this.server.projectCallToolResult(result, tool.outputSchemaJson);
+      } catch (error3) {
+        if (error3 instanceof ProtocolError && error3.code === ProtocolErrorCode.UrlElicitationRequired) throw error3;
+        return this.createToolError(error3 instanceof Error ? error3.message : String(error3));
+      }
+    });
+    this._toolHandlersInitialized = true;
+  }
+  /**
+  * Creates a tool error result.
+  *
+  * @param errorMessage - The error message.
+  * @returns The tool error result.
+  */
+  createToolError(errorMessage) {
+    return {
+      content: [{
+        type: "text",
+        text: errorMessage
+      }],
+      isError: true
+    };
+  }
+  /**
+  * Validates tool input arguments against the tool's input schema.
+  */
+  async validateToolInput(tool, args, toolName) {
+    if (!tool.inputSchema) return;
+    const parseResult = await validateStandardSchema(tool.inputSchema, args ?? {});
+    if (!parseResult.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${parseResult.error}`);
+    return parseResult.data;
+  }
+  /**
+  * Validates tool output against the tool's output schema.
+  */
+  async validateToolOutput(tool, result, toolName) {
+    if (!tool.outputSchema) return;
+    if (isInputRequiredResult(result)) return;
+    if (result.isError) return;
+    if (result.structuredContent === void 0) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
+    const parseResult = await validateStandardSchema(tool.outputSchema, result.structuredContent);
+    if (!parseResult.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${parseResult.error}`);
+  }
+  /**
+  * Executes a tool handler.
+  */
+  async executeToolHandler(tool, args, ctx) {
+    return tool.executor(args, ctx);
+  }
+  _completionHandlerInitialized = false;
+  setCompletionRequestHandler() {
+    if (this._completionHandlerInitialized) return;
+    this.server.assertCanSetRequestHandler("completion/complete");
+    this.server.registerCapabilities({ completions: {} });
+    this.server.setRequestHandler("completion/complete", async (request) => {
+      switch (request.params.ref.type) {
+        case "ref/prompt":
+          assertCompleteRequestPrompt(request);
+          return this.handlePromptCompletion(request, request.params.ref);
+        case "ref/resource":
+          assertCompleteRequestResourceTemplate(request);
+          return this.handleResourceCompletion(request, request.params.ref);
+        default:
+          throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid completion reference: ${request.params.ref}`);
+      }
+    });
+    this._completionHandlerInitialized = true;
+  }
+  async handlePromptCompletion(request, ref) {
+    const prompt = this._registeredPrompts[ref.name];
+    if (!prompt) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${ref.name} not found`);
+    if (!prompt.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${ref.name} disabled`);
+    if (!prompt.argsSchema) return EMPTY_COMPLETION_RESULT;
+    const field = unwrapOptionalSchema(getSchemaShape(prompt.argsSchema)?.[request.params.argument.name]);
+    if (!isCompletable(field)) return EMPTY_COMPLETION_RESULT;
+    const completer = getCompleter(field);
+    if (!completer) return EMPTY_COMPLETION_RESULT;
+    return createCompletionResult(await completer(request.params.argument.value, request.params.context));
+  }
+  async handleResourceCompletion(request, ref) {
+    const template = Object.values(this._registeredResourceTemplates).find((t) => t.resourceTemplate.uriTemplate.toString() === ref.uri);
+    if (!template) {
+      if (this._registeredResources[ref.uri]) return EMPTY_COMPLETION_RESULT;
+      throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Resource template ${request.params.ref.uri} not found`);
+    }
+    const completer = template.resourceTemplate.completeCallback(request.params.argument.name);
+    if (!completer) return EMPTY_COMPLETION_RESULT;
+    return createCompletionResult(await completer(request.params.argument.value, request.params.context));
+  }
+  _resourceHandlersInitialized = false;
+  setResourceRequestHandlers() {
+    if (this._resourceHandlersInitialized) return;
+    this.server.assertCanSetRequestHandler("resources/list");
+    this.server.assertCanSetRequestHandler("resources/templates/list");
+    this.server.assertCanSetRequestHandler("resources/read");
+    this.server.registerCapabilities({ resources: { listChanged: this.server.getCapabilities().resources?.listChanged ?? true } });
+    this.server.setRequestHandler("resources/list", async (_request, ctx) => {
+      const resources = Object.entries(this._registeredResources).filter(([_, resource2]) => resource2.enabled).map(([uri, resource2]) => ({
+        uri,
+        name: resource2.name,
+        ...resource2.metadata
+      }));
+      const templateResources = [];
+      for (const template of Object.values(this._registeredResourceTemplates)) {
+        if (!template.resourceTemplate.listCallback) continue;
+        const result = await template.resourceTemplate.listCallback(ctx);
+        for (const resource2 of result.resources) templateResources.push({
+          ...template.metadata,
+          ...resource2
+        });
+      }
+      return { resources: [...resources, ...templateResources] };
+    });
+    this.server.setRequestHandler("resources/templates/list", async () => {
+      return { resourceTemplates: Object.entries(this._registeredResourceTemplates).map(([name, template]) => ({
+        name,
+        uriTemplate: template.resourceTemplate.uriTemplate.toString(),
+        ...template.metadata
+      })) };
+    });
+    this.server.setRequestHandler("resources/read", async (request, ctx) => {
+      let uri;
+      try {
+        uri = new URL(request.params.uri);
+      } catch {
+        throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Resource URI ${request.params.uri} is invalid`, {
+          uri: request.params.uri,
+          reason: "invalid_uri"
+        });
+      }
+      const resource2 = this._registeredResources[uri.toString()];
+      if (resource2) {
+        if (!resource2.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Resource ${uri} disabled`);
+        return attachCacheHintFallback(await resource2.readCallback(uri, ctx), resource2.cacheHint);
+      }
+      for (const template of Object.values(this._registeredResourceTemplates)) {
+        const variables = template.resourceTemplate.uriTemplate.match(uri.toString());
+        if (variables) return attachCacheHintFallback(await template.readCallback(uri, variables, ctx), template.cacheHint);
+      }
+      throw new ResourceNotFoundError(request.params.uri);
+    });
+    this._resourceHandlersInitialized = true;
+  }
+  _promptHandlersInitialized = false;
+  setPromptRequestHandlers() {
+    if (this._promptHandlersInitialized) return;
+    this.server.assertCanSetRequestHandler("prompts/list");
+    this.server.assertCanSetRequestHandler("prompts/get");
+    this.server.registerCapabilities({ prompts: { listChanged: this.server.getCapabilities().prompts?.listChanged ?? true } });
+    this.server.setRequestHandler("prompts/list", () => ({ prompts: Object.entries(this._registeredPrompts).filter(([, prompt]) => prompt.enabled).map(([name, prompt]) => {
+      return {
+        name,
+        title: prompt.title,
+        description: prompt.description,
+        arguments: prompt.argsSchema ? promptArgumentsFromStandardSchema(prompt.argsSchema) : void 0,
+        icons: prompt.icons,
+        _meta: prompt._meta
+      };
+    }) }));
+    this.server.setRequestHandler("prompts/get", async (request, ctx) => {
+      const prompt = this._registeredPrompts[request.params.name];
+      if (!prompt) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${request.params.name} not found`);
+      if (!prompt.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${request.params.name} disabled`);
+      return prompt.handler(request.params.arguments, ctx);
+    });
+    this._promptHandlersInitialized = true;
+  }
+  registerResource(name, uriOrTemplate, config3, readCallback) {
+    const cacheHint = config3.cacheHint;
+    let metadata = config3;
+    if (cacheHint !== void 0) {
+      assertValidCacheHint(cacheHint, `resource ${name}`);
+      const rest = { ...config3 };
+      delete rest.cacheHint;
+      metadata = rest;
+    }
+    if (typeof uriOrTemplate === "string") {
+      if (this._registeredResources[uriOrTemplate]) throw new Error(`Resource ${uriOrTemplate} is already registered`);
+      const registeredResource = this._createRegisteredResource(name, config3.title, uriOrTemplate, metadata, readCallback);
+      if (cacheHint !== void 0) registeredResource.cacheHint = cacheHint;
+      this.setResourceRequestHandlers();
+      this.sendResourceListChanged();
+      return registeredResource;
+    } else {
+      if (this._registeredResourceTemplates[name]) throw new Error(`Resource template ${name} is already registered`);
+      const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config3.title, uriOrTemplate, metadata, readCallback);
+      if (cacheHint !== void 0) registeredResourceTemplate.cacheHint = cacheHint;
+      this.setResourceRequestHandlers();
+      this.sendResourceListChanged();
+      return registeredResourceTemplate;
+    }
+  }
+  _createRegisteredResource(name, title, uri, metadata, readCallback) {
+    const registeredResource = {
+      name,
+      title,
+      metadata,
+      readCallback,
+      enabled: true,
+      disable: () => registeredResource.update({ enabled: false }),
+      enable: () => registeredResource.update({ enabled: true }),
+      remove: () => registeredResource.update({ uri: null }),
+      update: (updates) => {
+        if (updates.uri !== void 0 && updates.uri !== uri) {
+          delete this._registeredResources[uri];
+          if (updates.uri) this._registeredResources[updates.uri] = registeredResource;
+        }
+        if (updates.name !== void 0) registeredResource.name = updates.name;
+        if (updates.title !== void 0) registeredResource.title = updates.title;
+        if (updates.metadata !== void 0) registeredResource.metadata = updates.metadata;
+        if (updates.callback !== void 0) registeredResource.readCallback = updates.callback;
+        if (updates.enabled !== void 0) registeredResource.enabled = updates.enabled;
+        this.sendResourceListChanged();
+      }
+    };
+    this._registeredResources[uri] = registeredResource;
+    return registeredResource;
+  }
+  _createRegisteredResourceTemplate(name, title, template, metadata, readCallback) {
+    const registeredResourceTemplate = {
+      resourceTemplate: template,
+      title,
+      metadata,
+      readCallback,
+      enabled: true,
+      disable: () => registeredResourceTemplate.update({ enabled: false }),
+      enable: () => registeredResourceTemplate.update({ enabled: true }),
+      remove: () => registeredResourceTemplate.update({ name: null }),
+      update: (updates) => {
+        if (updates.name !== void 0 && updates.name !== name) {
+          delete this._registeredResourceTemplates[name];
+          if (updates.name) this._registeredResourceTemplates[updates.name] = registeredResourceTemplate;
+        }
+        if (updates.title !== void 0) registeredResourceTemplate.title = updates.title;
+        if (updates.template !== void 0) registeredResourceTemplate.resourceTemplate = updates.template;
+        if (updates.metadata !== void 0) registeredResourceTemplate.metadata = updates.metadata;
+        if (updates.callback !== void 0) registeredResourceTemplate.readCallback = updates.callback;
+        if (updates.enabled !== void 0) registeredResourceTemplate.enabled = updates.enabled;
+        this.sendResourceListChanged();
+      }
+    };
+    this._registeredResourceTemplates[name] = registeredResourceTemplate;
+    const variableNames = template.uriTemplate.variableNames;
+    if (Array.isArray(variableNames) && variableNames.some((v) => !!template.completeCallback(v))) this.setCompletionRequestHandler();
+    return registeredResourceTemplate;
+  }
+  _createRegisteredPrompt(name, title, description8, argsSchema, callback, icons, _meta) {
+    let currentArgsSchema = argsSchema;
+    let currentCallback = callback;
+    const registeredPrompt = {
+      title,
+      description: description8,
+      argsSchema,
+      icons,
+      _meta,
+      handler: createPromptHandler(name, argsSchema, callback),
+      enabled: true,
+      disable: () => registeredPrompt.update({ enabled: false }),
+      enable: () => registeredPrompt.update({ enabled: true }),
+      remove: () => registeredPrompt.update({ name: null }),
+      update: (updates) => {
+        if (updates.name !== void 0 && updates.name !== name) {
+          delete this._registeredPrompts[name];
+          if (updates.name) this._registeredPrompts[updates.name] = registeredPrompt;
+        }
+        if (updates.title !== void 0) registeredPrompt.title = updates.title;
+        if (updates.description !== void 0) registeredPrompt.description = updates.description;
+        if (updates.icons !== void 0) registeredPrompt.icons = updates.icons;
+        if (updates._meta !== void 0) registeredPrompt._meta = updates._meta;
+        let needsHandlerRegen = false;
+        if (updates.argsSchema !== void 0) {
+          registeredPrompt.argsSchema = updates.argsSchema;
+          currentArgsSchema = updates.argsSchema;
+          needsHandlerRegen = true;
+        }
+        if (updates.callback !== void 0) {
+          currentCallback = updates.callback;
+          needsHandlerRegen = true;
+        }
+        if (needsHandlerRegen) registeredPrompt.handler = createPromptHandler(name, currentArgsSchema, currentCallback);
+        if (updates.enabled !== void 0) registeredPrompt.enabled = updates.enabled;
+        this.sendPromptListChanged();
+      }
+    };
+    this._registeredPrompts[name] = registeredPrompt;
+    if (argsSchema) {
+      const shape = getSchemaShape(argsSchema);
+      if (shape) {
+        if (Object.values(shape).some((field) => {
+          return isCompletable(unwrapOptionalSchema(field));
+        })) this.setCompletionRequestHandler();
+      }
+    }
+    return registeredPrompt;
+  }
+  _createRegisteredTool(name, title, description8, inputSchema9, outputSchema9, annotations, icons, execution, _meta, handler) {
+    validateAndWarnToolName(name);
+    if (inputSchema9 !== void 0) try {
+      const json = standardSchemaToJsonSchema(inputSchema9, "input");
+      this._toolInputSchemaJson[name] = json;
+      const scan = scanXMcpHeaderDeclarations(json);
+      if (!scan.valid) console.warn(`[mcp-sdk] tool '${name}' carries an invalid x-mcp-header declaration and will be excluded by conforming Streamable HTTP clients: ${scan.reason}`);
+    } catch {
+    }
+    let currentHandler = handler;
+    const registeredTool = {
+      title,
+      description: description8,
+      inputSchema: inputSchema9,
+      outputSchema: outputSchema9,
+      outputSchemaJson: convertOutputSchemaJson(outputSchema9),
+      annotations,
+      icons,
+      execution,
+      _meta,
+      handler,
+      executor: createToolExecutor(inputSchema9, handler),
+      enabled: true,
+      disable: () => registeredTool.update({ enabled: false }),
+      enable: () => registeredTool.update({ enabled: true }),
+      remove: () => registeredTool.update({ name: null }),
+      update: (updates) => {
+        if (updates.name !== void 0 && updates.name !== name) {
+          if (typeof updates.name === "string") validateAndWarnToolName(updates.name);
+          delete this._registeredTools[name];
+          delete this._toolInputSchemaJson[name];
+          if (updates.name) {
+            delete this._toolInputSchemaJson[updates.name];
+            this._registeredTools[updates.name] = registeredTool;
+            name = updates.name;
+          }
+        }
+        if (updates.title !== void 0) registeredTool.title = updates.title;
+        if (updates.description !== void 0) registeredTool.description = updates.description;
+        let needsExecutorRegen = false;
+        if (updates.paramsSchema !== void 0) {
+          registeredTool.inputSchema = updates.paramsSchema;
+          delete this._toolInputSchemaJson[name];
+          needsExecutorRegen = true;
+        }
+        if (updates.callback !== void 0) {
+          registeredTool.handler = updates.callback;
+          currentHandler = updates.callback;
+          needsExecutorRegen = true;
+        }
+        if (needsExecutorRegen) registeredTool.executor = createToolExecutor(registeredTool.inputSchema, currentHandler);
+        if (updates.outputSchema !== void 0) {
+          registeredTool.outputSchema = updates.outputSchema;
+          registeredTool.outputSchemaJson = convertOutputSchemaJson(updates.outputSchema);
+        }
+        if (updates.annotations !== void 0) registeredTool.annotations = updates.annotations;
+        if (updates.icons !== void 0) registeredTool.icons = updates.icons;
+        if (updates._meta !== void 0) registeredTool._meta = updates._meta;
+        if (updates.enabled !== void 0) registeredTool.enabled = updates.enabled;
+        this.sendToolListChanged();
+      }
+    };
+    this._registeredTools[name] = registeredTool;
+    this.setToolRequestHandlers();
+    this.sendToolListChanged();
+    return registeredTool;
+  }
+  registerTool(name, config3, cb) {
+    if (this._registeredTools[name]) throw new Error(`Tool ${name} is already registered`);
+    const { title, description: description8, inputSchema: inputSchema9, outputSchema: outputSchema9, annotations, icons, _meta } = config3;
+    return this._createRegisteredTool(name, title, description8, normalizeRawShapeSchema(inputSchema9), normalizeRawShapeSchema(outputSchema9), annotations, icons, void 0, _meta, cb);
+  }
+  registerPrompt(name, config3, cb) {
+    if (this._registeredPrompts[name]) throw new Error(`Prompt ${name} is already registered`);
+    const { title, description: description8, argsSchema, icons, _meta } = config3;
+    const registeredPrompt = this._createRegisteredPrompt(name, title, description8, normalizeRawShapeSchema(argsSchema), cb, icons, _meta);
+    this.setPromptRequestHandlers();
+    this.sendPromptListChanged();
+    return registeredPrompt;
+  }
+  /**
+  * Checks if the server is connected to a transport.
+  * @returns `true` if the server is connected
+  */
+  isConnected() {
+    return this.server.transport !== void 0;
+  }
+  /**
+  * Sends a logging message to the client, if connected.
+  * Note: You only need to send the parameters object, not the entire JSON-RPC message.
+  * @see {@linkcode LoggingMessageNotification}
+  * @param params
+  * @param sessionId Optional for stateless transports and backward compatibility.
+  *
+  * @example
+  * ```ts source="./mcp.examples.ts#McpServer_sendLoggingMessage_basic"
+  * await server.sendLoggingMessage({
+  *     level: 'info',
+  *     data: 'Processing complete'
+  * });
+  * ```
+  *
+  * @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
+  * Remains functional during the deprecation window (at least twelve months).
+  * Migrate to stderr logging (STDIO servers) or OpenTelemetry.
+  */
+  async sendLoggingMessage(params, sessionId) {
+    return this.server.sendLoggingMessage(params, sessionId);
+  }
+  /**
+  * Sends a resource list changed event to the client, if connected.
+  */
+  sendResourceListChanged() {
+    if (this.isConnected()) this.server.sendResourceListChanged();
+  }
+  /**
+  * Sends a tool list changed event to the client, if connected.
+  */
+  sendToolListChanged() {
+    if (this.isConnected()) this.server.sendToolListChanged();
+  }
+  /**
+  * Sends a prompt list changed event to the client, if connected.
+  */
+  sendPromptListChanged() {
+    if (this.isConnected()) this.server.sendPromptListChanged();
+  }
+};
+function createToolExecutor(inputSchema9, handler) {
+  if (inputSchema9) {
+    const callback$1 = handler;
+    return async (args, ctx) => callback$1(args, ctx);
+  }
+  const callback = handler;
+  return async (_args, ctx) => callback(ctx);
+}
+var EMPTY_OBJECT_JSON_SCHEMA = {
+  type: "object",
+  properties: {}
+};
+function convertOutputSchemaJson(outputSchema9) {
+  if (outputSchema9 === void 0) return void 0;
+  try {
+    return standardSchemaToJsonSchema(outputSchema9, "output");
+  } catch {
+    return;
+  }
+}
+function createPromptHandler(name, argsSchema, callback) {
+  if (argsSchema) {
+    const typedCallback = callback;
+    return async (args, ctx) => {
+      const parseResult = await validateStandardSchema(argsSchema, args);
+      if (!parseResult.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid arguments for prompt ${name}: ${parseResult.error}`);
+      return typedCallback(parseResult.data, ctx);
+    };
+  } else {
+    const typedCallback = callback;
+    return async (_args, ctx) => {
+      return typedCallback(ctx);
+    };
+  }
+}
+function createCompletionResult(suggestions) {
+  return { completion: {
+    values: suggestions.map(String).slice(0, 100),
+    total: suggestions.length,
+    hasMore: suggestions.length > 100
+  } };
+}
+var EMPTY_COMPLETION_RESULT = { completion: {
+  values: [],
+  hasMore: false
+} };
+function getSchemaShape(schema2) {
+  const candidate = schema2;
+  if (candidate.shape && typeof candidate.shape === "object") return candidate.shape;
+}
+function isOptionalSchema(schema2) {
+  return schema2?.type === "optional";
+}
+function unwrapOptionalSchema(schema2) {
+  if (!isOptionalSchema(schema2)) return schema2;
+  return schema2.def?.innerType ?? schema2;
+}
 
 // ../node_modules/.pnpm/@modelcontextprotocol+server@2.0.0/node_modules/@modelcontextprotocol/server/dist/stdio.mjs
 var StdioServerTransport = class {
@@ -150763,6 +151973,400 @@ var StdioServerTransport = class {
     });
   }
 };
+var DISCARD_ANSWER_TIMEOUT_MS = 3e3;
+var StdioConnectionChannel = class {
+  onclose;
+  onerror;
+  onmessage;
+  _closed = false;
+  /** Request ids the entry delivered to the instance that the instance has not yet answered. */
+  _pendingRequests = /* @__PURE__ */ new Set();
+  _drainWaiters = [];
+  constructor(_wire, _onInstanceClose, _outboundIntercept) {
+    this._wire = _wire;
+    this._onInstanceClose = _onInstanceClose;
+    this._outboundIntercept = _outboundIntercept;
+  }
+  async start() {
+  }
+  async send(message, options) {
+    if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+      const { id } = message;
+      if (id !== void 0) this._settle(id);
+    }
+    if (this._closed) return;
+    if (this._outboundIntercept?.(message) === "handled") return;
+    return this._wire.send(message, options);
+  }
+  setProtocolVersion = (version4) => {
+    this._wire.setProtocolVersion?.(version4);
+  };
+  /** Forwards one inbound message to the connected instance. */
+  deliver(message, extra) {
+    if (this._closed) return;
+    if (isJSONRPCRequest(message)) this._pendingRequests.add(message.id);
+    else if (isJSONRPCNotification(message) && message.method === "notifications/cancelled") {
+      const cancelledId = message.params?.requestId;
+      if (cancelledId !== void 0) this._settle(cancelledId);
+    }
+    this.onmessage?.(message, extra);
+  }
+  /**
+  * Resolves once every request delivered to the instance has been answered
+  * through {@linkcode send}, settled by a delivered cancellation, or the
+  * channel has been closed and nothing further can be answered. The wait is
+  * bounded by `timeoutMs` as a backstop so no edge can hold the caller
+  * indefinitely; resolves `false` only when the bound elapsed with requests
+  * still unanswered. Used by the probe-discard path so a probe request the
+  * entry accepted is never silently dropped.
+  */
+  async whenRequestsAnswered(timeoutMs) {
+    if (this._closed || this._pendingRequests.size === 0) return true;
+    return await new Promise((resolve2) => {
+      const waiter = () => {
+        clearTimeout(timer);
+        resolve2(true);
+      };
+      const timer = setTimeout(() => {
+        this._drainWaiters = this._drainWaiters.filter((pending) => pending !== waiter);
+        resolve2(false);
+      }, timeoutMs);
+      this._drainWaiters.push(waiter);
+    });
+  }
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    this._pendingRequests.clear();
+    this._releaseDrainWaiters();
+    try {
+      this._onInstanceClose();
+    } finally {
+      this.onclose?.();
+    }
+  }
+  _settle(id) {
+    this._pendingRequests.delete(id);
+    if (this._pendingRequests.size === 0) this._releaseDrainWaiters();
+  }
+  _releaseDrainWaiters() {
+    const waiters = this._drainWaiters;
+    this._drainWaiters = [];
+    for (const waiter of waiters) waiter();
+  }
+};
+function classifyOpeningMessage(message) {
+  const params = message.params;
+  if (message.method === "initialize" && !carriesValidModernEnvelopeClaim(params)) {
+    const requestedVersion = params !== null && typeof params === "object" && typeof params.protocolVersion === "string" ? params.protocolVersion : void 0;
+    return {
+      kind: "legacy",
+      reason: "initialize",
+      ...requestedVersion !== void 0 && { requestedVersion }
+    };
+  }
+  if (!hasEnvelopeClaim(params)) return {
+    kind: "legacy",
+    reason: "no-claim"
+  };
+  const meta2 = requestMetaOf(params);
+  const firstIssue = (meta2 === void 0 ? [] : validateEnvelopeMeta(meta2))[0];
+  if (firstIssue !== void 0) return {
+    kind: "invalid-envelope",
+    issue: firstIssue
+  };
+  const claimedVersion = envelopeClaimVersion(params);
+  if (claimedVersion === void 0 || !SUPPORTED_MODERN_PROTOCOL_VERSIONS.includes(claimedVersion)) return {
+    kind: "unsupported-revision",
+    requested: claimedVersion ?? "unknown"
+  };
+  return {
+    kind: "modern",
+    revision: claimedVersion,
+    classification: {
+      era: "modern",
+      revision: claimedVersion
+    }
+  };
+}
+function serveStdio(factory, options = {}) {
+  const legacyMode = options.legacy ?? "serve";
+  const wire = options.transport ?? new StdioServerTransport();
+  let state = { phase: "opening" };
+  let discarding;
+  let closing = false;
+  const isTornDown = () => closing || state.phase === "closed";
+  const reportError = (error3) => {
+    try {
+      options.onerror?.(error3);
+    } catch {
+    }
+  };
+  const writeErrorResponse = (id, code2, message, data2) => wire.send({
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: code2,
+      message,
+      ...data2 !== void 0 && { data: data2 }
+    }
+  }).catch((error3) => reportError(toError(error3)));
+  const listenRouter = new StdioListenRouter(options.maxSubscriptions ?? DEFAULT_MAX_SUBSCRIPTIONS);
+  const modernOutboundIntercept = (message) => {
+    if (!isJSONRPCNotification(message)) return void 0;
+    const routed = listenRouter.routeOutbound(message);
+    if (routed === "passthrough") return void 0;
+    for (const stamped of routed) wire.send({
+      jsonrpc: "2.0",
+      ...stamped
+    }).catch((error3) => reportError(toError(error3)));
+    return "handled";
+  };
+  const tryServeListen = async (message) => {
+    if (isJSONRPCRequest(message) && message.method === "subscriptions/listen") {
+      const meta2 = requestMetaOf(message.params);
+      const issue2 = hasEnvelopeClaim(message.params) ? (meta2 === void 0 ? [] : validateEnvelopeMeta(meta2))[0] : {
+        key: "_meta",
+        problem: "the per-request envelope is required on protocol revision 2026-07-28"
+      };
+      const claimedVersion = envelopeClaimVersion(message.params);
+      let reply;
+      if (issue2 !== void 0) reply = {
+        jsonrpc: "2.0",
+        id: message.id,
+        error: {
+          code: -32602,
+          message: `Invalid _meta envelope: ${issue2.key}: ${issue2.problem}`
+        }
+      };
+      else if (claimedVersion === void 0 || !SUPPORTED_MODERN_PROTOCOL_VERSIONS.includes(claimedVersion)) {
+        const error3 = new UnsupportedProtocolVersionError({
+          supported: [...SUPPORTED_MODERN_PROTOCOL_VERSIONS],
+          requested: claimedVersion ?? "unknown"
+        });
+        reply = {
+          jsonrpc: "2.0",
+          id: message.id,
+          error: {
+            code: error3.code,
+            message: error3.message,
+            data: error3.data
+          }
+        };
+      } else reply = listenRouter.serve(message);
+      await wire.send("error" in reply ? reply : {
+        jsonrpc: "2.0",
+        method: reply.method,
+        params: reply.params
+      }).catch((error3) => reportError(toError(error3)));
+      return true;
+    }
+    if (isJSONRPCNotification(message) && message.method === "notifications/cancelled") {
+      const cancelledId = message.params?.requestId;
+      if (cancelledId !== void 0 && listenRouter.cancel(cancelledId)) return true;
+    }
+    return false;
+  };
+  const answerLegacyRejection = (request, reason, requestedVersion) => {
+    const rejection2 = modernOnlyStrictRejection({
+      kind: "legacy",
+      reason,
+      ...requestedVersion !== void 0 && { requestedVersion }
+    }, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
+    if (rejection2 === void 0) return Promise.resolve();
+    reportError(/* @__PURE__ */ new Error(`Rejected 2025-era request on a modern-only stdio connection (${rejection2.cell}): ${rejection2.message}`));
+    return writeErrorResponse(request.id, rejection2.code, rejection2.message, rejection2.data);
+  };
+  const onInstanceClosed = (channel) => {
+    if (closing || channel === discarding) return;
+    closeAll();
+  };
+  const connectInstance = async (era, revision) => {
+    const product = await factory({ era });
+    const server = product instanceof McpServer ? product.server : product;
+    if (era === "modern") {
+      setNegotiatedProtocolVersion(server, revision);
+      installModernOnlyHandlers(server, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
+      listenRouter.setServerCapabilities(server.getCapabilities(), serverIdentityOf(server));
+    }
+    const channel = new StdioConnectionChannel(wire, () => onInstanceClosed(channel), era === "modern" ? modernOutboundIntercept : void 0);
+    await product.connect(channel);
+    return {
+      product,
+      channel
+    };
+  };
+  const disposeLateInstance = (instance) => instance.product.close().catch((error3) => reportError(toError(error3)));
+  const discardProbeInstance = async (instance) => {
+    discarding = instance.channel;
+    try {
+      if (!await instance.channel.whenRequestsAnswered(DISCARD_ANSWER_TIMEOUT_MS)) reportError(/* @__PURE__ */ new Error(`Discarded the probe instance with requests still unanswered after ${DISCARD_ANSWER_TIMEOUT_MS}ms; continuing with the fallback`));
+      await instance.product.close();
+    } catch (error3) {
+      reportError(toError(error3));
+    } finally {
+      discarding = void 0;
+    }
+  };
+  const processMessage = async (message) => {
+    if (state.phase === "closed") return;
+    if (state.phase === "pinned") {
+      if (state.era === "modern" && isJSONRPCRequest(message) && message.method === "initialize" && !carriesValidModernEnvelopeClaim(message.params)) {
+        await answerLegacyRejection(message, "initialize", message.params !== null && typeof message.params === "object" && typeof message.params.protocolVersion === "string" ? message.params.protocolVersion : void 0);
+        return;
+      }
+      if (state.era === "modern" && await tryServeListen(message)) return;
+      state.instance.channel.deliver(message);
+      return;
+    }
+    if (!isJSONRPCRequest(message) && !isJSONRPCNotification(message)) {
+      reportError(/* @__PURE__ */ new Error("Discarded a JSON-RPC response received before the connection negotiated an era"));
+      return;
+    }
+    const opening = classifyOpeningMessage(message);
+    switch (opening.kind) {
+      case "invalid-envelope": {
+        const detail = `Invalid _meta envelope for protocol revision 2026-07-28: ${opening.issue.key}: ${opening.issue.problem}`;
+        if (isJSONRPCRequest(message)) await writeErrorResponse(message.id, ProtocolErrorCode.InvalidParams, detail, { envelope: opening.issue });
+        else reportError(/* @__PURE__ */ new Error(`Discarded a notification with a malformed envelope: ${detail}`));
+        return;
+      }
+      case "unsupported-revision":
+        if (isJSONRPCRequest(message)) {
+          const error3 = new UnsupportedProtocolVersionError({
+            supported: [...SUPPORTED_MODERN_PROTOCOL_VERSIONS],
+            requested: opening.requested
+          });
+          reportError(error3);
+          await writeErrorResponse(message.id, error3.code, error3.message, error3.data);
+        } else reportError(/* @__PURE__ */ new Error(`Discarded a notification claiming unsupported protocol revision ${opening.requested}`));
+        return;
+      case "modern":
+        if (isJSONRPCRequest(message) && message.method === "server/discover") {
+          if (state.phase === "probe") {
+            state.instance.channel.deliver(message, { classification: opening.classification });
+            return;
+          }
+          const instance = await connectInstance("modern", opening.revision);
+          if (isTornDown()) {
+            await disposeLateInstance(instance);
+            return;
+          }
+          state = {
+            phase: "probe",
+            instance
+          };
+          instance.channel.deliver(message, { classification: opening.classification });
+          return;
+        }
+        if (state.phase === "probe") {
+          if (isJSONRPCNotification(message)) {
+            state.instance.channel.deliver(message, { classification: opening.classification });
+            return;
+          }
+          state = {
+            phase: "pinned",
+            era: "modern",
+            instance: state.instance
+          };
+        } else {
+          const instance = await connectInstance("modern", opening.revision);
+          if (isTornDown()) {
+            await disposeLateInstance(instance);
+            return;
+          }
+          state = {
+            phase: "pinned",
+            era: "modern",
+            instance
+          };
+        }
+        if (await tryServeListen(message)) return;
+        state.instance.channel.deliver(message, { classification: opening.classification });
+        return;
+      case "legacy": {
+        if (legacyMode === "reject") {
+          if (isJSONRPCRequest(message)) await answerLegacyRejection(message, opening.reason, opening.requestedVersion);
+          return;
+        }
+        if (state.phase === "probe") {
+          await discardProbeInstance(state.instance);
+          if (isTornDown()) return;
+          state = { phase: "opening" };
+        }
+        const instance = await connectInstance("legacy");
+        if (isTornDown()) {
+          await disposeLateInstance(instance);
+          return;
+        }
+        state = {
+          phase: "pinned",
+          era: "legacy",
+          instance
+        };
+        state.instance.channel.deliver(message);
+        return;
+      }
+    }
+  };
+  const queue = [];
+  let pumping = false;
+  const pump = async () => {
+    if (pumping) return;
+    pumping = true;
+    try {
+      while (queue.length > 0) {
+        const message = queue.shift();
+        try {
+          await processMessage(message);
+        } catch (error3) {
+          if (isJSONRPCRequest(message)) await writeErrorResponse(message.id, ProtocolErrorCode.InternalError, "Internal server error");
+          reportError(toError(error3));
+        }
+      }
+    } finally {
+      pumping = false;
+    }
+  };
+  const closeAll = async () => {
+    if (closing || state.phase === "closed") return;
+    closing = true;
+    const current = state;
+    state = { phase: "closed" };
+    for (const result of listenRouter.teardownAll()) await wire.send(result).catch((error3) => reportError(toError(error3)));
+    if (current.phase === "probe" || current.phase === "pinned") await current.instance.product.close().catch((error3) => reportError(toError(error3)));
+    await wire.close().catch((error3) => reportError(toError(error3)));
+  };
+  wire.onmessage = (message) => {
+    queue.push(message);
+    pump();
+  };
+  wire.onerror = (error3) => {
+    reportError(error3);
+    if (state.phase === "probe" || state.phase === "pinned") state.instance.channel.onerror?.(error3);
+  };
+  wire.onclose = () => {
+    if (closing || state.phase === "closed") return;
+    closing = true;
+    const current = state;
+    state = { phase: "closed" };
+    if (current.phase === "probe" || current.phase === "pinned") current.instance.product.close().catch((error3) => reportError(toError(error3)));
+  };
+  const started = wire.start().catch((error3) => {
+    reportError(toError(error3));
+    throw error3;
+  });
+  started.catch(() => {
+  });
+  return { close: async () => {
+    await started.catch(() => {
+    });
+    await closeAll();
+  } };
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
 
 // src/cli/lib/mcp/requestContext.ts
 init_fs();
@@ -153159,11 +154763,7 @@ mcp.command("start").summary("Start the MCP server").description(
 ).addDeploymentSelectionOptions(actionDescription("Run the MCP server on")).action(async (options) => {
   const ctx = await oneoffContext(options);
   try {
-    const server = makeServer(options);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    await new Promise(() => {
-    });
+    enabledTools(options);
   } catch (error3) {
     await ctx.crash({
       exitCode: 1,
@@ -153172,8 +154772,17 @@ mcp.command("start").summary("Start the MCP server").description(
       printedMessage: `Failed to start MCP server: ${error3}`
     });
   }
+  serveStdio(() => makeServer(options), {
+    legacy: "serve",
+    // The only channel for out-of-band failures (transport errors, dropped
+    // malformed notifications). stdout carries the protocol, so they go to
+    // stderr.
+    onerror: (error3) => logError(`MCP server error: ${error3.message}`)
+  });
+  await new Promise(() => {
+  });
 });
-function makeServer(options) {
+function enabledTools(options) {
   const disabledToolNames = /* @__PURE__ */ new Set();
   for (const toolName of options.disableTools?.split(",") ?? []) {
     const name = toolName.trim();
@@ -153190,6 +154799,10 @@ function makeServer(options) {
       enabledToolsByName[tool.name] = tool;
     }
   }
+  return enabledToolsByName;
+}
+function makeServer(options) {
+  const enabledToolsByName = enabledTools(options);
   const mutex = new Mutex();
   const server = new Server(
     {