opennextjs-azure 0.1.4 → 0.2.0

package/dist/deploy.js

@@ -5,6 +5,9 @@ import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { build as build$1 } from '@opennextjs/aws/build.js';
 import fs$1, { existsSync } from 'node:fs';
+import { BlobServiceClient } from '@azure/storage-blob';
+import { TableClient } from '@azure/data-tables';
+import { encodeTableKey } from './overrides/tagCache/azure-table.js';
 import readline from 'node:readline';
 
 const execAsync$3 = promisify(exec);
@@ -227,6 +230,35 @@ function redX() {
 }
 
 const execAsync$2 = promisify(exec);
+async function readInstalledVersion(dep) {
+  try {
+    const pkgPath = path.join(process.cwd(), "node_modules", dep, "package.json");
+    const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+async function pruneWrongPlatformBinaries(nodeModulesPath) {
+  const nextScope = path.join(nodeModulesPath, "@next");
+  try {
+    for (const entry of await fs.readdir(nextScope)) {
+      if (entry.startsWith("swc-")) {
+        await fs.rm(path.join(nextScope, entry), { recursive: true, force: true });
+      }
+    }
+  } catch {
+  }
+  const imgScope = path.join(nodeModulesPath, "@img");
+  try {
+    for (const entry of await fs.readdir(imgScope)) {
+      if (!entry.includes("linux-x64") && !entry.includes("wasm")) {
+        await fs.rm(path.join(imgScope, entry), { recursive: true, force: true });
+      }
+    }
+  } catch {
+  }
+}
 async function prepareFunctions() {
   const functionsDir = path.join(process.cwd(), ".open-next/server-functions/default");
   try {
@@ -251,7 +283,14 @@ async function prepareFunctions() {
     },
     extensions: {
       http: {
-        routePrefix: ""
+        routePrefix: "",
+        // Bound per-instance concurrency and queueing so bursts
+        // trigger scale-out (the Consumption defaults queue ~200
+        // requests on a single 1-core SSR worker) while keeping
+        // enough queue to ride out the scale-out delay without
+        // shedding 429s.
+        maxConcurrentRequests: 16,
+        maxOutstandingRequests: 100
       }
     }
   };
@@ -341,24 +380,72 @@ async function prepareFunctions() {
     console.log(`  ${greenCheck()} Image optimization function added`);
   } catch {
   }
+  const revalidationDir = path.join(process.cwd(), ".open-next/revalidation-function");
+  try {
+    await fs.access(path.join(revalidationDir, "index.mjs"));
+    console.log("  Adding revalidation queue consumer...");
+    const revalidateFunctionDir = path.join(functionsDir, "revalidate");
+    await fs.mkdir(revalidateFunctionDir, { recursive: true });
+    const revalidateFunctionJson = {
+      bindings: [
+        {
+          type: "queueTrigger",
+          direction: "in",
+          name: "queueItem",
+          // Binding expression: resolves the AZURE_QUEUE_NAME app
+          // setting (set by the bicep template), so the consumer
+          // follows the same queue the producer writes to.
+          queueName: "%AZURE_QUEUE_NAME%",
+          connection: "AZURE_STORAGE_CONNECTION_STRING"
+        }
+      ],
+      scriptFile: "../index-revalidate.mjs",
+      entryPoint: "handler"
+    };
+    await fs.writeFile(
+      path.join(revalidateFunctionDir, "function.json"),
+      JSON.stringify(revalidateFunctionJson, null, 2)
+    );
+    await fs.copyFile(path.join(revalidationDir, "index.mjs"), path.join(functionsDir, "index-revalidate.mjs"));
+    await fs.copyFile(
+      path.join(revalidationDir, "prerender-manifest.json"),
+      path.join(functionsDir, "prerender-manifest.json")
+    );
+    console.log(`  ${greenCheck()} Revalidation queue consumer added`);
+  } catch {
+  }
   console.log(`  ${greenCheck()} Azure Functions metadata created`);
   console.log("Installing minimal runtime dependencies...");
   try {
     const originalPackageJson = JSON.parse(await fs.readFile(path.join(functionsDir, "package.json"), "utf-8"));
+    const runtimeDependencies = {};
+    for (const [dep, spec] of Object.entries(
+      originalPackageJson.dependencies ?? {}
+    )) {
+      if (/^(file:|link:|workspace:|portal:|catalog:)/.test(spec)) {
+        const installedVersion = await readInstalledVersion(dep);
+        if (installedVersion && !spec.startsWith("file:") && !spec.startsWith("link:")) {
+          runtimeDependencies[dep] = installedVersion;
+        } else if (/^(workspace:|catalog:)/.test(spec)) {
+          console.warn(`  Skipping "${dep}" (${spec}): not resolvable outside the workspace`);
+        }
+        continue;
+      }
+      runtimeDependencies[dep] = spec;
+    }
+    runtimeDependencies.next ||= "latest";
+    runtimeDependencies.react ||= "latest";
+    runtimeDependencies["react-dom"] ||= "latest";
     const minimalPackageJson = {
       name: originalPackageJson.name || "nextjs-app",
       version: originalPackageJson.version || "1.0.0",
       private: true,
-      dependencies: {
-        next: originalPackageJson.dependencies?.next || "latest",
-        react: originalPackageJson.dependencies?.react || "latest",
-        "react-dom": originalPackageJson.dependencies?.["react-dom"] || "latest"
-      }
+      dependencies: runtimeDependencies
     };
     await fs.writeFile(path.join(functionsDir, "package.json"), JSON.stringify(minimalPackageJson, null, 2));
     const nodeModulesPath = path.join(functionsDir, "node_modules");
     await fs.rm(nodeModulesPath, { recursive: true, force: true });
-    await execAsync$2("npm install --production --no-package-lock --loglevel=error", {
+    await execAsync$2("npm install --omit=dev --no-package-lock --loglevel=error --os=linux --cpu=x64 --libc=glibc", {
       cwd: functionsDir
     });
     console.log(`  ${greenCheck()} Runtime dependencies installed`);
@@ -371,12 +458,20 @@ async function prepareFunctions() {
     await fs.access(imageOptDir2);
     console.log("Installing Sharp with Linux x64 binaries for image optimization...");
     await execAsync$2(
-      "npm install --force sharp@0.33.5 @img/sharp-linux-x64@0.33.5 @img/sharp-libvips-linux-x64@1.0.4",
+      "npm install --force --no-package-lock --os=linux --cpu=x64 --libc=glibc sharp@0.33.5 @img/sharp-linux-x64@0.33.5 @img/sharp-libvips-linux-x64@1.0.4",
       { cwd: functionsDir }
     );
     console.log(`  ${greenCheck()} Sharp with Linux x64 binaries installed`);
   } catch (error) {
   }
+  await pruneWrongPlatformBinaries(path.join(functionsDir, "node_modules"));
+  await fs.rm(path.join(functionsDir, "package-lock.json"), { force: true });
+  try {
+    const assetsDir = path.join(process.cwd(), ".open-next/assets");
+    const rootAssets = (await fs.readdir(assetsDir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name);
+    await fs.writeFile(path.join(functionsDir, "static-assets.json"), JSON.stringify(rootAssets));
+  } catch {
+  }
 }
 
 async function build(configPath) {
@@ -391,11 +486,12 @@ async function build(configPath) {
     const { createRequire } = await import('node:module');
     const require = createRequire(import.meta.url);
     const packagePath = path.dirname(require.resolve("opennextjs-azure/package.json"));
-    const wrapperPath = path.join(packagePath, "dist/adapters/wrappers/azure-functions.js");
-    const converterPath = path.join(packagePath, "dist/adapters/converters/azure-http.js");
-    const incrementalCachePath = path.join(packagePath, "dist/overrides/incrementalCache/azure-blob.js");
-    const tagCachePath = path.join(packagePath, "dist/overrides/tagCache/azure-table.js");
-    const queuePath = path.join(packagePath, "dist/overrides/queue/azure-queue.js");
+    const distPath = (rel) => path.join(packagePath, rel).split(path.sep).join("/");
+    const wrapperPath = distPath("dist/adapters/wrappers/azure-functions.js");
+    const converterPath = distPath("dist/adapters/converters/azure-http.js");
+    const incrementalCachePath = distPath("dist/overrides/incrementalCache/azure-blob.js");
+    const tagCachePath = distPath("dist/overrides/tagCache/azure-table.js");
+    const queuePath = distPath("dist/overrides/queue/azure-queue.js");
     tempConfigPath = path.join(baseDir, "open-next.config.ts");
     const configContent = `// @ts-nocheck
 export default {
@@ -413,6 +509,12 @@ export default {
     middleware: {
         external: false,
     },
+    revalidate: {
+        override: {
+            wrapper: () => import("${distPath("dist/adapters/wrappers/azure-queue-revalidate.js")}").then(m => m.default),
+            converter: () => import("${distPath("dist/adapters/converters/azure-queue-revalidate.js")}").then(m => m.default),
+        },
+    },
     buildOutputPath: ".",
     appPath: ".",
 };
@@ -446,6 +548,81 @@ export default {
   }
 }
 
+async function seedCacheAssets(connectionString, options = {}) {
+  const openNextDir = options.openNextDir ?? path.join(process.cwd(), ".open-next");
+  const containerName = options.containerName ?? process.env.AZURE_STORAGE_CONTAINER_NAME ?? "nextjs-cache";
+  const tableName = options.tableName ?? process.env.AZURE_TABLE_NAME ?? "nextjstags";
+  await Promise.all([
+    seedIncrementalCache(connectionString, path.join(openNextDir, "cache"), containerName),
+    seedTagTable(connectionString, path.join(openNextDir, "dynamodb-provider/dynamodb-cache.json"), tableName)
+  ]);
+}
+async function runPool(items, limit, fn) {
+  let index = 0;
+  let done = 0;
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, async () => {
+      for (let i = index++; i < items.length; i = index++) {
+        await fn(items[i]);
+        done++;
+      }
+    })
+  );
+  return done;
+}
+async function seedIncrementalCache(connectionString, cacheDir, containerName = "nextjs-cache") {
+  let files;
+  try {
+    files = (await fs.readdir(cacheDir, { recursive: true, withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => path.join(entry.parentPath ?? entry.path, entry.name));
+  } catch {
+    return 0;
+  }
+  const container = BlobServiceClient.fromConnectionString(connectionString).getContainerClient(containerName);
+  await container.createIfNotExists();
+  const keyPrefix = process.env.AZURE_CACHE_KEY_PREFIX ? `${process.env.AZURE_CACHE_KEY_PREFIX}/` : "";
+  return runPool(files, 8, async (file) => {
+    const blobName = keyPrefix + path.relative(cacheDir, file).split(path.sep).join("/");
+    await container.getBlockBlobClient(blobName).uploadFile(file, {
+      blobHTTPHeaders: { blobContentType: "application/json" }
+    });
+  });
+}
+async function seedTagTable(connectionString, seedFile, tableName = "nextjstags") {
+  let entries;
+  try {
+    entries = JSON.parse(await fs.readFile(seedFile, "utf-8"));
+  } catch {
+    return 0;
+  }
+  const table = TableClient.fromConnectionString(connectionString, tableName, {
+    allowInsecureConnection: connectionString.includes("http://")
+  });
+  await table.createTable().catch((error) => {
+    if (error.statusCode !== 409)
+      throw error;
+  });
+  return runPool(entries, 8, async (entry) => {
+    await Promise.all([
+      table.upsertEntity(
+        {
+          partitionKey: encodeTableKey(entry.tag.S),
+          rowKey: encodeTableKey(entry.path.S),
+          revalidatedAt: Number(entry.revalidatedAt.N)
+        },
+        "Merge"
+      ),
+      table.upsertEntity(
+        {
+          partitionKey: encodeTableKey(`path#${entry.path.S}`),
+          rowKey: encodeTableKey(entry.tag.S),
+          revalidatedAt: Number(entry.revalidatedAt.N)
+        },
+        "Merge"
+      )
+    ]);
+  });
+}
+
 const execAsync$1 = promisify(exec);
 const colors = {
   green: "\x1B[32m",
@@ -479,12 +656,14 @@ async function deploy$1(options) {
       await checkExistingInfrastructure(appName, resourceGroup, environment);
     }
     let deploymentOutputs;
+    const expectedFunctionAppName = `${appName}-func-${environment}`;
     if (!skipInfrastructure) {
       await syncBicepTemplate();
       console.log("Provisioning Azure infrastructure...");
       console.log(`  Resource Group: ${resourceGroup}`);
       console.log(`  Location: ${location}`);
       console.log(`  Environment: ${environment}`);
+      const runFromPackage = await readRunFromPackage(resourceGroup, expectedFunctionAppName);
       deploymentOutputs = await provisionInfrastructure({
         appName,
         resourceGroup,
@@ -492,13 +671,22 @@ async function deploy$1(options) {
         environment,
         applicationInsights: options.applicationInsights ?? false
       });
+      if (runFromPackage?.startsWith("http")) {
+        await execAsync$1(
+          `az functionapp config appsettings set --resource-group ${resourceGroup} --name ${expectedFunctionAppName} --settings "WEBSITE_RUN_FROM_PACKAGE=${runFromPackage}" --output none`
+        );
+      }
       console.log(`  ${greenCheck()} Infrastructure ready`);
     } else {
       console.log("Skipping infrastructure provisioning");
     }
+    const storageAccountName = deploymentOutputs?.storageAccount || await getStorageAccountName(resourceGroup);
     console.log("Uploading static assets...");
-    await uploadStaticAssets(appName, resourceGroup);
+    await uploadStaticAssets(storageAccountName);
     console.log(`  ${greenCheck()} Assets uploaded`);
+    console.log("Seeding ISR cache and tag table...");
+    await seedRuntimeCaches(resourceGroup, storageAccountName);
+    console.log(`  ${greenCheck()} Cache seeded`);
     console.log("Deploying Function App...");
     const functionAppName = deploymentOutputs?.functionApp || `${appName}-func-${environment}`;
     await deployFunctionApp(functionAppName, resourceGroup);
@@ -571,7 +759,7 @@ async function checkQuotaAvailability(location, environment) {
     const ep1Limit = ep1Quota?.properties?.limit?.value || 0;
     const skuMap = {
       dev: { name: "Y1 (Consumption)", quota: y1Limit, type: "Dynamic" },
-      staging: { name: "EP1 (Elastic Premium)", quota: ep1Limit, type: "ElasticPremium" },
+      staging: { name: "Y1 (Consumption)", quota: y1Limit, type: "Dynamic" },
       prod: { name: "EP1 (Elastic Premium)", quota: ep1Limit, type: "ElasticPremium" }
     };
     const requiredSku = skuMap[environment];
@@ -800,7 +988,7 @@ async function provisionInfrastructure(options) {
   const bicepPath = path.join(process.cwd(), "infrastructure/main.bicep");
   const enableAppInsights = applicationInsights ? "true" : "false";
   const { stdout } = await execAsync$1(
-    `az deployment group create       --resource-group ${resourceGroup}       --template-file ${bicepPath}       --parameters appName=${appName} environment=${environment} enableApplicationInsights=${enableAppInsights}       --query 'properties.outputs.deploymentInfo.value'       --output json`
+    `az deployment group create       --resource-group ${resourceGroup}       --template-file "${bicepPath}"       --parameters appName=${appName} environment=${environment} enableApplicationInsights=${enableAppInsights}       --query 'properties.outputs.deploymentInfo.value'       --output json`
   );
   return JSON.parse(stdout);
 }
@@ -818,31 +1006,56 @@ async function patchCSSForBlobStorage(assetsPath) {
     await fs.writeFile(filePath, content, "utf-8");
   }
 }
-async function uploadStaticAssets(appName, resourceGroup) {
-  const assetsPath = path.join(process.cwd(), ".open-next/assets");
-  await patchCSSForBlobStorage(assetsPath);
+async function getStorageAccountName(resourceGroup) {
   const { stdout } = await execAsync$1(
     `az storage account list --resource-group ${resourceGroup} --query "[0].name" -o tsv`
   );
-  const storageAccountName = stdout.trim();
+  const name = stdout.trim();
+  if (!name) {
+    throw new Error(`No storage account found in resource group "${resourceGroup}"`);
+  }
+  return name;
+}
+async function readRunFromPackage(resourceGroup, functionAppName) {
+  try {
+    const { stdout } = await execAsync$1(
+      `az functionapp config appsettings list --resource-group ${resourceGroup} --name ${functionAppName} --query "[?name=='WEBSITE_RUN_FROM_PACKAGE'].value | [0]" -o tsv`
+    );
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function seedRuntimeCaches(resourceGroup, storageAccountName) {
+  const { stdout: connectionString } = await execAsync$1(
+    `az storage account show-connection-string --resource-group ${resourceGroup} --name ${storageAccountName} --query connectionString -o tsv`
+  );
+  await seedCacheAssets(connectionString.trim());
+}
+async function uploadStaticAssets(storageAccountName) {
+  const assetsPath = path.join(process.cwd(), ".open-next/assets");
+  await patchCSSForBlobStorage(assetsPath);
   await execAsync$1(
-    `az storage blob upload-batch       --account-name ${storageAccountName}       --destination assets       --source ${assetsPath}       --content-cache-control "public, max-age=0, must-revalidate"       --overwrite`
+    `az storage blob upload-batch       --account-name ${storageAccountName}       --destination assets       --source "${assetsPath}"       --content-cache-control "public, max-age=0, must-revalidate"       --overwrite`,
+    { maxBuffer: 100 * 1024 * 1024 }
   );
   const nextStaticPath = path.join(assetsPath, "_next/static");
   if (existsSync(nextStaticPath)) {
     await execAsync$1(
-      `az storage blob upload-batch         --account-name ${storageAccountName}         --destination assets         --source ${nextStaticPath}         --destination-path _next/static         --content-cache-control "public, max-age=31536000, immutable"         --overwrite`
+      `az storage blob upload-batch         --account-name ${storageAccountName}         --destination assets         --source "${nextStaticPath}"         --destination-path _next/static         --content-cache-control "public, max-age=31536000, immutable"         --overwrite`,
+      { maxBuffer: 100 * 1024 * 1024 }
     );
   }
 }
 async function deployFunctionApp(functionAppName, resourceGroup) {
   const functionsPath = path.join(process.cwd(), ".open-next/server-functions/default");
   const zipPath = path.join(process.cwd(), ".open-next/function-app.zip");
-  await execAsync$1(`cd ${functionsPath} && zip -r ${zipPath} . -q`, {
+  await fs.rm(zipPath, { force: true });
+  await execAsync$1(`cd "${functionsPath}" && zip -r "${zipPath}" . -q`, {
     maxBuffer: 100 * 1024 * 1024
   });
   await execAsync$1(
-    `az functionapp deployment source config-zip       --resource-group ${resourceGroup}       --name ${functionAppName}       --src ${zipPath}`,
+    `az functionapp deployment source config-zip       --resource-group ${resourceGroup}       --name ${functionAppName}       --src "${zipPath}"`,
     {
       maxBuffer: 100 * 1024 * 1024
     }
@@ -850,6 +1063,41 @@ async function deployFunctionApp(functionAppName, resourceGroup) {
   await fs.unlink(zipPath);
 }
 
+const RULES = {
+  appName: {
+    pattern: /^[a-zA-Z0-9][a-zA-Z0-9-]{0,58}[a-zA-Z0-9]$/,
+    hint: "2-60 alphanumeric characters or hyphens, starting and ending with an alphanumeric"
+  },
+  resourceGroup: {
+    pattern: /^[a-zA-Z0-9_()\-.]{1,90}$/,
+    hint: "1-90 alphanumerics, underscores, parentheses, hyphens, or periods"
+  },
+  location: {
+    pattern: /^[a-z0-9]{3,30}$/,
+    hint: "a lowercase Azure region name like eastus or westeurope"
+  },
+  environment: {
+    pattern: /^(dev|staging|prod)$/,
+    hint: "one of: dev, staging, prod"
+  }
+};
+function validateAzureName(kind, value) {
+  if (value === void 0)
+    return;
+  const rule = RULES[kind];
+  if (!rule.pattern.test(value)) {
+    console.error(`\u274C Invalid ${kind}: ${JSON.stringify(value)}`);
+    console.error(`   Expected ${rule.hint}.`);
+    process.exit(1);
+  }
+}
+function validateAzureNames(values) {
+  validateAzureName("appName", values.appName);
+  validateAzureName("resourceGroup", values.resourceGroup);
+  validateAzureName("location", values.location);
+  validateAzureName("environment", values.environment);
+}
+
 const execAsync = promisify(exec);
 async function promptForInput(question) {
   const rl = readline.createInterface({
@@ -947,6 +1195,7 @@ async function deploy(options) {
   if (!resourceGroup) {
     const result = await selectResourceGroup();
     resourceGroup = result.name;
+    validateAzureNames({ resourceGroup });
     if (result.isNew) {
       resourceGroupLocation = result.location;
     } else {
@@ -954,10 +1203,13 @@ async function deploy(options) {
     }
   }
   const environment = options.environment || config.environment || await selectEnvironment();
+  const appName = options.appName || config.appName || path.basename(cwd);
+  const location = resourceGroupLocation || options.location || config.location || "eastus";
+  validateAzureNames({ appName, resourceGroup, location, environment });
   await deploy$1({
-    appName: options.appName || config.appName || path.basename(cwd),
+    appName,
     resourceGroup,
-    location: resourceGroupLocation || options.location || config.location || "eastus",
+    location,
     environment,
     skipInfrastructure: options.skipInfrastructure,
     skipResourceChecks: options.skipResourceChecks,
@@ -976,4 +1228,4 @@ async function getResourceGroupLocation(resourceGroup) {
   }
 }
 
-export { build as b, deploy as d, greenCheck as g, init as i, promptForInput as p, redX as r };
+export { build as b, deploy as d, greenCheck as g, init as i, promptForInput as p, redX as r, validateAzureNames as v };

package/dist/index.d.mts

@@ -7,6 +7,7 @@ export { default as azureHttpConverter } from './adapters/converters/azure-http.
 import '@opennextjs/aws/types/open-next.js';
 import '@opennextjs/aws/types/overrides.js';
 import '@azure/functions';
+import 'node:buffer';
 
 interface ScaffoldOptions {
     typescript?: boolean;

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export { default as azureHttpConverter } from './adapters/converters/azure-http.
 import '@opennextjs/aws/types/open-next.js';
 import '@opennextjs/aws/types/overrides.js';
 import '@azure/functions';
+import 'node:buffer';
 
 interface ScaffoldOptions {
     typescript?: boolean;

package/dist/index.js

@@ -12,9 +12,9 @@ import 'node:child_process';
 import 'node:util';
 import '@opennextjs/aws/build.js';
 import 'node:fs';
-import 'node:readline';
 import '@azure/storage-blob';
 import '@azure/data-tables';
+import 'node:readline';
 import '@azure/storage-queue';
 import 'node:stream';
 import 'node:buffer';

package/dist/infrastructure/main.bicep

@@ -136,6 +136,9 @@ resource appServicePlan 'Microsoft.Web/serverfarms@2023-01-01' = {
   kind: 'functionapp'
   properties: {
     reserved: true // Linux
+    // Elastic Premium defaults to a max of 1 worker when this is omitted,
+    // which pins the prod plan to a single instance. Y1 ignores it.
+    maximumElasticWorkerCount: environment == 'prod' ? 20 : 1
   }
 }
 
@@ -170,12 +173,10 @@ resource functionApp 'Microsoft.Web/sites@2023-01-01' = {
           value: 'node'
         }
         {
-          name: 'WEBSITE_NODE_DEFAULT_VERSION'
-          value: '~${nodeVersion}'
-        }
-        {
-          name: 'WEBSITE_RUN_FROM_PACKAGE'
-          value: '1'
+          // A second worker process buys resilience to GC stalls; SSR is
+          // single-threaded per worker. Memory-bounded on Y1 (1.5 GB).
+          name: 'FUNCTIONS_WORKER_PROCESS_COUNT'
+          value: '2'
         }
         {
           name: 'AzureWebJobsDisableHomepage'
@@ -223,6 +224,12 @@ resource functionApp 'Microsoft.Web/sites@2023-01-01' = {
       
       ftpsState: 'Disabled'
       minTlsVersion: '1.2'
+      // Always-ready SSR on Elastic Premium; both stay null on Y1.
+      // WEBSITE_RUN_FROM_PACKAGE is deliberately absent: '1' is unsupported
+      // on Linux Consumption, and the deploy step sets the blob-URL form
+      // that provisioning must not overwrite.
+      minimumElasticInstanceCount: environment == 'prod' ? 1 : null
+      preWarmedInstanceCount: environment == 'prod' ? 1 : null
       cors: {
         allowedOrigins: ['*']
       }

package/dist/overrides/incrementalCache/azure-blob.d.mts

@@ -1,5 +1,18 @@
 import { IncrementalCache, CacheEntryType, WithLastModified, CacheValue } from '@opennextjs/aws/types/overrides.js';
 
+/**
+ * Retry policy for blob calls on the request hot path. The SDK's default
+ * first retry waits 4s; fail fast instead and let cache layers treat
+ * errors as misses. Shared with the image-optimization wrapper.
+ */
+declare const BLOB_RETRY_OPTIONS: {
+    retryOptions: {
+        maxTries: number;
+        retryDelayInMs: number;
+        maxRetryDelayInMs: number;
+        tryTimeoutInMs: number;
+    };
+};
 /**
  * Azure Blob Storage implementation of IncrementalCache.
  *
@@ -13,6 +26,9 @@ declare class AzureBlobIncrementalCache implements IncrementalCache {
     /**
      * Builds the blob key path, mimicking S3 structure:
      * [prefix]/[__fetch]/[buildId]/[key].[extension]
+     *
+     * Keys must match the .open-next/cache layout the seeder uploads, so no
+     * container-name prefix and no leading slash.
      */
     private buildBlobKey;
     get<CacheType extends CacheEntryType = "cache">(key: string, cacheType?: CacheType): Promise<WithLastModified<CacheValue<CacheType>> | null>;
@@ -20,4 +36,4 @@ declare class AzureBlobIncrementalCache implements IncrementalCache {
     delete(key: string): Promise<void>;
 }
 
-export { AzureBlobIncrementalCache as default };
+export { BLOB_RETRY_OPTIONS, AzureBlobIncrementalCache as default };

package/dist/overrides/incrementalCache/azure-blob.d.ts

@@ -1,5 +1,18 @@
 import { IncrementalCache, CacheEntryType, WithLastModified, CacheValue } from '@opennextjs/aws/types/overrides.js';
 
+/**
+ * Retry policy for blob calls on the request hot path. The SDK's default
+ * first retry waits 4s; fail fast instead and let cache layers treat
+ * errors as misses. Shared with the image-optimization wrapper.
+ */
+declare const BLOB_RETRY_OPTIONS: {
+    retryOptions: {
+        maxTries: number;
+        retryDelayInMs: number;
+        maxRetryDelayInMs: number;
+        tryTimeoutInMs: number;
+    };
+};
 /**
  * Azure Blob Storage implementation of IncrementalCache.
  *
@@ -13,6 +26,9 @@ declare class AzureBlobIncrementalCache implements IncrementalCache {
     /**
      * Builds the blob key path, mimicking S3 structure:
      * [prefix]/[__fetch]/[buildId]/[key].[extension]
+     *
+     * Keys must match the .open-next/cache layout the seeder uploads, so no
+     * container-name prefix and no leading slash.
      */
     private buildBlobKey;
     get<CacheType extends CacheEntryType = "cache">(key: string, cacheType?: CacheType): Promise<WithLastModified<CacheValue<CacheType>> | null>;
@@ -20,4 +36,4 @@ declare class AzureBlobIncrementalCache implements IncrementalCache {
     delete(key: string): Promise<void>;
 }
 
-export { AzureBlobIncrementalCache as default };
+export { BLOB_RETRY_OPTIONS, AzureBlobIncrementalCache as default };

package/dist/overrides/incrementalCache/azure-blob.js

@@ -1,6 +1,9 @@
-import { BlobServiceClient } from '@azure/storage-blob';
+import { BlobServiceClient, StorageSharedKeyCredential } from '@azure/storage-blob';
 import { getAzureConfig } from '../../config/index.js';
 
+const BLOB_RETRY_OPTIONS = {
+  retryOptions: { maxTries: 3, retryDelayInMs: 300, maxRetryDelayInMs: 2e3, tryTimeoutInMs: 1e4 }
+};
 class AzureBlobIncrementalCache {
   name = "azure-blob";
   containerClient;
@@ -9,27 +12,33 @@ class AzureBlobIncrementalCache {
     const connectionString = storage.connectionString;
     const accountName = storage.accountName;
     const accountKey = storage.accountKey;
+    const clientOptions = BLOB_RETRY_OPTIONS;
     if (connectionString) {
-      const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString);
+      const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString, clientOptions);
       this.containerClient = blobServiceClient.getContainerClient(storage.containerName || "nextjs-cache");
     } else if (accountName && accountKey) {
-      const blobServiceClient = new BlobServiceClient(`https://${accountName}.blob.core.windows.net`, {
-        accountName,
-        accountKey
-      });
+      const credential = new StorageSharedKeyCredential(accountName, accountKey);
+      const blobServiceClient = new BlobServiceClient(
+        `https://${accountName}.blob.core.windows.net`,
+        credential,
+        clientOptions
+      );
       this.containerClient = blobServiceClient.getContainerClient(storage.containerName || "nextjs-cache");
     }
   }
   /**
    * Builds the blob key path, mimicking S3 structure:
    * [prefix]/[__fetch]/[buildId]/[key].[extension]
+   *
+   * Keys must match the .open-next/cache layout the seeder uploads, so no
+   * container-name prefix and no leading slash.
    */
   buildBlobKey(key, cacheType = "cache") {
-    const { storage } = getAzureConfig();
     const { NEXT_BUILD_ID } = process.env;
-    const prefix = storage.containerName || "";
+    const prefix = process.env.AZURE_CACHE_KEY_PREFIX || "";
     const type = cacheType === "fetch" ? "__fetch" : "";
-    return [prefix, type, NEXT_BUILD_ID, cacheType === "fetch" ? key : `${key}.${cacheType}`].filter(Boolean).join("/");
+    const cleanKey = key.replace(/^\/+/, "");
+    return [prefix, type, NEXT_BUILD_ID, cacheType === "fetch" ? cleanKey : `${cleanKey}.${cacheType}`].filter(Boolean).join("/");
   }
   async get(key, cacheType) {
     try {
@@ -63,7 +72,7 @@ class AzureBlobIncrementalCache {
       const blobKey = this.buildBlobKey(key, cacheType);
       const blobClient = this.containerClient.getBlockBlobClient(blobKey);
       const content = JSON.stringify(value);
-      await blobClient.upload(content, content.length, {
+      await blobClient.upload(content, Buffer.byteLength(content), {
         blobHTTPHeaders: {
           blobContentType: "application/json"
         }
@@ -86,4 +95,4 @@ class AzureBlobIncrementalCache {
   }
 }
 
-export { AzureBlobIncrementalCache as default };
+export { BLOB_RETRY_OPTIONS, AzureBlobIncrementalCache as default };