@gigadrive/network-config 4.5.0 → 4.6.1

package/dist/index.mjs

@@ -55,6 +55,9 @@ var StaticAssetManifestV1Schema = Schema2.mutable(
 ).pipe(Schema2.filter(({ assets }) => new Set(assets.map(({ path: path2 }) => path2)).size === assets.length));
 var parseStaticAssetManifest = (content) => decodeJson(StaticAssetManifestV1Schema, content);
 
+// src/define-config.ts
+var defineConfig = (config) => config;
+
 // src/detection/detect-framework.ts
 import { FileSystem as FileSystem8, Path as Path6 } from "@effect/platform";
 import { Effect as Effect10 } from "effect";
@@ -451,38 +454,60 @@ var ImagePolicySchema = Schema3.mutable(
     variants: Schema3.mutable(Schema3.Record({ key: Schema3.String, value: ImageVariantSchema }))
   })
 );
-var GigadriveNextPrerenderOutputSchema = Schema3.mutable(
-  Schema3.Struct({
-    id: Schema3.String,
-    type: Schema3.Literal("PRERENDER"),
-    pathname: UrlPathnameSchema,
-    parentOutputId: Schema3.String,
-    groupId: Schema3.Number,
-    pprChain: Schema3.optional(Schema3.mutable(Schema3.Struct({ headers: HttpSingleValueHeadersSchema }))),
-    parentFallbackMode: Schema3.optional(JsonValueSchema),
-    fallback: Schema3.optional(
-      Schema3.mutable(
-        Schema3.Struct({
-          filePath: Schema3.optional(PortableRelativePathSchema),
-          initialStatus: Schema3.optional(Schema3.Int.pipe(Schema3.between(100, 599))),
-          initialHeaders: Schema3.optional(HttpHeadersSchema),
-          initialExpiration: Schema3.optional(Schema3.Number),
-          initialRevalidate: Schema3.optional(Schema3.Union(Schema3.Number, Schema3.Literal(false))),
-          postponedState: Schema3.optional(Schema3.String)
-        })
-      )
-    ),
-    config: Schema3.mutable(
+var GigadriveNextPrerenderOutputFields = {
+  id: Schema3.String,
+  type: Schema3.Literal("PRERENDER"),
+  pathname: UrlPathnameSchema,
+  route: Schema3.optional(UrlPathnameSchema),
+  parentOutputId: Schema3.String,
+  groupId: Schema3.Number,
+  pprChain: Schema3.optional(Schema3.mutable(Schema3.Struct({ headers: HttpSingleValueHeadersSchema }))),
+  parentFallbackMode: Schema3.optional(JsonValueSchema),
+  fallback: Schema3.optional(
+    Schema3.mutable(
       Schema3.Struct({
-        allowQuery: Schema3.optional(StringArraySchema),
-        allowHeader: Schema3.optional(StringArraySchema),
-        bypassFor: Schema3.optional(Schema3.mutable(Schema3.Array(JsonValueSchema))),
-        renderingMode: Schema3.optional(Schema3.String),
-        partialFallback: Schema3.optional(Schema3.Boolean),
-        bypassToken: Schema3.optional(Schema3.String)
+        filePath: Schema3.optional(PortableRelativePathSchema),
+        initialStatus: Schema3.optional(Schema3.Int.pipe(Schema3.between(100, 599))),
+        initialHeaders: Schema3.optional(HttpHeadersSchema),
+        initialExpiration: Schema3.optional(Schema3.Number),
+        initialRevalidate: Schema3.optional(Schema3.Union(Schema3.Number, Schema3.Literal(false))),
+        postponedState: Schema3.optional(Schema3.String)
       })
     )
-  })
+  ),
+  config: Schema3.mutable(
+    Schema3.Struct({
+      allowQuery: Schema3.optional(StringArraySchema),
+      allowHeader: Schema3.optional(StringArraySchema),
+      bypassFor: Schema3.optional(Schema3.mutable(Schema3.Array(JsonValueSchema))),
+      renderingMode: Schema3.optional(Schema3.String),
+      partialFallback: Schema3.optional(Schema3.Boolean),
+      bypassToken: Schema3.optional(Schema3.String)
+    })
+  )
+};
+var GigadriveNextPrerenderClassificationSchema = Schema3.Struct({
+  routeType: Schema3.Literal("route", "fallback", "shell", "page"),
+  response: Schema3.Literal("empty", "initial", "complete"),
+  compute: Schema3.Literal("blocking", "resuming", "static"),
+  htmlSize: Schema3.optional(Schema3.Number)
+});
+var GigadriveNextPrerenderWithoutClassificationSchema = Schema3.Struct({
+  routeType: Schema3.optional(Schema3.Never),
+  response: Schema3.optional(Schema3.Never),
+  compute: Schema3.optional(Schema3.Never),
+  htmlSize: Schema3.optional(Schema3.Never)
+});
+var GigadriveNextPrerenderOutputSchema = Schema3.Union(
+  Schema3.mutable(
+    Schema3.Struct({ ...GigadriveNextPrerenderOutputFields, ...GigadriveNextPrerenderClassificationSchema.fields })
+  ),
+  Schema3.mutable(
+    Schema3.Struct({
+      ...GigadriveNextPrerenderOutputFields,
+      ...GigadriveNextPrerenderWithoutClassificationSchema.fields
+    })
+  )
 );
 var GigadriveNextStaticAssetPrefixSchema = Schema3.mutable(
   Schema3.Struct({
@@ -491,6 +516,43 @@ var GigadriveNextStaticAssetPrefixSchema = Schema3.mutable(
     immutable: Schema3.Boolean
   })
 );
+var GigadriveNextRouteConditionSchema = Schema3.Union(
+  Schema3.mutable(
+    Schema3.Struct({
+      type: Schema3.Literal("header", "cookie", "query"),
+      key: Schema3.String,
+      value: Schema3.optional(Schema3.String)
+    })
+  ),
+  Schema3.mutable(
+    Schema3.Struct({
+      type: Schema3.Literal("host"),
+      value: Schema3.String
+    })
+  )
+);
+var GigadriveNextMiddlewareMatcherSchema = Schema3.mutable(
+  Schema3.Struct({
+    source: Schema3.String,
+    sourceRegex: Schema3.String,
+    has: Schema3.optional(Schema3.mutable(Schema3.Array(GigadriveNextRouteConditionSchema))),
+    missing: Schema3.optional(Schema3.mutable(Schema3.Array(GigadriveNextRouteConditionSchema)))
+  })
+);
+var GigadriveNextMiddlewareDescriptorSchema = Schema3.Union(
+  Schema3.mutable(
+    Schema3.Struct({
+      present: Schema3.Literal(true),
+      matchers: Schema3.mutable(Schema3.Array(GigadriveNextMiddlewareMatcherSchema))
+    })
+  ),
+  Schema3.mutable(
+    Schema3.Struct({
+      present: Schema3.Literal(false),
+      matchers: Schema3.mutable(Schema3.Tuple())
+    })
+  )
+);
 var GigadriveNextServerDescriptorSchema = Schema3.mutable(
   Schema3.Struct({
     maxDuration: Schema3.optional(Schema3.Number),
@@ -501,6 +563,9 @@ var GigadriveNextServerDescriptorSchema = Schema3.mutable(
 var PrerenderArraySchema = Schema3.mutable(Schema3.Array(GigadriveNextPrerenderOutputSchema));
 var StaticAssetArraySchema = Schema3.mutable(Schema3.Array(GigadriveNextStaticAssetPrefixSchema));
 var JsonValueArraySchema = Schema3.mutable(Schema3.Array(JsonValueSchema));
+var GigadriveNextPrerenderSeedMethodsSchema = Schema3.mutable(
+  Schema3.Tuple(Schema3.Literal("GET"), Schema3.Literal("HEAD"))
+);
 var GigadriveNextBuildManifestV1Schema = Schema3.mutable(
   Schema3.Struct({
     version: Schema3.Literal(1),
@@ -557,7 +622,8 @@ var GigadriveNextBuildManifestV2StandaloneSchema = Schema3.mutable(
         prerenderManifest: Schema3.optional(PortableRelativePathSchema),
         assetManifest: Schema3.optional(PortableRelativePathSchema),
         entryPagePaths: Schema3.optional(Schema3.mutable(Schema3.Array(UrlPathnameSchema))),
-        staticAssets: StaticAssetArraySchema
+        staticAssets: StaticAssetArraySchema,
+        middleware: Schema3.optional(GigadriveNextMiddlewareDescriptorSchema)
       })
     )
   })
@@ -570,6 +636,7 @@ var GigadriveNextBuildManifestSchema = Schema3.Union(
 var GigadriveNextPrerenderManifestV1Schema = Schema3.mutable(
   Schema3.Struct({
     version: Schema3.Literal(1),
+    seedMethods: Schema3.optional(GigadriveNextPrerenderSeedMethodsSchema),
     prerenders: PrerenderArraySchema
   })
 );
@@ -1206,6 +1273,12 @@ var ConfigFileParseError = class extends Schema5.TaggedError()("ConfigFileParseE
   cause: Schema5.optional(Schema5.String)
 }) {
 };
+var ConfigModuleLoadError = class extends Schema5.TaggedError()("ConfigModuleLoadError", {
+  message: Schema5.String,
+  filePath: Schema5.String,
+  cause: Schema5.optional(Schema5.String)
+}) {
+};
 var ConfigVersionError = class extends Schema5.TaggedError()("ConfigVersionError", {
   message: Schema5.String,
   filePath: Schema5.String,
@@ -1243,85 +1316,157 @@ var DEFAULT_FUNCTION_DURATION_SECONDS = 30;
 var MAX_FUNCTION_DURATION_SECONDS = 28800;
 
 // src/parse-config.ts
-import { Effect as Effect16 } from "effect";
+import { Effect as Effect17 } from "effect";
 
 // src/services/raw-config-reader.ts
 import { FileSystem as FileSystem9, Path as Path7 } from "@effect/platform";
-import { Effect as Effect12 } from "effect";
+import { Effect as Effect13 } from "effect";
 import { parse as parseYaml } from "yaml";
+
+// src/services/config-module-loader.ts
+import { Effect as Effect12 } from "effect";
+import { createJiti } from "jiti";
+var MISSING_DEFAULT_EXPORT = /* @__PURE__ */ Symbol("MissingDefaultExport");
+var STRICT_DEFAULT_EXPORT_EXTENSIONS = [".ts", ".mts", ".mjs"];
+var ConfigModuleLoader = class extends Effect12.Service()("ConfigModuleLoader", {
+  effect: Effect12.gen(function* () {
+    const loadConfigModule = Effect12.fn("ConfigModuleLoader.loadConfigModule")(function* (filePath) {
+      const extension = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+      const mod = yield* Effect12.tryPromise({
+        try: async () => {
+          const jiti = createJiti(filePath, { fsCache: false, interopDefault: true, moduleCache: false });
+          const namespace = await jiti.import(filePath);
+          if (typeof namespace === "object" && namespace !== null && "default" in namespace) {
+            return namespace.default;
+          }
+          if (!STRICT_DEFAULT_EXPORT_EXTENSIONS.includes(extension)) {
+            return namespace.default ?? MISSING_DEFAULT_EXPORT;
+          }
+          return MISSING_DEFAULT_EXPORT;
+        },
+        catch: (error) => new ConfigModuleLoadError({
+          message: `Failed to load config module at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
+          filePath,
+          cause: error instanceof Error ? error.message : void 0
+        })
+      });
+      if (mod === MISSING_DEFAULT_EXPORT) {
+        return yield* Effect12.fail(
+          new ConfigModuleLoadError({
+            message: `Config module at ${filePath} does not have a default export. Export the config object as the default export (or via module.exports for CommonJS files), optionally wrapped in defineConfig.`,
+            filePath
+          })
+        );
+      }
+      if (typeof mod === "function") {
+        return yield* Effect12.fail(
+          new ConfigModuleLoadError({
+            message: `Config module at ${filePath} default-exports a function; config factories are not supported. Export a config object instead (optionally wrapped in defineConfig).`,
+            filePath
+          })
+        );
+      }
+      if (typeof mod !== "object" || mod === null || Array.isArray(mod)) {
+        return yield* Effect12.fail(
+          new ConfigModuleLoadError({
+            message: `Config module at ${filePath} must default-export a config object.`,
+            filePath
+          })
+        );
+      }
+      return mod;
+    });
+    return { loadConfigModule };
+  })
+}) {
+};
+
+// src/services/raw-config-reader.ts
 var ALLOWED_CONFIG_NAMES = [
+  "gigadrive.ts",
+  "gigadrive.mts",
+  "gigadrive.cts",
+  "gigadrive.js",
+  "gigadrive.mjs",
+  "gigadrive.cjs",
   "gigadrive.yaml",
   "gigadrive.yml",
+  "gigadrive.json",
   "nebula.yaml",
   "nebula.yml",
   "nebula.json"
 ];
-var RawConfigReader = class extends Effect12.Service()("RawConfigReader", {
-  effect: Effect12.gen(function* () {
+var MODULE_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+var RawConfigReader = class extends Effect13.Service()("RawConfigReader", {
+  dependencies: [ConfigModuleLoader.Default],
+  effect: Effect13.gen(function* () {
     const fs = yield* FileSystem9.FileSystem;
     const pathService = yield* Path7.Path;
-    const findConfig = Effect12.fn("RawConfigReader.findConfig")(function* (projectFolder) {
+    const moduleLoader = yield* ConfigModuleLoader;
+    const findConfig = Effect13.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(Effect12.catchAll(() => Effect12.succeed(false)));
+        const exists = yield* fs.exists(filePath).pipe(Effect13.catchAll(() => Effect13.succeed(false)));
         if (exists) {
           return filePath;
         }
       }
       return null;
     });
-    const readRawConfig = Effect12.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
-      const exists = yield* fs.exists(filePath).pipe(Effect12.catchAll(() => Effect12.succeed(false)));
+    const readRawConfig = Effect13.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
+      const exists = yield* fs.exists(filePath).pipe(Effect13.catchAll(() => Effect13.succeed(false)));
       if (!exists) {
-        return yield* Effect12.fail(
+        return yield* Effect13.fail(
           new ConfigFileNotFoundError({ message: `Config file not found at ${filePath}`, filePath })
         );
       }
       const fileContents = yield* fs.readFileString(filePath).pipe(
-        Effect12.mapError(
+        Effect13.mapError(
           () => new ConfigFileParseError({ message: `Failed to read config file at ${filePath}`, filePath })
         )
       );
       if (fileContents.length === 0) {
-        return yield* Effect12.fail(
+        return yield* Effect13.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);
+      if (MODULE_EXTENSIONS.includes(fileExtension)) {
+        parsed = yield* moduleLoader.loadConfigModule(filePath);
+      } else {
+        try {
+          if (fileExtension === ".json") {
+            parsed = JSON.parse(fileContents);
+          } else {
+            parsed = parseYaml(fileContents);
+          }
+        } catch (error) {
+          return yield* Effect13.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
+            })
+          );
         }
-      } catch (error) {
-        return yield* Effect12.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* Effect12.fail(
+        return yield* Effect13.fail(
           new ConfigFileParseError({ message: `Config file could not be parsed at ${filePath}`, filePath })
         );
       }
       if (!options?.disableVersionCheck && typeof parsed.version !== "number") {
-        return yield* Effect12.fail(
+        return yield* Effect13.fail(
           new ConfigVersionError({ message: `Config file is missing version at ${filePath}`, filePath })
         );
       }
       return parsed;
     });
     const readConfigFile = (configFilePath) => readRawConfig(configFilePath, { disableVersionCheck: true }).pipe(
-      Effect12.map((parsed) => parsed),
-      Effect12.catchTag("ConfigFileNotFoundError", () => Effect12.succeed(null)),
-      Effect12.withSpan("RawConfigReader.readConfigFile")
+      Effect13.map((parsed) => parsed),
+      Effect13.catchTag("ConfigFileNotFoundError", () => Effect13.succeed(null)),
+      Effect13.withSpan("RawConfigReader.readConfigFile")
     );
     return { findConfig, readRawConfig, readConfigFile };
   })
@@ -1331,17 +1476,17 @@ var RawConfigReader = class extends Effect12.Service()("RawConfigReader", {
 // src/services/schema-validator.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-import { Effect as Effect13 } from "effect";
-var SchemaValidator = class extends Effect13.Service()("SchemaValidator", {
-  effect: Effect13.gen(function* () {
+import { Effect as Effect14 } from "effect";
+var SchemaValidator = class extends Effect14.Service()("SchemaValidator", {
+  effect: Effect14.gen(function* () {
     const ajv = new Ajv();
     addFormats(ajv);
-    const validate = Effect13.fn("SchemaValidator.validate")(function* (config, schema, filePath) {
+    const validate = Effect14.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* Effect13.fail(
+        return yield* Effect14.fail(
           new ConfigSchemaValidationError({
             message: `Config file at ${filePath} is invalid: ${ajv.errorsText(compiledValidate.errors)}`,
             filePath,
@@ -1357,9 +1502,51 @@ var SchemaValidator = class extends Effect13.Service()("SchemaValidator", {
 
 // src/services/v4-config-parser.ts
 import { FileSystem as FileSystem10, Path as Path8 } from "@effect/platform";
-import { getFilesForPattern } from "@gigadrive/build-utils";
-import { Effect as Effect14 } from "effect";
+
+// ../build-utils/src/get-files-for-pattern.ts
 import { minimatch } from "minimatch";
+import { readdir } from "fs/promises";
+var getFilesForPattern = async (pattern, projectFolder, excludeFiles = []) => {
+  const files = [];
+  const filesInFolder = await readdir(projectFolder, { recursive: true });
+  const exactFiles = new Set(filesInFolder.filter((file) => typeof file === "string"));
+  let regex = null;
+  if (!exactFiles.has(pattern)) {
+    try {
+      regex = new RegExp(`^(?:${pattern})$`);
+    } catch {
+    }
+  }
+  const finalExclusions = Array.isArray(excludeFiles) ? excludeFiles : [excludeFiles];
+  for (const file of filesInFolder) {
+    if (typeof file !== "string") {
+      continue;
+    }
+    if (finalExclusions.some((excludeFile) => {
+      if (minimatch(file, excludeFile)) {
+        return true;
+      }
+      if (!exactFiles.has(excludeFile)) {
+        try {
+          return new RegExp(`^(?:${excludeFile})$`).test(file);
+        } catch {
+          return false;
+        }
+      }
+      return false;
+    })) {
+      continue;
+    }
+    if (minimatch(file, pattern) || regex != null && regex.test(file)) {
+      files.push(file);
+    }
+  }
+  return files;
+};
+
+// src/services/v4-config-parser.ts
+import { Effect as Effect15 } from "effect";
+import { minimatch as minimatch2 } from "minimatch";
 import safeRegex from "safe-regex2";
 var MAX_ASSET_DEPTH = 100;
 var DISALLOWED_ASSET_EXTENSIONS = [".htaccess", ".htpasswd"];
@@ -1424,7 +1611,7 @@ var destinationMatchesEntrypoint = (destination, entrypointPath) => {
   return new RegExp(`^${pattern}$`).test(entrypointPath);
 };
 var matchesPattern = (path2, pattern) => {
-  if (minimatch(path2, pattern)) return true;
+  if (minimatch2(path2, pattern)) return true;
   try {
     if (safeRegex(pattern)) {
       return new RegExp(pattern).test(path2);
@@ -1464,7 +1651,7 @@ var mapRoute = (route, entrypoints) => ({
   negativeRequirements: route.missing,
   status: route.statusCode
 });
-var parseEntrypoints = Effect14.fn("parseEntrypoints")(function* (config, projectFolder) {
+var parseEntrypoints = Effect15.fn("parseEntrypoints")(function* (config, projectFolder) {
   const entrypoints = [];
   if (config.functions == null) return entrypoints;
   for (const [fnPath, func] of Object.entries(config.functions)) {
@@ -1474,7 +1661,7 @@ var parseEntrypoints = Effect14.fn("parseEntrypoints")(function* (config, projec
         functionPath: fnPath
       });
     }
-    const matchedFiles = yield* Effect14.tryPromise({
+    const matchedFiles = yield* Effect15.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)}`,
@@ -1510,14 +1697,14 @@ var parseEntrypoints = Effect14.fn("parseEntrypoints")(function* (config, projec
   }
   return entrypoints;
 });
-var collectAssets = Effect14.fn("collectAssets")(function* (config, projectFolder) {
+var collectAssets = Effect15.fn("collectAssets")(function* (config, projectFolder) {
   if (config.assets == null) return [];
   const fs = yield* FileSystem10.FileSystem;
   const pathService = yield* Path8.Path;
   const assetsPath = pathService.join(projectFolder, config.assets);
-  const assetsExist = yield* fs.exists(assetsPath).pipe(Effect14.catchAll(() => Effect14.succeed(false)));
+  const assetsExist = yield* fs.exists(assetsPath).pipe(Effect15.catchAll(() => Effect15.succeed(false)));
   if (!assetsExist) return [];
-  const stat = yield* fs.stat(assetsPath).pipe(Effect14.catchAll(() => Effect14.succeed(null)));
+  const stat = yield* fs.stat(assetsPath).pipe(Effect15.catchAll(() => Effect15.succeed(null)));
   if (!stat || stat.type !== "Directory") return [];
   const allFiles = yield* collectFilesRecursively(assetsPath);
   const assets = [];
@@ -1528,18 +1715,18 @@ var collectAssets = Effect14.fn("collectAssets")(function* (config, projectFolde
   }
   return assets;
 });
-var collectFilesRecursively = Effect14.fn("collectFilesRecursively")(
+var collectFilesRecursively = Effect15.fn("collectFilesRecursively")(
   function* (basePath, relativePath = "", depth = 0) {
     if (depth > MAX_ASSET_DEPTH) return [];
     const fs = yield* FileSystem10.FileSystem;
     const pathSvc = yield* Path8.Path;
     const currentPath = relativePath ? pathSvc.join(basePath, relativePath) : basePath;
-    const entries = yield* fs.readDirectory(currentPath).pipe(Effect14.catchAll(() => Effect14.succeed([])));
+    const entries = yield* fs.readDirectory(currentPath).pipe(Effect15.catchAll(() => Effect15.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(Effect14.catchAll(() => Effect14.succeed(null)));
+      const stat = yield* fs.stat(fullPath).pipe(Effect15.catchAll(() => Effect15.succeed(null)));
       if (!stat) continue;
       if (stat.type === "Directory") {
         const nested = yield* collectFilesRecursively(basePath, entryRelative, depth + 1);
@@ -1551,16 +1738,16 @@ var collectFilesRecursively = Effect14.fn("collectFilesRecursively")(
     return result;
   }
 );
-var V4ConfigParser = class extends Effect14.Service()("V4ConfigParser", {
+var V4ConfigParser = class extends Effect15.Service()("V4ConfigParser", {
   accessors: true,
-  effect: Effect14.succeed({
+  effect: Effect15.succeed({
     /**
      * Parses a ConfigV4 into a NormalizedConfig.
      *
      * @param config - The raw V4 config object
      * @param projectFolder - Absolute path to the project root
      */
-    parse: Effect14.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
+    parse: Effect15.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
       const entrypoints = yield* parseEntrypoints(config, projectFolder);
       const assets = yield* collectAssets(config, projectFolder);
       return {
@@ -1587,9 +1774,35 @@ var V4ConfigParser = class extends Effect14.Service()("V4ConfigParser", {
 
 // src/services/vercel-build-output-parser.ts
 import { Path as Path9 } from "@effect/platform";
-import { getFilesForPattern as getFilesForPattern2 } from "@gigadrive/build-utils";
-import { deepMerge } from "@gigadrive/commons";
-import { Effect as Effect15 } from "effect";
+
+// ../commons/src/deep-merge.ts
+var deepMerge = (target, ...partials) => {
+  const isObject = (item) => item !== null && typeof item === "object";
+  if (!isObject(target)) {
+    return target;
+  }
+  for (const partial of partials) {
+    if (!isObject(partial)) {
+      continue;
+    }
+    Object.keys(partial).forEach((key) => {
+      if (key === "__proto__" || key === "constructor") return;
+      const targetValue = target[key];
+      const sourceValue = partial[key];
+      if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+        targetValue.push(...sourceValue);
+      } else if (isObject(targetValue) && isObject(sourceValue)) {
+        deepMerge(targetValue, sourceValue);
+      } else {
+        target[key] = sourceValue;
+      }
+    });
+  }
+  return target;
+};
+
+// src/services/vercel-build-output-parser.ts
+import { Effect as Effect16 } from "effect";
 
 // src/build-output-v3/determine-repo-root.ts
 import path from "path";
@@ -1685,11 +1898,11 @@ var translateVercelRuntime = (runtime) => {
 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 Effect15.Service()("VercelBuildOutputParser", {
-  effect: Effect15.gen(function* () {
+var VercelBuildOutputParser = class extends Effect16.Service()("VercelBuildOutputParser", {
+  effect: Effect16.gen(function* () {
     const rawConfigReader = yield* RawConfigReader;
     const pathService = yield* Path9.Path;
-    const parse = Effect15.fn("VercelBuildOutputParser.parse")(function* (parseResult, projectFolder) {
+    const parse = Effect16.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;
@@ -1701,9 +1914,9 @@ var VercelBuildOutputParser = class extends Effect15.Service()("VercelBuildOutpu
       merged.regions = [...new Set(merged.regions)];
       return merged;
     });
-    const loadFunctions = Effect15.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
-      const functionConfigs = yield* Effect15.tryPromise({
-        try: () => getFilesForPattern2(FUNCTION_CONFIGS_PATTERN, projectFolder),
+    const loadFunctions = Effect16.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
+      const functionConfigs = yield* Effect16.tryPromise({
+        try: () => getFilesForPattern(FUNCTION_CONFIGS_PATTERN, projectFolder),
         catch: (error) => new ConfigFileParseError({
           message: `Failed to scan for function configs: ${error instanceof Error ? error.message : String(error)}`,
           filePath: projectFolder
@@ -2301,7 +2514,7 @@ var schema_default = {
 };
 
 // src/parse-config.ts
-var parseConfigRaw = Effect16.fn("parseConfigRaw")(function* (filePath, projectFolder) {
+var parseConfigRaw = Effect17.fn("parseConfigRaw")(function* (filePath, projectFolder) {
   const rawReader = yield* RawConfigReader;
   const validator = yield* SchemaValidator;
   const v4Parser = yield* V4ConfigParser;
@@ -2312,7 +2525,7 @@ var parseConfigRaw = Effect16.fn("parseConfigRaw")(function* (filePath, projectF
   };
   const schema = schemaMap[version];
   if (!schema) {
-    return yield* Effect16.fail(
+    return yield* Effect17.fail(
       new ConfigVersionError({
         message: `Config file at ${filePath} has an unsupported version: ${version}`,
         filePath,
@@ -2323,11 +2536,11 @@ var parseConfigRaw = Effect16.fn("parseConfigRaw")(function* (filePath, projectF
   yield* validator.validate(parsed, schema, filePath);
   return yield* v4Parser.parse(parsed, projectFolder);
 });
-var parseConfig = Effect16.fn("parseConfig")(function* (filePath, projectFolder) {
+var parseConfig = Effect17.fn("parseConfig")(function* (filePath, projectFolder) {
   const parseResult = yield* parseConfigRaw(filePath, projectFolder);
   return yield* postProcessConfig(parseResult, projectFolder);
 });
-var postProcessConfig = Effect16.fn("postProcessConfig")(function* (config, projectFolder) {
+var postProcessConfig = Effect17.fn("postProcessConfig")(function* (config, projectFolder) {
   const vercelParser = yield* VercelBuildOutputParser;
   let result = yield* vercelParser.parse(config, projectFolder);
   const hasAssets = (result.assets?.paths?.length ?? 0) > 0 || (result.assets?.prefixes?.length ?? 0) > 0 || (result.assets?.manifests?.length ?? 0) > 0;
@@ -2357,7 +2570,12 @@ var AVAILABLE_RUNTIMES = [...RUNTIME_DEFINITIONS];
 
 // src/services/index.ts
 import { Layer } from "effect";
-var BaseLayers = Layer.mergeAll(RawConfigReader.Default, SchemaValidator.Default, V4ConfigParser.Default);
+var BaseLayers = Layer.mergeAll(
+  ConfigModuleLoader.Default,
+  RawConfigReader.Default,
+  SchemaValidator.Default,
+  V4ConfigParser.Default
+);
 var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(Layer.provideMerge(BaseLayers));
 export {
   ALLOWED_CONFIG_NAMES,
@@ -2366,6 +2584,8 @@ export {
   ConfigFileEmptyError,
   ConfigFileNotFoundError,
   ConfigFileParseError,
+  ConfigModuleLoadError,
+  ConfigModuleLoader,
   ConfigSchemaValidationError,
   ConfigVersionError,
   DEFAULT_FUNCTION_DURATION_SECONDS,
@@ -2376,8 +2596,12 @@ export {
   GigadriveNextBuildManifestV1Schema,
   GigadriveNextBuildManifestV2ExportSchema,
   GigadriveNextBuildManifestV2StandaloneSchema,
+  GigadriveNextMiddlewareDescriptorSchema,
+  GigadriveNextMiddlewareMatcherSchema,
   GigadriveNextPrerenderManifestV1Schema,
   GigadriveNextPrerenderOutputSchema,
+  GigadriveNextPrerenderSeedMethodsSchema,
+  GigadriveNextRouteConditionSchema,
   GigadriveNextServerDescriptorSchema,
   GigadriveNextStaticAssetPrefixSchema,
   MAX_FUNCTION_DURATION_SECONDS,
@@ -2392,6 +2616,7 @@ export {
   StaticAssetManifestV1Schema,
   V4ConfigParser,
   VercelBuildOutputParser,
+  defineConfig,
   detectFramework,
   detectPackageManager,
   filterFunctionsFromAssets,