@ecopages/core 0.2.0-alpha.7 → 0.2.0-alpha.9

package/src/static-site-generator/static-site-generator.js

@@ -0,0 +1,353 @@
+import path from "node:path";
+import { DEFAULT_ECOPAGES_WORK_DIR } from "../constants.js";
+import { appLogger } from "../global/app-logger.js";
+import { fileSystem } from "@ecopages/file-system";
+import { PathUtils } from "../utils/path-utils.module.js";
+import { getAppServerModuleTranspiler } from "../services/module-loading/app-server-module-transpiler.service.js";
+const STATIC_SITE_GENERATOR_ERRORS = {
+  ROUTE_RENDERER_FACTORY_REQUIRED: "RouteRendererFactory is required for render strategy",
+  unsupportedBodyType: (bodyType) => `Unsupported body type for static generation: ${bodyType}`,
+  missingIntegration: (routePath) => `View at ${routePath} is missing __eco.integration. Ensure it's defined with eco.page().`,
+  noRendererForIntegration: (integrationName) => `No renderer found for integration: ${integrationName}`,
+  dynamicRouteRequiresStaticPaths: (routePath) => `Dynamic route ${routePath} requires staticPaths to be defined on the view.`
+};
+class StaticSiteGenerator {
+  appConfig;
+  serverModuleTranspiler;
+  /**
+   * Creates the static-site generator for one app config.
+   */
+  constructor({ appConfig }) {
+    this.appConfig = appConfig;
+    this.serverModuleTranspiler = getAppServerModuleTranspiler(appConfig);
+  }
+  /**
+   * Returns the transpiler output directory used for static page-module probes.
+   */
+  getStaticPageModuleOutdir() {
+    const workDir = this.appConfig.absolutePaths?.workDir ?? path.join(this.appConfig.rootDir, this.appConfig.workDir ?? DEFAULT_ECOPAGES_WORK_DIR);
+    return path.join(workDir, ".server-static-page-modules");
+  }
+  getExportDir() {
+    return this.appConfig.absolutePaths?.distDir ?? path.join(this.appConfig.rootDir, this.appConfig.distDir);
+  }
+  /**
+   * Logs the standardized warning emitted when a dynamic-cache page is skipped.
+   */
+  warnDynamicPageSkipped(filePath) {
+    appLogger.warn(
+      "Pages with cache: 'dynamic' are not supported in static generation or preview, so they will be skipped\n",
+      `\u27A4 ${filePath}`
+    );
+  }
+  /**
+   * Determines whether one filesystem-discovered page should be excluded from
+   * static generation.
+   */
+  async shouldSkipStaticPageFile(filePath) {
+    const module = await this.serverModuleTranspiler.importModule({
+      filePath,
+      outdir: this.getStaticPageModuleOutdir(),
+      externalPackages: false,
+      transpileErrorMessage: (details) => `Error transpiling static page module: ${details}`,
+      noOutputMessage: (targetFilePath) => `No transpiled output generated for static page module: ${targetFilePath}`
+    });
+    if (module.default?.cache !== "dynamic") {
+      return false;
+    }
+    this.warnDynamicPageSkipped(filePath);
+    return true;
+  }
+  /**
+   * Determines whether one explicit static route view should be excluded from
+   * static generation.
+   */
+  shouldSkipStaticView(routePath, view) {
+    if (view.cache !== "dynamic") {
+      return false;
+    }
+    this.warnDynamicPageSkipped(routePath);
+    return true;
+  }
+  /**
+   * Writes the robots.txt file declared by the app config.
+   */
+  generateRobotsTxt() {
+    let data = "";
+    const preferences = this.appConfig.robotsTxt.preferences;
+    for (const userAgent in preferences) {
+      data += `user-agent: ${userAgent}
+`;
+      for (const path2 of preferences[userAgent]) {
+        data += `disallow: ${path2}
+`;
+      }
+      data += "\n";
+    }
+    fileSystem.ensureDir(this.getExportDir());
+    fileSystem.write(path.join(this.getExportDir(), "robots.txt"), data);
+  }
+  /**
+   * Returns whether the input path points at the root directory.
+   */
+  isRootDir(path2) {
+    const slashes = path2.match(/\//g);
+    return slashes && slashes.length === 1;
+  }
+  /**
+   * Collects parent directories that must exist for the generated route set.
+   */
+  getDirectories(routes) {
+    const directories = /* @__PURE__ */ new Set();
+    for (const route of routes) {
+      const path2 = route.startsWith("http") ? new URL(route).pathname : route;
+      const segments = path2.split("/");
+      if (segments.length > 2) {
+        directories.add(segments.slice(0, segments.length - 1).join("/"));
+      }
+    }
+    return Array.from(directories);
+  }
+  /**
+   * Extracts dynamic parameters from the actual path based on the template path.
+   *
+   * @param templatePath - The template path (e.g., "/blog/[slug]")
+   * @param actualPath - The actual path (e.g., "/blog/my-post")
+   * @returns A record of extracted parameters (e.g., { slug: "my-post" })
+   */
+  extractParams(templatePath, actualPath) {
+    const templateSegments = templateSegmentsFromPath(templatePath);
+    const actualSegments = templateSegmentsFromPath(actualPath);
+    const params = {};
+    for (let i = 0; i < templateSegments.length; i++) {
+      const segment = templateSegments[i];
+      if (segment.startsWith("[") && segment.endsWith("]")) {
+        const paramName = segment.slice(1, -1).replace("...", "");
+        params[paramName] = actualSegments[i];
+      }
+    }
+    return params;
+  }
+  /**
+   * Generates static output for all filesystem-discovered routes.
+   *
+   * @remarks
+   * Routes whose integrations opt into fetch-based static builds are rendered by
+   * issuing a request against the running server origin. Render-strategy routes
+   * go through the normal route renderer directly.
+   */
+  async generateStaticPages(router, baseUrl, routeRendererFactory) {
+    const routes = Object.keys(router.routes).filter((route) => !route.includes("["));
+    appLogger.debug("Static Pages", routes);
+    const directories = this.getDirectories(routes);
+    for (const directory of directories) {
+      fileSystem.ensureDir(path.join(this.getExportDir(), directory));
+    }
+    for (const route of routes) {
+      try {
+        const { filePath, pathname: routePathname } = router.routes[route];
+        if (await this.shouldSkipStaticPageFile(filePath)) {
+          continue;
+        }
+        const ext = PathUtils.getEcoTemplateExtension(filePath);
+        const integration = this.appConfig.integrations.find((plugin) => plugin.extensions.includes(ext));
+        const strategy = integration?.staticBuildStep || "render";
+        let contents;
+        if (strategy === "fetch") {
+          const fetchUrl = route.startsWith("http") ? route : `${baseUrl}${route}`;
+          const response = await fetch(fetchUrl);
+          if (!response.ok) {
+            appLogger.error(`Failed to fetch ${fetchUrl}. Status: ${response.status}`);
+            continue;
+          }
+          contents = await response.text();
+        } else {
+          if (!routeRendererFactory) {
+            throw new Error(STATIC_SITE_GENERATOR_ERRORS.ROUTE_RENDERER_FACTORY_REQUIRED);
+          }
+          let pathname2 = routePathname;
+          const pathnameSegments2 = pathname2.split("/").filter(Boolean);
+          if (pathname2 === "/") {
+            pathname2 = "/index.html";
+          } else if (pathnameSegments2.join("/").includes("[")) {
+            pathname2 = `${route.replace(router.origin, "")}.html`;
+          } else if (pathnameSegments2.length >= 1 && directories.includes(`/${pathnameSegments2.join("/")}`)) {
+            pathname2 = `${pathname2.endsWith("/") ? pathname2 : `${pathname2}/`}index.html`;
+          } else {
+            pathname2 += ".html";
+          }
+          const renderer = routeRendererFactory.createRenderer(filePath);
+          const params = this.extractParams(routePathname, pathname2.replace(".html", ""));
+          const result = await renderer.createRoute({
+            file: filePath,
+            params
+          });
+          const body = result.body;
+          if (typeof body === "string" || Buffer.isBuffer(body)) {
+            contents = body;
+          } else if (body instanceof ReadableStream) {
+            contents = await new Response(body).text();
+          } else {
+            throw new Error(STATIC_SITE_GENERATOR_ERRORS.unsupportedBodyType(typeof body));
+          }
+        }
+        let pathname = routePathname;
+        const pathnameSegments = pathname.split("/").filter(Boolean);
+        if (pathname === "/") {
+          pathname = "/index.html";
+        } else if (pathnameSegments.join("/").includes("[")) {
+          pathname = `${route.replace(router.origin, "")}.html`;
+        } else if (pathnameSegments.length >= 1 && directories.includes(`/${pathnameSegments.join("/")}`)) {
+          pathname = `${pathname.endsWith("/") ? pathname : `${pathname}/`}index.html`;
+        } else {
+          pathname += ".html";
+        }
+        const outputPath = path.join(this.getExportDir(), pathname);
+        fileSystem.write(outputPath, contents);
+      } catch (error) {
+        appLogger.error(
+          `Error generating static page for ${route}:`,
+          error instanceof Error ? error : String(error)
+        );
+      }
+    }
+  }
+  /**
+   * Executes the full static-generation workflow for one app run.
+   */
+  async run({
+    router,
+    baseUrl,
+    routeRendererFactory,
+    staticRoutes
+  }) {
+    this.generateRobotsTxt();
+    await this.generateStaticPages(router, baseUrl, routeRendererFactory);
+    if (staticRoutes && staticRoutes.length > 0 && routeRendererFactory) {
+      await this.generateExplicitStaticPages(staticRoutes, routeRendererFactory);
+    }
+  }
+  /**
+   * Generates static pages from explicit static routes registered via app.static().
+   * These routes use eco.page views via loader functions for HMR support.
+   */
+  async generateExplicitStaticPages(staticRoutes, routeRendererFactory) {
+    appLogger.debug(
+      "Generating explicit static routes",
+      staticRoutes.map((r) => r.path)
+    );
+    for (const route of staticRoutes) {
+      try {
+        const mod = await route.loader();
+        const view = mod.default;
+        if (this.shouldSkipStaticView(route.path, view)) {
+          continue;
+        }
+        const isDynamic = route.path.includes(":") || route.path.includes("[");
+        if (isDynamic) {
+          await this.generateDynamicStaticRoute(route.path, view, routeRendererFactory);
+        } else {
+          await this.generateSingleStaticRoute(route.path, view, routeRendererFactory);
+        }
+      } catch (error) {
+        appLogger.error(
+          `Error generating explicit static page for ${route.path}:`,
+          error instanceof Error ? error : String(error)
+        );
+      }
+    }
+  }
+  /**
+   * Generate a single static page for a non-dynamic route.
+   */
+  async generateSingleStaticRoute(routePath, view, routeRendererFactory) {
+    const integrationName = view.config?.__eco?.integration;
+    if (!integrationName) {
+      throw new Error(STATIC_SITE_GENERATOR_ERRORS.missingIntegration(routePath));
+    }
+    const renderer = routeRendererFactory.getRendererByIntegration(integrationName);
+    if (!renderer) {
+      throw new Error(STATIC_SITE_GENERATOR_ERRORS.noRendererForIntegration(integrationName));
+    }
+    const props = view.staticProps ? (await view.staticProps({
+      pathname: { params: {} },
+      appConfig: this.appConfig,
+      runtimeOrigin: this.appConfig.baseUrl
+    })).props : {};
+    const response = await renderer.renderToResponse(view, props, {});
+    const contents = await response.text();
+    const outputPath = this.getOutputPath(routePath);
+    fileSystem.ensureDir(path.dirname(outputPath));
+    fileSystem.write(outputPath, contents);
+    appLogger.debug(`Generated static page: ${routePath} -> ${outputPath}`);
+  }
+  /**
+   * Generate static pages for a dynamic route using staticPaths.
+   */
+  async generateDynamicStaticRoute(routePath, view, routeRendererFactory) {
+    if (!view.staticPaths) {
+      throw new Error(STATIC_SITE_GENERATOR_ERRORS.dynamicRouteRequiresStaticPaths(routePath));
+    }
+    const integrationName = view.config?.__eco?.integration;
+    if (!integrationName) {
+      throw new Error(STATIC_SITE_GENERATOR_ERRORS.missingIntegration(routePath));
+    }
+    const renderer = routeRendererFactory.getRendererByIntegration(integrationName);
+    if (!renderer) {
+      throw new Error(STATIC_SITE_GENERATOR_ERRORS.noRendererForIntegration(integrationName));
+    }
+    const { paths } = await view.staticPaths({
+      appConfig: this.appConfig,
+      runtimeOrigin: this.appConfig.baseUrl
+    });
+    for (const { params } of paths) {
+      const resolvedPath = this.resolveRoutePath(routePath, params);
+      const props = view.staticProps ? (await view.staticProps({
+        pathname: { params },
+        appConfig: this.appConfig,
+        runtimeOrigin: this.appConfig.baseUrl
+      })).props : {};
+      const response = await renderer.renderToResponse(view, props, {});
+      const contents = await response.text();
+      const outputPath = this.getOutputPath(resolvedPath);
+      fileSystem.ensureDir(path.dirname(outputPath));
+      fileSystem.write(outputPath, contents);
+      appLogger.debug(`Generated static page: ${resolvedPath} -> ${outputPath}`);
+    }
+  }
+  /**
+   * Resolve a route path template with actual params.
+   * Supports both :param and [param] syntax.
+   */
+  resolveRoutePath(routePath, params) {
+    let resolved = routePath;
+    for (const [key, value] of Object.entries(params)) {
+      const paramValue = Array.isArray(value) ? value.join("/") : value;
+      resolved = resolved.replace(`:${key}`, paramValue);
+      resolved = resolved.replace(`[${key}]`, paramValue);
+      resolved = resolved.replace(`[...${key}]`, paramValue);
+    }
+    return resolved;
+  }
+  /**
+   * Get the output file path for a given route.
+   */
+  getOutputPath(routePath) {
+    let outputName;
+    if (routePath === "/") {
+      outputName = "index.html";
+    } else if (routePath.endsWith("/")) {
+      outputName = `${routePath}index.html`;
+    } else {
+      outputName = `${routePath}.html`;
+    }
+    return path.join(this.getExportDir(), outputName);
+  }
+}
+function templateSegmentsFromPath(path2) {
+  return path2.split("/").filter(Boolean);
+}
+export {
+  STATIC_SITE_GENERATOR_ERRORS,
+  StaticSiteGenerator
+};

package/src/utils/css.d.ts

@@ -0,0 +1 @@
+export declare const css: (strings: TemplateStringsArray, ...values: any[]) => Promise<string>;

package/src/utils/css.js

@@ -0,0 +1,7 @@
+const css = async (strings, ...values) => {
+  const css2 = strings.reduce((acc, str, i) => acc + str + (values[i] || ""), "");
+  return css2;
+};
+export {
+  css
+};

package/src/utils/deep-merge.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This module contains a simple utility function to merge two objects deeply
+ * @module
+ */
+/**
+ * Deeply merges two objects or arrays
+ * @function deepMerge
+ * @template T - Type of target object
+ * @template U - Type of source object
+ * @param target - The target object to merge into
+ * @param source - The source object to merge from
+ * @returns A new object with merged properties
+ */
+export declare function deepMerge<T, U>(target: T, source: U): T & U;

package/src/utils/deep-merge.js

@@ -0,0 +1,32 @@
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+function isArray(item) {
+  return Array.isArray(item);
+}
+function deepMerge(target, source) {
+  if (isArray(target) && isArray(source)) {
+    return [...target, ...source];
+  }
+  if (!isObject(target) || !isObject(source)) {
+    return source;
+  }
+  const output = Object.assign({}, target);
+  for (const key in source) {
+    if (isObject(source[key])) {
+      if (!target[key]) {
+        Object.assign(output, { [key]: source[key] });
+      } else {
+        output[key] = deepMerge(target[key], source[key]);
+      }
+    } else if (isArray(source[key])) {
+      output[key] = [...target[key] || [], ...source[key]];
+    } else if (source[key] !== void 0) {
+      Object.assign(output, { [key]: source[key] });
+    }
+  }
+  return output;
+}
+export {
+  deepMerge
+};

package/src/utils/hash.d.ts

@@ -0,0 +1 @@
+export declare const rapidhash: (content: string | Buffer<ArrayBufferLike>) => number | bigint;

package/src/utils/hash.js

@@ -0,0 +1,7 @@
+import { runtimeHash } from "./runtime.js";
+const rapidhash = (content) => {
+  return runtimeHash(content);
+};
+export {
+  rapidhash
+};

package/src/utils/html.d.ts

@@ -0,0 +1 @@
+export { html } from 'ghtml';

package/src/utils/html.js

@@ -0,0 +1,4 @@
+import { html } from "ghtml";
+export {
+  html
+};

package/src/utils/invariant.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This module contains a simple utility invariant function that throws an error if the condition is not met
+ * @module
+ */
+export declare function invariant(condition: boolean, message?: string): asserts condition;

package/src/utils/invariant.js

@@ -0,0 +1,11 @@
+const prefix = "[ecopages]";
+function invariant(condition, message) {
+  if (condition) {
+    return;
+  }
+  const value = message ? `${prefix} ${message}` : `${prefix} An error occurred`;
+  throw new Error(value);
+}
+export {
+  invariant
+};

package/src/utils/locals-utils.d.ts

@@ -0,0 +1,15 @@
+import type { ApiHandlerContext } from '../public-types.js';
+/**
+ * Creates a require function for validating and retrieving request locals.
+ * Supports both single key access and multiple keys with type safety.
+ *
+ * @param getLocals - Function that returns the current locals object
+ * @returns A require function that throws the onMissing response if keys are not found
+ *
+ * @example
+ * ```ts
+ * const require = createRequire(() => context.locals);
+ * const userId = require('userId', () => new Response('Unauthorized', { status: 401 }));
+ * ```
+ */
+export declare function createRequire(getLocals: () => Record<string, unknown>): ApiHandlerContext['require'];

package/src/utils/locals-utils.js

@@ -0,0 +1,24 @@
+function createRequire(getLocals) {
+  return (keyOrKeys, onMissing) => {
+    const locals = getLocals();
+    if (Array.isArray(keyOrKeys)) {
+      const result = {};
+      for (const key of keyOrKeys) {
+        const value2 = locals[key];
+        if (value2 === void 0 || value2 === null) {
+          throw onMissing();
+        }
+        result[key] = value2;
+      }
+      return result;
+    }
+    const value = locals[keyOrKeys];
+    if (value === void 0 || value === null) {
+      throw onMissing();
+    }
+    return value;
+  };
+}
+export {
+  createRequire
+};

package/src/utils/parse-cli-args.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parsed command line arguments for the Ecopages server.
+ * @property preview - Whether to run in preview mode
+ * @property build - Whether to run a static build
+ * @property start - Whether to start the server
+ * @property dev - Whether to run in development mode
+ * @property port - Optional port number
+ * @property hostname - Optional hostname
+ * @property reactFastRefresh - Whether React Fast Refresh is enabled
+ */
+export type ReturnParseCliArgs = {
+    preview: boolean;
+    build: boolean;
+    start: boolean;
+    dev: boolean;
+    port?: number;
+    hostname?: string;
+    reactFastRefresh?: boolean;
+};
+/**
+ * Parses command line arguments for the server.
+ * It returns {@link ReturnParseCliArgs}
+ */
+export declare function parseCliArgs(): ReturnParseCliArgs;

package/src/utils/parse-cli-args.js

@@ -0,0 +1,47 @@
+import { parseArgs } from "node:util";
+import { getRuntimeArgv } from "./runtime.js";
+const ECOPAGES_BIN_FILES = ["ecopages.ts", "ecopages.js", "cli.js"];
+const ECOPAGES_AVAILABLE_COMMANDS = ["dev", "build", "start", "preview"];
+function parseCliArgs() {
+  const runtimeArgv = getRuntimeArgv();
+  const { values } = parseArgs({
+    args: runtimeArgv,
+    options: {
+      dev: { type: "boolean" },
+      preview: { type: "boolean" },
+      build: { type: "boolean" },
+      port: { type: "string" },
+      hostname: { type: "string" },
+      "react-fast-refresh": { type: "boolean" }
+    },
+    allowPositionals: true
+  });
+  let command = "";
+  const ecopagesIndex = runtimeArgv.findIndex((arg) => ECOPAGES_BIN_FILES.some((filename) => arg.endsWith(filename)));
+  const isAvailableCommand = ecopagesIndex !== -1;
+  if (isAvailableCommand) {
+    command = ecopagesIndex < runtimeArgv.length - 1 && ECOPAGES_AVAILABLE_COMMANDS.some((cmd) => {
+      return runtimeArgv[ecopagesIndex + 1] === cmd;
+    }) ? runtimeArgv[ecopagesIndex + 1] : "start";
+  }
+  const isStartCommand = command === "start" || !values.dev && !values.build && !values.preview;
+  const isDevCommand = command === "dev" || !!values.dev;
+  const isBuildCommand = command === "build" || !!values.build;
+  const isPreviewCommand = command === "preview" || !!values.preview;
+  const parsedCommandOptions = {
+    preview: isPreviewCommand,
+    build: isBuildCommand,
+    start: isStartCommand,
+    dev: isDevCommand,
+    port: values.port ? Number(values.port) : void 0,
+    hostname: values.hostname,
+    reactFastRefresh: values["react-fast-refresh"]
+  };
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = isDevCommand ? "development" : "production";
+  }
+  return parsedCommandOptions;
+}
+export {
+  parseCliArgs
+};

package/src/utils/path-utils.module.d.ts

@@ -0,0 +1,5 @@
+declare function getEcoTemplateExtension(filePath: string): string;
+export declare const PathUtils: {
+    getEcoTemplateExtension: typeof getEcoTemplateExtension;
+};
+export {};

package/src/utils/path-utils.module.js

@@ -0,0 +1,14 @@
+import path from "node:path";
+function getEcoTemplateExtension(filePath) {
+  const { name, ext } = path.parse(filePath);
+  const nameParts = name.split(".");
+  const descriptor = nameParts.length > 1 ? nameParts.pop() : void 0;
+  const templateExtension = descriptor ? `.${descriptor}${ext}` : ext;
+  return templateExtension;
+}
+const PathUtils = {
+  getEcoTemplateExtension
+};
+export {
+  PathUtils
+};

package/src/utils/resolve-work-dir.d.ts

@@ -0,0 +1,11 @@
+type InternalPathConfig = {
+    rootDir?: string;
+    workDir?: string;
+    absolutePaths?: {
+        workDir?: string;
+        distDir?: string;
+    };
+};
+export declare function resolveInternalWorkDir(appConfig: InternalPathConfig): string;
+export declare function resolveInternalExecutionDir(appConfig: InternalPathConfig): string;
+export {};

package/src/utils/resolve-work-dir.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { DEFAULT_ECOPAGES_WORK_DIR } from "../constants.js";
+function isInsideNodeModules(directory) {
+  return path.normalize(directory).split(path.sep).includes("node_modules");
+}
+function resolveInternalWorkDir(appConfig) {
+  if (appConfig.absolutePaths?.workDir) {
+    return appConfig.absolutePaths.workDir;
+  }
+  if (appConfig.rootDir) {
+    return path.join(appConfig.rootDir, appConfig.workDir ?? DEFAULT_ECOPAGES_WORK_DIR);
+  }
+  if (appConfig.workDir) {
+    return appConfig.workDir;
+  }
+  return DEFAULT_ECOPAGES_WORK_DIR;
+}
+function resolveInternalExecutionDir(appConfig) {
+  const workDir = resolveInternalWorkDir(appConfig);
+  if (!isInsideNodeModules(workDir)) {
+    return workDir;
+  }
+  if (appConfig.rootDir) {
+    return path.join(appConfig.rootDir, DEFAULT_ECOPAGES_WORK_DIR);
+  }
+  return DEFAULT_ECOPAGES_WORK_DIR;
+}
+export {
+  resolveInternalExecutionDir,
+  resolveInternalWorkDir
+};

package/src/utils/runtime.d.ts

@@ -0,0 +1,11 @@
+export declare const RUNTIME_ERRORS: {
+    readonly BUN_RUNTIME_REQUIRED: "Bun runtime is required";
+};
+type RuntimeBun = typeof Bun;
+export declare function getBunRuntime(): RuntimeBun | undefined;
+export declare function getRequiredBunRuntime(): RuntimeBun;
+export declare function getRuntimeArgv(): string[];
+export declare function isDevelopmentRuntime(): boolean;
+export declare function isProductionRuntime(): boolean;
+export declare function runtimeHash(content: string | Buffer<ArrayBufferLike>): number | bigint;
+export {};