run402 4.129.1 → 4.130.1

package/sdk/dist/namespaces/deploy.js

@@ -24,7 +24,7 @@ import { isGrantKeyCredentials } from "../grant-key-credentials.js";
 import { isKnownBinaryContent, isUtf8StringSource } from "../validation.js";
 import { assertCiDeployableSpec } from "./ci.js";
 import { ROUTE_PRICING_NETWORKS, ROUTE_HTTP_METHODS, isModernPlanMigrationDiff, normalizeDeployResolveRequest, } from "./deploy.types.js";
-import { ApiError, LocalError, NetworkError, PaymentRequired, Run402DeployError, Unauthorized, isRun402Error, isTransferFreezeError, } from "../errors.js";
+import { ApiError, LocalError, PaymentRequired, Run402DeployError, Unauthorized, isNoResponseError, isRun402Error, isTransferFreezeError, } from "../errors.js";
 import { assertAssetMetadata, assertExifPolicy, } from "./assets-validation.js";
 import { withSiteRemovalSummaries } from "./site-removal-summary.js";
 // ─── Constants ───────────────────────────────────────────────────────────────
@@ -85,18 +85,22 @@ const STATIC_FUNCTION_LIMITS_BY_TIER = {
     prototype: {
         maxTimeoutSeconds: 10,
         maxMemoryMb: 128,
+        maxSsrMemoryMb: 128,
         maxScheduledFunctions: 1,
         minCronIntervalMinutes: 15,
     },
     hobby: {
         maxTimeoutSeconds: 30,
         maxMemoryMb: 256,
+        maxSsrMemoryMb: 256,
         maxScheduledFunctions: 3,
         minCronIntervalMinutes: 5,
     },
     team: {
         maxTimeoutSeconds: 60,
         maxMemoryMb: 512,
+        // An SSR-class function (the Astro `ssr` function) may use one vCPU.
+        maxSsrMemoryMb: 1769,
         maxScheduledFunctions: 10,
         minCronIntervalMinutes: 1,
     },
@@ -1338,7 +1342,7 @@ async function preflightTierFunctionLimits(client, spec, ciCredentials) {
         return;
     if (!hasFunctionTierPreflightInputs(spec.functions))
         return;
-    const limits = await readTierFunctionLimits(client);
+    const limits = await readTierFunctionLimits(client, spec.project_id);
     if (!limits)
         return;
     const entries = collectFunctionPreflightEntries(spec.functions);
@@ -1353,12 +1357,19 @@ async function preflightTierFunctionLimits(client, spec, ciCredentials) {
             });
         }
         const memory = entry.fn.config?.memoryMb;
+        // An SSR-class function has its own cap. With no class declared the
+        // function keeps its stored one, which only the gateway knows.
+        const memoryLimit = entry.fn.class === "ssr"
+            ? limits.maxSsrMemoryMb ?? limits.maxMemoryMb
+            : entry.fn.class === undefined
+                ? largerLimit(limits.maxMemoryMb, limits.maxSsrMemoryMb)
+                : limits.maxMemoryMb;
         if (memory !== undefined &&
-            limits.maxMemoryMb &&
-            memory > limits.maxMemoryMb.value) {
-            throw tierLimitError(`Function ${entry.name} memoryMb ${memory} exceeds the ${limits.tier} tier maximum of ${limits.maxMemoryMb.value}.`, `${entry.fieldPrefix}.config.memoryMb`, memory, limits, limits.maxMemoryMb, {
-                tier_max: limits.maxMemoryMb.value,
-                max_function_memory_mb: limits.maxMemoryMb.value,
+            memoryLimit &&
+            memory > memoryLimit.value) {
+            throw tierLimitError(`Function ${entry.name} memoryMb ${memory} exceeds the ${limits.tier} tier maximum of ${memoryLimit.value}.`, `${entry.fieldPrefix}.config.memoryMb`, memory, limits, memoryLimit, {
+                tier_max: memoryLimit.value,
+                max_function_memory_mb: memoryLimit.value,
             });
         }
         for (const trigger of scheduleTriggersForFunction(entry.fn)) {
@@ -1387,6 +1398,13 @@ async function preflightTierFunctionLimits(client, spec, ciCredentials) {
         }
     }
 }
+function largerLimit(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return b.value > a.value ? b : a;
+}
 function hasFunctionTierPreflightInputs(functions) {
     if (!functions)
         return false;
@@ -1406,7 +1424,14 @@ function collectFunctionPreflightEntries(functions) {
     }
     return entries;
 }
-async function readTierFunctionLimits(client) {
+/**
+ * The function caps of the tier the deploy is judged by: the tier of the
+ * organization that owns the project. `/tiers/v1/status` describes the
+ * wallet's own organization, so its caps count only when the project's tier
+ * is the same; otherwise the static table for the project's tier applies.
+ * When the project cannot be read, the wallet's own tier is used.
+ */
+async function readTierFunctionLimits(client, projectId) {
     let status;
     try {
         status = await client.request("/tiers/v1/status", {
@@ -1416,6 +1441,10 @@ async function readTierFunctionLimits(client) {
     catch {
         return null;
     }
+    const projectTier = await readProjectTier(client, projectId);
+    if (projectTier && projectTier.toLowerCase() !== String(status.tier ?? "").toLowerCase()) {
+        status = { tier: projectTier };
+    }
     if (typeof status.tier !== "string" || status.tier.length === 0) {
         return null;
     }
@@ -1434,6 +1463,9 @@ async function readTierFunctionLimits(client) {
         "memory_mb_max",
         "function_memory_mb_max",
     ], fallback?.maxMemoryMb);
+    // tier status names no SSR memory cap, so it comes from the static table.
+    if (fallback)
+        limits.maxSsrMemoryMb = { value: fallback.maxSsrMemoryMb, source: "local_static_fallback" };
     limits.maxScheduledFunctions = tierStatusLimitOrFallback(status, [
         "max_scheduled_functions",
         "scheduled_functions_limit",
@@ -1454,6 +1486,18 @@ async function readTierFunctionLimits(client) {
     ]);
     return hasAnyTierFunctionLimit(limits) ? limits : null;
 }
+async function readProjectTier(client, projectId) {
+    try {
+        const project = await client.request(`/projects/v1/${encodeURIComponent(projectId)}`, {
+            method: "GET",
+            context: "checking the project's tier for deploy preflight",
+        });
+        return typeof project.tier === "string" && project.tier.length > 0 ? project.tier : null;
+    }
+    catch {
+        return null;
+    }
+}
 function tierStatusLimitOrFallback(status, keys, fallback) {
     return tierStatusLimit(status, keys) ?? (fallback === undefined
         ? undefined
@@ -1895,7 +1939,7 @@ async function requestWithTransientRetry(send) {
 function isTransientGatewayFailure(err) {
     if (!isRun402Error(err))
         return false;
-    if (err.kind === "network_error")
+    if (isNoResponseError(err))
         return true;
     return err.status === 502 || err.status === 503 || err.status === 504;
 }
@@ -4544,15 +4588,8 @@ function translateDeployError(err, phase, planId, operationId) {
             context: err.context,
         });
     }
-    if (err instanceof NetworkError) {
-        return new Run402DeployError(err.message, {
-            code: "NETWORK_ERROR",
-            phase,
-            retryable: true,
-            operationId,
-            planId,
-            context: phase,
-        });
+    if (isNoResponseError(err)) {
+        return noResponseDeployError(err, phase, planId, operationId);
     }
     // Re-throw other Run402Error subclasses (PaymentRequired, Unauthorized, etc.)
     // as-is — the consumer handles them at a different layer than
@@ -4579,6 +4616,68 @@ function translateDeployError(err, phase, planId, operationId) {
         context: phase,
     });
 }
+/**
+ * A deploy request that got no response: the connection failed or the client
+ * gave up waiting (Node's fetch stops waiting for response headers after
+ * 300 s). For a commit that is not a failed deploy: the gateway may still be
+ * running the operation, and committing the plan again is safe (a plan commits
+ * once), so the error says so and points at the operation.
+ */
+function noResponseDeployError(err, phase, planId, operationId) {
+    const transportCode = noResponseTransportCode(err);
+    const cause = transportCode ? ` (${transportCode})` : "";
+    const isCommit = phase === "commit";
+    const message = isCommit
+        ? `The deploy commit got no response from the API${cause}. The deploy may still be running on the gateway${operationId ? ` as operation ${operationId}` : ""}; nothing failed that is known. Check the operation, or commit the same plan again: a plan commits once, so a repeat follows the running deploy.`
+        : `The deploy request (${phase}) got no response from the API${cause}. Repeating it is safe.`;
+    const nextActions = [];
+    if (operationId) {
+        nextActions.push({
+            type: "poll",
+            method: "GET",
+            path: `/apply/v1/operations/${operationId}`,
+            command: `run402 deploy status ${operationId}`,
+            safe_to_auto_execute: true,
+            why: "Read the operation to learn whether the deploy is still running, finished, or failed.",
+        });
+    }
+    nextActions.push({
+        type: "retry",
+        safe_to_auto_execute: true,
+        why: isCommit
+            ? "Committing the same plan again cannot run the deploy twice: it attaches to the running operation or returns its stored result."
+            : "The request got no response; repeating it is safe.",
+    });
+    return new Run402DeployError(message, {
+        code: "NETWORK_ERROR",
+        phase,
+        retryable: true,
+        operationId,
+        planId,
+        context: phase,
+        body: {
+            code: "NETWORK_ERROR",
+            category: "network",
+            retryable: true,
+            safe_to_retry: true,
+            mutation_state: isCommit ? "unknown" : "none",
+            details: {
+                ...(transportCode ? { transport_code: transportCode } : {}),
+                ...(operationId ? { operation_id: operationId } : {}),
+            },
+            next_actions: nextActions,
+        },
+    });
+}
+function noResponseTransportCode(err) {
+    const details = err.details;
+    if (details && typeof details === "object" && !Array.isArray(details)) {
+        const code = details.transport_code;
+        if (typeof code === "string")
+            return code;
+    }
+    return null;
+}
 function extractGatewayError(body) {
     // Gateway returns the error in any of:
     //   { error: { code, message?, phase?, ... } }       — nested