@gigadrive/network-config 2.1.2 → 3.0.0

package/dist/index.mjs

@@ -1,28 +1,908 @@
-// src/find-config.ts
-import fs from "fs";
-import path from "path";
-var ALLOWED_CONFIG_NAMES = ["gigadrive.yaml", "gigadrive.yml", "nebula.yaml", "nebula.yml", "nebula.json"];
-var findConfig = (projectFolder) => {
-  for (const name of ALLOWED_CONFIG_NAMES) {
-    const filePath = path.join(projectFolder, name);
-    if (fs.existsSync(filePath)) {
-      return filePath;
+// src/detection/detect-framework.ts
+import { FileSystem as FileSystem3, Path as Path3 } from "@effect/platform";
+import { Effect as Effect4 } from "effect";
+
+// src/detection/detect-package-manager.ts
+import { FileSystem, Path } from "@effect/platform";
+import { Effect } from "effect";
+var LOCKFILE_MAP = [
+  { files: ["bun.lockb", "bun.lock"], pm: "bun" },
+  { files: ["pnpm-lock.yaml"], pm: "pnpm" },
+  { files: ["yarn.lock"], pm: "yarn" },
+  { files: ["package-lock.json"], pm: "npm" },
+  { files: ["composer.lock"], pm: "composer" }
+];
+var detectPackageManager = Effect.fn("detectPackageManager")(function* (projectFolder) {
+  const fs = yield* FileSystem.FileSystem;
+  const pathService = yield* Path.Path;
+  for (const { files, pm } of LOCKFILE_MAP) {
+    for (const file of files) {
+      const exists = yield* fs.exists(pathService.join(projectFolder, file)).pipe(Effect.catchAll(() => Effect.succeed(false)));
+      if (exists) {
+        yield* Effect.logDebug(`Detected package manager: ${pm} (via ${file})`);
+        return pm;
+      }
+    }
+  }
+  yield* Effect.logDebug("No lockfile found, defaulting to npm");
+  return "npm";
+});
+
+// src/detection/frameworks/astro.ts
+var astro = {
+  slug: "astro",
+  name: "Astro",
+  language: "node",
+  detectors: [{ matchPackage: "astro" }],
+  priority: 85,
+  getDefaultConfig: () => ({
+    runtime: "node-22",
+    memory: 256,
+    maxDuration: 30,
+    streaming: true,
+    commands: ["astro build"],
+    entrypoint: "dist/server/entry.mjs",
+    assetsDir: "dist/client",
+    populateAssetCache: true,
+    routes: [{ source: "/*", destination: "dist/server/entry.mjs" }],
+    environmentVariables: { NODE_ENV: "production" }
+  })
+};
+
+// src/detection/frameworks/elysia.ts
+var elysia = {
+  slug: "elysia",
+  name: "Elysia",
+  language: "node",
+  detectors: [{ matchPackage: "elysia" }],
+  priority: 45,
+  getDefaultConfig: () => ({
+    runtime: "bun-1",
+    memory: 128,
+    maxDuration: 30,
+    streaming: true,
+    commands: [],
+    entrypoint: "src/index.ts",
+    routes: [{ source: "/*", destination: "src/index.ts" }],
+    environmentVariables: { NODE_ENV: "production" }
+  })
+};
+
+// src/detection/frameworks/express.ts
+var express = {
+  slug: "express",
+  name: "Express",
+  language: "node",
+  detectors: [{ matchPackage: "express" }],
+  priority: 10,
+  getDefaultConfig: () => ({
+    runtime: "node-22",
+    memory: 128,
+    maxDuration: 30,
+    streaming: true,
+    commands: [],
+    entrypoint: "index.js",
+    routes: [{ source: "/*", destination: "index.js" }],
+    environmentVariables: { NODE_ENV: "production" }
+  })
+};
+
+// src/detection/frameworks/fastify.ts
+var fastify = {
+  slug: "fastify",
+  name: "Fastify",
+  language: "node",
+  detectors: [{ matchPackage: "fastify" }],
+  priority: 40,
+  getDefaultConfig: () => ({
+    runtime: "node-22",
+    memory: 128,
+    maxDuration: 30,
+    streaming: true,
+    commands: [],
+    entrypoint: "src/index.ts",
+    routes: [{ source: "/*", destination: "src/index.ts" }],
+    environmentVariables: { NODE_ENV: "production" }
+  })
+};
+
+// src/detection/frameworks/hono.ts
+var hono = {
+  slug: "hono",
+  name: "Hono",
+  language: "node",
+  detectors: [{ matchPackage: "hono" }],
+  priority: 50,
+  getDefaultConfig: () => ({
+    runtime: "node-22",
+    memory: 128,
+    maxDuration: 30,
+    streaming: true,
+    commands: [],
+    entrypoint: "src/index.ts",
+    routes: [{ source: "/*", destination: "src/index.ts" }],
+    environmentVariables: { NODE_ENV: "production" }
+  })
+};
+
+// src/detection/frameworks/laravel.ts
+var laravel = {
+  slug: "laravel",
+  name: "Laravel",
+  language: "php",
+  detectors: [{ matchPackage: "laravel/framework" }, { path: "artisan" }],
+  priority: 80,
+  getDefaultConfig: () => ({
+    runtime: "php-84",
+    memory: 256,
+    maxDuration: 30,
+    streaming: false,
+    commands: ["composer require bref/laravel-bridge --update-with-dependencies", "bun install", "bun run build"],
+    entrypoint: "public/index.php",
+    assetsDir: "public",
+    populateAssetCache: true,
+    excludeFiles: ["tests/", "storage/", ".ddev", "node_modules/"],
+    routes: [{ source: "/*", destination: "public/index.php" }],
+    environmentVariables: {
+      APP_NAME: "Laravel",
+      APP_ENV: "production",
+      APP_DEBUG: "false",
+      LOG_CHANNEL: "stderr",
+      LOG_DEPRECATIONS_CHANNEL: "stderr",
+      LOG_LEVEL: "debug",
+      BROADCAST_DRIVER: "log",
+      SESSION_DRIVER: "cookie"
+    }
+  })
+};
+
+// src/detection/frameworks/nestjs.ts
+var nestjs = {
+  slug: "nestjs",
+  name: "NestJS",
+  language: "node",
+  detectors: [{ matchPackage: "@nestjs/core" }],
+  priority: 90,
+  getDefaultConfig: () => ({
+    runtime: "node-22",
+    memory: 256,
+    maxDuration: 30,
+    streaming: true,
+    commands: ["nest build"],
+    entrypoint: "dist/main.js",
+    routes: [{ source: "/*", destination: "dist/main.js" }],
+    environmentVariables: { NODE_ENV: "production" }
+  })
+};
+
+// src/detection/frameworks/nextjs.ts
+var nextjs = {
+  slug: "nextjs",
+  name: "Next.js",
+  language: "node",
+  detectors: [{ matchPackage: "next" }],
+  priority: 100,
+  getDefaultConfig: () => ({
+    runtime: "node-22",
+    memory: 256,
+    maxDuration: 30,
+    streaming: true,
+    commands: ["next build"],
+    entrypoint: ".next/standalone/server.js",
+    assetsDir: ".next/static",
+    populateAssetCache: true,
+    routes: [{ source: "/*", destination: ".next/standalone/server.js" }],
+    environmentVariables: { NODE_ENV: "production" }
+  })
+};
+
+// src/detection/frameworks/nuxt.ts
+var nuxt = {
+  slug: "nuxt",
+  name: "Nuxt",
+  language: "node",
+  detectors: [{ matchPackage: "nuxt" }],
+  priority: 95,
+  getDefaultConfig: () => ({
+    runtime: "node-22",
+    memory: 256,
+    maxDuration: 30,
+    streaming: true,
+    commands: ["nuxt build"],
+    entrypoint: ".output/server/index.mjs",
+    assetsDir: ".output/public",
+    populateAssetCache: true,
+    routes: [{ source: "/*", destination: ".output/server/index.mjs" }],
+    environmentVariables: { NODE_ENV: "production", NITRO_PRESET: "node-server" }
+  })
+};
+
+// src/detection/frameworks/remix.ts
+var remix = {
+  slug: "remix",
+  name: "Remix",
+  language: "node",
+  detectors: [{ matchPackage: "@remix-run/dev" }],
+  priority: 90,
+  getDefaultConfig: () => ({
+    runtime: "node-22",
+    memory: 256,
+    maxDuration: 30,
+    streaming: true,
+    commands: ["remix build"],
+    entrypoint: "build/server/index.js",
+    assetsDir: "build/client",
+    populateAssetCache: true,
+    routes: [{ source: "/*", destination: "build/server/index.js" }],
+    environmentVariables: { NODE_ENV: "production" }
+  })
+};
+
+// src/detection/frameworks/sveltekit.ts
+var sveltekit = {
+  slug: "sveltekit",
+  name: "SvelteKit",
+  language: "node",
+  detectors: [{ matchPackage: "@sveltejs/kit" }],
+  priority: 90,
+  getDefaultConfig: () => ({
+    runtime: "node-22",
+    memory: 256,
+    maxDuration: 30,
+    streaming: true,
+    commands: ["vite build"],
+    entrypoint: "build/index.js",
+    assetsDir: "build/client",
+    populateAssetCache: true,
+    routes: [{ source: "/*", destination: "build/index.js" }],
+    environmentVariables: { NODE_ENV: "production" }
+  })
+};
+
+// src/detection/frameworks/symfony.ts
+var symfony = {
+  slug: "symfony",
+  name: "Symfony",
+  language: "php",
+  detectors: [{ matchPackage: "symfony/framework-bundle" }, { path: "bin/console" }],
+  priority: 80,
+  getDefaultConfig: () => ({
+    runtime: "php-84",
+    memory: 512,
+    maxDuration: 30,
+    streaming: false,
+    installCommand: "composer install --prefer-dist --optimize-autoloader --no-dev",
+    commands: ["bun install", "bun run build"],
+    entrypoint: "public/index.php",
+    assetsDir: "public",
+    populateAssetCache: true,
+    excludeFiles: ["tests/*", ".ddev", "var"],
+    symlinks: { var: "/tmp" },
+    routes: [{ source: "/*", destination: "public/index.php" }],
+    environmentVariables: {
+      APP_ENV: "prod",
+      APP_DEBUG: "false",
+      APP_SECRET: "please_change_this_value_in_your_settings",
+      MESSENGER_TRANSPORT_DSN: "doctrine://default?auto_setup=0"
+    }
+  })
+};
+
+// src/detection/frameworks/vite.ts
+var vite = {
+  slug: "vite",
+  name: "Vite",
+  language: "node",
+  detectors: [{ matchPackage: "vite" }],
+  priority: 5,
+  getDefaultConfig: () => ({
+    runtime: "node-22",
+    memory: 128,
+    maxDuration: 30,
+    streaming: false,
+    commands: ["vite build"],
+    assetsDir: "dist",
+    populateAssetCache: true,
+    routes: [],
+    environmentVariables: { NODE_ENV: "production" }
+  })
+};
+
+// src/detection/frameworks/index.ts
+var FRAMEWORK_DEFINITIONS = [
+  nextjs,
+  nuxt,
+  nestjs,
+  remix,
+  sveltekit,
+  astro,
+  laravel,
+  symfony,
+  hono,
+  elysia,
+  fastify,
+  express,
+  vite
+].sort((a, b) => b.priority - a.priority);
+
+// src/detection/generate-config.ts
+import { Effect as Effect2 } from "effect";
+
+// src/regions.ts
+var REGION_DEFINITIONS = [
+  "us-east-1",
+  "us-east-2",
+  "us-west-1",
+  "us-west-2",
+  "ap-south-1",
+  "ap-northeast-3",
+  "ap-northeast-2",
+  "ap-southeast-1",
+  "ap-southeast-2",
+  "ap-northeast-1",
+  "ca-central-1",
+  "eu-central-1",
+  "eu-west-1",
+  "eu-west-2",
+  "eu-west-3",
+  "eu-north-1",
+  "sa-east-1"
+];
+var AVAILABLE_REGIONS = [...REGION_DEFINITIONS];
+
+// src/detection/generate-config.ts
+var getInstallCommand = (pm) => {
+  switch (pm) {
+    case "bun":
+      return "bun install";
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn install";
+    case "composer":
+      return "composer install";
+    case "npm":
+    default:
+      return "npm install";
+  }
+};
+var generateConfig = Effect2.fn("generateConfig")(function* (framework, packageManager) {
+  const defaults = framework.getDefaultConfig(packageManager);
+  const installCmd = defaults.installCommand ?? getInstallCommand(packageManager);
+  const commands = [installCmd, ...defaults.commands];
+  yield* Effect2.logDebug(`Generating config for ${framework.name}`, {
+    runtime: defaults.runtime,
+    entrypoint: defaults.entrypoint,
+    commands
+  });
+  const entrypoints = defaults.entrypoint ? [
+    {
+      path: defaults.entrypoint,
+      runtime: defaults.runtime,
+      memory: defaults.memory,
+      maxDuration: defaults.maxDuration,
+      streaming: defaults.streaming,
+      symlinks: defaults.symlinks
+    }
+  ] : [];
+  const routes = defaults.entrypoint ? defaults.routes.map((route) => ({
+    path: route.source,
+    destination: route.destination,
+    handler: defaults.streaming ? "SERVERLESS_FUNCTION_STREAMING" : "SERVERLESS_FUNCTION",
+    methods: ["ANY"],
+    headers: {}
+  })) : [];
+  const config = {
+    regions: [...AVAILABLE_REGIONS],
+    environmentVariables: { ...defaults.environmentVariables },
+    commands,
+    entrypoints,
+    routes,
+    excludeFiles: defaults.excludeFiles && defaults.excludeFiles.length > 0 ? [...defaults.excludeFiles] : void 0,
+    warnings: [`Auto-detected framework: ${framework.name}. Create a gigadrive.yaml to customize.`],
+    errors: []
+  };
+  if (defaults.assetsDir) {
+    config.assets = {
+      paths: [],
+      prefixToStrip: defaults.assetsDir + "/",
+      dynamicRoutes: true,
+      populateCache: defaults.populateAssetCache ?? false
+    };
+  }
+  return config;
+});
+
+// src/detection/read-dependencies.ts
+import { FileSystem as FileSystem2, Path as Path2 } from "@effect/platform";
+import { Effect as Effect3 } from "effect";
+
+// src/detection/types.ts
+import { Schema } from "effect";
+var ManifestNotFoundError = class extends Schema.TaggedError()("ManifestNotFoundError", {
+  message: Schema.String,
+  filePath: Schema.String
+}) {
+};
+var ManifestReadError = class extends Schema.TaggedError()("ManifestReadError", {
+  message: Schema.String,
+  filePath: Schema.String
+}) {
+};
+var ManifestParseError = class extends Schema.TaggedError()("ManifestParseError", {
+  message: Schema.String,
+  filePath: Schema.String
+}) {
+};
+var FrameworkNotDetectedError = class extends Schema.TaggedError()(
+  "FrameworkNotDetectedError",
+  {
+    message: Schema.String,
+    directory: Schema.String
+  }
+) {
+};
+
+// src/detection/read-dependencies.ts
+var MANIFEST_CONFIG = {
+  node: { file: "package.json", depKeys: ["dependencies", "devDependencies"] },
+  php: { file: "composer.json", depKeys: ["require", "require-dev"] }
+};
+var readManifest = Effect3.fn("readManifest")(function* (filePath) {
+  const fs = yield* FileSystem2.FileSystem;
+  const exists = yield* fs.exists(filePath).pipe(Effect3.catchAll(() => Effect3.succeed(false)));
+  if (!exists) {
+    return yield* Effect3.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
+  }
+  const content = yield* fs.readFileString(filePath).pipe(Effect3.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
+  const parsed = yield* Effect3.try({
+    try: () => JSON.parse(content),
+    catch: () => new ManifestParseError({ message: "Failed to parse manifest JSON", filePath })
+  });
+  return parsed;
+});
+var readDependencies = Effect3.fn("readDependencies")(function* (projectFolder, language) {
+  const pathService = yield* Path2.Path;
+  const config = MANIFEST_CONFIG[language];
+  const filePath = pathService.join(projectFolder, config.file);
+  const manifest = yield* readManifest(filePath).pipe(
+    Effect3.catchTag("ManifestNotFoundError", () => Effect3.succeed(null))
+  );
+  if (!manifest) {
+    return /* @__PURE__ */ new Set();
+  }
+  const deps = /* @__PURE__ */ new Set();
+  for (const key of config.depKeys) {
+    const section = manifest[key];
+    if (section && typeof section === "object" && !Array.isArray(section)) {
+      for (const name of Object.keys(section)) {
+        deps.add(name);
+      }
+    }
+  }
+  return deps;
+});
+
+// src/detection/detect-framework.ts
+var matchesDetectionItem = Effect4.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
+  const fs = yield* FileSystem3.FileSystem;
+  const pathService = yield* Path3.Path;
+  if (item.matchPackage != null) {
+    const deps = yield* cachedReadDeps(`${projectFolder}\0${framework.language}`);
+    if (!deps.has(item.matchPackage)) {
+      return false;
+    }
+  }
+  if (item.path != null) {
+    const filePath = pathService.join(projectFolder, item.path);
+    const exists = yield* fs.exists(filePath).pipe(Effect4.catchAll(() => Effect4.succeed(false)));
+    if (!exists) {
+      return false;
     }
+    if (item.matchContent != null) {
+      const content = yield* fs.readFileString(filePath).pipe(Effect4.catchAll(() => Effect4.succeed("")));
+      let regexMatch = false;
+      try {
+        regexMatch = new RegExp(item.matchContent).test(content);
+      } catch {
+      }
+      if (!regexMatch) {
+        return false;
+      }
+    }
+  }
+  return true;
+});
+var matchesFramework = Effect4.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
+  for (const detector of framework.detectors) {
+    const matches = yield* matchesDetectionItem(detector, projectFolder, framework, cachedReadDeps);
+    if (!matches) {
+      return false;
+    }
+  }
+  return true;
+});
+var detectFramework = Effect4.fn("detectFramework")(function* (projectFolder) {
+  yield* Effect4.logDebug(`Detecting framework in ${projectFolder}`);
+  const cachedReadDeps = yield* Effect4.cachedFunction((key) => {
+    const sepIndex = key.lastIndexOf("\0");
+    const folder = key.slice(0, sepIndex);
+    const language = key.slice(sepIndex + 1);
+    return readDependencies(folder, language);
+  });
+  for (const framework of FRAMEWORK_DEFINITIONS) {
+    const matches = yield* matchesFramework(framework, projectFolder, cachedReadDeps);
+    if (matches) {
+      yield* Effect4.log(`Detected framework: ${framework.name}`, { slug: framework.slug });
+      const packageManager = yield* detectPackageManager(projectFolder);
+      const config = yield* generateConfig(framework, packageManager);
+      return { framework, packageManager, config };
+    }
+  }
+  return yield* Effect4.fail(
+    new FrameworkNotDetectedError({
+      message: `No framework detected in project directory`,
+      directory: projectFolder
+    })
+  );
+});
+
+// src/detection/merge-config.ts
+import { Effect as Effect5 } from "effect";
+var mergeWithFrameworkDefaults = Effect5.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
+  yield* Effect5.logDebug("Merging user config with framework defaults");
+  const merged = {
+    regions: userConfig.regions,
+    commands: userConfig.commands.length > 0 ? userConfig.commands : frameworkConfig.commands,
+    entrypoints: userConfig.entrypoints.length > 0 ? userConfig.entrypoints : frameworkConfig.entrypoints,
+    routes: userConfig.routes.length > 0 ? userConfig.routes : frameworkConfig.routes,
+    assets: userConfig.assets?.paths && userConfig.assets.paths.length > 0 ? userConfig.assets : frameworkConfig.assets,
+    environmentVariables: {
+      ...frameworkConfig.environmentVariables,
+      ...userConfig.environmentVariables
+    },
+    excludeFiles: userConfig.excludeFiles && userConfig.excludeFiles.length > 0 ? userConfig.excludeFiles : frameworkConfig.excludeFiles,
+    services: userConfig.services,
+    userArchive: userConfig.userArchive,
+    warnings: [...frameworkConfig.warnings, ...userConfig.warnings],
+    errors: [...frameworkConfig.errors, ...userConfig.errors]
+  };
+  return merged;
+});
+
+// src/errors.ts
+import { Schema as Schema2 } from "effect";
+var ConfigFileNotFoundError = class extends Schema2.TaggedError()("ConfigFileNotFoundError", {
+  message: Schema2.String,
+  filePath: Schema2.String
+}) {
+};
+var ConfigFileEmptyError = class extends Schema2.TaggedError()("ConfigFileEmptyError", {
+  message: Schema2.String,
+  filePath: Schema2.String
+}) {
+};
+var ConfigFileParseError = class extends Schema2.TaggedError()("ConfigFileParseError", {
+  message: Schema2.String,
+  filePath: Schema2.String,
+  cause: Schema2.optional(Schema2.String)
+}) {
+};
+var ConfigVersionError = class extends Schema2.TaggedError()("ConfigVersionError", {
+  message: Schema2.String,
+  filePath: Schema2.String,
+  version: Schema2.optional(Schema2.Number)
+}) {
+};
+var ConfigSchemaValidationError = class extends Schema2.TaggedError()(
+  "ConfigSchemaValidationError",
+  {
+    message: Schema2.String,
+    filePath: Schema2.String,
+    validationErrors: Schema2.Array(Schema2.String)
   }
-  return null;
+) {
+};
+var FunctionConfigError = class extends Schema2.TaggedError()("FunctionConfigError", {
+  message: Schema2.String,
+  functionPath: Schema2.String
+}) {
+};
+
+// src/filter-functions-from-assets.ts
+var filterFunctionsFromAssets = (config) => {
+  return {
+    ...config,
+    assets: {
+      ...config.assets,
+      paths: config.assets?.paths?.filter((path2) => !config.entrypoints.some((entrypoint) => entrypoint.path === path2))
+    }
+  };
 };
 
 // src/parse-config.ts
+import { Effect as Effect11 } from "effect";
+
+// src/services/raw-config-reader.ts
+import { FileSystem as FileSystem4, Path as Path4 } from "@effect/platform";
+import { Effect as Effect6 } from "effect";
+import { parse as parseYaml } from "yaml";
+var ALLOWED_CONFIG_NAMES = [
+  "gigadrive.yaml",
+  "gigadrive.yml",
+  "nebula.yaml",
+  "nebula.yml",
+  "nebula.json"
+];
+var RawConfigReader = class extends Effect6.Service()("RawConfigReader", {
+  effect: Effect6.gen(function* () {
+    const fs = yield* FileSystem4.FileSystem;
+    const pathService = yield* Path4.Path;
+    const findConfig = Effect6.fn("RawConfigReader.findConfig")(function* (projectFolder) {
+      for (const name of ALLOWED_CONFIG_NAMES) {
+        const filePath = pathService.join(projectFolder, name);
+        const exists = yield* fs.exists(filePath).pipe(Effect6.catchAll(() => Effect6.succeed(false)));
+        if (exists) {
+          return filePath;
+        }
+      }
+      return null;
+    });
+    const readRawConfig = Effect6.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
+      const exists = yield* fs.exists(filePath).pipe(Effect6.catchAll(() => Effect6.succeed(false)));
+      if (!exists) {
+        return yield* Effect6.fail(
+          new ConfigFileNotFoundError({ message: `Config file not found at ${filePath}`, filePath })
+        );
+      }
+      const fileContents = yield* fs.readFileString(filePath).pipe(
+        Effect6.mapError(
+          () => new ConfigFileParseError({ message: `Failed to read config file at ${filePath}`, filePath })
+        )
+      );
+      if (fileContents.length === 0) {
+        return yield* Effect6.fail(
+          new ConfigFileEmptyError({ message: `Config file is empty at ${filePath}`, filePath })
+        );
+      }
+      const fileExtension = pathService.extname(filePath).toLowerCase();
+      let parsed;
+      try {
+        if (fileExtension === ".json") {
+          parsed = JSON.parse(fileContents);
+        } else if ([".yml", ".yaml"].includes(fileExtension)) {
+          parsed = parseYaml(fileContents);
+        } else {
+          parsed = parseYaml(fileContents);
+        }
+      } catch (error) {
+        return yield* Effect6.fail(
+          new ConfigFileParseError({
+            message: `Failed to parse config file at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
+            filePath,
+            cause: error instanceof Error ? error.message : void 0
+          })
+        );
+      }
+      if (parsed == null) {
+        return yield* Effect6.fail(
+          new ConfigFileParseError({ message: `Config file could not be parsed at ${filePath}`, filePath })
+        );
+      }
+      if (!options?.disableVersionCheck && typeof parsed.version !== "number") {
+        return yield* Effect6.fail(
+          new ConfigVersionError({ message: `Config file is missing version at ${filePath}`, filePath })
+        );
+      }
+      return parsed;
+    });
+    const readConfigFile = (configFilePath) => readRawConfig(configFilePath, { disableVersionCheck: true }).pipe(
+      Effect6.map((parsed) => parsed),
+      Effect6.catchTag("ConfigFileNotFoundError", () => Effect6.succeed(null)),
+      Effect6.withSpan("RawConfigReader.readConfigFile")
+    );
+    return { findConfig, readRawConfig, readConfigFile };
+  })
+}) {
+};
+
+// src/services/schema-validator.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
+import { Effect as Effect7 } from "effect";
+var SchemaValidator = class extends Effect7.Service()("SchemaValidator", {
+  effect: Effect7.gen(function* () {
+    const ajv = new Ajv();
+    addFormats(ajv);
+    const validate = Effect7.fn("SchemaValidator.validate")(function* (config, schema, filePath) {
+      const compiledValidate = ajv.compile(schema);
+      const valid = compiledValidate(config);
+      if (!valid) {
+        const errors = compiledValidate.errors?.map((e) => `${e.instancePath || "/"} ${e.message ?? ""}`.trim()) ?? [];
+        return yield* Effect7.fail(
+          new ConfigSchemaValidationError({
+            message: `Config file at ${filePath} is invalid: ${ajv.errorsText(compiledValidate.errors)}`,
+            filePath,
+            validationErrors: errors
+          })
+        );
+      }
+    });
+    return { validate };
+  })
+}) {
+};
 
-// src/build-output-v3/parse.ts
+// src/services/v4-config-parser.ts
+import { FileSystem as FileSystem5, Path as Path5 } from "@effect/platform";
 import { getFilesForPattern } from "@gigadrive/build-utils";
+import { Effect as Effect8 } from "effect";
+import { minimatch } from "minimatch";
+import safeRegex from "safe-regex2";
+var MAX_ASSET_DEPTH = 100;
+var DISALLOWED_ASSET_EXTENSIONS = [".htaccess", ".htpasswd"];
+var DEFAULT_FUNCTION_SETTINGS = {
+  memory: 128,
+  max_duration: 30,
+  schedule: void 0,
+  symlinks: void 0,
+  excludeFiles: void 0,
+  includeFiles: void 0
+};
+var matchesPattern = (path2, pattern) => {
+  if (minimatch(path2, pattern)) return true;
+  try {
+    if (safeRegex(pattern)) {
+      return new RegExp(pattern).test(path2);
+    }
+  } catch {
+  }
+  return false;
+};
+var getFunctionSettings = (path2, config) => {
+  let settings;
+  for (const [pattern, value] of Object.entries(config.functions ?? {})) {
+    if (!matchesPattern(path2, pattern)) continue;
+    settings = { ...DEFAULT_FUNCTION_SETTINGS, ...settings, ...value };
+  }
+  return settings;
+};
+var resolveRouteHandler = (destination, redirect) => {
+  const isExternal = destination.toLowerCase().startsWith("http://") || destination.toLowerCase().startsWith("https://");
+  if (redirect === true) return "HTTP_REDIRECT";
+  return isExternal ? "HTTP_PROXY" : "SERVERLESS_FUNCTION";
+};
+var isRegion = (r) => AVAILABLE_REGIONS.includes(r);
+var resolveRegions = (configRegions) => {
+  if (configRegions?.includes("global") === true) return AVAILABLE_REGIONS;
+  const valid = configRegions?.filter(isRegion);
+  return valid && valid.length > 0 ? valid : AVAILABLE_REGIONS;
+};
+var mapRoute = (route) => ({
+  path: route.source,
+  destination: route.destination,
+  handler: resolveRouteHandler(route.destination, route.redirect),
+  headers: route.headers ?? {},
+  methods: route.methods ?? ["ANY"],
+  positiveRequirements: route.has,
+  negativeRequirements: route.missing,
+  status: route.statusCode
+});
+var parseEntrypoints = Effect8.fn("parseEntrypoints")(function* (config, projectFolder) {
+  const entrypoints = [];
+  if (config.functions == null) return entrypoints;
+  for (const [fnPath, func] of Object.entries(config.functions)) {
+    const settings = getFunctionSettings(fnPath, config);
+    if (settings == null) {
+      yield* new FunctionConfigError({
+        message: `Settings invalid for function at path '${fnPath}'`,
+        functionPath: fnPath
+      });
+    }
+    const matchedFiles = yield* Effect8.tryPromise({
+      try: () => getFilesForPattern(fnPath, projectFolder, func.excludeFiles),
+      catch: (error) => new FunctionConfigError({
+        message: `Failed to resolve files for function pattern '${fnPath}': ${error instanceof Error ? error.message : String(error)}`,
+        functionPath: fnPath
+      })
+    });
+    for (const file of matchedFiles) {
+      if (entrypoints.some((ep) => ep.path === file)) continue;
+      if (Object.keys(config.functions).some((f) => f === file && f !== fnPath)) continue;
+      entrypoints.push({
+        path: file,
+        runtime: settings.runtime ?? "node-20",
+        memory: settings.memory ?? 128,
+        maxDuration: settings.max_duration ?? 30,
+        schedule: func.schedule,
+        symlinks: func.symlinks,
+        streaming: settings.runtime == null || settings.runtime.startsWith("node-") || settings.runtime.startsWith("bun-")
+      });
+    }
+  }
+  return entrypoints;
+});
+var collectAssets = Effect8.fn("collectAssets")(function* (config, projectFolder) {
+  if (config.assets == null) return [];
+  const fs = yield* FileSystem5.FileSystem;
+  const pathService = yield* Path5.Path;
+  const assetsPath = pathService.join(projectFolder, config.assets);
+  const assetsExist = yield* fs.exists(assetsPath).pipe(Effect8.catchAll(() => Effect8.succeed(false)));
+  if (!assetsExist) return [];
+  const stat = yield* fs.stat(assetsPath).pipe(Effect8.catchAll(() => Effect8.succeed(null)));
+  if (!stat || stat.type !== "Directory") return [];
+  const allFiles = yield* collectFilesRecursively(assetsPath);
+  const assets = [];
+  for (const assetName of allFiles) {
+    if (DISALLOWED_ASSET_EXTENSIONS.some((ext) => assetName.toLowerCase().endsWith(ext.toLowerCase()))) continue;
+    if (getFunctionSettings(`${config.assets}/${assetName}`, config) != null) continue;
+    assets.push(`${config.assets}/${assetName}`);
+  }
+  return assets;
+});
+var collectFilesRecursively = Effect8.fn("collectFilesRecursively")(
+  function* (basePath, relativePath = "", depth = 0) {
+    if (depth > MAX_ASSET_DEPTH) return [];
+    const fs = yield* FileSystem5.FileSystem;
+    const pathSvc = yield* Path5.Path;
+    const currentPath = relativePath ? pathSvc.join(basePath, relativePath) : basePath;
+    const entries = yield* fs.readDirectory(currentPath).pipe(Effect8.catchAll(() => Effect8.succeed([])));
+    const result = [];
+    for (const name of entries) {
+      const fullPath = pathSvc.join(currentPath, name);
+      const entryRelative = relativePath ? pathSvc.join(relativePath, name) : name;
+      const stat = yield* fs.stat(fullPath).pipe(Effect8.catchAll(() => Effect8.succeed(null)));
+      if (!stat) continue;
+      if (stat.type === "Directory") {
+        const nested = yield* collectFilesRecursively(basePath, entryRelative, depth + 1);
+        result.push(...nested);
+      } else {
+        result.push(entryRelative);
+      }
+    }
+    return result;
+  }
+);
+var V4ConfigParser = class extends Effect8.Service()("V4ConfigParser", {
+  accessors: true,
+  effect: Effect8.succeed({
+    /**
+     * Parses a ConfigV4 into a NormalizedConfig.
+     *
+     * @param config - The raw V4 config object
+     * @param projectFolder - Absolute path to the project root
+     */
+    parse: Effect8.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
+      const entrypoints = yield* parseEntrypoints(config, projectFolder);
+      const assets = yield* collectAssets(config, projectFolder);
+      return {
+        regions: resolveRegions(config.regions),
+        assets: {
+          paths: assets.sort(),
+          prefixToStrip: (config.assets ?? "") + "/",
+          dynamicRoutes: true,
+          populateCache: config.populateAssetCache ?? false
+        },
+        environmentVariables: config.env ?? {},
+        commands: config.build_commands ?? [],
+        entrypoints,
+        errors: [],
+        warnings: [],
+        routes: (config.routes ?? []).map(mapRoute)
+      };
+    })
+  })
+}) {
+};
+
+// src/services/vercel-build-output-parser.ts
+import { Path as Path7 } from "@effect/platform";
+import { getFilesForPattern as getFilesForPattern2 } from "@gigadrive/build-utils";
 import { deepMerge } from "@gigadrive/commons";
-import path5 from "path";
+import { Effect as Effect10 } from "effect";
 
 // src/build-output-v3/determine-repo-root.ts
-import path2 from "path";
+import path from "path";
 var determineRepoRoot = (projectFolder, config) => {
   if (!config.entrypoints?.length) {
     return projectFolder;
@@ -36,7 +916,7 @@ var determineRepoRoot = (projectFolder, config) => {
   if (filePaths.length === 0) {
     return projectFolder;
   }
-  const pathParts = filePaths.map((p) => p.split(path2.sep));
+  const pathParts = filePaths.map((p) => p.split(path.sep));
   const firstPath = pathParts[0];
   const commonParts = [];
   for (let i = 0; i < firstPath.length; i++) {
@@ -47,7 +927,7 @@ var determineRepoRoot = (projectFolder, config) => {
       break;
     }
   }
-  const commonRoot = commonParts.join(path2.sep);
+  const commonRoot = commonParts.join(path.sep);
   if (commonRoot && projectFolder.startsWith(commonRoot) && commonRoot !== projectFolder) {
     return commonRoot;
   }
@@ -55,28 +935,35 @@ var determineRepoRoot = (projectFolder, config) => {
 };
 
 // src/build-output-v3/get-default-path-map.ts
-import fs2 from "fs";
-import path3 from "path";
-var getDefaultPathMap = (directory) => {
+import { FileSystem as FileSystem6, Path as Path6 } from "@effect/platform";
+import { Effect as Effect9 } from "effect";
+var getDefaultPathMap = Effect9.fn("getDefaultPathMap")(function* (directory) {
+  const fs = yield* FileSystem6.FileSystem;
+  const pathService = yield* Path6.Path;
   const result = {};
-  if (!fs2.existsSync(directory)) {
+  const exists = yield* fs.exists(directory).pipe(Effect9.catchAll(() => Effect9.succeed(false)));
+  if (!exists) {
     return result;
   }
-  const processDirectory = (currentPath, basePath = "") => {
-    const files = fs2.readdirSync(currentPath, { withFileTypes: true });
-    for (const file of files) {
-      const fullPath = path3.join(currentPath, file.name);
-      const relativePath = path3.join(basePath, file.name);
-      if (file.isDirectory()) {
-        processDirectory(fullPath, relativePath);
+  const MAX_DEPTH = 100;
+  const processDirectory = (currentPath, basePath = "", depth = 0) => Effect9.gen(function* () {
+    if (depth > MAX_DEPTH) return;
+    const entries = yield* fs.readDirectory(currentPath).pipe(Effect9.catchAll(() => Effect9.succeed([])));
+    for (const name of entries) {
+      const fullPath = pathService.join(currentPath, name);
+      const relativePath = basePath ? pathService.join(basePath, name) : name;
+      const stat = yield* fs.stat(fullPath).pipe(Effect9.catchAll(() => Effect9.succeed(null)));
+      if (!stat) continue;
+      if (stat.type === "Directory") {
+        yield* processDirectory(fullPath, relativePath, depth + 1);
       } else {
         result[fullPath] = relativePath;
       }
     }
-  };
-  processDirectory(directory);
+  });
+  yield* processDirectory(directory);
   return result;
-};
+});
 
 // src/build-output-v3/get-monorepo-files.ts
 function getMonorepoFiles(directory, filePathMaps) {
@@ -94,56 +981,6 @@ function getMonorepoFiles(directory, filePathMaps) {
   return result;
 }
 
-// src/build-output-v3/read-config-file.ts
-import fs4 from "fs";
-
-// src/parse-raw-config.ts
-import fs3 from "fs/promises";
-import path4 from "path";
-import { parse as parseYaml } from "yaml";
-var parseRawConfig = async (filePath, { disableVersionCheck = false } = {}) => {
-  try {
-    await fs3.access(filePath);
-  } catch {
-    throw new Error(`Config file not found at ${filePath}`);
-  }
-  const fileContents = await fs3.readFile(filePath, "utf8");
-  if (fileContents.length === 0) {
-    throw new Error(`Config file is empty at ${filePath}`);
-  }
-  const fileExtension = path4.extname(filePath).toLowerCase();
-  let parsed;
-  try {
-    if (fileExtension === ".json") {
-      parsed = JSON.parse(fileContents);
-    } else if ([".yml", ".yaml"].includes(fileExtension)) {
-      parsed = parseYaml(fileContents);
-    } else {
-      parsed = parseYaml(fileContents);
-    }
-  } catch (error) {
-    throw new Error(
-      `Failed to parse config file at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-  if (parsed === void 0) {
-    throw new Error(`Config file could not be parsed at ${filePath}`);
-  }
-  if (!disableVersionCheck && typeof parsed.version !== "number") {
-    throw new Error(`Config file is missing version at ${filePath}`);
-  }
-  return parsed;
-};
-
-// src/build-output-v3/read-config-file.ts
-var readConfigFile = async (configFilePath) => {
-  if (!fs4.existsSync(configFilePath)) {
-    return null;
-  }
-  const parsed = await parseRawConfig(configFilePath, { disableVersionCheck: true });
-  return parsed;
-};
-
 // src/build-output-v3/translate-vercel-region.ts
 var translateVercelRegion = (region) => {
   const regionMap = {
@@ -185,284 +1022,141 @@ var translateVercelRuntime = (runtime) => {
   }
 };
 
-// src/build-output-v3/parse.ts
-var configPath = ".vercel/output/config.json";
-var functionsFolder = ".vercel/output/functions";
-var functionConfigsPattern = `${functionsFolder}/**/*.func/.vc-config.json`;
-var parseVercelBuildOutputV3 = async (parseResult, projectFolder) => {
-  const config = await readConfigFile(path5.join(projectFolder, configPath));
-  if (!config || config.version < 3) {
-    return parseResult;
-  }
-  const functionData = await loadFunctions(config, parseResult, projectFolder);
-  const assetOverrides = loadAssetOverrides(config, parseResult);
-  return deepMerge(parseResult, functionData, assetOverrides);
-};
-var loadAssetOverrides = (config, parseResult) => {
-  return {
-    assets: {
-      overrides: {
-        ...parseResult.assets?.overrides ?? {},
-        ...config.overrides
-      }
-    }
-  };
-};
-var loadFunctions = async (config, parseResult, projectFolder) => {
-  const functionConfigs = await getFilesForPattern(functionConfigsPattern, projectFolder);
-  const result = {
-    entrypoints: [],
-    routes: [],
-    regions: []
-  };
-  for (const functionConfigPath of functionConfigs) {
-    const functionConfig = await readConfigFile(path5.join(projectFolder, functionConfigPath));
-    if (!functionConfig) {
-      parseResult.errors.push(`Failed to read function config at ${functionConfigPath}`);
-      continue;
-    }
-    const functionPathRelative = path5.dirname(functionConfigPath).replace(functionsFolder, "");
-    const functionName = functionPathRelative.replace(/^\/|\.func$/g, "");
-    const runtime = translateVercelRuntime(functionConfig.runtime);
-    if (!runtime) {
-      parseResult.errors.push(`Unsupported runtime for function ${functionName}: ${functionConfig.runtime}`);
-      continue;
-    }
-    const functionDirectory = `.vercel/output/functions/${functionName}.func`;
-    const {
-      handler,
-      maxDuration,
-      memory,
-      regions = [],
-      environment,
-      filePathMap: configFilePathMap = {}
-    } = functionConfig;
-    const translatedRegions = regions.length > 0 ? regions.map(translateVercelRegion) : ["us-east-1"];
-    result.regions = Array.from(/* @__PURE__ */ new Set([...parseResult.regions, ...translatedRegions]));
-    const environmentVariables = {};
-    if (environment && typeof environment === "object") {
-      for (const env of Object.values(environment)) {
-        Object.assign(environmentVariables, env);
-      }
-    }
-    const streaming = runtime.startsWith("node-") || runtime.startsWith("bun-");
-    let filePathMap = {};
-    for (const [key, value] of Object.entries(configFilePathMap)) {
-      filePathMap[path5.join(projectFolder, key)] = value;
-    }
-    if (Object.keys(filePathMap).length === 0) {
-      filePathMap = getDefaultPathMap(path5.join(projectFolder, functionDirectory));
-    }
-    if (!result.entrypoints) {
-      result.entrypoints = [];
-    }
-    result.entrypoints.push({
-      displayName: functionName,
-      runtime,
-      path: path5.join(functionDirectory, handler),
-      memory: memory ?? 1024,
-      maxDuration: maxDuration ?? 15,
-      environmentVariables,
-      streaming,
-      package: {
-        filePathMap
+// src/services/vercel-build-output-parser.ts
+var CONFIG_PATH = ".vercel/output/config.json";
+var FUNCTIONS_FOLDER = ".vercel/output/functions";
+var FUNCTION_CONFIGS_PATTERN = `${FUNCTIONS_FOLDER}/**/*.func/.vc-config.json`;
+var VercelBuildOutputParser = class extends Effect10.Service()("VercelBuildOutputParser", {
+  effect: Effect10.gen(function* () {
+    const rawConfigReader = yield* RawConfigReader;
+    const pathService = yield* Path7.Path;
+    const parse = Effect10.fn("VercelBuildOutputParser.parse")(function* (parseResult, projectFolder) {
+      const config = yield* rawConfigReader.readConfigFile(pathService.join(projectFolder, CONFIG_PATH));
+      if (!config || typeof config.version !== "number" || config.version < 3) {
+        return parseResult;
       }
+      const functionData = yield* loadFunctions(config, parseResult, projectFolder);
+      const assetOverrides = loadAssetOverrides(config, parseResult);
+      const merged = deepMerge(parseResult, functionData, assetOverrides);
+      merged.regions = [...new Set(merged.regions)];
+      return merged;
     });
-    const handlerType = streaming ? "SERVERLESS_FUNCTION_STREAMING" : "SERVERLESS_FUNCTION";
-    const defaultRoute = {
-      path: `/${functionName}`,
-      methods: ["ANY"],
-      headers: {},
-      destination: handler,
-      handler: handlerType
-    };
-    const configRoutes = config.routes?.filter((r) => r.dest === `/${functionName}`).map(
-      (r) => ({
-        path: r.src ?? `/${functionName}`,
-        methods: ["ANY"],
-        headers: {},
-        destination: handler,
-        handler: handlerType
-      })
-    ) ?? [];
-    if (!result.routes) {
-      result.routes = [];
-    }
-    result.routes.push(defaultRoute, ...configRoutes);
-  }
-  return {
-    ...result,
-    userArchive: {
-      rootOverwrite: determineRepoRoot(projectFolder, result),
-      fileWhitelist: [
-        `${projectFolder}/*`,
-        ...getMonorepoFiles(projectFolder, result.entrypoints?.map((e) => e.package?.filePathMap ?? {}) ?? [])
-      ]
-    }
-  };
-};
-
-// src/filter-functions-from-assets.ts
-var filterFunctionsFromAssets = (config) => {
-  return {
-    ...config,
-    assets: {
-      ...config.assets,
-      paths: config.assets?.paths?.filter((path6) => !config.entrypoints.some((entrypoint) => entrypoint.path === path6))
-    }
-  };
-};
-
-// src/v4/parse.ts
-import { getFilesForPattern as getFilesForPattern2 } from "@gigadrive/build-utils";
-import fs5 from "fs";
-import { minimatch } from "minimatch";
-
-// src/regions.ts
-var REGION_DEFINITIONS = [
-  "us-east-1",
-  "us-east-2",
-  "us-west-1",
-  "us-west-2",
-  "ap-south-1",
-  "ap-northeast-3",
-  "ap-northeast-2",
-  "ap-southeast-1",
-  "ap-southeast-2",
-  "ap-northeast-1",
-  "ca-central-1",
-  "eu-central-1",
-  "eu-west-1",
-  "eu-west-2",
-  "eu-west-3",
-  "eu-north-1",
-  "sa-east-1"
-];
-var AVAILABLE_REGIONS = [...REGION_DEFINITIONS];
-
-// src/v4/parse.ts
-var parseConfigV4 = async (config, projectFolder) => {
-  const regions = config.regions?.includes("global") === true ? AVAILABLE_REGIONS : config.regions?.filter((region) => region !== "global") ?? ["global"];
-  const populateAssetCache = config.populateAssetCache ?? false;
-  const environmentVariables = config.env ?? {};
-  const commands = config.build_commands ?? [];
-  const entrypoints = [];
-  const errors = [];
-  const warnings = [];
-  if (config.functions != null) {
-    for (const [path6, func] of Object.entries(config.functions)) {
-      const settings = getFunctionSettings(path6, config);
-      if (settings == null) {
-        throw new Error(`Settings invalid for function at path '${path6}'`);
-      }
-      (await getFilesForPattern2(path6, projectFolder, func.excludeFiles)).forEach((file) => {
-        if (entrypoints.find((entrypoint) => entrypoint.path === file)) {
-          return;
-        }
-        if (config.functions != null && Object.keys(config.functions).find((func2) => func2 === file && func2 !== path6)) {
-          return;
-        }
-        entrypoints.push({
-          path: file,
-          runtime: settings.runtime ?? "node-20",
-          memory: settings.memory ?? 128,
-          maxDuration: settings.max_duration ?? 30,
-          schedule: func.schedule,
-          symlinks: func.symlinks,
-          streaming: settings.runtime == null || settings.runtime.startsWith("node-") || settings.runtime.startsWith("bun-")
-        });
+    const loadFunctions = Effect10.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
+      const functionConfigs = yield* Effect10.tryPromise({
+        try: () => getFilesForPattern2(FUNCTION_CONFIGS_PATTERN, projectFolder),
+        catch: (error) => new ConfigFileParseError({
+          message: `Failed to scan for function configs: ${error instanceof Error ? error.message : String(error)}`,
+          filePath: projectFolder
+        })
       });
-    }
-  }
-  const assets = [];
-  if (config.assets != null) {
-    const assetsPath = `${projectFolder}/${config.assets}`;
-    if (fs5.existsSync(assetsPath) && fs5.statSync(assetsPath).isDirectory()) {
-      for (const asset of fs5.readdirSync(`${projectFolder}/${config.assets}`, {
-        recursive: true
-      })) {
-        if (fs5.statSync(`${projectFolder}/${config.assets}/${asset.toString()}`).isDirectory()) {
+      const result = {
+        entrypoints: [],
+        routes: [],
+        regions: [],
+        errors: []
+      };
+      for (const functionConfigPath of functionConfigs) {
+        const functionConfig = yield* rawConfigReader.readConfigFile(
+          pathService.join(projectFolder, functionConfigPath)
+        );
+        if (!functionConfig) {
+          result.errors.push(`Failed to read function config at ${functionConfigPath}`);
           continue;
         }
-        const disallowedExtensions = [".htaccess", ".htpasswd"];
-        const assetName = asset.toString();
-        if (disallowedExtensions.some((ext) => assetName.toLowerCase().endsWith(ext.toLowerCase()))) {
+        const functionPathRelative = pathService.dirname(functionConfigPath).replace(FUNCTIONS_FOLDER, "");
+        const functionName = functionPathRelative.replace(/^\/|\.func$/g, "");
+        const runtime = translateVercelRuntime(functionConfig.runtime);
+        if (!runtime) {
+          result.errors.push(`Unsupported runtime for function ${functionName}: ${functionConfig.runtime}`);
           continue;
         }
-        if (getFunctionSettings(`${config.assets}/${assetName}`, config) != null) {
-          continue;
+        const functionDirectory = `.vercel/output/functions/${functionName}.func`;
+        const {
+          handler,
+          maxDuration,
+          memory,
+          regions = [],
+          environment,
+          filePathMap: configFilePathMap = {}
+        } = functionConfig;
+        const functionEntrypointPath = pathService.join(functionDirectory, handler);
+        const translatedRegions = regions.length > 0 ? regions.map(translateVercelRegion) : ["us-east-1"];
+        result.regions = Array.from(/* @__PURE__ */ new Set([...result.regions ?? [], ...translatedRegions]));
+        const environmentVariables = {};
+        if (environment && typeof environment === "object") {
+          for (const env of Object.values(environment)) {
+            Object.assign(environmentVariables, env);
+          }
+        }
+        const streaming = runtime.startsWith("node-") || runtime.startsWith("bun-");
+        let filePathMap = {};
+        for (const [key, value] of Object.entries(configFilePathMap)) {
+          filePathMap[pathService.join(projectFolder, key)] = value;
+        }
+        if (Object.keys(filePathMap).length === 0) {
+          filePathMap = yield* getDefaultPathMap(pathService.join(projectFolder, functionDirectory));
+        }
+        if (!result.entrypoints) {
+          result.entrypoints = [];
+        }
+        result.entrypoints.push({
+          displayName: functionName,
+          runtime,
+          path: functionEntrypointPath,
+          memory: memory ?? 1024,
+          maxDuration: maxDuration ?? 15,
+          environmentVariables,
+          streaming,
+          package: {
+            filePathMap
+          }
+        });
+        const handlerType = streaming ? "SERVERLESS_FUNCTION_STREAMING" : "SERVERLESS_FUNCTION";
+        const defaultRoute = {
+          path: `/${functionName}`,
+          methods: ["ANY"],
+          headers: {},
+          destination: functionEntrypointPath,
+          handler: handlerType
+        };
+        const configRoutes = config.routes?.filter((r) => "dest" in r && r.dest === `/${functionName}`).map(
+          (r) => ({
+            path: ("src" in r ? r.src : void 0) ?? `/${functionName}`,
+            methods: ["ANY"],
+            headers: {},
+            destination: functionEntrypointPath,
+            handler: handlerType
+          })
+        ) ?? [];
+        if (!result.routes) {
+          result.routes = [];
         }
-        assets.push(`${config.assets}/${assetName}`);
+        result.routes.push(defaultRoute, ...configRoutes);
       }
-    }
-  }
-  const routes = config.routes ?? [];
-  return {
-    regions,
-    assets: {
-      paths: assets.sort(),
-      prefixToStrip: (config.assets ?? "") + "/",
-      dynamicRoutes: true,
-      populateCache: populateAssetCache
-    },
-    environmentVariables,
-    commands,
-    entrypoints,
-    errors,
-    warnings,
-    routes: routes.map((route) => {
-      const handler = route.destination.toLowerCase().startsWith("http://") || route.destination.toLowerCase().startsWith("https://") ? route.redirect === true ? "HTTP_REDIRECT" : "HTTP_PROXY" : route.redirect === true ? "HTTP_REDIRECT" : "SERVERLESS_FUNCTION";
       return {
-        path: route.source,
-        destination: route.destination,
-        handler,
-        headers: route.headers ?? {},
-        methods: route.methods ?? ["ANY"],
-        positiveRequirements: route.has,
-        negativeRequirements: route.missing,
-        status: route.statusCode
+        ...result,
+        userArchive: {
+          rootOverwrite: determineRepoRoot(projectFolder, result),
+          fileWhitelist: [
+            `${projectFolder}/*`,
+            ...getMonorepoFiles(projectFolder, result.entrypoints?.map((e) => e.package?.filePathMap ?? {}) ?? [])
+          ]
+        }
       };
-    })
-  };
+    });
+    return { parse };
+  })
+}) {
 };
-var getFunctionSettings = (path6, config) => {
-  let functionSettings;
-  for (const [key, value] of Object.entries(config.functions ?? {})) {
-    if (minimatch(path6, key) || new RegExp(key).test(path6)) {
-      if (functionSettings == null) {
-        functionSettings = {
-          memory: 128,
-          max_duration: 30,
-          schedule: void 0,
-          symlinks: void 0,
-          excludeFiles: void 0,
-          includeFiles: void 0
-        };
-      }
-      if (value.runtime != null) {
-        functionSettings.runtime = value.runtime;
-      }
-      if (value.memory != null) {
-        functionSettings.memory = value.memory;
-      }
-      if (value.max_duration != null) {
-        functionSettings.max_duration = value.max_duration;
-      }
-      if (value.schedule != null) {
-        functionSettings.schedule = value.schedule;
-      }
-      if (value.symlinks != null) {
-        functionSettings.symlinks = value.symlinks;
-      }
-      if (value.excludeFiles != null) {
-        functionSettings.excludeFiles = value.excludeFiles;
-      }
-      if (value.includeFiles != null) {
-        functionSettings.includeFiles = value.includeFiles;
+var loadAssetOverrides = (config, parseResult) => {
+  return {
+    assets: {
+      overrides: {
+        ...parseResult.assets?.overrides ?? {},
+        ...config.overrides
       }
     }
-  }
-  return functionSettings;
+  };
 };
 
 // src/v4/schema.json
@@ -748,7 +1442,7 @@ var schema_default = {
   $defs: {
     runtimes: {
       type: "string",
-      enum: ["php-83", "php-82", "php-81", "php-80", "node-20", "node-18", "node-16", "bun-1"]
+      enum: ["php-84", "php-83", "php-81", "node-22", "node-20", "node-18", "node-16", "bun-1"]
     },
     matchRequirements: {
       description: "An array of requirements that are needed to match",
@@ -802,45 +1496,45 @@ var schema_default = {
 };
 
 // src/parse-config.ts
-var parseConfig = async (filePath, projectFolder) => {
-  const parsed = await parseRawConfig(filePath);
+var parseConfigRaw = Effect11.fn("parseConfigRaw")(function* (filePath, projectFolder) {
+  const rawReader = yield* RawConfigReader;
+  const validator = yield* SchemaValidator;
+  const v4Parser = yield* V4ConfigParser;
+  const parsed = yield* rawReader.readRawConfig(filePath);
   const version = parsed.version;
   const schemaMap = {
-    /*1: schemaV1,
-      2: schemaV2,
-      3: schemaV3,*/
     4: schema_default
   };
-  const relativePath = filePath.replace("/tmp/unzipped/", "");
   const schema = schemaMap[version];
   if (!schema) {
-    throw new Error(`Config file at ${relativePath} has an unsupported version: ${version}`);
-  }
-  const ajv = new Ajv();
-  addFormats(ajv);
-  const validate = ajv.compile(schema);
-  const valid = validate(parsed);
-  if (!valid) {
-    throw new Error(`Config file at ${relativePath} is invalid: ${ajv.errorsText(validate.errors)}`);
+    return yield* Effect11.fail(
+      new ConfigVersionError({
+        message: `Config file at ${filePath} has an unsupported version: ${version}`,
+        filePath,
+        version
+      })
+    );
   }
-  const parserMap = {
-    /*1: parseConfigV1,
-    2: parseConfigV2,
-    3: parseConfigV3,*/
-    4: parseConfigV4
-  };
-  let parseResult = await parserMap[version](parsed, projectFolder);
-  parseResult = await parseVercelBuildOutputV3(parseResult, projectFolder);
-  if (parseResult.entrypoints.length === 0 && (parseResult.assets?.paths?.length || 0) === 0) {
-    parseResult.warnings.push("The current project does not have any functions or assets to deploy.");
-  } else if (parseResult.entrypoints.length === 0 && (parseResult.assets?.paths?.length || 0) === 0 && parseResult.routes.length === 0) {
-    parseResult.errors.push(
+  yield* validator.validate(parsed, schema, filePath);
+  return yield* v4Parser.parse(parsed, projectFolder);
+});
+var parseConfig = Effect11.fn("parseConfig")(function* (filePath, projectFolder) {
+  const parseResult = yield* parseConfigRaw(filePath, projectFolder);
+  return yield* postProcessConfig(parseResult, projectFolder);
+});
+var postProcessConfig = Effect11.fn("postProcessConfig")(function* (config, projectFolder) {
+  const vercelParser = yield* VercelBuildOutputParser;
+  let result = yield* vercelParser.parse(config, projectFolder);
+  if (result.entrypoints.length === 0 && (result.assets?.paths?.length || 0) === 0 && result.routes.length === 0) {
+    result.errors.push(
       "The current project config does not resolve to any functions, assets or routes and can not be deployed."
     );
+  } else if (result.entrypoints.length === 0 && (result.assets?.paths?.length || 0) === 0) {
+    result.warnings.push("The current project does not have any functions or assets to deploy.");
   }
-  parseResult = filterFunctionsFromAssets(parseResult);
-  return parseResult;
-};
+  result = filterFunctionsFromAssets(result);
+  return result;
+});
 
 // src/runtime.ts
 var RUNTIME_DEFINITIONS = [
@@ -854,12 +1548,40 @@ var RUNTIME_DEFINITIONS = [
   "bun-1"
 ];
 var AVAILABLE_RUNTIMES = [...RUNTIME_DEFINITIONS];
+
+// src/services/index.ts
+import { Layer } from "effect";
+var BaseLayers = Layer.mergeAll(RawConfigReader.Default, SchemaValidator.Default, V4ConfigParser.Default);
+var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(Layer.provideMerge(BaseLayers));
 export {
   ALLOWED_CONFIG_NAMES,
   AVAILABLE_REGIONS,
   AVAILABLE_RUNTIMES,
-  findConfig,
+  ConfigFileEmptyError,
+  ConfigFileNotFoundError,
+  ConfigFileParseError,
+  ConfigSchemaValidationError,
+  ConfigVersionError,
+  FRAMEWORK_DEFINITIONS,
+  FrameworkNotDetectedError,
+  FunctionConfigError,
+  ManifestNotFoundError,
+  ManifestParseError,
+  ManifestReadError,
+  NetworkConfigLive,
+  RawConfigReader,
+  SchemaValidator,
+  V4ConfigParser,
+  VercelBuildOutputParser,
+  detectFramework,
+  detectPackageManager,
+  filterFunctionsFromAssets,
+  generateConfig,
+  getFunctionSettings,
+  mergeWithFrameworkDefaults,
   parseConfig,
-  parseRawConfig
+  parseConfigRaw,
+  postProcessConfig,
+  readDependencies
 };
 //# sourceMappingURL=index.mjs.map