@edgeone/opennextjs-pages 0.0.7 → 0.0.8

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

@@ -0,0 +1,58 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../../../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/build/functions/middleware/middleware.ts
+import { compile } from "./compiler.js";
+import { join } from "node:path";
+import { existsSync, writeFileSync, mkdirSync, readFileSync } from "node:fs";
+var compileMiddleware = async (ctx) => {
+  const possiblePaths = [
+    // 1. Next.js 15+: distDir/server/middleware.js (直接在 .next 目录下)
+    join(ctx.distDir, "server/middleware.js"),
+    // 2. Next.js 15+: standaloneDir/.next/server/middleware.js
+    join(ctx.standaloneDir, ".next/server/middleware.js"),
+    // 3. 旧版: standaloneDir/.next/server/src/middleware.js
+    join(ctx.standaloneDir, ".next/server/src/middleware.js"),
+    // 4. 旧版: distDir/server/src/middleware.js
+    join(ctx.distDir, "server/src/middleware.js"),
+    // 5. 相对于当前工作目录
+    join(process.cwd(), ".next/server/middleware.js"),
+    join(process.cwd(), ".next/server/src/middleware.js")
+  ];
+  let middlewareFilePath = "";
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      middlewareFilePath = path;
+      break;
+    }
+  }
+  if (!middlewareFilePath) {
+    console.error("[Middleware Compiler] Could not find middleware.js in any of the expected locations:");
+    possiblePaths.forEach((p) => console.error("  -", p));
+    throw new Error("middleware.js not found");
+  }
+  const result = await compile(middlewareFilePath, {
+    env: { DEBUG: "true" }
+  });
+  const outputDir = join(ctx.distDir, "functions");
+  mkdirSync(outputDir, { recursive: true });
+  const outputPath = join(outputDir, "compiled-middleware.js");
+  writeFileSync(outputPath, result.code || "", "utf-8");
+  const edgeFunctionPath = join(process.cwd(), ".edgeone/edge-functions/index.js");
+  if (existsSync(edgeFunctionPath)) {
+    let edgeFunctionCode = readFileSync(edgeFunctionPath, "utf-8");
+    if (edgeFunctionCode.includes(`'__MIDDLEWARE_BUNDLE_CODE__'`)) {
+      edgeFunctionCode = edgeFunctionCode.replace(`'__MIDDLEWARE_BUNDLE_CODE__'`, () => result.code || "");
+      writeFileSync(edgeFunctionPath, edgeFunctionCode, "utf-8");
+    }
+  }
+  return result;
+};
+export {
+  compileMiddleware
+};

package/dist/build/functions/middleware/polyfills/async-local-storage.js

@@ -0,0 +1,100 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../../../../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/build/functions/middleware/polyfills/async-local-storage.ts
+var asyncLocalStoragePolyfill = `
+// === AsyncLocalStorage Polyfill ===
+const AsyncLocalStorage = (function() {
+  // \u4F7F\u7528 WeakMap \u5B58\u50A8\u5F02\u6B65\u4E0A\u4E0B\u6587
+  const asyncContexts = new WeakMap();
+  let currentContext = null;
+
+  class AsyncLocalStoragePolyfill {
+    constructor() {
+      this._enabled = true;
+      this._store = undefined;
+    }
+
+    disable() {
+      this._enabled = false;
+    }
+
+    getStore() {
+      if (!this._enabled) return undefined;
+      return this._store;
+    }
+
+    run(store, callback, ...args) {
+      if (!this._enabled) {
+        return callback(...args);
+      }
+      const previousStore = this._store;
+      this._store = store;
+      try {
+        return callback(...args);
+      } finally {
+        this._store = previousStore;
+      }
+    }
+
+    exit(callback, ...args) {
+      if (!this._enabled) {
+        return callback(...args);
+      }
+      const previousStore = this._store;
+      this._store = undefined;
+      try {
+        return callback(...args);
+      } finally {
+        this._store = previousStore;
+      }
+    }
+
+    enterWith(store) {
+      if (!this._enabled) return;
+      this._store = store;
+    }
+
+    static bind(fn) {
+      return fn;
+    }
+
+    static snapshot() {
+      return (fn, ...args) => fn(...args);
+    }
+  }
+
+  return AsyncLocalStoragePolyfill;
+})();
+
+// \u6A21\u62DF node:async_hooks \u6A21\u5757
+const async_hooks = {
+  AsyncLocalStorage,
+  createHook: () => ({
+    enable: () => {},
+    disable: () => {}
+  }),
+  executionAsyncId: () => 0,
+  triggerAsyncId: () => 0,
+  executionAsyncResource: () => ({}),
+  AsyncResource: class AsyncResource {
+    constructor(type) { this.type = type; }
+    runInAsyncScope(fn, thisArg, ...args) { return fn.call(thisArg, ...args); }
+    emitDestroy() { return this; }
+    asyncId() { return 0; }
+    triggerAsyncId() { return 0; }
+    bind(fn) { return fn; }
+    static bind(fn) { return fn; }
+  }
+};
+
+globalThis.AsyncLocalStorage = AsyncLocalStorage;
+`;
+export {
+  asyncLocalStoragePolyfill
+};

package/dist/build/functions/middleware/polyfills/buffer.js

@@ -0,0 +1,214 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../../../../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/build/functions/middleware/polyfills/buffer.ts
+var bufferPolyfill = `
+// === Buffer Polyfill ===
+const Buffer = (function() {
+  class BufferPolyfill extends Uint8Array {
+    static isBuffer(obj) {
+      return obj instanceof BufferPolyfill || obj instanceof Uint8Array;
+    }
+
+    static from(value, encodingOrOffset, length) {
+      if (typeof value === 'string') {
+        const encoding = encodingOrOffset || 'utf8';
+        if (encoding === 'base64') {
+          const binaryString = atob(value);
+          const bytes = new Uint8Array(binaryString.length);
+          for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+          }
+          return new BufferPolyfill(bytes);
+        } else if (encoding === 'hex') {
+          const bytes = new Uint8Array(value.length / 2);
+          for (let i = 0; i < value.length; i += 2) {
+            bytes[i / 2] = parseInt(value.substr(i, 2), 16);
+          }
+          return new BufferPolyfill(bytes);
+        } else {
+          // utf8
+          const encoder = new TextEncoder();
+          return new BufferPolyfill(encoder.encode(value));
+        }
+      }
+      if (Array.isArray(value) || value instanceof Uint8Array) {
+        return new BufferPolyfill(value);
+      }
+      if (value instanceof ArrayBuffer) {
+        return new BufferPolyfill(new Uint8Array(value, encodingOrOffset, length));
+      }
+      throw new TypeError('Invalid argument type for Buffer.from');
+    }
+
+    static alloc(size, fill, encoding) {
+      const buf = new BufferPolyfill(size);
+      if (fill !== undefined) {
+        if (typeof fill === 'number') {
+          buf.fill(fill);
+        } else if (typeof fill === 'string') {
+          const fillBuf = BufferPolyfill.from(fill, encoding);
+          for (let i = 0; i < size; i++) {
+            buf[i] = fillBuf[i % fillBuf.length];
+          }
+        }
+      }
+      return buf;
+    }
+
+    static allocUnsafe(size) {
+      return new BufferPolyfill(size);
+    }
+
+    static concat(list, totalLength) {
+      if (totalLength === undefined) {
+        totalLength = list.reduce((acc, buf) => acc + buf.length, 0);
+      }
+      const result = new BufferPolyfill(totalLength);
+      let offset = 0;
+      for (const buf of list) {
+        result.set(buf, offset);
+        offset += buf.length;
+      }
+      return result;
+    }
+
+    static byteLength(string, encoding) {
+      if (typeof string !== 'string') {
+        return string.length || string.byteLength || 0;
+      }
+      if (encoding === 'base64') {
+        return Math.ceil(string.length * 3 / 4);
+      }
+      return new TextEncoder().encode(string).length;
+    }
+
+    toString(encoding = 'utf8', start = 0, end = this.length) {
+      const slice = this.subarray(start, end);
+      if (encoding === 'base64') {
+        let binary = '';
+        for (let i = 0; i < slice.length; i++) {
+          binary += String.fromCharCode(slice[i]);
+        }
+        return btoa(binary);
+      } else if (encoding === 'hex') {
+        return Array.from(slice)
+          .map(b => b.toString(16).padStart(2, '0'))
+          .join('');
+      } else {
+        // utf8
+        return new TextDecoder().decode(slice);
+      }
+    }
+
+    write(string, offset = 0, length, encoding = 'utf8') {
+      const buf = BufferPolyfill.from(string, encoding);
+      const bytesToWrite = Math.min(buf.length, length || this.length - offset);
+      this.set(buf.subarray(0, bytesToWrite), offset);
+      return bytesToWrite;
+    }
+
+    copy(target, targetStart = 0, sourceStart = 0, sourceEnd = this.length) {
+      const slice = this.subarray(sourceStart, sourceEnd);
+      target.set(slice, targetStart);
+      return slice.length;
+    }
+
+    slice(start, end) {
+      return new BufferPolyfill(this.subarray(start, end));
+    }
+
+    equals(otherBuffer) {
+      if (this.length !== otherBuffer.length) return false;
+      for (let i = 0; i < this.length; i++) {
+        if (this[i] !== otherBuffer[i]) return false;
+      }
+      return true;
+    }
+
+    compare(otherBuffer) {
+      const len = Math.min(this.length, otherBuffer.length);
+      for (let i = 0; i < len; i++) {
+        if (this[i] < otherBuffer[i]) return -1;
+        if (this[i] > otherBuffer[i]) return 1;
+      }
+      if (this.length < otherBuffer.length) return -1;
+      if (this.length > otherBuffer.length) return 1;
+      return 0;
+    }
+
+    indexOf(value, byteOffset = 0, encoding) {
+      if (typeof value === 'string') {
+        value = BufferPolyfill.from(value, encoding);
+      }
+      if (typeof value === 'number') {
+        for (let i = byteOffset; i < this.length; i++) {
+          if (this[i] === value) return i;
+        }
+        return -1;
+      }
+      outer: for (let i = byteOffset; i <= this.length - value.length; i++) {
+        for (let j = 0; j < value.length; j++) {
+          if (this[i + j] !== value[j]) continue outer;
+        }
+        return i;
+      }
+      return -1;
+    }
+
+    includes(value, byteOffset, encoding) {
+      return this.indexOf(value, byteOffset, encoding) !== -1;
+    }
+
+    // \u8BFB\u5199\u65B9\u6CD5
+    readUInt8(offset = 0) { return this[offset]; }
+    readUInt16BE(offset = 0) { return (this[offset] << 8) | this[offset + 1]; }
+    readUInt16LE(offset = 0) { return this[offset] | (this[offset + 1] << 8); }
+    readUInt32BE(offset = 0) {
+      return (this[offset] * 0x1000000) + ((this[offset + 1] << 16) | (this[offset + 2] << 8) | this[offset + 3]);
+    }
+    readUInt32LE(offset = 0) {
+      return ((this[offset + 3] * 0x1000000) + ((this[offset + 2] << 16) | (this[offset + 1] << 8) | this[offset])) >>> 0;
+    }
+    readInt8(offset = 0) { return this[offset] > 127 ? this[offset] - 256 : this[offset]; }
+    readInt16BE(offset = 0) { const val = this.readUInt16BE(offset); return val > 0x7FFF ? val - 0x10000 : val; }
+    readInt16LE(offset = 0) { const val = this.readUInt16LE(offset); return val > 0x7FFF ? val - 0x10000 : val; }
+    readInt32BE(offset = 0) { return (this[offset] << 24) | (this[offset + 1] << 16) | (this[offset + 2] << 8) | this[offset + 3]; }
+    readInt32LE(offset = 0) { return this[offset] | (this[offset + 1] << 8) | (this[offset + 2] << 16) | (this[offset + 3] << 24); }
+
+    writeUInt8(value, offset = 0) { this[offset] = value & 0xFF; return offset + 1; }
+    writeUInt16BE(value, offset = 0) { this[offset] = (value >> 8) & 0xFF; this[offset + 1] = value & 0xFF; return offset + 2; }
+    writeUInt16LE(value, offset = 0) { this[offset] = value & 0xFF; this[offset + 1] = (value >> 8) & 0xFF; return offset + 2; }
+    writeUInt32BE(value, offset = 0) {
+      this[offset] = (value >>> 24) & 0xFF;
+      this[offset + 1] = (value >>> 16) & 0xFF;
+      this[offset + 2] = (value >>> 8) & 0xFF;
+      this[offset + 3] = value & 0xFF;
+      return offset + 4;
+    }
+    writeUInt32LE(value, offset = 0) {
+      this[offset] = value & 0xFF;
+      this[offset + 1] = (value >>> 8) & 0xFF;
+      this[offset + 2] = (value >>> 16) & 0xFF;
+      this[offset + 3] = (value >>> 24) & 0xFF;
+      return offset + 4;
+    }
+
+    toJSON() {
+      return { type: 'Buffer', data: Array.from(this) };
+    }
+  }
+
+  return BufferPolyfill;
+})();
+
+globalThis.Buffer = Buffer;
+`;
+export {
+  bufferPolyfill
+};

package/dist/build/functions/middleware/polyfills/crypto.js

@@ -0,0 +1,117 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../../../../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/build/functions/middleware/polyfills/crypto.ts
+var cryptoPolyfill = `
+// === Crypto Polyfill ===
+const crypto = globalThis.crypto || {};
+
+// \u786E\u4FDD getRandomValues \u53EF\u7528
+if (!crypto.getRandomValues) {
+  crypto.getRandomValues = (array) => {
+    for (let i = 0; i < array.length; i++) {
+      array[i] = Math.floor(Math.random() * 256);
+    }
+    return array;
+  };
+}
+
+// \u6DFB\u52A0 randomBytes \u65B9\u6CD5\uFF08Node.js \u98CE\u683C\uFF09
+crypto.randomBytes = (size) => {
+  const bytes = new Uint8Array(size);
+  crypto.getRandomValues(bytes);
+  return Buffer.from(bytes);
+};
+
+// \u6DFB\u52A0 randomUUID \u65B9\u6CD5
+if (!crypto.randomUUID) {
+  crypto.randomUUID = () => {
+    return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
+      (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
+    );
+  };
+}
+
+// \u6DFB\u52A0 createHash \u65B9\u6CD5\uFF08\u7B80\u5316\u7248\uFF09
+crypto.createHash = (algorithm) => {
+  const data = [];
+  return {
+    update(chunk, encoding) {
+      if (typeof chunk === 'string') {
+        chunk = new TextEncoder().encode(chunk);
+      }
+      data.push(chunk);
+      return this;
+    },
+    async digest(encoding) {
+      const buffer = Buffer.concat(data);
+      const hashBuffer = await crypto.subtle.digest(
+        algorithm.toUpperCase().replace('SHA', 'SHA-'),
+        buffer
+      );
+      const result = Buffer.from(hashBuffer);
+      if (encoding === 'hex') {
+        return result.toString('hex');
+      } else if (encoding === 'base64') {
+        return result.toString('base64');
+      }
+      return result;
+    }
+  };
+};
+
+// \u6DFB\u52A0 createHmac \u65B9\u6CD5\uFF08\u7B80\u5316\u7248\uFF09
+crypto.createHmac = (algorithm, key) => {
+  const data = [];
+  return {
+    update(chunk, encoding) {
+      if (typeof chunk === 'string') {
+        chunk = new TextEncoder().encode(chunk);
+      }
+      data.push(chunk);
+      return this;
+    },
+    async digest(encoding) {
+      const keyData = typeof key === 'string' ? new TextEncoder().encode(key) : key;
+      const cryptoKey = await crypto.subtle.importKey(
+        'raw',
+        keyData,
+        { name: 'HMAC', hash: algorithm.toUpperCase().replace('SHA', 'SHA-') },
+        false,
+        ['sign']
+      );
+      const buffer = Buffer.concat(data);
+      const signature = await crypto.subtle.sign('HMAC', cryptoKey, buffer);
+      const result = Buffer.from(signature);
+      if (encoding === 'hex') {
+        return result.toString('hex');
+      } else if (encoding === 'base64') {
+        return result.toString('base64');
+      }
+      return result;
+    }
+  };
+};
+
+// \u65F6\u95F4\u5B89\u5168\u6BD4\u8F83
+crypto.timingSafeEqual = (a, b) => {
+  if (a.length !== b.length) {
+    return false;
+  }
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a[i] ^ b[i];
+  }
+  return result === 0;
+};
+
+globalThis.crypto = crypto;
+`;
+export {
+  cryptoPolyfill
+};

package/dist/build/functions/middleware/polyfills/index.js

@@ -0,0 +1,200 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../../../../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/build/functions/middleware/polyfills/index.ts
+import { bufferPolyfill } from "./buffer.js";
+import { processPolyfill } from "./process.js";
+import { asyncLocalStoragePolyfill } from "./async-local-storage.js";
+import { cryptoPolyfill } from "./crypto.js";
+var headersPolyfill = `
+// === Headers Polyfill for EdgeOne ===
+// EdgeOne Headers \u6784\u9020\u51FD\u6570\u4E0D\u63A5\u53D7 undefined \u53C2\u6570\uFF0C\u9700\u8981\u5305\u88C5\u5904\u7406
+(function() {
+  const OriginalHeaders = globalThis.Headers;
+  
+  // \u68C0\u67E5\u662F\u5426\u9700\u8981 polyfill
+  let needsPatch = false;
+  try {
+    new OriginalHeaders(undefined);
+  } catch (e) {
+    needsPatch = true;
+  }
+  
+  if (needsPatch) {
+    // \u4F7F\u7528 Proxy \u5305\u88C5 Headers \u6784\u9020\u51FD\u6570
+    globalThis.Headers = new Proxy(OriginalHeaders, {
+      construct(target, args) {
+        // \u5982\u679C\u7B2C\u4E00\u4E2A\u53C2\u6570\u662F undefined \u6216 null\uFF0C\u4F20\u5165\u7A7A\u5BF9\u8C61
+        if (args[0] === undefined || args[0] === null) {
+          return new target({});
+        }
+        return new target(...args);
+      },
+      get(target, prop, receiver) {
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+  }
+})();
+`;
+var responsePolyfill = `
+// === Response Polyfill for EdgeOne ===
+// \u786E\u4FDD Response \u6784\u9020\u51FD\u6570\u80FD\u6B63\u786E\u5904\u7406\u5404\u79CD\u53C2\u6570
+(function() {
+  const OriginalResponse = globalThis.Response;
+  
+  // \u6E05\u7406 ResponseInit \u53C2\u6570\uFF0C\u53EA\u4FDD\u7559 EdgeOne \u652F\u6301\u7684\u5C5E\u6027
+  function cleanResponseInit(init) {
+    if (init === undefined || init === null) {
+      return {};
+    }
+    if (typeof init !== 'object') {
+      return init;
+    }
+    // \u53EA\u4FDD\u7559 EdgeOne \u652F\u6301\u7684\u5C5E\u6027: status, statusText, headers
+    const cleanInit = {};
+    if (init.status !== undefined) cleanInit.status = init.status;
+    if (init.statusText !== undefined) cleanInit.statusText = init.statusText;
+    if (init.headers !== undefined) cleanInit.headers = init.headers;
+    return cleanInit;
+  }
+  
+  // \u5305\u88C5 Response.redirect \u9759\u6001\u65B9\u6CD5
+  // EdgeOne \u7684 Response.redirect \u53EA\u63A5\u53D7\u5B57\u7B26\u4E32\uFF0C\u4E0D\u63A5\u53D7 URL \u5BF9\u8C61
+  const originalRedirect = OriginalResponse.redirect;
+  const patchedRedirect = function(url, status) {
+    // \u5982\u679C url \u662F URL \u5BF9\u8C61\uFF0C\u8F6C\u6362\u4E3A\u5B57\u7B26\u4E32
+    const urlString = (url && typeof url === 'object' && url.toString) ? url.toString() : url;
+    return originalRedirect.call(OriginalResponse, urlString, status);
+  };
+  
+  // \u521B\u5EFA cookies \u5BF9\u8C61\u7684\u5DE5\u5382\u51FD\u6570
+  function createResponseCookies(response) {
+    const cookieStore = new Map();
+    return {
+      get: (name) => cookieStore.get(name),
+      getAll: () => Array.from(cookieStore.values()),
+      has: (name) => cookieStore.has(name),
+      set: (nameOrOptions, value, options) => {
+        let cookieName, cookieValue, cookieOptions;
+        if (typeof nameOrOptions === 'object') {
+          cookieName = nameOrOptions.name;
+          cookieValue = nameOrOptions.value;
+          cookieOptions = nameOrOptions;
+        } else {
+          cookieName = nameOrOptions;
+          cookieValue = value;
+          cookieOptions = options || {};
+        }
+        cookieStore.set(cookieName, { name: cookieName, value: cookieValue, ...cookieOptions });
+        // \u540C\u6B65\u5230 Set-Cookie header
+        const cookieParts = [cookieName + '=' + encodeURIComponent(cookieValue)];
+        if (cookieOptions.path) cookieParts.push('Path=' + cookieOptions.path);
+        if (cookieOptions.domain) cookieParts.push('Domain=' + cookieOptions.domain);
+        if (cookieOptions.maxAge) cookieParts.push('Max-Age=' + cookieOptions.maxAge);
+        if (cookieOptions.expires) cookieParts.push('Expires=' + cookieOptions.expires.toUTCString());
+        if (cookieOptions.httpOnly) cookieParts.push('HttpOnly');
+        if (cookieOptions.secure) cookieParts.push('Secure');
+        if (cookieOptions.sameSite) cookieParts.push('SameSite=' + cookieOptions.sameSite);
+        response.headers.append('Set-Cookie', cookieParts.join('; '));
+      },
+      delete: (name) => {
+        cookieStore.delete(name);
+        response.headers.append('Set-Cookie', name + '=; Max-Age=0; Path=/');
+      },
+      clear: () => cookieStore.clear(),
+      [Symbol.iterator]: () => cookieStore.values(),
+      size: cookieStore.size
+    };
+  }
+  
+  // \u4F7F\u7528 Proxy \u5305\u88C5 Response \u6784\u9020\u51FD\u6570
+  globalThis.Response = new Proxy(OriginalResponse, {
+    construct(target, args) {
+      // args[0] = body, args[1] = init
+      const body = args[0];
+      const init = cleanResponseInit(args[1]);
+      const response = new target(body, init);
+      
+      // \u4E3A response \u6DFB\u52A0 cookies \u5C5E\u6027\uFF08NextResponse \u517C\u5BB9\uFF09
+      if (!response.cookies) {
+        Object.defineProperty(response, 'cookies', {
+          value: createResponseCookies(response),
+          writable: true,
+          enumerable: true
+        });
+      }
+      
+      return response;
+    },
+    get(target, prop, receiver) {
+      // \u62E6\u622A redirect \u9759\u6001\u65B9\u6CD5
+      if (prop === 'redirect') {
+        return patchedRedirect;
+      }
+      // \u5176\u4ED6\u9759\u6001\u65B9\u6CD5\u76F4\u63A5\u4ECE\u539F\u59CB Response \u83B7\u53D6
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+})();
+`;
+function getPolyfillsCode() {
+  return `
+// ============================================================
+// Node.js Polyfills for Edge Runtime
+// ============================================================
+
+${headersPolyfill}
+
+${responsePolyfill}
+
+${bufferPolyfill}
+
+${processPolyfill}
+
+${asyncLocalStoragePolyfill}
+
+${cryptoPolyfill}
+
+// === Additional Globals ===
+if (typeof globalThis.self === 'undefined') {
+  globalThis.self = globalThis;
+}
+
+// === Node.js \u8DEF\u5F84\u76F8\u5173\u5168\u5C40\u53D8\u91CF ===
+// \u8FB9\u7F18\u73AF\u5883\u4E0D\u652F\u6301 __dirname \u548C __filename\uFF0C\u63D0\u4F9B\u6A21\u62DF\u503C
+if (typeof __dirname === 'undefined') {
+  globalThis.__dirname = '/';
+}
+if (typeof __filename === 'undefined') {
+  globalThis.__filename = '/index.js';
+}
+
+// === module \u548C exports \u517C\u5BB9 ===
+// \u67D0\u4E9B CommonJS \u4EE3\u7801\u53EF\u80FD\u5F15\u7528\u8FD9\u4E9B\u53D8\u91CF
+if (typeof module === 'undefined') {
+  globalThis.module = { exports: {} };
+}
+if (typeof exports === 'undefined') {
+  globalThis.exports = globalThis.module.exports;
+}
+
+// \u6A21\u62DF node:buffer \u6A21\u5757
+const nodeBuffer = { Buffer };
+
+// \u6A21\u62DF node:async_hooks \u6A21\u5757\u5BFC\u51FA
+const nodeAsyncHooks = async_hooks;
+`;
+}
+export {
+  asyncLocalStoragePolyfill,
+  bufferPolyfill,
+  cryptoPolyfill,
+  getPolyfillsCode,
+  processPolyfill
+};