@edgeone/opennextjs-pages 0.2.2 → 0.2.4

package/dist/build/content/server.js

@@ -86,7 +86,11 @@ var copyNextServerCode = async (ctx) => {
     [`*`, `server/*`, `server/**/*`, `server/edge-chunks/*`, `server/+(app|pages)/**/*.js`],
     {
       cwd: srcDir,
-      extglob: true
+      extglob: true,
+      // Exclude files that are not needed at runtime to reduce package size:
+      // - *.map: source maps, only useful for debugging (~40MB+ on large apps)
+      // - *.nft.json: Next.js file-tracing metadata, only used at build time (~13MB+)
+      ignore: ["**/*.map", "**/*.nft.json"]
     }
   );
   await Promise.all(

package/dist/build/functions/middleware/compiler.js

@@ -2384,35 +2384,55 @@ function transformForEdgeOneRuntime(code) {
 }
 function fixWebpackConfigExport(code) {
   let transformed = code;
-  const configDefPatterns = [
-    // 字符串 matcher: let be={matcher:"/normal/test"}
-    /(?:let|var|const)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*\{\s*matcher\s*:\s*"([^"]+)"\s*\}/,
-    // 压缩格式: ;be={matcher:"/normal/test"} 或 ,be={matcher:"..."}
-    /[;,]([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*\{\s*matcher\s*:\s*"([^"]+)"\s*\}/,
-    // 数组 matcher: let be={matcher:["/api/:path*", "/dashboard/:path*"]}
-    /(?:let|var|const)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*\{\s*matcher\s*:\s*(\[[^\]]+\])\s*\}/,
-    // 压缩格式数组: ;be={matcher:[...]}
-    /[;,]([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*\{\s*matcher\s*:\s*(\[[^\]]+\])\s*\}/
-  ];
   let configVarName = null;
   let configValue = null;
-  for (const pattern of configDefPatterns) {
-    const match = pattern.exec(code);
-    if (match) {
-      configVarName = match[1];
-      if (match[2].startsWith("[")) {
-        configValue = `{matcher:${match[2]}}`;
-      } else {
-        configValue = `{matcher:"${match[2]}"}`;
+  const exportPattern = /c\.d\s*\(\s*\w+\s*,\s*\{[^}]*config\s*:\s*\(\s*\)\s*=>\s*([a-zA-Z_$][a-zA-Z0-9_$]*)/s;
+  const exportMatch = code.match(exportPattern);
+  if (exportMatch) {
+    configVarName = exportMatch[1];
+  }
+  if (configVarName) {
+    const escapedVarName = configVarName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const defPattern = new RegExp(
+      `(?:let|var|const|[;,])\\s*${escapedVarName}\\s*=\\s*\\{\\s*matcher\\s*:`
+    );
+    const defMatch = defPattern.exec(code);
+    if (defMatch) {
+      const matchStr = defMatch[0];
+      const openBraceOffset = matchStr.indexOf("{");
+      const assignStart = defMatch.index + openBraceOffset;
+      let depth = 0;
+      let endIdx = -1;
+      for (let i = assignStart; i < code.length; i++) {
+        if (code[i] === "{") {
+          depth++;
+        } else if (code[i] === "}") {
+          depth--;
+          if (depth === 0) {
+            endIdx = i + 1;
+            break;
+          }
+        }
+      }
+      if (endIdx !== -1) {
+        configValue = code.slice(assignStart, endIdx);
       }
-      break;
     }
   }
-  if (!configVarName) {
-    const exportPattern = /c\.d\s*\(\s*\w+\s*,\s*\{[^}]*config\s*:\s*\(\s*\)\s*=>\s*([a-zA-Z_$][a-zA-Z0-9_$]*)[^}]*\}/;
-    const exportMatch = code.match(exportPattern);
-    if (exportMatch) {
-      configVarName = exportMatch[1];
+  if (!configVarName || !configValue) {
+    const simplePatterns = [
+      // 字符串 matcher（简单路径，不含特殊字符）
+      /(?:let|var|const)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*\{\s*matcher\s*:\s*"([^"]+)"\s*\}/,
+      // 压缩格式字符串
+      /[;,]([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*\{\s*matcher\s*:\s*"([^"]+)"\s*\}/
+    ];
+    for (const pattern of simplePatterns) {
+      const match = pattern.exec(code);
+      if (match) {
+        configVarName = match[1];
+        configValue = `{matcher:"${match[2]}"}`;
+        break;
+      }
     }
   }
   if (configVarName && configValue) {
@@ -2429,8 +2449,7 @@ function fixWebpackConfigExport(code) {
         if (match.includes("config:")) {
           return match;
         }
-        const configRef = configValue;
-        const replacement = `${prefix}Object.assign({},${varName},{config:${configRef}})`;
+        const replacement = `${prefix}Object.assign({},${varName},{config:${configValue}})`;
         return replacement;
       });
     }
@@ -2935,6 +2954,43 @@ function getExternalMock(id) {
     return result;
   }
   
+  // shared-cache-controls mock - must be matched before the general incremental-cache mock
+  // Next.js 16+ uses SharedCacheControls from this module in IncrementalCache constructor
+  if (id.includes('shared-cache-controls')) {
+    class SharedCacheControls {
+      constructor(prerenderManifest) {
+        this.prerenderManifest = prerenderManifest;
+        this.controls = new Map();
+      }
+      get(key) { return this.controls.get(key); }
+      set(key, value) { this.controls.set(key, value); }
+    }
+    const result = {
+      SharedCacheControls,
+      default: { SharedCacheControls }
+    };
+    Object.defineProperty(result, '__esModule', { value: true });
+    return result;
+  }
+
+  // shared-revalidate-timings mock - similarly used by IncrementalCache in older versions
+  if (id.includes('shared-revalidate-timings')) {
+    class SharedRevalidateTimings {
+      constructor(prerenderManifest) {
+        this.prerenderManifest = prerenderManifest;
+        this.timings = new Map();
+      }
+      get(key) { return this.timings.get(key); }
+      set(key, value) { this.timings.set(key, value); }
+    }
+    const result = {
+      SharedRevalidateTimings,
+      default: { SharedRevalidateTimings }
+    };
+    Object.defineProperty(result, '__esModule', { value: true });
+    return result;
+  }
+
   // incremental-cache/tags-manifest mock
   if (id.includes('incremental-cache') || id.includes('tags-manifest')) {
     const result = {

package/dist/build/functions/server.js

@@ -16,6 +16,7 @@ import {
 } from "../../esm-chunks/chunk-6BT4RYQJ.js";
 
 // src/build/functions/server.ts
+import { existsSync, readFileSync } from "node:fs";
 import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join, relative } from "node:path";
 import { join as posixJoin } from "node:path/posix";
@@ -26,9 +27,63 @@ import {
   verifyHandlerDirStructure
 } from "../content/server.js";
 var tracer = wrapTracer(trace.getTracer("Next runtime"));
+function getOutputFileTracingIncludes(appDir) {
+  const configFiles = [
+    "next.config.original.ts",
+    "next.config.original.mjs",
+    "next.config.original.js",
+    "next.config.original.cjs",
+    "next.config.ts",
+    "next.config.mjs",
+    "next.config.js",
+    "next.config.cjs"
+  ];
+  for (const configFile of configFiles) {
+    const configPath = join(appDir, configFile);
+    if (!existsSync(configPath)) continue;
+    try {
+      const content = readFileSync(configPath, "utf-8");
+      const match = content.match(
+        /outputFileTracingIncludes\s*:\s*\{([\s\S]*?)(?=\n\s*\}[,;\s]*\n|\n\s*\}\s*[,\n])/
+      );
+      if (!match) continue;
+      const body = match[1];
+      const result = {};
+      const pairPattern = /['"]([^'"]+)['"]\s*:\s*\[([\s\S]*?)\]/g;
+      let pairMatch;
+      while ((pairMatch = pairPattern.exec(body)) !== null) {
+        const key = pairMatch[1];
+        const arrayBody = pairMatch[2];
+        const patterns = [];
+        const strPattern = /['"]([^'"]+)['"]/g;
+        let strMatch;
+        while ((strMatch = strPattern.exec(arrayBody)) !== null) {
+          patterns.push(strMatch[1]);
+        }
+        if (patterns.length > 0) {
+          result[key] = patterns;
+        }
+      }
+      if (Object.keys(result).length > 0) {
+        return result;
+      }
+    } catch {
+    }
+  }
+  return {};
+}
 var copyHandlerDependencies = async (ctx) => {
   const promises = [];
-  const { included_files: includedFiles = [] } = {};
+  const includedFiles = [];
+  const appDir = ctx.requiredServerFiles?.appDir || process.cwd();
+  const outputFileTracingIncludes = getOutputFileTracingIncludes(appDir);
+  for (const patterns of Object.values(outputFileTracingIncludes)) {
+    for (const pattern of patterns) {
+      includedFiles.push(
+        ctx.relativeAppDir ? posixJoin(ctx.relativeAppDir, pattern) : pattern
+      );
+    }
+  }
   includedFiles.push(
     posixJoin(ctx.relativeAppDir, ".env"),
     posixJoin(ctx.relativeAppDir, ".env.production"),

package/dist/build/image-optimization.js

@@ -51,47 +51,81 @@ function generateWrapperConfig(ext, importPath) {
   const isTS = ext.includes("ts");
   const isMJS = ext.includes("mjs") || ext.includes("mts");
   if (isTS) {
-    return `import originalConfig from '${importPath}'
+    return `import originalExport from '${importPath}'
 import type { NextConfig } from 'next'
 
-const config: NextConfig = {
-  ...originalConfig as any,
-  images: {
-    ...(originalConfig as any)?.images,
-    loader: 'custom',
-    loaderFile: './.edgeone/image-loader.mjs',
-  },
-};
+let config: NextConfig;
+if (typeof originalExport === 'function') {
+  // Function-style config: (phase, context) => NextConfig
+  // Wrap it to inject images config after resolution
+  const origFn = originalExport as any;
+  config = ((...args: any[]) => {
+    const resolved = origFn(...args);
+    if (resolved && typeof resolved.then === 'function') {
+      return (resolved as Promise<NextConfig>).then((c: any) => {
+        c.images = { ...c.images, loader: 'custom', loaderFile: './.edgeone/image-loader.mjs' };
+        return c;
+      });
+    }
+    (resolved as any).images = { ...(resolved as any).images, loader: 'custom', loaderFile: './.edgeone/image-loader.mjs' };
+    return resolved;
+  }) as any;
+} else {
+  config = { ...(originalExport as any) };
+  config.images = { ...config.images, loader: 'custom', loaderFile: './.edgeone/image-loader.mjs' };
+}
 
 export default config;
 `;
   }
   if (isMJS) {
-    return `import originalConfig from '${importPath}';
+    return `import originalExport from '${importPath}';
 
-const config = {
-  ...originalConfig,
-  images: {
-    ...originalConfig?.images,
-    loader: 'custom',
-    loaderFile: './.edgeone/image-loader.mjs',
-  },
-};
+let config;
+if (typeof originalExport === 'function') {
+  const origFn = originalExport;
+  config = (...args) => {
+    const resolved = origFn(...args);
+    if (resolved && typeof resolved.then === 'function') {
+      return resolved.then((c) => {
+        c.images = { ...c.images, loader: 'custom', loaderFile: './.edgeone/image-loader.mjs' };
+        return c;
+      });
+    }
+    resolved.images = { ...resolved.images, loader: 'custom', loaderFile: './.edgeone/image-loader.mjs' };
+    return resolved;
+  };
+} else {
+  config = { ...originalExport };
+  config.images = { ...config.images, loader: 'custom', loaderFile: './.edgeone/image-loader.mjs' };
+}
 
 export default config;
 `;
   }
-  return `const originalConfig = require('${importPath}');
-const resolved = originalConfig.default || originalConfig;
+  return `const originalExport = require('${importPath}');
+const resolved = originalExport.default || originalExport;
 
-module.exports = {
-  ...resolved,
-  images: {
-    ...resolved?.images,
-    loader: 'custom',
-    loaderFile: './.edgeone/image-loader.mjs',
-  },
-};
+let config;
+if (typeof resolved === 'function') {
+  const origFn = resolved;
+  config = (...args) => {
+    const result = origFn(...args);
+    if (result && typeof result.then === 'function') {
+      return result.then((c) => {
+        c.images = { ...c.images, loader: 'custom', loaderFile: './.edgeone/image-loader.mjs' };
+        return c;
+      });
+    }
+    result.images = { ...result.images, loader: 'custom', loaderFile: './.edgeone/image-loader.mjs' };
+    return result;
+  };
+} else {
+  config = { ...resolved };
+  config.images = { ...config.images, loader: 'custom', loaderFile: './.edgeone/image-loader.mjs' };
+}
+
+module.exports = config;
 `;
 }
 function injectImageLoader(cwd) {

package/dist/run/handlers/cache.cjs

@@ -141,21 +141,32 @@ var EdgeoneCacheHandler = class {
         const prerenderManifest = await this.getPrerenderManifest(this.options.serverDistDir);
         if (typeof cacheControl !== "undefined") {
           try {
-            const { SharedCacheControls } = await import(
+            const sharedCacheControlsModule = await import(
               // @ts-expect-error supporting multiple next version, this module is not resolvable with currently used dev dependency
               // eslint-disable-next-line import/no-unresolved, n/no-missing-import
               "next/dist/server/lib/incremental-cache/shared-cache-controls.external.js"
             );
+            const SharedCacheControls = sharedCacheControlsModule.SharedCacheControls || sharedCacheControlsModule.default?.SharedCacheControls || sharedCacheControlsModule.default;
+            if (typeof SharedCacheControls !== "function") {
+              throw new Error("SharedCacheControls is not a constructor in .external.js module");
+            }
             const sharedCacheControls = new SharedCacheControls(prerenderManifest);
             sharedCacheControls.set(key, cacheControl);
           } catch {
-            const { SharedCacheControls } = await import(
-              // @ts-expect-error supporting multiple next version, this module is not resolvable with currently used dev dependency
-              // eslint-disable-next-line import/no-unresolved, n/no-missing-import
-              "next/dist/server/lib/incremental-cache/shared-cache-controls.js"
-            );
-            const sharedCacheControls = new SharedCacheControls(prerenderManifest);
-            sharedCacheControls.set(key, cacheControl);
+            try {
+              const sharedCacheControlsModule = await import(
+                // @ts-expect-error supporting multiple next version, this module is not resolvable with currently used dev dependency
+                // eslint-disable-next-line import/no-unresolved, n/no-missing-import
+                "next/dist/server/lib/incremental-cache/shared-cache-controls.js"
+              );
+              const SharedCacheControls = sharedCacheControlsModule.SharedCacheControls || sharedCacheControlsModule.default?.SharedCacheControls || sharedCacheControlsModule.default;
+              if (typeof SharedCacheControls !== "function") {
+                throw new Error("SharedCacheControls is not a constructor in .js module");
+              }
+              const sharedCacheControls = new SharedCacheControls(prerenderManifest);
+              sharedCacheControls.set(key, cacheControl);
+            } catch {
+            }
           }
         } else if (typeof revalidate === "number" || revalidate === false) {
           try {

package/dist/run/handlers/server.js

@@ -3124,6 +3124,18 @@ var disableFaultyTransferEncodingHandling = (res) => {
     return originalStoreHeader.call(this, firstLine, headers);
   };
 };
+function getRealHostInfo(headers) {
+  const get = (key) => {
+    if (typeof headers.get === "function") {
+      return headers.get(key) || "";
+    }
+    return headers[key] || "";
+  };
+  const host = get("eo-pages-host") || get("host") || "localhost";
+  const protocol = get("x-forwarded-proto") || "https";
+  return { host, protocol };
+}
+var NEXT_REQUEST_META = Symbol.for("NextInternalRequestMeta");
 var server_default = async (request, _context, topLevelSpan, requestContext) => {
   const tracer = getTracer();
   if (!nextHandler) {
@@ -3139,9 +3151,14 @@ var server_default = async (request, _context, topLevelSpan, requestContext) =>
     });
   }
   return await tracer.withActiveSpan("generate response", async (span) => {
+    const { host: realHost, protocol: realProtocol } = getRealHostInfo(request.headers);
     const headersList = [];
     for (var key in request.headers) {
-      headersList.push([key, request.headers[key]]);
+      if (key === "host") {
+        headersList.push([key, realHost]);
+      } else {
+        headersList.push([key, request.headers[key]]);
+      }
     }
     let bodyStream = request.body;
     if (typeof bodyStream === "undefined" && request.method !== "GET" && request.method !== "HEAD") {
@@ -3166,7 +3183,7 @@ var server_default = async (request, _context, topLevelSpan, requestContext) =>
     const { req, res } = toReqRes({
       ...request,
       body: bodyStream,
-      url: "http://localhost:9000" + request.url,
+      url: `${realProtocol}://${realHost}${request.url}`,
       headers: headersList
     });
     Object.defineProperty(req, "connection", {
@@ -3180,6 +3197,21 @@ var server_default = async (request, _context, topLevelSpan, requestContext) =>
       }
     });
     disableFaultyTransferEncodingHandling(res);
+    const realOrigin = `${realProtocol}://${realHost}`;
+    const metaProxy = new Proxy({}, {
+      set(target, prop, value) {
+        if (prop === "initURL" && typeof value === "string") {
+          target[prop] = value.replace(/^https?:\/\/localhost(:\d+)?/, realOrigin);
+        } else {
+          target[prop] = value;
+        }
+        return true;
+      },
+      get(target, prop) {
+        return target[prop];
+      }
+    });
+    req[NEXT_REQUEST_META] = metaProxy;
     const resProxy = nextResponseProxy(res, requestContext);
     const nextHandlerPromise = nextHandler(req, resProxy).catch((error) => {
       getLogger().withError(error).error("next handler error");

package/dist/run/handlers/tags-handler.cjs

@@ -28,7 +28,7 @@ module.exports = __toCommonJS(tags_handler_exports);
 
 // package.json
 var name = "@edgeone/opennextjs-pages";
-var version = "0.2.2";
+var version = "0.2.4";
 
 // src/run/handlers/tags-handler.cts
 var import_request_context = require("./request-context.cjs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edgeone/opennextjs-pages",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "",
   "main": "./dist/index.js",
   "type": "module",