@edgeone/opennextjs-pages 0.0.1

package/dist/index.js

@@ -0,0 +1,50 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "./esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/index.ts
+import { rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { copyPrerenderedContent } from "./build/content/prerendered.js";
+import {
+  copyStaticAssets,
+  copyStaticContent,
+  copyStaticExport
+} from "./build/content/static.js";
+import { createServerHandler } from "./build/functions/server.js";
+import { PluginContext } from "./build/plugin-context.js";
+import { createRouteMeta } from "./build/routes.js";
+var onPreBuild = async (options) => {
+  process.env.NEXT_PRIVATE_STANDALONE = "true";
+};
+var onBuild = async (options) => {
+  const ctx = new PluginContext(options);
+  await rm(ctx.staticDir, { recursive: true, force: true });
+  if (existsSync(ctx.serverHandlerDir)) {
+    await rm(ctx.serverHandlerDir, { recursive: true, force: true });
+  }
+  if (ctx.buildConfig.output === "export") {
+    return Promise.all([copyStaticExport(ctx)]);
+  }
+  await copyStaticAssets(ctx);
+  await Promise.all([
+    // copyStaticAssets(ctx),
+    copyStaticContent(ctx),
+    copyPrerenderedContent(ctx),
+    createServerHandler(ctx)
+  ]);
+  createRouteMeta(ctx);
+};
+var onPostBuild = async (options) => {
+  console.log("onPostBuild");
+  const ctx = new PluginContext(options);
+};
+export {
+  onBuild,
+  onPostBuild,
+  onPreBuild
+};

package/dist/run/config.js

@@ -0,0 +1,37 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/run/config.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { PLUGIN_DIR, RUN_CONFIG_FILE } from "./constants.js";
+import { setInMemoryCacheMaxSizeFromNextConfig } from "./storage/storage.cjs";
+var getRunConfig = async () => {
+  return JSON.parse(await readFile(resolve(PLUGIN_DIR, RUN_CONFIG_FILE), "utf-8"));
+};
+var setRunConfig = (config) => {
+  const cacheHandler = join(PLUGIN_DIR, ".edgeone/dist/run/handlers/cache.cjs");
+  if (!existsSync(cacheHandler)) {
+    throw new Error(`Cache handler not found at ${cacheHandler}`);
+  }
+  config.experimental = {
+    ...config.experimental,
+    // Before Next.js 14.1.0 path to the cache handler was in experimental section, see NextConfigForMultipleVersions type
+    incrementalCacheHandlerPath: cacheHandler
+  };
+  config.cacheHandler = cacheHandler;
+  setInMemoryCacheMaxSizeFromNextConfig(
+    config.cacheMaxMemorySize ?? config.experimental?.isrMemoryCacheSize
+  );
+  process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
+};
+export {
+  getRunConfig,
+  setRunConfig
+};

package/dist/run/constants.js

@@ -0,0 +1,19 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/run/constants.ts
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
+var PLUGIN_DIR = resolve(`${MODULE_DIR}../../..`);
+var RUN_CONFIG_FILE = "run-config.json";
+export {
+  MODULE_DIR,
+  PLUGIN_DIR,
+  RUN_CONFIG_FILE
+};

package/dist/run/handlers/cache.cjs

@@ -0,0 +1,369 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/handlers/cache.cts
+var cache_exports = {};
+__export(cache_exports, {
+  EdgeoneCacheHandler: () => EdgeoneCacheHandler,
+  default: () => cache_default
+});
+module.exports = __toCommonJS(cache_exports);
+var import_node_buffer = require("node:buffer");
+var import_node_path = require("node:path");
+var import_posix = require("node:path/posix");
+var import_constants = require("next/dist/lib/constants.js");
+var import_cache_types = require("../../shared/cache-types.cjs");
+var import_request_context = require("./request-context.cjs");
+var import_tags_handler = require("./tags-handler.cjs");
+var import_tracer = require("./tracer.cjs");
+var memoizedPrerenderManifest;
+var EdgeoneCacheHandler = class {
+  options;
+  revalidatedTags;
+  cacheStore;
+  tracer = (0, import_tracer.getTracer)();
+  constructor(options) {
+    this.options = options;
+    this.revalidatedTags = options.revalidatedTags;
+    this.cacheStore = {};
+  }
+  getTTL(blob) {
+    if (blob.value?.kind === "FETCH" || blob.value?.kind === "ROUTE" || blob.value?.kind === "APP_ROUTE" || blob.value?.kind === "PAGE" || blob.value?.kind === "PAGES" || blob.value?.kind === "APP_PAGE") {
+      const { revalidate } = blob.value;
+      if (typeof revalidate === "number") {
+        const revalidateAfter = revalidate * 1e3 + blob.lastModified;
+        return (revalidateAfter - Date.now()) / 1e3;
+      }
+      if (revalidate === false) {
+        return "PERMANENT";
+      }
+    }
+    return "NOT SET";
+  }
+  captureResponseCacheLastModified(cacheValue, key, getCacheKeySpan) {
+    if (cacheValue.value?.kind === "FETCH") {
+      return;
+    }
+    const requestContext = (0, import_request_context.getRequestContext)();
+    if (!requestContext) {
+      (0, import_tracer.recordWarning)(new Error("CacheHandler was called without a request context"), getCacheKeySpan);
+      return;
+    }
+    if (requestContext.responseCacheKey && requestContext.responseCacheKey !== key) {
+      requestContext.responseCacheGetLastModified = void 0;
+      (0, import_tracer.recordWarning)(
+        new Error(
+          `Multiple response cache keys used in single request: ["${requestContext.responseCacheKey}, "${key}"]`
+        ),
+        getCacheKeySpan
+      );
+      return;
+    }
+    requestContext.responseCacheKey = key;
+    if (cacheValue.lastModified) {
+      requestContext.responseCacheGetLastModified = cacheValue.lastModified;
+    }
+  }
+  captureRouteRevalidateAndRemoveFromObject(cacheValue) {
+    const { revalidate, ...restOfRouteValue } = cacheValue;
+    const requestContext = (0, import_request_context.getRequestContext)();
+    if (requestContext) {
+      requestContext.routeHandlerRevalidate = revalidate;
+    }
+    return restOfRouteValue;
+  }
+  captureCacheTags(cacheValue, key) {
+    const requestContext = (0, import_request_context.getRequestContext)();
+    if (!requestContext) {
+      return;
+    }
+    if (requestContext.responseCacheTags) {
+      return;
+    }
+    if (!cacheValue) {
+      const cacheTags = [`_N_T_${key === "/index" ? "/" : encodeURI(key)}`];
+      requestContext.responseCacheTags = cacheTags;
+      return;
+    }
+    if (cacheValue.kind === "PAGE" || cacheValue.kind === "PAGES" || cacheValue.kind === "APP_PAGE" || cacheValue.kind === "ROUTE" || cacheValue.kind === "APP_ROUTE") {
+      if (cacheValue.headers?.[import_constants.NEXT_CACHE_TAGS_HEADER]) {
+        const cacheTags = cacheValue.headers[import_constants.NEXT_CACHE_TAGS_HEADER].split(/,|%2c/gi);
+        requestContext.responseCacheTags = cacheTags;
+      } else if ((cacheValue.kind === "PAGE" || cacheValue.kind === "PAGES") && typeof cacheValue.pageData === "object") {
+        const cacheTags = [`_N_T_${key === "/index" ? "/" : encodeURI(key)}`];
+        requestContext.responseCacheTags = cacheTags;
+      }
+    }
+  }
+  async getPrerenderManifest(serverDistDir) {
+    if (memoizedPrerenderManifest) {
+      return memoizedPrerenderManifest;
+    }
+    const prerenderManifestPath = (0, import_node_path.join)(serverDistDir, "..", "prerender-manifest.json");
+    try {
+      const { loadManifest } = await import("next/dist/server/load-manifest.external.js");
+      memoizedPrerenderManifest = loadManifest(prerenderManifestPath);
+    } catch {
+      const { loadManifest } = await import("next/dist/server/load-manifest.js");
+      memoizedPrerenderManifest = loadManifest(prerenderManifestPath);
+    }
+    return memoizedPrerenderManifest;
+  }
+  async injectEntryToPrerenderManifest(key, { revalidate, cacheControl }) {
+    if (this.options.serverDistDir && (typeof revalidate === "number" || revalidate === false || typeof cacheControl !== "undefined")) {
+      try {
+        const prerenderManifest = await this.getPrerenderManifest(this.options.serverDistDir);
+        if (typeof cacheControl !== "undefined") {
+          try {
+            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.external.js"
+            );
+            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);
+          }
+        } else if (typeof revalidate === "number" || revalidate === false) {
+          try {
+            const { normalizePagePath } = await import("next/dist/shared/lib/page-path/normalize-page-path.js");
+            prerenderManifest.routes[key] = {
+              experimentalPPR: void 0,
+              dataRoute: (0, import_posix.join)("/_next/data", `${normalizePagePath(key)}.json`),
+              srcRoute: null,
+              // FIXME: provide actual source route, however, when dynamically appending it doesn't really matter
+              initialRevalidateSeconds: revalidate,
+              // Pages routes do not have a prefetch data route.
+              prefetchDataRoute: void 0
+            };
+          } catch {
+            const { SharedRevalidateTimings } = await import("next/dist/server/lib/incremental-cache/shared-revalidate-timings.js");
+            const sharedRevalidateTimings = new SharedRevalidateTimings(prerenderManifest);
+            sharedRevalidateTimings.set(key, revalidate);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  async get(...args) {
+    return this.tracer.withActiveSpan("get cache key", async (span) => {
+      const [key, context = {}] = args;
+      (0, import_request_context.getLogger)();
+      span.setAttributes({ key });
+      const blob = null;
+      if (!blob) {
+        span.addEvent("Cache miss", { key });
+        return null;
+      }
+      const ttl = this.getTTL(blob);
+      if ((0, import_request_context.getRequestContext)()?.isBackgroundRevalidation && typeof ttl === "number" && ttl < 0) {
+        span.addEvent("Discarding stale entry due to SWR background revalidation request", {
+          key,
+          ttl
+        });
+        (0, import_request_context.getLogger)().withFields({
+          ttl,
+          key
+        });
+        return null;
+      }
+      const staleByTags = await this.checkCacheEntryStaleByTags(
+        blob,
+        context.tags,
+        context.softTags
+      );
+      if (staleByTags) {
+        span.addEvent("Stale", { staleByTags, key, ttl });
+        return null;
+      }
+      this.captureResponseCacheLastModified(blob, key, span);
+      const isDataRequest = Boolean(context.fetchUrl);
+      if (!isDataRequest) {
+        this.captureCacheTags(blob.value, key);
+      }
+      switch (blob.value?.kind) {
+        case "FETCH":
+          span.addEvent("FETCH", {
+            lastModified: blob.lastModified,
+            revalidate: context.revalidate,
+            ttl
+          });
+          return {
+            lastModified: blob.lastModified,
+            value: blob.value
+          };
+        case "ROUTE":
+        case "APP_ROUTE": {
+          span.addEvent(blob.value?.kind, {
+            lastModified: blob.lastModified,
+            status: blob.value.status,
+            revalidate: blob.value.revalidate,
+            ttl
+          });
+          const valueWithoutRevalidate = this.captureRouteRevalidateAndRemoveFromObject(blob.value);
+          return {
+            lastModified: blob.lastModified,
+            value: {
+              ...valueWithoutRevalidate,
+              body: import_node_buffer.Buffer.from(valueWithoutRevalidate.body, "base64")
+            }
+          };
+        }
+        case "PAGE":
+        case "PAGES": {
+          const { revalidate, ...restOfPageValue } = blob.value;
+          const requestContext = (0, import_request_context.getRequestContext)();
+          if (requestContext) {
+            requestContext.pageHandlerRevalidate = revalidate;
+          }
+          span.addEvent(blob.value?.kind, { lastModified: blob.lastModified, revalidate, ttl });
+          await this.injectEntryToPrerenderManifest(key, blob.value);
+          return {
+            lastModified: blob.lastModified,
+            value: restOfPageValue
+          };
+        }
+        case "APP_PAGE": {
+          const requestContext = (0, import_request_context.getRequestContext)();
+          if (requestContext && blob.value?.kind === "APP_PAGE") {
+            requestContext.isCacheableAppPage = true;
+          }
+          const { revalidate, rscData, ...restOfPageValue } = blob.value;
+          span.addEvent(blob.value?.kind, { lastModified: blob.lastModified, revalidate, ttl });
+          await this.injectEntryToPrerenderManifest(key, blob.value);
+          return {
+            lastModified: blob.lastModified,
+            value: {
+              ...restOfPageValue,
+              rscData: rscData ? import_node_buffer.Buffer.from(rscData, "base64") : void 0
+            }
+          };
+        }
+        default:
+          span.recordException(new Error(`Unknown cache entry kind: ${blob.value?.kind}`));
+      }
+      return null;
+    });
+  }
+  transformToStorableObject(data, context) {
+    if (!data) {
+      return null;
+    }
+    if ((0, import_cache_types.isCachedRouteValue)(data)) {
+      return {
+        ...data,
+        revalidate: context.revalidate ?? context.cacheControl?.revalidate,
+        cacheControl: context.cacheControl,
+        body: data.body.toString("base64")
+      };
+    }
+    if ((0, import_cache_types.isCachedPageValue)(data)) {
+      return {
+        ...data,
+        revalidate: context.revalidate ?? context.cacheControl?.revalidate,
+        cacheControl: context.cacheControl
+      };
+    }
+    if (data?.kind === "APP_PAGE") {
+      return {
+        ...data,
+        revalidate: context.revalidate ?? context.cacheControl?.revalidate,
+        cacheControl: context.cacheControl,
+        rscData: data.rscData?.toString("base64")
+      };
+    }
+    return data;
+  }
+  async set(...args) {
+    return {};
+    return this.tracer.withActiveSpan("set cache key", async (span) => {
+      const [key, data, context] = args;
+      const lastModified = Date.now();
+      span.setAttributes({ key, lastModified });
+      (0, import_request_context.getLogger)().debug(`[EdgeoneCacheHandler.set]: ${key}`);
+      const value = this.transformToStorableObject(data, context);
+      const isDataReq = Boolean(context.fetchUrl);
+      if (!isDataReq) {
+        this.captureCacheTags(value, key);
+      }
+      await this.cacheStore.set(key, { lastModified, value }, "blobStore.set");
+      if (data?.kind === "APP_PAGE") {
+        const requestContext = (0, import_request_context.getRequestContext)();
+        if (requestContext) {
+          requestContext.isCacheableAppPage = true;
+        }
+      }
+      if (!data && !isDataReq || data?.kind === "PAGE" || data?.kind === "PAGES") {
+        const requestContext = (0, import_request_context.getRequestContext)();
+        if (requestContext?.didPagesRouterOnDemandRevalidate) {
+          const tag = `_N_T_${key === "/index" ? "/" : encodeURI(key)}`;
+          requestContext?.trackBackgroundWork((0, import_tags_handler.purgeEdgeCache)(tag));
+        }
+      }
+    });
+  }
+  async revalidateTag(tagOrTags) {
+    return (0, import_tags_handler.markTagsAsStaleAndPurgeEdgeCache)(tagOrTags);
+  }
+  resetRequestCache() {
+  }
+  /**
+   * Checks if a cache entry is stale through on demand revalidated tags
+   */
+  checkCacheEntryStaleByTags(cacheEntry, tags = [], softTags = []) {
+    let cacheTags = [];
+    if (cacheEntry.value?.kind === "FETCH") {
+      cacheTags = [...tags, ...softTags];
+    } else if (cacheEntry.value?.kind === "PAGE" || cacheEntry.value?.kind === "PAGES" || cacheEntry.value?.kind === "APP_PAGE" || cacheEntry.value?.kind === "ROUTE" || cacheEntry.value?.kind === "APP_ROUTE") {
+      cacheTags = cacheEntry.value.headers?.[import_constants.NEXT_CACHE_TAGS_HEADER]?.split(/,|%2c/gi) || [];
+    } else {
+      return false;
+    }
+    if (this.revalidatedTags && this.revalidatedTags.length !== 0) {
+      for (const tag of this.revalidatedTags) {
+        if (cacheTags.includes(tag)) {
+          return true;
+        }
+      }
+    }
+  }
+};
+var cache_default = EdgeoneCacheHandler;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EdgeoneCacheHandler
+});

package/dist/run/handlers/request-context.cjs

@@ -0,0 +1,148 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/handlers/request-context.cts
+var request_context_exports = {};
+__export(request_context_exports, {
+  createRequestContext: () => createRequestContext,
+  getLogger: () => getLogger,
+  getRequestContext: () => getRequestContext,
+  runWithRequestContext: () => runWithRequestContext
+});
+module.exports = __toCommonJS(request_context_exports);
+var import_node_async_hooks = require("node:async_hooks");
+
+// node_modules/@netlify/functions/dist/internal.js
+var import_process = require("process");
+var systemLogTag = "__nfSystemLog";
+var serializeError = (error) => {
+  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack
+  };
+};
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Debug"] = 1] = "Debug";
+  LogLevel2[LogLevel2["Log"] = 2] = "Log";
+  LogLevel2[LogLevel2["Error"] = 3] = "Error";
+  return LogLevel2;
+})(LogLevel || {});
+var SystemLogger = class _SystemLogger {
+  fields;
+  logLevel;
+  constructor(fields = {}, logLevel = 2) {
+    this.fields = fields;
+    this.logLevel = logLevel;
+  }
+  doLog(logger, message) {
+    if (import_process.env.NETLIFY_DEV && !import_process.env.NETLIFY_ENABLE_SYSTEM_LOGGING) {
+      return;
+    }
+    logger(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+  }
+  log(message) {
+    if (this.logLevel > 2) {
+      return;
+    }
+    this.doLog(console.log, message);
+  }
+  debug(message) {
+    if (this.logLevel > 1) {
+      return;
+    }
+    this.doLog(console.debug, message);
+  }
+  error(message) {
+    if (this.logLevel > 3) {
+      return;
+    }
+    this.doLog(console.error, message);
+  }
+  withLogLevel(level) {
+    return new _SystemLogger(this.fields, level);
+  }
+  withFields(fields) {
+    return new _SystemLogger(
+      {
+        ...this.fields,
+        ...fields
+      },
+      this.logLevel
+    );
+  }
+  withError(error) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+    return this.withFields(fields);
+  }
+};
+var systemLogger = new SystemLogger();
+
+// src/run/handlers/request-context.cts
+var REQUEST_CONTEXT_GLOBAL_KEY = Symbol.for("nf-request-context-async-local-storage");
+var REQUEST_COUNTER_KEY = Symbol.for("nf-request-counter");
+var extendedGlobalThis = globalThis;
+function createRequestContext(request, context) {
+  const backgroundWorkPromises = [];
+  const logger = systemLogger.withLogLevel(LogLevel.Log);
+  return {
+    isBackgroundRevalidation: false,
+    captureServerTiming: false,
+    trackBackgroundWork: (promise) => {
+      if (context?.waitUntil) {
+        context.waitUntil(promise);
+      } else {
+        backgroundWorkPromises.push(promise);
+      }
+    },
+    get backgroundWorkPromise() {
+      return Promise.allSettled(backgroundWorkPromises);
+    },
+    logger,
+    requestID: ""
+  };
+}
+var requestContextAsyncLocalStorage;
+function getRequestContextAsyncLocalStorage() {
+  if (requestContextAsyncLocalStorage) {
+    return requestContextAsyncLocalStorage;
+  }
+  if (extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY]) {
+    return extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY];
+  }
+  const storage = new import_node_async_hooks.AsyncLocalStorage();
+  requestContextAsyncLocalStorage = storage;
+  extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY] = storage;
+  return storage;
+}
+var getRequestContext = () => getRequestContextAsyncLocalStorage().getStore();
+function runWithRequestContext(requestContext, fn) {
+  return getRequestContextAsyncLocalStorage().run(requestContext, fn);
+}
+function getLogger() {
+  return getRequestContext()?.logger ?? systemLogger;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRequestContext,
+  getLogger,
+  getRequestContext,
+  runWithRequestContext
+});