@opennextjs/cloudflare 1.19.1 → 1.19.3

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.d.ts

@@ -140,7 +140,7 @@ declare class ShardedDOTagCache implements NextModeTagCache {
      * @returns An array of objects with the tag and the last revalidation time
      */
     getFromRegionalCache(opts: CacheTagKeyOptions): Promise<CachedTagValue[]>;
-    putToRegionalCache(optsKey: CacheTagKeyOptions, stub: DurableObjectStub<DOShardedTagCache>): Promise<void>;
+    putToRegionalCache(optsKey: CacheTagKeyOptions, stub: DurableObjectStub<DOShardedTagCache>, prefetchedTagData?: Record<string, TagData>): Promise<void>;
     /**
      * Deletes the regional cache for the given tags
      * This is used to ensure that the cache is cleared when the tags are revalidated

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.js

@@ -211,14 +211,14 @@ class ShardedDOTagCache {
             return [];
         }
     }
-    async putToRegionalCache(optsKey, stub) {
+    async putToRegionalCache(optsKey, stub, prefetchedTagData) {
         if (!this.opts.regionalCache)
             return;
         const cache = await this.getCacheInstance();
         if (!cache)
             return;
         const tags = optsKey.tags;
-        const tagData = await stub.getTagData(tags);
+        const tagData = prefetchedTagData ?? (await stub.getTagData(tags));
         await Promise.all(tags.map(async (tag) => {
             let data = tagData[tag];
             if (data === undefined) {
@@ -316,7 +316,7 @@ class ShardedDOTagCache {
             for (const tag of remainingTags) {
                 result.set(tag, tagData[tag] ?? null);
             }
-            getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags: remainingTags }, stub));
+            getCloudflareContext().ctx.waitUntil(this.putToRegionalCache({ doId, tags: remainingTags }, stub, tagData));
         }));
         return result;
     }

package/dist/cli/build/patches/plugins/load-manifest.d.ts

@@ -6,3 +6,40 @@
 import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
 import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";
 export declare function inlineLoadManifest(updater: ContentUpdater, buildOpts: BuildOptions): Plugin;
+/**
+ * Factor out large manifest values into separate variables.
+ *
+ * @param manifest The manifest code.
+ * @param key The key to factor out.
+ * @param values A map to store the factored values (indexed by variable name).
+ * @param prefixMap Map of short hash prefix → full hash, updated in place for
+ *   collision resolution across calls.
+ * @returns The manifest code with large values factored out.
+ */
+export declare function factorManifestValue(manifest: string, key: string, values: Map<string, string>, prefixMap: Map<string, string>): string;
+/**
+ * Factor out large object values into separate variables.
+ *
+ * @param valueText The JS source text of the module mapping object.
+ * @param sharedVars Map to accumulate shared variable declarations.
+ * @param prefixMap Map of short hash prefix → full hash, updated in place for
+ *   collision resolution across calls.
+ * @returns The rewritten value text with chunks arrays replaced by variable refs.
+ */
+export declare function factorObjectValues(valueText: string, sharedVars: Map<string, string>, prefixMap: Map<string, string>): string;
+/**
+ * Get or create a short variable name for a value, resolving collisions.
+ *
+ * Computes a SHA1 hash of the value, then finds the shortest unique prefix
+ * (minimum {@link MIN_PREFIX_LENGTH} hex chars). When a new hash collides with
+ * an existing prefix, the new entry is given a longer prefix — existing entries
+ * are never renamed.
+ *
+ * This allows saving space in the generated code (A full SHA1 is 40 hex chars) because
+ * identifiers are not minimized by the Open Next build process.
+ *
+ * @param value The value to hash.
+ * @param prefixMap Map of short prefix → full hash, updated in place.
+ * @returns The variable name (`v<shortPrefix>`).
+ */
+export declare function getOrCreateVarName(value: string, prefixMap: Map<string, string>): string;

package/dist/cli/build/patches/plugins/load-manifest.js

@@ -3,10 +3,12 @@
  *
  * They rely on `readFileSync` that is not supported by workerd.
  */
+import crypto from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { join, posix, relative, sep } from "node:path";
+import { Lang, parse } from "@ast-grep/napi";
 import { getPackagePath } from "@opennextjs/aws/build/helper.js";
-import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+import { applyRule, patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
 import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
 import { glob } from "glob";
 import { normalizePath } from "../../../utils/normalize-path.js";
@@ -75,19 +77,62 @@ async function getEvalManifestRule(buildOpts) {
     const { outputDir } = buildOpts;
     const baseDir = join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next");
     const appDir = join(baseDir, "server/app");
-    const manifests = await glob(join(baseDir, "**/*_client-reference-manifest.js"), {
+    const manifestPaths = await glob(join(baseDir, "**/*_client-reference-manifest.js"), {
         windowsPathsNoEscape: true,
     });
-    // Sort by path length descending so longer (more specific) paths match first,
-    // preventing suffix collisions in the `.endsWith()` chain (see #1156).
-    const sortedManifests = [...manifests].sort((a, b) => b.length - a.length);
-    const returnManifests = sortedManifests
-        .map((manifest) => {
-        const endsWith = normalizePath(relative(baseDir, manifest));
-        const key = normalizePath("/" + relative(appDir, manifest)).replace("_client-reference-manifest.js", "");
+    // Map of factored large objects (variable name -> {...})
+    const factoredObjects = new Map();
+    // Map of manifest path -> factored manifest content
+    const factoredManifest = new Map();
+    // Shared map of short hash prefix -> full SHA1 hash, used for collision resolution.
+    const prefixMap = new Map();
+    for (const path of manifestPaths) {
+        if (path.endsWith("page_client-reference-manifest.js")) {
+            // `page_client-reference-manifest.js` files could contain large repeated values.
+            // Factor out large values into separate variables to reduce the overall size of the generated code.
+            let manifest = await readFile(path, "utf-8");
+            for (const key of [
+                "clientModules",
+                "ssrModuleMapping",
+                "edgeSSRModuleMapping",
+                "rscModuleMapping",
+                "entryCSSFiles",
+                "entryJSFiles",
+            ]) {
+                manifest = factorManifestValue(manifest, key, factoredObjects, prefixMap);
+            }
+            factoredManifest.set(path, manifest);
+        }
+    }
+    // Map of factored values in an object
+    const factoredValues = new Map();
+    for (const [varName, value] of factoredObjects) {
+        factoredObjects.set(varName, factorObjectValues(value, factoredValues, prefixMap));
+    }
+    // Prepend chunks variable declarations before the factored values
+    const factoredValueCode = [...factoredValues.entries()]
+        .map(([name, val]) => `const ${name} = ${val};`)
+        .join("\n");
+    const factoredObjectCode = [...factoredObjects.entries()]
+        .map(([varName, value]) => `const ${varName} = ${value};`)
+        .join("\n");
+    const returnManifests = manifestPaths
+        // Sort by path length descending so longer (more specific) paths match first,
+        // preventing suffix collisions in the `.endsWith()` chain (see #1156).
+        .toSorted((a, b) => b.length - a.length)
+        .map((path) => {
+        let manifest;
+        if (factoredManifest.has(path)) {
+            manifest = factoredManifest.get(path);
+        }
+        else {
+            manifest = `require(${JSON.stringify(path)});`;
+        }
+        const endsWith = normalizePath(relative(baseDir, path));
+        const key = normalizePath("/" + relative(appDir, path)).replace("_client-reference-manifest.js", "");
         return `
 if ($PATH.endsWith("${endsWith}")) {
-  require(${JSON.stringify(manifest)});
+  ${manifest}
   return {
     __RSC_MANIFEST: {
     "${key}": globalThis.__RSC_MANIFEST["${key}"],
@@ -104,6 +149,9 @@ function evalManifest($PATH, $$$ARGS) {
 }`,
         },
         fix: `
+${factoredValueCode}
+${factoredObjectCode}
+
 function evalManifest($PATH, $$$ARGS) {
   $PATH = $PATH.replaceAll(${JSON.stringify(sep)}, ${JSON.stringify(posix.sep)});
   ${returnManifests}
@@ -116,3 +164,130 @@ function evalManifest($PATH, $$$ARGS) {
 }`,
     };
 }
+/**
+ * Factor out large manifest values into separate variables.
+ *
+ * @param manifest The manifest code.
+ * @param key The key to factor out.
+ * @param values A map to store the factored values (indexed by variable name).
+ * @param prefixMap Map of short hash prefix → full hash, updated in place for
+ *   collision resolution across calls.
+ * @returns The manifest code with large values factored out.
+ */
+export function factorManifestValue(manifest, key, values, prefixMap) {
+    const valueName = "VALUE";
+    // ASTGrep rule to extract the value of a specific key from the manifest object in the evalManifest function.
+    //
+    // globalThis.__RSC_MANIFEST["/path/to/page"] = {
+    //  // ...
+    //  key: $VALUE
+    //  // ...
+    // }
+    const extractValueRule = `
+rule:
+  kind: pair
+  all:
+    - has:
+        field: key
+        pattern: '"${key}"'
+    - has:
+        field: value
+        pattern: $${valueName}
+inside:
+  pattern: globalThis.__RSC_MANIFEST[$$$_] = { $$$ };
+  stopBy: end
+`;
+    const rootNode = parse(Lang.JavaScript, manifest).root();
+    const { matches } = applyRule(extractValueRule, rootNode, { once: true });
+    if (matches.length === 1 && matches[0]?.getMatch(valueName)) {
+        const match = matches[0];
+        const value = match.getMatch(valueName).text();
+        if (value.length > 30) {
+            // Factor out large values into separate variables.
+            const varName = getOrCreateVarName(value, prefixMap);
+            values.set(varName, value);
+            // Replace the value in the manifest with the variable reference.
+            return rootNode.commitEdits([match.replace(`"${key}": ${varName}`)]);
+        }
+    }
+    // Return the original manifest if the value is not found or is small enough to not warrant factoring out.
+    return manifest;
+}
+/**
+ * Factor out large object values into separate variables.
+ *
+ * @param valueText The JS source text of the module mapping object.
+ * @param sharedVars Map to accumulate shared variable declarations.
+ * @param prefixMap Map of short hash prefix → full hash, updated in place for
+ *   collision resolution across calls.
+ * @returns The rewritten value text with chunks arrays replaced by variable refs.
+ */
+export function factorObjectValues(valueText, sharedVars, prefixMap) {
+    const rootNode = parse(Lang.JavaScript, valueText).root();
+    // Find all "chunks": [...] pairs
+    const chunksRule = `
+rule:
+  kind: pair
+  all:
+    - has:
+        field: key
+        pattern: '"chunks"'
+    - has:
+        field: value
+        kind: array
+        pattern: $CHUNKS
+`;
+    const { matches } = applyRule(chunksRule, rootNode, { once: false });
+    const edits = [];
+    for (const match of matches) {
+        const chunksNode = match.getMatch("CHUNKS");
+        if (!chunksNode)
+            continue;
+        const chunksText = chunksNode.text();
+        if (chunksText.length <= 30)
+            continue; // Skip small arrays
+        const varName = getOrCreateVarName(chunksText, prefixMap);
+        sharedVars.set(varName, chunksText);
+        edits.push({ match, replacement: `"chunks": ${varName}` });
+    }
+    return edits.length === 0
+        ? valueText
+        : rootNode.commitEdits(edits.map((e) => e.match.replace(e.replacement)));
+}
+/** Minimum number of hex characters used for short hash prefixes. */
+const MIN_PREFIX_LENGTH = 3;
+/**
+ * Get or create a short variable name for a value, resolving collisions.
+ *
+ * Computes a SHA1 hash of the value, then finds the shortest unique prefix
+ * (minimum {@link MIN_PREFIX_LENGTH} hex chars). When a new hash collides with
+ * an existing prefix, the new entry is given a longer prefix — existing entries
+ * are never renamed.
+ *
+ * This allows saving space in the generated code (A full SHA1 is 40 hex chars) because
+ * identifiers are not minimized by the Open Next build process.
+ *
+ * @param value The value to hash.
+ * @param prefixMap Map of short prefix → full hash, updated in place.
+ * @returns The variable name (`v<shortPrefix>`).
+ */
+export function getOrCreateVarName(value, prefixMap) {
+    const sha1 = crypto.createHash("sha1").update(value).digest("hex");
+    // Find the shortest prefix (>= MIN_PREFIX_LENGTH) that doesn't collide
+    // with any existing prefix. Only the new entry is lengthened.
+    for (let len = MIN_PREFIX_LENGTH; len <= sha1.length; len++) {
+        const candidate = sha1.slice(0, len);
+        const existing = prefixMap.get(candidate);
+        if (existing === undefined) {
+            prefixMap.set(candidate, sha1);
+            return `v${candidate}`;
+        }
+        if (existing === sha1) {
+            // Same content seen again — reuse the existing variable.
+            return `v${candidate}`;
+        }
+        // A different hash occupies this exact prefix — lengthen and retry.
+    }
+    // Unreachable: two different SHA1 hashes always diverge before 40 chars.
+    throw new Error("Failed to find a unique prefix");
+}

package/dist/cli/build/patches/plugins/turbopack.js

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "node:path";
 import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
 import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
 const inlineChunksRule = `
@@ -7,6 +9,179 @@ rule:
 fix:
   requireChunk(chunkPath)
 `;
+/**
+ * Discover Turbopack external module mappings by reading symlinks in .next/node_modules/.
+ *
+ * Turbopack externalizes packages listed in serverExternalPackages and creates hashed
+ * identifiers (e.g. "shiki-43d062b67f27bbdc") with symlinks in .next/node_modules/ pointing
+ * to the real packages (e.g. ../../node_modules/shiki). At runtime, externalImport() does
+ * `await import("shiki-43d062b67f27bbdc/wasm")` which fails because the bundler can't
+ * statically analyze those hashed names. This function discovers the mappings so we can
+ * generate explicit switch cases for the bundler.
+ *
+ * @param filePath Absolute path to the Turbopack runtime file being patched
+ *                 (e.g. `/abs/path/to/.open-next/server-functions/default/.../.next/server/chunks/ssr/[turbopack]_runtime.js`).
+ *                 This must be the actual file in `.open-next/` (not `buildOptions.appBuildOutputPath`)
+ *                 because the `.next/node_modules/` symlinks are in the traced copy, not the original.
+ * @returns A map from hashed identifiers to real package names (e.g. "shiki-43d062b67f27bbdc" -> "shiki").
+ */
+function discoverExternalModuleMappings(filePath) {
+    // filePath is like: .../.next/server/chunks/ssr/[turbopack]_runtime.js
+    // We need: .../.next/node_modules/
+    const dotNextDir = filePath.replace(/\/server\/chunks\/.*$/, "");
+    const nodeModulesDir = path.join(dotNextDir, "node_modules");
+    const mappings = new Map();
+    if (!fs.existsSync(nodeModulesDir)) {
+        return mappings;
+    }
+    for (const entry of fs.readdirSync(nodeModulesDir, { withFileTypes: true })) {
+        try {
+            if (entry.isSymbolicLink()) {
+                const entryPath = path.join(nodeModulesDir, entry.name);
+                const target = fs.readlinkSync(entryPath);
+                // target is like "../../node_modules/shiki" — extract package name
+                const match = target.match(/node_modules\/(.+)$/);
+                if (match?.[1]) {
+                    mappings.set(entry.name, match[1]);
+                }
+            }
+        }
+        catch {
+            // skip entries we can't read
+        }
+    }
+    return mappings;
+}
+/**
+ * Build a dynamic inlineExternalImportRule that includes cases for all discovered
+ * Turbopack external module hashes, mapping them back to their real package names.
+ *
+ * We use a switch for exact matches (including bare + subpath cases) and a fallback
+ * for the default case. Since switch/case can only match exact strings, we enumerate
+ * known subpaths from the traced files to cover cases like "shiki-hash/wasm".
+ */
+function buildExternalImportRule(mappings, tracedFiles, runtimeCode) {
+    // Tracks module names that already have a switch case, to avoid duplicates.
+    const casedModules = new Set();
+    const cases = [];
+    function addCase(moduleName, importPath) {
+        if (!casedModules.has(moduleName)) {
+            casedModules.add(moduleName);
+            cases.push(`case "${moduleName}":\n  $RAW = await import("${importPath}");\n  break;`);
+        }
+    }
+    // Always include the @vercel/og rewrite
+    addCase("next/dist/compiled/@vercel/og/index.node.js", "next/dist/compiled/@vercel/og/index.edge.js");
+    // Add case for each discovered external module mapping (bare import)
+    for (const [hashedName, realName] of mappings) {
+        addCase(hashedName, realName);
+    }
+    // Discover subpath imports from the traced chunk files.
+    // Chunks reference external modules like "shiki-hash/wasm" — scan for these patterns.
+    const subpathCases = discoverExternalSubpaths(mappings, tracedFiles);
+    for (const [hashedSubpath, realSubpath] of subpathCases) {
+        addCase(hashedSubpath, realSubpath);
+    }
+    // Discover bare external imports from chunk files (e.g. externalImport("shiki")).
+    // These need explicit switch cases so the bundler can statically resolve them.
+    const bareImports = discoverBareExternalImports(tracedFiles, runtimeCode);
+    for (const [moduleName, realName] of bareImports) {
+        addCase(moduleName, realName);
+    }
+    // Indent each case line by 4 spaces to align with the switch body in the YAML fix block.
+    const indentedCases = cases
+        .flatMap((c) => c.split("\n"))
+        .map((line) => `    ${line}`)
+        .join("\n");
+    return `
+rule:
+  pattern: "$RAW = await import($ID)"
+  inside:
+    regex: "externalImport"
+    kind: function_declaration
+    stopBy: end
+fix: |-
+  switch ($ID) {
+${indentedCases}
+    default:
+      $RAW = await import($ID);
+  }
+`;
+}
+/**
+ * Scan traced chunk files for bare external module imports (e.g. `externalImport("shiki")`).
+ *
+ * In some Turbopack versions, externalized packages are referenced by their real names
+ * (not hashed). The default `await import(id)` with a variable `id` can't be statically
+ * analyzed by the bundler (ESBuild). By adding explicit switch cases with string literals,
+ * we make these imports statically discoverable so they get bundled into the worker.
+ */
+function discoverBareExternalImports(tracedFiles, runtimeCode) {
+    const bareImports = new Map();
+    // Turbopack assigns `externalImport` to a property on the context prototype,
+    // e.g. `contextPrototype.y = externalImport`. The property name could change between versions,
+    // so we extract it dynamically from the runtime code rather than hardcoding it.
+    const propMatch = runtimeCode.match(/contextPrototype\.(\w+)\s*=\s*externalImport/);
+    if (!propMatch?.[1]) {
+        return bareImports;
+    }
+    const externalImportAlias = propMatch[1];
+    // Chunks call externalImport as e.g. `.y("shiki")` — build a regex using the discovered property name.
+    const externalImportRegexp = new RegExp(`\\.${externalImportAlias}\\("([^"]+)"\\)`, "g");
+    const chunkFiles = tracedFiles.filter((f) => f.includes(".next/server/chunks/"));
+    for (const filePath of chunkFiles) {
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            for (const externalImportMatch of content.matchAll(externalImportRegexp)) {
+                const moduleName = externalImportMatch[1];
+                if (moduleName) {
+                    // Identity mapping — the module name is already the real name
+                    bareImports.set(moduleName, moduleName);
+                }
+            }
+        }
+        catch {
+            // skip files we can't read
+        }
+    }
+    return bareImports;
+}
+/**
+ * Scan traced chunk files for external module subpath imports.
+ * E.g. find "shiki-43d062b67f27bbdc/wasm" in chunk code and map it to "shiki/wasm".
+ *
+ * Only scans files with "[externals]" in the name since those are the chunks that
+ * contain externalImport calls.
+ */
+function discoverExternalSubpaths(mappings, tracedFiles) {
+    const subpaths = new Map();
+    const externalChunks = tracedFiles.filter((f) => f.includes("[externals]"));
+    for (const [hashedName, realName] of mappings) {
+        // Build a regex to find quoted subpath imports of this hashed module in chunk source code.
+        // E.g. for hashedName "shiki-43d062b67f27bbdc", this matches strings like
+        // "shiki-43d062b67f27bbdc/wasm" or "shiki-43d062b67f27bbdc/engine/javascript".
+        // The hashedName is escaped to safely use it as a literal in the regex pattern.
+        const escaped = getCrossPlatformPathRegex(hashedName, { escape: true });
+        const pattern = new RegExp(`"(${escaped}/[^"]*)"`, "g");
+        for (const filePath of externalChunks) {
+            try {
+                const content = fs.readFileSync(filePath, "utf-8");
+                for (const match of content.matchAll(pattern)) {
+                    const fullHashedPath = match[1];
+                    if (fullHashedPath) {
+                        const subpath = fullHashedPath.slice(hashedName.length);
+                        const realSubpath = realName + subpath;
+                        subpaths.set(fullHashedPath, realSubpath);
+                    }
+                }
+            }
+            catch {
+                // skip files we can't read
+            }
+        }
+    }
+    return subpaths;
+}
 export const patchTurbopackRuntime = {
     name: "inline-turbopack-chunks",
     patches: [
@@ -16,8 +191,10 @@ export const patchTurbopackRuntime = {
                 escape: false,
             }),
             contentFilter: /loadRuntimeChunkPath/,
-            patchCode: async ({ code, tracedFiles }) => {
-                let patched = patchCode(code, inlineExternalImportRule);
+            patchCode: async ({ code, tracedFiles, filePath }) => {
+                const mappings = discoverExternalModuleMappings(filePath);
+                const externalImportRule = buildExternalImportRule(mappings, tracedFiles, code);
+                let patched = patchCode(code, externalImportRule);
                 patched = patchCode(patched, inlineChunksRule);
                 return `${patched}\n${inlineChunksFn(tracedFiles)}`;
             },
@@ -53,26 +230,3 @@ ${chunks
   }
 `;
 }
-// Turbopack imports `og` via `externalImport`.
-// We patch it to:
-// - add the explicit path so that the file is inlined by wrangler
-// - use the edge version of the module instead of the node version.
-//
-// Modules that are not inlined (no added to the switch), would generate an error similar to:
-// Failed to load external module path/to/module: Error: No such module "path/to/module"
-const inlineExternalImportRule = `
-rule:
-  pattern: "$RAW = await import($ID)"
-  inside:
-    regex: "externalImport"
-    kind: function_declaration
-    stopBy: end
-fix: |-
-  switch ($ID) {
-    case "next/dist/compiled/@vercel/og/index.node.js":
-      $RAW = await import("next/dist/compiled/@vercel/og/index.edge.js");
-      break;
-    default:
-      $RAW = await import($ID);
-  }
-`;

package/dist/cli/commands/build.js

@@ -2,6 +2,7 @@ import logger from "@opennextjs/aws/logger.js";
 import { build as buildImpl } from "../build/build.js";
 import { askConfirmation } from "../utils/ask-confirmation.js";
 import { createWranglerConfigFile, findWranglerConfig } from "../utils/create-wrangler-config.js";
+import { isNonInteractiveOrCI } from "../utils/is-interactive.js";
 import { compileConfig, getNormalizedOptions, nextAppDir, printHeaders, readWranglerConfig, withWranglerOptions, withWranglerPassthroughArgs, } from "./utils/utils.js";
 /**
  * Implementation of the `opennextjs-cloudflare build` command.
@@ -18,6 +19,12 @@ export async function buildCommand(args) {
     //       nor when `--skipWranglerConfigCheck` is used.
     if (!projectOpts.wranglerConfigPath && !args.skipWranglerConfigCheck) {
         if (!findWranglerConfig(projectOpts.sourceDir)) {
+            // In non-interactive environments (CI, Cloudflare Workers Builds,
+            // Docker, etc.) the prompt would hang or crash. Fail fast with a
+            // clear message pointing at the existing escape hatch.
+            if (isNonInteractiveOrCI()) {
+                throw new Error("No `wrangler.(toml|json|jsonc)` config file found.\n\nCreate one at the project root before running the build, or skip this check with `--skipWranglerConfigCheck` or `SKIP_WRANGLER_CONFIG_CHECK=yes`.");
+            }
             const confirmCreate = "No `wrangler.(toml|json|jsonc)` config file found, do you want to create one?";
             if (await askConfirmation(confirmCreate)) {
                 await createWranglerConfigFile(projectOpts.sourceDir);

package/dist/cli/commands/deploy.js

@@ -15,7 +15,10 @@ export async function deployCommand(args) {
     const { config } = await retrieveCompiledConfig();
     const buildOpts = getNormalizedOptions(config);
     const wranglerConfig = await readWranglerConfig(args);
-    const envVars = await getEnvFromPlatformProxy(config, buildOpts);
+    const envVars = await getEnvFromPlatformProxy({
+        configPath: args.wranglerConfigPath,
+        environment: args.env,
+    }, buildOpts);
     await populateCache(buildOpts, config, wranglerConfig, {
         target: "remote",
         environment: args.env,

package/dist/cli/commands/populate-cache.js

@@ -29,7 +29,10 @@ async function populateCacheCommand(target, args) {
     const { config } = await retrieveCompiledConfig();
     const buildOpts = getNormalizedOptions(config);
     const wranglerConfig = await readWranglerConfig(args);
-    const envVars = await getEnvFromPlatformProxy(config, buildOpts);
+    const envVars = await getEnvFromPlatformProxy({
+        configPath: args.wranglerConfigPath,
+        environment: args.env,
+    }, buildOpts);
     await populateCache(buildOpts, config, wranglerConfig, {
         target,
         environment: args.env,

package/dist/cli/commands/preview.js

@@ -13,7 +13,10 @@ export async function previewCommand(args) {
     const { config } = await retrieveCompiledConfig();
     const buildOpts = getNormalizedOptions(config);
     const wranglerConfig = await readWranglerConfig(args);
-    const envVars = await getEnvFromPlatformProxy(config, buildOpts);
+    const envVars = await getEnvFromPlatformProxy({
+        configPath: args.wranglerConfigPath,
+        environment: args.env,
+    }, buildOpts);
     await populateCache(buildOpts, config, wranglerConfig, {
         target: args.remote ? "remote" : "local",
         environment: args.env,

package/dist/cli/commands/utils/utils.js

@@ -9,7 +9,8 @@ import logger from "@opennextjs/aws/logger.js";
 import { unstable_readConfig } from "wrangler";
 import { ensureCloudflareConfig } from "../../build/utils/ensure-cf-config.js";
 import { askConfirmation } from "../../utils/ask-confirmation.js";
-import { createOpenNextConfigFile, findOpenNextConfig } from "../../utils/create-open-next-config.js";
+import { createOpenNextConfigFile, findOpenNextConfig, OPEN_NEXT_CONFIG_FILE_NAME, } from "../../utils/create-open-next-config.js";
+import { isNonInteractiveOrCI } from "../../utils/is-interactive.js";
 export const nextAppDir = process.cwd();
 /**
  * Print headers and warnings for the CLI.
@@ -41,9 +42,15 @@ export async function compileConfig(configPath) {
     }
     configPath ??= findOpenNextConfig(nextAppDir);
     if (!configPath) {
-        const answer = await askConfirmation("Missing required `open-next.config.ts` file, do you want to create one?");
+        // In non-interactive environments (CI, Cloudflare Workers Builds,
+        // Docker, etc.) there is no TTY to answer a prompt — the build would
+        // hang or crash. Fail fast with an actionable message instead.
+        if (isNonInteractiveOrCI()) {
+            throw new Error(`No \`${OPEN_NEXT_CONFIG_FILE_NAME}\` file was found in the project root.\n\nThis file is required for OpenNext Cloudflare builds.\nRun \`opennextjs-cloudflare migrate\` to create it, or see https://opennext.js.org/cloudflare/get-started for setup guidance.\nCommit it and re-run the build.`);
+        }
+        const answer = await askConfirmation(`Missing required \`${OPEN_NEXT_CONFIG_FILE_NAME}\` file, do you want to create one?`);
         if (!answer) {
-            throw new Error("The `open-next.config.ts` file is required, aborting!");
+            throw new Error(`The \`${OPEN_NEXT_CONFIG_FILE_NAME}\` file is required, aborting!`);
         }
         configPath = createOpenNextConfigFile(nextAppDir, { cache: false });
     }

package/dist/cli/templates/init.js

@@ -37,11 +37,6 @@ function init(request, env) {
     populateProcessEnv(url, env);
 }
 function initRuntime() {
-    // Some packages rely on `process.version` and `process.versions.node` (i.e. Jose@4)
-    // TODO: Remove when https://github.com/unjs/unenv/pull/493 is merged
-    Object.assign(process, { version: process.version || "v22.14.0" });
-    // @ts-expect-error Node type does not match workerd
-    Object.assign(process.versions, { node: "22.14.0", ...process.versions });
     globalThis.__dirname ??= "";
     globalThis.__filename ??= "";
     // Some packages rely on `import.meta.url` but it is undefined in workerd

package/dist/cli/utils/create-open-next-config.d.ts

@@ -1,3 +1,4 @@
+export declare const OPEN_NEXT_CONFIG_FILE_NAME = "open-next.config.ts";
 /**
  * Finds the path to the OpenNext configuration file if it exists.
  *

package/dist/cli/utils/create-open-next-config.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
 import { getPackageTemplatesDirPath } from "../../utils/get-package-templates-dir-path.js";
+export const OPEN_NEXT_CONFIG_FILE_NAME = "open-next.config.ts";
 /**
  * Finds the path to the OpenNext configuration file if it exists.
  *
@@ -9,7 +10,7 @@ import { getPackageTemplatesDirPath } from "../../utils/get-package-templates-di
  * @returns The full path to open-next.config.ts if it exists, undefined otherwise
  */
 export function findOpenNextConfig(appDir) {
-    const openNextConfigPath = join(appDir, "open-next.config.ts");
+    const openNextConfigPath = join(appDir, OPEN_NEXT_CONFIG_FILE_NAME);
     if (existsSync(openNextConfigPath)) {
         return openNextConfigPath;
     }
@@ -23,8 +24,8 @@ export function findOpenNextConfig(appDir) {
  * @returns The path to the created configuration file
  */
 export function createOpenNextConfigFile(appDir, options) {
-    const openNextConfigPath = join(appDir, "open-next.config.ts");
-    let content = readFileSync(join(getPackageTemplatesDirPath(), "open-next.config.ts"), "utf8");
+    const openNextConfigPath = join(appDir, OPEN_NEXT_CONFIG_FILE_NAME);
+    let content = readFileSync(join(getPackageTemplatesDirPath(), OPEN_NEXT_CONFIG_FILE_NAME), "utf8");
     if (!options.cache) {
         content = patchCode(content, commentOutR2ImportRule);
         content = patchCode(content, commentOutIncrementalCacheRule);

package/dist/cli/utils/is-interactive.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Whether the current process is running in an interactive terminal.
+ */
+export declare function isInteractive(): boolean;
+/**
+ * Whether prompts should be suppressed.
+ */
+export declare function isNonInteractiveOrCI(): boolean;

package/dist/cli/utils/is-interactive.js

@@ -0,0 +1,13 @@
+import ci from "ci-info";
+/**
+ * Whether the current process is running in an interactive terminal.
+ */
+export function isInteractive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+/**
+ * Whether prompts should be suppressed.
+ */
+export function isNonInteractiveOrCI() {
+    return !isInteractive() || ci.isCI;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.19.1",
+  "version": "1.19.3",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -44,7 +44,8 @@
   "dependencies": {
     "@ast-grep/napi": "^0.40.5",
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "3.10.1",
+    "@opennextjs/aws": "3.10.2",
+    "ci-info": "^4.2.0",
     "cloudflare": "^4.4.1",
     "comment-json": "^4.5.1",
     "enquirer": "^2.4.1",
@@ -57,7 +58,7 @@
     "@eslint/js": "^9.11.1",
     "@tsconfig/strictest": "^2.0.5",
     "@types/mock-fs": "^4.13.4",
-    "@types/node": "^22.2.0",
+    "@types/node": "^22.12.0",
     "@types/picomatch": "^4.0.0",
     "@types/yargs": "^17.0.33",
     "diff": "^8.0.2",
@@ -73,10 +74,10 @@
     "rimraf": "^6.0.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.48.0",
-    "vitest": "^2.1.1"
+    "vitest": "^4.1.4"
   },
   "peerDependencies": {
-    "next": ">=15.5.15 || >=16.2.3",
+    "next": ">=15.5.15 <16 || >=16.2.3",
     "wrangler": "^4.65.0"
   },
   "scripts": {