@opennextjs/cloudflare 1.19.0 → 1.19.2

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/api/overrides/tag-cache/tag-cache-filter.js

@@ -36,6 +36,15 @@ export function withFilter({ tagCache, filterFn }) {
             }
             return tagCache.writeTags(filteredTags);
         },
+        isStale: tagCache.isStale
+            ? async (tags, lastModified) => {
+                const filteredTags = tags.filter(filterFn);
+                if (filteredTags.length === 0) {
+                    return false;
+                }
+                return tagCache.isStale(filteredTags, lastModified);
+            }
+            : undefined,
     };
 }
 /**

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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.19.0",
+  "version": "1.19.2",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -44,7 +44,7 @@
   "dependencies": {
     "@ast-grep/napi": "^0.40.5",
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "3.10.1",
+    "@opennextjs/aws": "3.10.2",
     "cloudflare": "^4.4.1",
     "comment-json": "^4.5.1",
     "enquirer": "^2.4.1",
@@ -57,7 +57,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 +73,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": {