edge-functions 4.8.1 → 5.0.0-stage.1

package/dist/chunk-ACWSA73O.js

@@ -0,0 +1,1172 @@
+import {
+  debug,
+  generateTimestamp
+} from "./chunk-GVUH3USH.js";
+
+// lib/env/runtime.ts
+import { EdgeRuntime } from "edge-runtime";
+import {
+  fetchContext,
+  FetchEventContext,
+  AsyncHooksContext,
+  StorageContext,
+  EnvVarsContext,
+  NetworkListContext,
+  fsContext,
+  FirewallEventContext
+} from "azion/bundler/polyfills";
+function runtime(code, isFirewallEvent = false) {
+  const extend = (context) => {
+    context.RESERVED_FETCH = context.fetch.bind(context);
+    context.fetch = async (resource, options) => fetchContext(context, resource, options);
+    context.FetchEvent = isFirewallEvent ? FirewallEventContext : FetchEventContext;
+    context.Response = isFirewallEvent ? Response : context.Response;
+    context.eval = eval;
+    context.process = { env: process.env };
+    context.File = void 0;
+    context.WebSocket = void 0;
+    context.ASYNC_LOCAL_STORAGE = AsyncHooksContext;
+    context.STORAGE_CONTEXT = StorageContext;
+    context.ENV_VARS_CONTEXT = EnvVarsContext;
+    context.NETWORK_LIST_CONTEXT = NetworkListContext;
+    context.FS_CONTEXT = fsContext;
+    return context;
+  };
+  const edgeRuntime = new EdgeRuntime({
+    extend,
+    initialCode: code,
+    codeGeneration: {
+      strings: true
+    }
+  });
+  return edgeRuntime;
+}
+var runtime_default = runtime;
+
+// lib/env/server.ts
+import net from "net";
+import { feedback as feedback5 } from "azion/utils/node";
+import chokidar from "chokidar";
+
+// lib/env/bundler.ts
+import { feedback } from "azion/utils/node";
+import fs from "fs";
+import fsPromises from "fs/promises";
+import path from "path";
+import {
+  ModuleKind,
+  ModuleResolutionKind,
+  ScriptTarget,
+  transpileModule
+} from "typescript";
+import prettier from "prettier";
+import { createRequire } from "module";
+async function writeStore(values, scope = "global") {
+  let basePath;
+  switch (scope) {
+    case "global":
+      basePath = globalThis.bundler.tempPath;
+      break;
+    case "local":
+      basePath = path.join(process.cwd());
+      break;
+    default:
+      basePath = scope;
+      break;
+  }
+  const bundlerSesssionStorePath = path.join(basePath, ".azion-bundler.json");
+  try {
+    await fsPromises.mkdir(basePath, { recursive: true });
+  } catch (error) {
+    debug.error(error);
+    feedback.build.error(
+      `An error occurred while creating the ${bundlerSesssionStorePath} folder.`
+    );
+    throw error;
+  }
+  try {
+    await fsPromises.writeFile(
+      bundlerSesssionStorePath,
+      JSON.stringify(values, null, 2)
+    );
+  } catch (error) {
+    debug.error(error);
+    feedback.build.error(
+      `An error occurred while writing the ${bundlerSesssionStorePath} file.`
+    );
+    throw error;
+  }
+}
+async function readStore(scope = "global") {
+  let basePath;
+  switch (scope) {
+    case "global":
+      basePath = globalThis.bundler.tempPath;
+      break;
+    case "local":
+      basePath = path.join(process.cwd());
+      break;
+    default:
+      basePath = scope;
+      break;
+  }
+  if (!basePath) return {};
+  const bundlerStoreFilePath = path.join(basePath, ".azion-bundler.json");
+  try {
+    await fsPromises.access(bundlerStoreFilePath);
+    const fileContents = await fsPromises.readFile(
+      bundlerStoreFilePath,
+      "utf8"
+    );
+    return JSON.parse(fileContents);
+  } catch (error) {
+    return {};
+  }
+}
+function handleDependencyError(error, configPath) {
+  if (error.message.includes("ERR_MODULE_NOT_FOUND")) {
+    const missingPackage = error.message.match(/'([^']+)'/)?.[1];
+    if (missingPackage) {
+      feedback.build.error(
+        `Missing dependency: ${missingPackage}. Please install it using 'npm install ${missingPackage}' or 'yarn add ${missingPackage}'.`
+      );
+    } else {
+      feedback.build.error(
+        `A required dependency is missing. Please ensure all dependencies are installed.`
+      );
+    }
+    debug.error(
+      `Failed to load configuration from ${configPath}. ${error.message}`
+    );
+  } else {
+    throw error;
+  }
+}
+async function readUserConfig(configPath) {
+  const require2 = createRequire(import.meta.url);
+  const extensions = [".js", ".mjs", ".cjs", ".ts"];
+  const configName = "azion.config";
+  let resolvedConfigPath;
+  if (configPath) {
+    resolvedConfigPath = path.isAbsolute(configPath) ? configPath : path.join(process.cwd(), configPath);
+    if (!fs.existsSync(resolvedConfigPath)) {
+      return null;
+    }
+  } else {
+    for (const ext of extensions) {
+      const testPath = path.join(process.cwd(), `${configName}${ext}`);
+      if (fs.existsSync(testPath)) {
+        resolvedConfigPath = testPath;
+        break;
+      }
+    }
+  }
+  if (!resolvedConfigPath) {
+    return null;
+  }
+  const extension = path.extname(resolvedConfigPath);
+  let configModule;
+  try {
+    switch (extension) {
+      case ".ts":
+        const tsContent = await fsPromises.readFile(
+          resolvedConfigPath,
+          "utf-8"
+        );
+        const jsContent = transpileModule(tsContent, {
+          compilerOptions: {
+            module: ModuleKind.CommonJS,
+            target: ScriptTarget.ES2020,
+            moduleResolution: ModuleResolutionKind.Node10
+          }
+        }).outputText;
+        const tempJsPath = resolvedConfigPath.replace(".ts", ".temp.js");
+        await fsPromises.writeFile(tempJsPath, jsContent);
+        try {
+          configModule = require2(tempJsPath);
+        } finally {
+          await fsPromises.unlink(tempJsPath);
+        }
+        break;
+      case ".mjs":
+        configModule = await import(resolvedConfigPath);
+        break;
+      case ".cjs":
+      case ".js":
+        try {
+          configModule = await import(resolvedConfigPath);
+        } catch (error) {
+          if (error.message === "ERR_REQUIRE_ESM") {
+            configModule = require2(resolvedConfigPath);
+            throw error;
+          }
+        }
+        break;
+      default:
+        throw new Error(`Unsupported file extension: ${extension}`);
+    }
+    return configModule.default || configModule;
+  } catch (error) {
+    if (error.message.includes("ERR_MODULE_NOT_FOUND")) {
+      handleDependencyError(error, resolvedConfigPath);
+      return null;
+    }
+    throw error;
+  }
+}
+function isCommonJS() {
+  const packageJsonPath = path.join(process.cwd(), "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return packageJson.type !== "module";
+  }
+  return true;
+}
+async function writeUserConfig(config) {
+  const useCommonJS = isCommonJS();
+  const extension = useCommonJS ? ".cjs" : ".mjs";
+  const isTypeScript = config.build?.preset === "typescript";
+  const configExtension = isTypeScript ? ".ts" : extension;
+  const configPath = path.join(process.cwd(), `azion.config${configExtension}`);
+  const moduleExportStyle = isTypeScript ? "export default" : useCommonJS ? "module.exports =" : "export default";
+  const configComment = `/**
+ * This file was automatically generated based on your preset configuration.
+ * 
+ * For better type checking and IntelliSense:
+ * 1. Install azion as dev dependency:
+ *    npm install -D azion
+ * 
+ * 2. Use defineConfig:
+ *    import { defineConfig } from 'azion'
+ * 
+ * For more configuration options, visit:
+ * https://github.com/aziontech/azion
+ */
+
+`;
+  const replacer = (key, value) => {
+    if (typeof value === "function") {
+      return `__FUNCTION_START__${value.toString()}__FUNCTION_END__`;
+    }
+    return value;
+  };
+  const formattedContent = await prettier.format(
+    configComment + `${moduleExportStyle} ${JSON.stringify(config, replacer, 2)};`,
+    {
+      parser: "babel",
+      semi: false,
+      singleQuote: true,
+      trailingComma: "none"
+    }
+  );
+  if (!fs.existsSync(configPath)) {
+    await fsPromises.writeFile(configPath, formattedContent);
+  }
+}
+var bundler_default = {
+  writeStore,
+  readStore,
+  readUserConfig,
+  writeUserConfig
+};
+
+// lib/commands/build/build.ts
+import { feedback as feedback4 } from "azion/utils/node";
+import { writeFile } from "fs/promises";
+
+// lib/commands/build/utils.ts
+import { join } from "path";
+import fs2 from "fs";
+import { getPackageManager } from "azion/utils/node";
+var PackageJsonError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "PackageJsonError";
+  }
+};
+var DependenciesError = class extends Error {
+  constructor(packageManager) {
+    super(`Please install dependencies using ${packageManager}`);
+    this.name = "DependenciesError";
+  }
+};
+var readPackageJson = () => {
+  const packageJsonPath = join(process.cwd(), "package.json");
+  try {
+    const content = fs2.readFileSync(packageJsonPath, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new PackageJsonError(
+      "Failed to read package.json",
+      error.code
+    );
+  }
+};
+var hasNodeModulesDirectory = async () => {
+  const nodeModulesPath = join(process.cwd(), "node_modules");
+  try {
+    const stats = await fs2.promises.stat(nodeModulesPath);
+    return stats.isDirectory();
+  } catch (error) {
+    return false;
+  }
+};
+var checkDependencies = async () => {
+  let projectJson;
+  try {
+    projectJson = readPackageJson();
+  } catch (error) {
+    if (error instanceof PackageJsonError && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  if (projectJson && (projectJson.dependencies || projectJson.devDependencies)) {
+    const pkgManager = await getPackageManager();
+    const nodeModulesExists = await hasNodeModulesDirectory();
+    if (!nodeModulesExists) {
+      throw new DependenciesError(pkgManager);
+    }
+  }
+};
+function resolveConfigPriority({
+  inputValue,
+  fileValue,
+  storeValue,
+  defaultValue
+}) {
+  return inputValue ?? fileValue ?? storeValue ?? defaultValue;
+}
+function resolvePresetPriority({
+  inputValue,
+  fileValue,
+  storeValue,
+  defaultValue
+}) {
+  if (typeof fileValue === "object" && fileValue.metadata?.name) {
+    return fileValue;
+  }
+  if (typeof storeValue === "object" && storeValue.metadata?.name) {
+    return storeValue;
+  }
+  return resolveConfigPriority({
+    inputValue,
+    fileValue,
+    storeValue,
+    defaultValue
+  });
+}
+
+// lib/commands/build/modules/config/config.ts
+import { join as join2 } from "path";
+var setupBuildConfig = (azionConfig, preset) => {
+  const fileExtension = `${preset.metadata.ext || "js"}`;
+  const tempFile = `azion-${generateTimestamp()}.temp.${fileExtension}`;
+  const buildConfigSetup = {
+    ...azionConfig.build,
+    entry: join2(process.cwd(), tempFile),
+    preset,
+    setup: {
+      contentToInject: void 0,
+      defineVars: {}
+    }
+  };
+  buildConfigSetup.polyfills = Boolean(azionConfig.build?.polyfills);
+  buildConfigSetup.worker = Boolean(azionConfig.build?.worker);
+  return buildConfigSetup;
+};
+
+// lib/commands/build/modules/preset/preset.ts
+import * as presets2 from "azion/presets";
+import * as utilsNode from "azion/utils/node";
+
+// lib/commands/build/modules/preset/infer/infer-preset.ts
+import * as presets from "azion/presets";
+import { join as join3 } from "path";
+import fs3 from "fs";
+import { extname } from "path";
+
+// lib/commands/build/modules/preset/frameworks/frameworks-info.ts
+import { listFrameworks as netlifyListFrameworks } from "@netlify/framework-info";
+var listFrameworks = ({
+  projectDir = process.cwd()
+}) => {
+  return netlifyListFrameworks({
+    projectDir
+  });
+};
+
+// lib/commands/build/modules/preset/frameworks/index.ts
+var frameworks_default = { listFrameworks };
+
+// lib/commands/build/modules/preset/infer/infer-preset.ts
+async function inferPreset() {
+  try {
+    const detectedFramework = await frameworks_default.listFrameworks({
+      projectDir: process.cwd()
+    });
+    if (detectedFramework[0]?.id) {
+      const hasPreset = Object.values(presets).some(
+        (preset) => preset.metadata?.name === detectedFramework[0].id
+      );
+      if (hasPreset) return detectedFramework[0].id;
+    }
+    const tsConfigPath = join3(process.cwd(), "tsconfig.json");
+    const tsConfigExists = fs3.existsSync(tsConfigPath);
+    if (tsConfigExists) return "typescript";
+    const files = fs3.readdirSync(process.cwd());
+    const hasTypeScriptFiles = files.some(
+      (file) => [".ts", ".tsx"].includes(extname(file))
+    );
+    if (hasTypeScriptFiles) return "typescript";
+    return "javascript";
+  } catch (error) {
+    return "javascript";
+  }
+}
+var infer_preset_default = { inferPreset };
+
+// lib/commands/build/modules/preset/preset.ts
+var validatePreset = (preset) => {
+  if (!preset.metadata?.name || !preset.config) {
+    throw new Error("Preset must have name and config.");
+  }
+  const presetName = preset.metadata.name.toLowerCase();
+  const validPresets = Object.keys(presets2);
+  if (!validPresets.includes(presetName)) {
+    throw new Error(`Invalid build preset name: '${presetName}'`);
+  }
+  return true;
+};
+var loadPreset = async (presetName) => {
+  const normalizedName = presetName.toLowerCase();
+  return presets2[normalizedName];
+};
+var resolvePreset = async (input) => {
+  if (!input) {
+    utilsNode.feedback.build.info(
+      "No preset specified, using automatic detection..."
+    );
+    input = await infer_preset_default.inferPreset();
+  }
+  const preset = typeof input === "string" ? await loadPreset(input) : input;
+  validatePreset(preset);
+  return preset;
+};
+
+// lib/commands/build/modules/prebuild/utils.ts
+import fs4 from "fs";
+import fsPromises2 from "fs/promises";
+import { join as join4 } from "path";
+var injectWorkerMemoryFiles = async ({
+  namespace,
+  property,
+  dirs
+}) => {
+  const result = {};
+  if (dirs.length === 0) {
+    return "";
+  }
+  for (const dir of dirs) {
+    const files = await fsPromises2.readdir(dir);
+    for (const file of files) {
+      const filePath = join4(dir, file);
+      const stats = await fsPromises2.stat(filePath);
+      if (stats.isDirectory()) {
+        const subDirContent = await injectWorkerMemoryFiles({
+          namespace,
+          property,
+          dirs: [filePath]
+        });
+        Object.assign(result, subDirContent);
+      } else if (stats.isFile()) {
+        const bufferContent = await fsPromises2.readFile(filePath);
+        let key = filePath;
+        if (!filePath.startsWith("/")) key = `/${filePath}`;
+        result[key] = { content: bufferContent.toString("base64") };
+      }
+    }
+  }
+  return `globalThis.${namespace}.${property}=${JSON.stringify(result)};`;
+};
+var copyFilesToLocalEdgeStorage = ({
+  dirs,
+  prefix,
+  outputPath
+}) => {
+  dirs.forEach((dir) => {
+    const targetPath = prefix ? dir.replace(prefix, "") : dir;
+    const fullTargetPath = join4(outputPath, targetPath);
+    if (!fs4.existsSync(fullTargetPath)) {
+      fs4.mkdirSync(fullTargetPath, { recursive: true });
+    }
+    fs4.cpSync(dir, fullTargetPath, { recursive: true });
+  });
+};
+var injectWorkerGlobals = ({
+  namespace,
+  property,
+  vars
+}) => Object.entries(vars).reduce(
+  (acc, [key, value]) => {
+    const propPath = property ? `${namespace}.${property}` : namespace;
+    return `${acc} globalThis.${propPath}.${key}=${value};`;
+  },
+  property ? `globalThis.${namespace}.${property}={};` : `globalThis.${namespace}={};`
+);
+var injectWorkerPathPrefix = async ({
+  namespace,
+  property,
+  prefix
+}) => {
+  const formattedPrefix = prefix && typeof prefix === "string" && prefix !== "" ? prefix : '""';
+  return `globalThis.${namespace} = { ...globalThis.${namespace}, ${property}: '${formattedPrefix}'};`;
+};
+var utils_default = {
+  injectWorkerMemoryFiles,
+  copyFilesToLocalEdgeStorage,
+  injectWorkerGlobals,
+  injectWorkerPathPrefix
+};
+
+// lib/commands/build/modules/prebuild/prebuild.ts
+var EDGE_STORAGE = ".edge/storage";
+var BUNDLER_NAMESPACE = "bundler";
+var DEFAULT_PREBUILD_RESULT = {
+  filesToInject: [],
+  injection: {
+    globals: {},
+    entry: "",
+    banner: ""
+  },
+  bundler: {
+    defineVars: {},
+    plugins: []
+  }
+};
+var executePrebuild = async ({
+  buildConfig,
+  ctx
+}) => {
+  const result = await buildConfig.preset.prebuild?.(buildConfig, ctx) || DEFAULT_PREBUILD_RESULT;
+  const globalThisWithVars = utils_default.injectWorkerGlobals({
+    namespace: BUNDLER_NAMESPACE,
+    // Transform globals object:
+    // 1. Convert object to entries
+    // 2. Remove any entries with undefined values
+    // 3. Ensure remaining values are typed as string
+    vars: Object.fromEntries(
+      Object.entries(result.injection?.globals || {}).filter(([_, v]) => v !== void 0).map(([k, v]) => [k, v])
+    )
+  });
+  const memoryFiles = await utils_default.injectWorkerMemoryFiles({
+    namespace: BUNDLER_NAMESPACE,
+    property: "__FILES__",
+    dirs: buildConfig.memoryFS?.injectionDirs || []
+  });
+  if (buildConfig.memoryFS) {
+    utils_default.copyFilesToLocalEdgeStorage({
+      dirs: buildConfig.memoryFS?.injectionDirs,
+      prefix: buildConfig.memoryFS?.removePathPrefix,
+      outputPath: EDGE_STORAGE
+    });
+  }
+  const pathPrefix = await utils_default.injectWorkerPathPrefix({
+    namespace: BUNDLER_NAMESPACE,
+    property: "FS_PATH_PREFIX_TO_REMOVE",
+    prefix: buildConfig.memoryFS?.removePathPrefix || ""
+  });
+  const globalThisWithInjections = `${globalThisWithVars}${pathPrefix}
+${memoryFiles}`;
+  return {
+    filesToInject: result.filesToInject || [],
+    injection: {
+      globals: result.injection?.globals || {},
+      entry: "",
+      banner: globalThisWithInjections
+    },
+    bundler: {
+      defineVars: result.bundler?.defineVars || {},
+      plugins: result.bundler?.plugins || []
+    }
+  };
+};
+
+// lib/commands/build/modules/core/core.ts
+import fsPromises3 from "fs/promises";
+
+// lib/commands/build/modules/core/bundler-execute/index.ts
+import {
+  createAzionESBuildConfig,
+  executeESBuildBuild,
+  createAzionWebpackConfig,
+  executeWebpackBuild
+} from "azion/bundler";
+var createAzionESBuildConfigWrapper = (buildConfig, ctx) => {
+  return createAzionESBuildConfig(buildConfig, ctx);
+};
+var createAzionWebpackConfigWrapper = (buildConfig, ctx) => {
+  return createAzionWebpackConfig(buildConfig, ctx);
+};
+var executeESBuildBuildWrapper = async (esbuildConfig) => {
+  return executeESBuildBuild(esbuildConfig);
+};
+var executeWebpackBuildWrapper = async (webpackConfig) => {
+  return executeWebpackBuild(webpackConfig);
+};
+var bundler_execute_default = {
+  createAzionESBuildConfigWrapper,
+  createAzionWebpackConfigWrapper,
+  executeESBuildBuildWrapper,
+  executeWebpackBuildWrapper
+};
+
+// lib/commands/build/modules/core/utils.ts
+var moveImportsToTopLevel = (code) => {
+  const importRegex = /import\s+.*?from\s*['"](.*?)['"];?/g;
+  const requireRegex = /(const\s+.*?=\s*require\(.*\).*);/g;
+  const importsList = (code.match(importRegex) || []).map(
+    (match) => match.trim()
+  );
+  const requiresList = (code.match(requireRegex) || []).map(
+    (match) => match.trim()
+  );
+  let newCode = code.replace(importRegex, "").replace(requireRegex, "").replace(/\n\s*\n\s*\n/g, "\n\n");
+  if (importsList.length || requiresList.length) {
+    newCode = `${[...importsList, ...requiresList].join("\n")}
+
+${newCode.trim()}`;
+  }
+  return newCode;
+};
+
+// lib/commands/build/modules/core/core.ts
+import fs5 from "fs";
+var injectHybridFsPolyfill = (code, buildConfig, ctx) => {
+  if (buildConfig.polyfills && ctx.production) {
+    return `import SRC_NODE_FS from "node:fs";
+${code}`;
+  }
+  return code;
+};
+var executeBuild = async ({
+  buildConfig,
+  prebuildResult,
+  ctx
+}) => {
+  try {
+    if (prebuildResult.filesToInject.length > 0) {
+      const entryContent = await fsPromises3.readFile(
+        buildConfig.entry,
+        "utf-8"
+      );
+      const filesContent = prebuildResult.filesToInject.reduce(
+        (accumulator, filePath) => `${accumulator} ${fs5.readFileSync(filePath, "utf-8")}`,
+        " "
+      );
+      const contentWithInjection = `${filesContent} ${entryContent}`;
+      const contentWithTopLevelImports = moveImportsToTopLevel(contentWithInjection);
+      await fsPromises3.writeFile(buildConfig.entry, contentWithTopLevelImports);
+    }
+    const bundlerConfig = {
+      ...buildConfig,
+      preset: buildConfig.preset,
+      setup: {
+        contentToInject: prebuildResult.injection.banner,
+        defineVars: Object.fromEntries(
+          Object.entries(prebuildResult.bundler.defineVars).filter(([_, v]) => v !== void 0).map(([k, v]) => [k, v])
+        )
+      }
+    };
+    const bundler = buildConfig.bundler;
+    switch (bundler) {
+      case "esbuild": {
+        const esbuildConfig = bundler_execute_default.createAzionESBuildConfigWrapper(
+          bundlerConfig,
+          ctx
+        );
+        await bundler_execute_default.executeESBuildBuildWrapper(esbuildConfig);
+        break;
+      }
+      case "webpack": {
+        const webpackConfig = bundler_execute_default.createAzionWebpackConfigWrapper(
+          bundlerConfig,
+          ctx
+        );
+        await bundler_execute_default.executeWebpackBuildWrapper(webpackConfig);
+        break;
+      }
+      default:
+        throw new Error(`Unsupported bundler: ${bundler}`);
+    }
+    let bundledCode = "";
+    if (ctx.production === true) {
+      bundledCode = await fsPromises3.readFile(ctx.output, "utf-8");
+      bundledCode = injectHybridFsPolyfill(bundledCode, buildConfig, ctx);
+      await fsPromises3.writeFile(ctx.output, bundledCode);
+    }
+    return bundledCode;
+  } catch (error) {
+    return Promise.reject(error);
+  }
+};
+
+// lib/commands/build/modules/postbuild/postbuild.ts
+var executePostbuild = async ({
+  buildConfig,
+  ctx
+}) => {
+  const { postbuild } = buildConfig.preset;
+  if (postbuild) {
+    const outputWorker = ctx.production === false ? ctx.output.replace(".js", ".dev.js") : ctx.output;
+    await postbuild(buildConfig, { ...ctx, output: outputWorker });
+  }
+};
+
+// lib/commands/build/modules/environment/utils.ts
+import lodash from "lodash";
+var mergeConfigWithUserOverrides = (baseConfig, userConfig) => {
+  const customizer = (objValue, srcValue) => {
+    if (objValue && !objValue.build) {
+      return srcValue;
+    }
+    return void 0;
+  };
+  return lodash.mergeWith({}, baseConfig, userConfig, customizer);
+};
+var utils_default2 = { mergeConfigWithUserOverrides };
+
+// lib/commands/build/modules/environment/environment.ts
+var setEnvironment = async ({
+  config: userConfig,
+  preset,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  ctx
+}) => {
+  try {
+    const { config: presetConfig } = preset;
+    const mergedConfig = utils_default2.mergeConfigWithUserOverrides(
+      presetConfig,
+      userConfig
+    );
+    if (!mergedConfig.build?.preset) {
+      mergedConfig.build = {
+        ...mergedConfig.build,
+        preset: preset.metadata.name,
+        ...!preset.handler && preset.config.build?.entry && {
+          entry: preset.config.build.entry
+        }
+      };
+    }
+    const hasUserConfig = await env_default.readUserConfig();
+    if (!hasUserConfig) await env_default.writeUserConfig(mergedConfig);
+    const storeConfig = {
+      preset: mergedConfig.build.preset,
+      bundler: mergedConfig.build?.bundler,
+      polyfills: mergedConfig.build?.polyfills,
+      worker: mergedConfig.build?.worker,
+      entry: mergedConfig.build.entry
+    };
+    await env_default.writeStore(storeConfig);
+  } catch (error) {
+    throw new Error(`Failed to set environment: ${error.message}`);
+  }
+};
+
+// lib/commands/build/modules/worker/worker.ts
+import fsPromises4 from "fs/promises";
+import { dirname } from "path";
+
+// lib/commands/build/modules/worker/utils.ts
+var createEventHandlerCode = (entrypoint) => {
+  return `
+import moduleOrFunction from '${entrypoint}';
+
+// Handle the case where import returns a function directly
+const module = typeof moduleOrFunction === 'function' 
+  ? { default: moduleOrFunction } 
+  : moduleOrFunction;
+
+// Check standard handlers first
+const hasFirewallHandler = module.firewall || (module.default && module.default.firewall);
+
+// Detect if the module exports a function directly (legacy)
+const isLegacyDefaultFunction = typeof module.default === 'function';
+
+let eventType = 'fetch';
+let handler;
+
+if (hasFirewallHandler) {
+  eventType = 'firewall';
+  handler = module.firewall || module.default.firewall;
+} else if (isLegacyDefaultFunction) {
+  // Legacy case: function exported directly as default
+  handler = module.default;
+  } else {
+  // Normal case: look for fetch handler
+  handler = module.fetch || (module.default && module.default.fetch);
+}
+
+if (!handler) {
+  throw new Error("Handler not found in module");
+}
+
+addEventListener(eventType, (event) => {
+  if (eventType === 'fetch' && !hasFirewallHandler) {
+    event.respondWith((async function() {
+      try {
+        return handler(event);
+      } catch (error) {
+        return new Response(\`Error: \${error.message}\`, { status: 500 });
+      }
+    })());
+  } 
+  else {
+    (async function() {
+      try {
+        return handler(event);
+      } catch (error) {
+        return new Response(\`Error: \${error.message}\`, { status: 500 });
+      }
+    })();
+  }
+});
+`;
+};
+var utils_default3 = { createEventHandlerCode };
+
+// lib/commands/build/modules/worker/worker.ts
+var setupWorkerCode = async (buildConfig, ctx) => {
+  try {
+    if (buildConfig.worker) {
+      return fsPromises4.readFile(ctx.entrypoint, "utf-8");
+    }
+    const wrapperCode = utils_default3.createEventHandlerCode(ctx.entrypoint);
+    await fsPromises4.mkdir(dirname(ctx.output), { recursive: true });
+    if (ctx.production !== false) {
+      await fsPromises4.writeFile(ctx.output, wrapperCode, "utf-8");
+    }
+    return wrapperCode;
+  } catch (error) {
+    throw new Error(
+      `Failed to setup worker code: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+};
+
+// lib/commands/build/modules/entrypoint/entrypoint.ts
+import * as utilsNode2 from "azion/utils/node";
+import path2 from "path";
+import fsPromises5 from "fs/promises";
+var resolveEntrypoint = async ({
+  ctx,
+  preset
+}) => {
+  if (ctx.entrypoint && !preset.handler) {
+    const entrypointPath = path2.resolve(ctx.entrypoint);
+    try {
+      await fsPromises5.access(entrypointPath);
+      utilsNode2.feedback.build.info(`Using ${ctx.entrypoint} as entry point.`);
+      return ctx.entrypoint;
+    } catch (error) {
+      debug.error(error);
+      throw new Error(
+        `Entry point "${ctx.entrypoint}" was not found. Please verify the path and try again.`
+      );
+    }
+  }
+  if (preset.handler) {
+    const rootPathNodeModules = globalThis.bundler.root.includes("node_modules");
+    const presetPath = rootPathNodeModules ? path2.resolve(globalThis.bundler.root, "../") : path2.resolve(globalThis.bundler.root, "node_modules");
+    const handlerPath = path2.resolve(
+      presetPath,
+      "azion",
+      "packages",
+      "presets",
+      "src",
+      "presets",
+      preset.metadata.name,
+      "handler.ts"
+    );
+    utilsNode2.feedback.build.info(
+      `Using built-in handler from "${preset.metadata.name}" preset.`
+    );
+    return handlerPath;
+  }
+  if (preset.config.build?.entry) {
+    const presetEntry = preset.config.build.entry;
+    utilsNode2.feedback.build.info(`Using preset default entry: ${presetEntry}`);
+    return path2.resolve(presetEntry);
+  }
+  throw new Error(
+    `Cannot determine entry point. Please specify one using --entry or in your configuration.`
+  );
+};
+
+// lib/commands/build/build.ts
+var build = async ({
+  config,
+  ctx
+}) => {
+  try {
+    await checkDependencies();
+    const resolvedPreset = await resolvePreset(config.build?.preset);
+    const buildConfigSetup = setupBuildConfig(config, resolvedPreset);
+    ctx.entrypoint = await resolveEntrypoint({
+      ctx,
+      preset: resolvedPreset
+    });
+    const worker = await setupWorkerCode(buildConfigSetup, ctx);
+    await writeFile(buildConfigSetup.entry, worker);
+    feedback4.build.info("Starting prebuild...");
+    const prebuildResult = await executePrebuild({
+      buildConfig: buildConfigSetup,
+      ctx
+    });
+    feedback4.build.info("Prebuild completed successfully");
+    feedback4.build.info("Starting build...");
+    await executeBuild({
+      buildConfig: buildConfigSetup,
+      prebuildResult,
+      ctx
+    });
+    feedback4.build.success("Build completed successfully");
+    await executePostbuild({ buildConfig: buildConfigSetup, ctx });
+    await setEnvironment({ config, preset: resolvedPreset, ctx });
+    return {
+      config,
+      ctx
+    };
+  } catch (error) {
+    debug.error(error);
+    feedback4.build.error(
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+};
+
+// lib/commands/build/command.ts
+import { resolve } from "path";
+async function buildCommand(options) {
+  const userConfig = await readUserConfig() || {};
+  const { build: userBuildConfig } = userConfig;
+  const bundlerStore = await readStore();
+  const presetInput = resolvePresetPriority({
+    inputValue: options.preset,
+    fileValue: userBuildConfig?.preset,
+    storeValue: bundlerStore.preset,
+    defaultValue: void 0
+  });
+  const buildConfig = {
+    preset: presetInput,
+    entry: resolveConfigPriority({
+      inputValue: options.entry,
+      fileValue: userBuildConfig?.entry,
+      storeValue: bundlerStore?.entry,
+      defaultValue: void 0
+    }),
+    bundler: resolveConfigPriority({
+      inputValue: void 0,
+      fileValue: userBuildConfig?.bundler,
+      storeValue: bundlerStore?.bundler,
+      defaultValue: "esbuild"
+    }),
+    polyfills: resolveConfigPriority({
+      inputValue: userBuildConfig?.polyfills,
+      fileValue: options.polyfills,
+      storeValue: bundlerStore?.polyfills,
+      defaultValue: true
+    }),
+    worker: resolveConfigPriority({
+      inputValue: userBuildConfig?.worker,
+      fileValue: options.worker,
+      storeValue: bundlerStore?.worker,
+      defaultValue: false
+    })
+  };
+  await writeStore(buildConfig);
+  const config = {
+    ...userConfig,
+    build: {
+      ...buildConfig,
+      memoryFS: userConfig?.build?.memoryFS
+    }
+  };
+  return build({
+    config,
+    ctx: {
+      production: options.production ?? true,
+      output: resolve(".edge", "worker.js"),
+      entrypoint: buildConfig.entry ? resolve(buildConfig.entry) : ""
+    }
+  });
+}
+
+// lib/env/server.ts
+import { runServer } from "edge-runtime";
+import fs6 from "fs/promises";
+var currentServer;
+var isChangeHandlerRunning = false;
+var checkAndChangeAddEventListener = (eventTarget, newEvent, code, replaceCode = true) => {
+  let codeChanged = code;
+  const eventRegex = new RegExp(
+    `addEventListener\\((['"]?)${eventTarget}\\1,`,
+    "g"
+  );
+  const firewallFunctionRegex = /firewall:\s*\(event\)\s*=>\s*{/g;
+  const firewallFunction = !!code.match(firewallFunctionRegex);
+  const firewallEventTypeRegex = /eventType\s*=\s*['"]firewall['"];/g;
+  const matchEvent = !!code.match(eventRegex);
+  if (replaceCode && matchEvent || firewallFunction) {
+    codeChanged = code.replace(eventRegex, `addEventListener("${newEvent}",`);
+    if (firewallFunction) {
+      codeChanged = codeChanged.replace(
+        firewallEventTypeRegex,
+        "eventType = 'fetch';"
+      );
+    }
+  }
+  return { matchEvent: matchEvent || firewallFunction, codeChanged };
+};
+function checkPortAvailability(port) {
+  return new Promise((resolve2) => {
+    const client = new net.Socket();
+    client.setTimeout(1e3);
+    client.on("connect", () => {
+      client.destroy();
+      resolve2(true);
+    });
+    client.on("timeout", () => {
+      client.destroy();
+      resolve2(false);
+    });
+    client.on("error", (err) => {
+      client.destroy();
+      if (err.message.includes("ECONNREFUSED")) {
+        resolve2(false);
+      } else {
+        resolve2(true);
+      }
+    });
+    client.connect(port, "127.0.0.1");
+  });
+}
+async function readWorkerFile(filePath) {
+  try {
+    await fs6.access(filePath);
+    return await fs6.readFile(filePath, "utf8");
+  } catch (error) {
+    const errorMessage = error.message.includes("ENOENT") ? "File does not exist." : `An error occurred while reading the ${filePath} file.`;
+    throw new Error(errorMessage);
+  }
+}
+async function initializeServer(port, workerCode) {
+  const { matchEvent: isFirewallEvent, codeChanged } = (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    checkAndChangeAddEventListener("firewall", "fetch", workerCode)
+  );
+  const initialCode = isFirewallEvent ? codeChanged : workerCode;
+  const execution = runtime_default(initialCode, isFirewallEvent);
+  return runServer({ port, host: "0.0.0.0", runtime: execution });
+}
+async function buildToLocalServer() {
+  const vulcanEnv = await bundler_default.readStore("global");
+  if (!vulcanEnv) {
+    const msg = "Run the build command before running your project.";
+    feedback5.server.error(msg);
+    throw new Error(msg);
+  }
+  await buildCommand({ production: false });
+}
+async function manageServer(workerPath, port) {
+  try {
+    if (currentServer) {
+      await currentServer.close();
+    }
+    await buildToLocalServer();
+    const workerCode = await readWorkerFile(workerPath);
+    try {
+      currentServer = await initializeServer(port, workerCode);
+      feedback5.server.success(
+        `Function running on port 0.0.0.0:${port}, url: http://localhost:${port}`
+      );
+    } catch (error) {
+      if (error.message.includes("EADDRINUSE")) {
+        await manageServer(workerPath, port + 1);
+      } else {
+        throw error;
+      }
+    }
+  } catch (error) {
+    feedback5.server.error(error);
+    console.log(error);
+    process.exit(1);
+  } finally {
+    isChangeHandlerRunning = false;
+  }
+}
+async function handleFileChange(path3, workerPath, port) {
+  if (isChangeHandlerRunning) return;
+  if (path3.startsWith(".azion-bundler") || path3.startsWith("azion") && path3.includes(".temp") || path3.startsWith(".edge") || path3.startsWith("node_modules") || path3.startsWith(".vercel")) {
+    return;
+  }
+  isChangeHandlerRunning = true;
+  try {
+    feedback5.build.info("Rebuilding with the new changes...");
+    await manageServer(workerPath, port);
+  } catch (error) {
+    debug.error(`Build or server restart failed: ${error}`);
+  } finally {
+    isChangeHandlerRunning = false;
+  }
+}
+async function startServer(workerPath, port) {
+  const IsPortInUse = await checkPortAvailability(port);
+  if (IsPortInUse) {
+    feedback5.server.error(
+      `Port ${port} is in use. Please choose another port.`
+    );
+    process.exit(1);
+  }
+  await manageServer(workerPath, port);
+  const watcher = chokidar.watch("./", {
+    persistent: true,
+    ignoreInitial: true,
+    // Ignore the initial add events
+    depth: 99,
+    ignored: [".git", ".vscode", ".idea", ".sublime-text", ".history"]
+    // Added common IDE-related folders
+  });
+  const handleUserFileChange = async (path3) => {
+    await handleFileChange(path3, workerPath, port);
+  };
+  watcher.on("add", handleUserFileChange).on("change", handleUserFileChange).on("unlink", handleUserFileChange).on("addDir", handleUserFileChange).on("unlinkDir", handleUserFileChange).on("error", (error) => debug.error(`Watcher error: ${error}`)).on(
+    "ready",
+    () => feedback5.server.info("Initial scan complete. Ready for changes.")
+  );
+}
+var server_default = startServer;
+
+// lib/env/index.ts
+var env_default = {
+  runtime: runtime_default,
+  server: server_default,
+  readStore,
+  readUserConfig,
+  writeStore,
+  writeUserConfig
+};
+
+export {
+  runtime_default,
+  writeStore,
+  readStore,
+  readUserConfig,
+  writeUserConfig,
+  bundler_default,
+  server_default,
+  env_default,
+  buildCommand
+};