@gigadrive/network-config 4.6.0 → 5.0.0

package/dist/index.mjs

@@ -55,16 +55,54 @@ 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/collect-asset-files.ts
+import { FileSystem, Path } from "@effect/platform";
+import { Effect } from "effect";
+var MAX_ASSET_DEPTH = 100;
+var DISALLOWED_ASSET_EXTENSIONS = [".htaccess", ".htpasswd"];
+var collectFilesRecursively = Effect.fn("collectFilesRecursively")(
+  function* (basePath, relativePath = "", depth = 0) {
+    if (depth > MAX_ASSET_DEPTH) return [];
+    const fs = yield* FileSystem.FileSystem;
+    const pathSvc = yield* Path.Path;
+    const currentPath = relativePath ? pathSvc.join(basePath, relativePath) : basePath;
+    const entries = yield* fs.readDirectory(currentPath).pipe(Effect.catchAll(() => Effect.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(Effect.catchAll(() => Effect.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 collectAssetFiles = Effect.fn("collectAssetFiles")(function* (projectFolder, assetsDir) {
+  const fs = yield* FileSystem.FileSystem;
+  const pathService = yield* Path.Path;
+  const assetsPath = pathService.join(projectFolder, assetsDir);
+  const stat = yield* fs.stat(assetsPath).pipe(Effect.catchAll(() => Effect.succeed(null)));
+  if (!stat || stat.type !== "Directory") return [];
+  const files = yield* collectFilesRecursively(assetsPath);
+  return files.map((file) => file.replaceAll("\\", "/")).filter((file) => !DISALLOWED_ASSET_EXTENSIONS.some((extension) => file.toLowerCase().endsWith(extension))).sort();
+});
+
 // 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";
+import { FileSystem as FileSystem9, Path as Path7 } from "@effect/platform";
+import { Effect as Effect11 } from "effect";
 
 // src/detection/detect-package-manager.ts
-import { FileSystem, Path } from "@effect/platform";
-import { Effect } from "effect";
+import { FileSystem as FileSystem2, Path as Path2 } from "@effect/platform";
+import { Effect as Effect2 } from "effect";
 var LOCKFILE_MAP = [
   { files: ["bun.lockb", "bun.lock"], pm: "bun" },
   { files: ["pnpm-lock.yaml"], pm: "pnpm" },
@@ -72,19 +110,19 @@ var LOCKFILE_MAP = [
   { 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;
+var detectPackageManager = Effect2.fn("detectPackageManager")(function* (projectFolder) {
+  const fs = yield* FileSystem2.FileSystem;
+  const pathService = yield* Path2.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)));
+      const exists = yield* fs.exists(pathService.join(projectFolder, file)).pipe(Effect2.catchAll(() => Effect2.succeed(false)));
       if (exists) {
-        yield* Effect.logDebug(`Detected package manager: ${pm} (via ${file})`);
+        yield* Effect2.logDebug(`Detected package manager: ${pm} (via ${file})`);
         return pm;
       }
     }
   }
-  yield* Effect.logDebug("No lockfile found, defaulting to npm");
+  yield* Effect2.logDebug("No lockfile found, defaulting to npm");
   return "npm";
 });
 
@@ -110,8 +148,8 @@ var astro = {
 };
 
 // src/detection/frameworks/resolve-node-entrypoint.ts
-import { FileSystem as FileSystem2, Path as Path2 } from "@effect/platform";
-import { Effect as Effect2 } from "effect";
+import { FileSystem as FileSystem3, Path as Path3 } from "@effect/platform";
+import { Effect as Effect3 } from "effect";
 var SCRIPT_RUNNERS = /* @__PURE__ */ new Set(["node", "bun", "tsx", "ts-node"]);
 var COMMON_ENTRYPOINT_CANDIDATES = [
   "index.js",
@@ -159,14 +197,14 @@ var applyEntrypoint = (defaults, entrypoint) => ({
     (route) => route.destination === defaults.entrypoint ? { ...route, destination: entrypoint } : route
   )
 });
-var resolveNodeServerEntrypoint = (defaults, projectFolder) => Effect2.gen(function* () {
-  const fs = yield* FileSystem2.FileSystem;
-  const pathService = yield* Path2.Path;
+var resolveNodeServerEntrypoint = (defaults, projectFolder) => Effect3.gen(function* () {
+  const fs = yield* FileSystem3.FileSystem;
+  const pathService = yield* Path3.Path;
   const isFile = (relativePath) => fs.stat(pathService.join(projectFolder, relativePath)).pipe(
-    Effect2.map((info) => info.type === "File"),
-    Effect2.catchAll(() => Effect2.succeed(false))
+    Effect3.map((info) => info.type === "File"),
+    Effect3.catchAll(() => Effect3.succeed(false))
   );
-  const content = yield* fs.readFileString(pathService.join(projectFolder, "package.json")).pipe(Effect2.catchAll(() => Effect2.succeed(void 0)));
+  const content = yield* fs.readFileString(pathService.join(projectFolder, "package.json")).pipe(Effect3.catchAll(() => Effect3.succeed(void 0)));
   const manifest = content ? parsePackageJson(content) : void 0;
   const startScript = typeof manifest?.scripts?.start === "string" ? manifest.scripts.start : void 0;
   const candidates = [
@@ -298,8 +336,8 @@ var laravel = {
 };
 
 // src/detection/frameworks/nestjs.ts
-import { FileSystem as FileSystem3 } from "@effect/platform";
-import { Effect as Effect3 } from "effect";
+import { FileSystem as FileSystem4 } from "@effect/platform";
+import { Effect as Effect4 } from "effect";
 var isRecord2 = (value) => typeof value === "object" && value !== null;
 var parseNestCliJson = (content) => {
   try {
@@ -350,9 +388,9 @@ var nestjs = {
   detectors: [{ matchPackage: "@nestjs/core" }],
   priority: 90,
   getDefaultConfig: () => createNestConfig("dist"),
-  refineDefaultConfig: (defaults, projectFolder) => Effect3.gen(function* () {
-    const fs = yield* FileSystem3.FileSystem;
-    const content = yield* fs.readFileString(`${projectFolder}/nest-cli.json`).pipe(Effect3.catchAll(() => Effect3.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => Effect4.gen(function* () {
+    const fs = yield* FileSystem4.FileSystem;
+    const content = yield* fs.readFileString(`${projectFolder}/nest-cli.json`).pipe(Effect4.catchAll(() => Effect4.succeed(void 0)));
     if (!content) return defaults;
     const nestConfig = parseNestCliJson(content);
     const outputPath = nestConfig ? getProjectOutputPath(nestConfig) : void 0;
@@ -361,28 +399,28 @@ var nestjs = {
 };
 
 // src/detection/frameworks/nextjs.ts
-import { FileSystem as FileSystem5, Path as Path4 } from "@effect/platform";
-import { Effect as Effect5 } from "effect";
+import { FileSystem as FileSystem6, Path as Path5 } from "@effect/platform";
+import { Effect as Effect6 } from "effect";
 
 // src/build-output-v3/get-default-path-map.ts
-import { FileSystem as FileSystem4, Path as Path3 } from "@effect/platform";
-import { Effect as Effect4 } from "effect";
-var getDefaultPathMap = Effect4.fn("getDefaultPathMap")(function* (directory) {
-  const fs = yield* FileSystem4.FileSystem;
-  const pathService = yield* Path3.Path;
+import { FileSystem as FileSystem5, Path as Path4 } from "@effect/platform";
+import { Effect as Effect5 } from "effect";
+var getDefaultPathMap = Effect5.fn("getDefaultPathMap")(function* (directory) {
+  const fs = yield* FileSystem5.FileSystem;
+  const pathService = yield* Path4.Path;
   const result = {};
-  const exists = yield* fs.exists(directory).pipe(Effect4.catchAll(() => Effect4.succeed(false)));
+  const exists = yield* fs.exists(directory).pipe(Effect5.catchAll(() => Effect5.succeed(false)));
   if (!exists) {
     return result;
   }
   const MAX_DEPTH = 100;
-  const processDirectory = (currentPath, basePath = "", depth = 0) => Effect4.gen(function* () {
+  const processDirectory = (currentPath, basePath = "", depth = 0) => Effect5.gen(function* () {
     if (depth > MAX_DEPTH) return;
-    const entries = yield* fs.readDirectory(currentPath).pipe(Effect4.catchAll(() => Effect4.succeed([])));
+    const entries = yield* fs.readDirectory(currentPath).pipe(Effect5.catchAll(() => Effect5.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(Effect4.catchAll(() => Effect4.succeed(null)));
+      const stat = yield* fs.stat(fullPath).pipe(Effect5.catchAll(() => Effect5.succeed(null)));
       if (!stat) continue;
       if (stat.type === "Directory") {
         yield* processDirectory(fullPath, relativePath, depth + 1);
@@ -454,38 +492,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({
@@ -494,6 +554,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),
@@ -504,6 +601,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),
@@ -560,7 +660,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)
       })
     )
   })
@@ -573,6 +674,7 @@ var GigadriveNextBuildManifestSchema = Schema3.Union(
 var GigadriveNextPrerenderManifestV1Schema = Schema3.mutable(
   Schema3.Struct({
     version: Schema3.Literal(1),
+    seedMethods: Schema3.optional(GigadriveNextPrerenderSeedMethodsSchema),
     prerenders: PrerenderArraySchema
   })
 );
@@ -604,22 +706,22 @@ var AVAILABLE_REGIONS = [...REGION_DEFINITIONS];
 // src/detection/frameworks/nextjs.ts
 var toPortablePath = (value) => value.replaceAll("\\", "/");
 var STANDALONE_SERVER_MEMORY_MB = 1024;
-var resolveStandaloneServer = Effect5.fn("nextjs.resolveStandaloneServer")(function* (projectFolder, distDir, repoRootToProject) {
-  const fs = yield* FileSystem5.FileSystem;
-  const pathService = yield* Path4.Path;
+var resolveStandaloneServer = Effect6.fn("nextjs.resolveStandaloneServer")(function* (projectFolder, distDir, repoRootToProject) {
+  const fs = yield* FileSystem6.FileSystem;
+  const pathService = yield* Path5.Path;
   const standaloneRoot = pathService.join(projectFolder, distDir, "standalone");
   const monorepoServer = pathService.join(standaloneRoot, repoRootToProject, "server.js");
   const rootServer = pathService.join(standaloneRoot, "server.js");
-  const monorepoServerExists = yield* fs.exists(monorepoServer).pipe(Effect5.catchAll(() => Effect5.succeed(false)));
+  const monorepoServerExists = yield* fs.exists(monorepoServer).pipe(Effect6.catchAll(() => Effect6.succeed(false)));
   const serverPath = monorepoServerExists ? monorepoServer : rootServer;
-  const serverExists = yield* fs.exists(serverPath).pipe(Effect5.catchAll(() => Effect5.succeed(false)));
+  const serverExists = yield* fs.exists(serverPath).pipe(Effect6.catchAll(() => Effect6.succeed(false)));
   if (!serverExists) return void 0;
   const serverDirectory = pathService.dirname(serverPath);
   const entrypoint = toPortablePath(pathService.relative(standaloneRoot, serverPath));
   return { standaloneRoot, serverDirectory, entrypoint };
 });
-var buildStandalonePublicAssets = Effect5.fn("nextjs.buildStandalonePublicAssets")(function* (projectFolder, standaloneRoot, serverDirectory) {
-  const pathService = yield* Path4.Path;
+var buildStandalonePublicAssets = Effect6.fn("nextjs.buildStandalonePublicAssets")(function* (projectFolder, standaloneRoot, serverDirectory) {
+  const pathService = yield* Path5.Path;
   const publicFiles = yield* getDefaultPathMap(pathService.join(projectFolder, "public"));
   const assetPaths = [];
   const assetOverrides = {};
@@ -635,8 +737,8 @@ var buildStandalonePublicAssets = Effect5.fn("nextjs.buildStandalonePublicAssets
   }
   return { assetPaths, assetOverrides, filePathMap };
 });
-var createStaticExportConfig = Effect5.fn("nextjs.createStaticExportConfig")(function* (defaults, projectFolder) {
-  const pathService = yield* Path4.Path;
+var createStaticExportConfig = Effect6.fn("nextjs.createStaticExportConfig")(function* (defaults, projectFolder) {
+  const pathService = yield* Path5.Path;
   const outputDirectory = pathService.join(projectFolder, "out");
   const files = yield* getDefaultPathMap(outputDirectory);
   const assetPaths = [];
@@ -659,8 +761,8 @@ var createStaticExportConfig = Effect5.fn("nextjs.createStaticExportConfig")(fun
     package: void 0
   };
 });
-var createStandaloneConfig = Effect5.fn("nextjs.createStandaloneConfig")(function* (defaults, projectFolder, manifest) {
-  const pathService = yield* Path4.Path;
+var createStandaloneConfig = Effect6.fn("nextjs.createStandaloneConfig")(function* (defaults, projectFolder, manifest) {
+  const pathService = yield* Path5.Path;
   const resolved = yield* resolveStandaloneServer(projectFolder, manifest.distDir, manifest.repoRootToProject);
   if (!resolved) return defaults;
   const { standaloneRoot, serverDirectory, entrypoint } = resolved;
@@ -693,7 +795,7 @@ var createStandaloneConfig = Effect5.fn("nextjs.createStandaloneConfig")(functio
     }
   };
 });
-var createStandaloneV2Config = Effect5.fn("nextjs.createStandaloneV2Config")(function* (defaults, projectFolder, manifest) {
+var createStandaloneV2Config = Effect6.fn("nextjs.createStandaloneV2Config")(function* (defaults, projectFolder, manifest) {
   const resolved = yield* resolveStandaloneServer(projectFolder, manifest.distDir, manifest.repoRootToProject);
   if (!resolved) return defaults;
   const { standaloneRoot, serverDirectory, entrypoint } = resolved;
@@ -791,14 +893,19 @@ var nextjs = {
     streaming: true,
     commands: ["next build"],
     entrypoint: ".next/standalone/server.js",
-    assetsDir: ".next/static",
+    // No `assetsDir`: this is only the fallback for a standalone build whose
+    // Gigadrive manifest is missing, and `.next/static` answers
+    // `/_next/static/...` rather than its own stripped prefix. Every path that
+    // resolves a real Next.js build (`refineDefaultConfig`) maps those chunks
+    // itself, so declaring the directory here would publish them at the wrong
+    // URLs.
     populateAssetCache: true,
     routes: [{ source: "/*", destination: ".next/standalone/server.js" }],
     environmentVariables: { NODE_ENV: "production" }
   }),
-  refineDefaultConfig: (defaults, projectFolder) => Effect5.gen(function* () {
-    const fs = yield* FileSystem5.FileSystem;
-    const manifestContent = yield* fs.readFileString(`${projectFolder}/.gigadrive/nextjs.json`).pipe(Effect5.catchAll(() => Effect5.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => Effect6.gen(function* () {
+    const fs = yield* FileSystem6.FileSystem;
+    const manifestContent = yield* fs.readFileString(`${projectFolder}/.gigadrive/nextjs.json`).pipe(Effect6.catchAll(() => Effect6.succeed(void 0)));
     const manifest = manifestContent ? parseGigadriveNextBuildManifest(manifestContent) : void 0;
     if (!manifest) return defaults;
     if (manifest.version === 2) {
@@ -809,8 +916,8 @@ var nextjs = {
 };
 
 // src/detection/frameworks/nuxt.ts
-import { FileSystem as FileSystem6 } from "@effect/platform";
-import { Effect as Effect6 } from "effect";
+import { FileSystem as FileSystem7 } from "@effect/platform";
+import { Effect as Effect7 } from "effect";
 var isVercelBuildOutputV3 = (content) => {
   try {
     const config = JSON.parse(content);
@@ -837,9 +944,9 @@ var nuxt = {
     routes: [{ source: "/*", destination: ".output/server/index.mjs" }],
     environmentVariables: { NODE_ENV: "production", NITRO_PRESET: "node-server" }
   }),
-  refineDefaultConfig: (defaults, projectFolder) => Effect6.gen(function* () {
-    const fs = yield* FileSystem6.FileSystem;
-    const buildOutputConfig = yield* fs.readFileString(`${projectFolder}/.vercel/output/config.json`).pipe(Effect6.catchAll(() => Effect6.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => Effect7.gen(function* () {
+    const fs = yield* FileSystem7.FileSystem;
+    const buildOutputConfig = yield* fs.readFileString(`${projectFolder}/.vercel/output/config.json`).pipe(Effect7.catchAll(() => Effect7.succeed(void 0)));
     if (!buildOutputConfig || !isVercelBuildOutputV3(buildOutputConfig)) {
       return defaults;
     }
@@ -962,7 +1069,7 @@ var FRAMEWORK_DEFINITIONS = [
 ].sort((a, b) => b.priority - a.priority);
 
 // src/detection/generate-config.ts
-import { Effect as Effect7 } from "effect";
+import { Effect as Effect8 } from "effect";
 var getInstallCommand = (pm) => {
   switch (pm) {
     case "bun":
@@ -978,11 +1085,11 @@ var getInstallCommand = (pm) => {
       return "npm install";
   }
 };
-var generateConfig = Effect7.fn("generateConfig")(function* (framework, packageManager, refinedDefaults) {
+var generateConfig = Effect8.fn("generateConfig")(function* (framework, packageManager, projectFolder, refinedDefaults) {
   const defaults = refinedDefaults ?? framework.getDefaultConfig(packageManager);
   const installCmd = defaults.installCommand ?? getInstallCommand(packageManager);
   const commands = [installCmd, ...defaults.commands];
-  yield* Effect7.logDebug(`Generating config for ${framework.name}`, {
+  yield* Effect8.logDebug(`Generating config for ${framework.name}`, {
     runtime: defaults.runtime,
     entrypoint: defaults.entrypoint,
     commands
@@ -1017,10 +1124,26 @@ var generateConfig = Effect7.fn("generateConfig")(function* (framework, packageM
     ...defaults.normalizedConfig
   };
   if (defaults.assetsDir || defaults.assetPaths || defaults.assetPrefixes || defaults.assetManifests) {
+    const paths = defaults.assetPaths ? [...defaults.assetPaths] : [];
+    const overrides = { ...defaults.assetOverrides };
+    const servesDirectoryIndexes = entrypoints.length === 0 && routes.length === 0;
+    const assetsDir = defaults.assetsDir;
+    if (assetsDir && !defaults.assetPaths && !defaults.assetPrefixes && !defaults.assetManifests) {
+      for (const file of yield* collectAssetFiles(projectFolder, assetsDir)) {
+        if (framework.language === "php" && /\.(php|phtml|phar)$/i.test(file)) continue;
+        paths.push(`${assetsDir}/${file}`);
+        if (!servesDirectoryIndexes || file in overrides) continue;
+        if (file === "index.html") {
+          overrides[file] = { path: "" };
+        } else if (file.endsWith("/index.html")) {
+          overrides[file] = { path: file.slice(0, -"/index.html".length) };
+        }
+      }
+    }
     config.assets = {
-      paths: defaults.assetPaths ? [...defaults.assetPaths] : [],
+      paths,
       prefixToStrip: defaults.assetsPrefixToStrip ?? (defaults.assetsDir ? defaults.assetsDir + "/" : ""),
-      overrides: defaults.assetOverrides ? { ...defaults.assetOverrides } : void 0,
+      overrides: Object.keys(overrides).length > 0 ? overrides : void 0,
       prefixes: defaults.assetPrefixes ? defaults.assetPrefixes.map((prefix) => ({ ...prefix })) : void 0,
       manifests: defaults.assetManifests ? defaults.assetManifests.map((manifest) => ({ ...manifest })) : void 0,
       dynamicRoutes: true,
@@ -1031,8 +1154,8 @@ var generateConfig = Effect7.fn("generateConfig")(function* (framework, packageM
 });
 
 // src/detection/read-dependencies.ts
-import { FileSystem as FileSystem7, Path as Path5 } from "@effect/platform";
-import { Effect as Effect9 } from "effect";
+import { FileSystem as FileSystem8, Path as Path6 } from "@effect/platform";
+import { Effect as Effect10 } from "effect";
 
 // src/detection/types.ts
 import { Schema as Schema4 } from "effect";
@@ -1065,25 +1188,25 @@ var MANIFEST_CONFIG = {
   node: { file: "package.json", depKeys: ["dependencies", "devDependencies"] },
   php: { file: "composer.json", depKeys: ["require", "require-dev"] }
 };
-var readManifest = Effect9.fn("readManifest")(function* (filePath) {
-  const fs = yield* FileSystem7.FileSystem;
-  const exists = yield* fs.exists(filePath).pipe(Effect9.catchAll(() => Effect9.succeed(false)));
+var readManifest = Effect10.fn("readManifest")(function* (filePath) {
+  const fs = yield* FileSystem8.FileSystem;
+  const exists = yield* fs.exists(filePath).pipe(Effect10.catchAll(() => Effect10.succeed(false)));
   if (!exists) {
-    return yield* Effect9.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
+    return yield* Effect10.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
   }
-  const content = yield* fs.readFileString(filePath).pipe(Effect9.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
-  const parsed = yield* Effect9.try({
+  const content = yield* fs.readFileString(filePath).pipe(Effect10.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
+  const parsed = yield* Effect10.try({
     try: () => JSON.parse(content),
     catch: () => new ManifestParseError({ message: "Failed to parse manifest JSON", filePath })
   });
   return parsed;
 });
-var readDependencies = Effect9.fn("readDependencies")(function* (projectFolder, language) {
-  const pathService = yield* Path5.Path;
+var readDependencies = Effect10.fn("readDependencies")(function* (projectFolder, language) {
+  const pathService = yield* Path6.Path;
   const config = MANIFEST_CONFIG[language];
   const filePath = pathService.join(projectFolder, config.file);
   const manifest = yield* readManifest(filePath).pipe(
-    Effect9.catchTag("ManifestNotFoundError", () => Effect9.succeed(null))
+    Effect10.catchTag("ManifestNotFoundError", () => Effect10.succeed(null))
   );
   if (!manifest) {
     return /* @__PURE__ */ new Set();
@@ -1101,9 +1224,9 @@ var readDependencies = Effect9.fn("readDependencies")(function* (projectFolder,
 });
 
 // src/detection/detect-framework.ts
-var matchesDetectionItem = Effect10.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
-  const fs = yield* FileSystem8.FileSystem;
-  const pathService = yield* Path6.Path;
+var matchesDetectionItem = Effect11.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
+  const fs = yield* FileSystem9.FileSystem;
+  const pathService = yield* Path7.Path;
   if (item.matchPackage != null) {
     const deps = yield* cachedReadDeps(`${projectFolder}\0${framework.language}`);
     if (!deps.has(item.matchPackage)) {
@@ -1112,12 +1235,12 @@ var matchesDetectionItem = Effect10.fn("matchesDetectionItem")(function* (item,
   }
   if (item.path != null) {
     const filePath = pathService.join(projectFolder, item.path);
-    const exists = yield* fs.exists(filePath).pipe(Effect10.catchAll(() => Effect10.succeed(false)));
+    const exists = yield* fs.exists(filePath).pipe(Effect11.catchAll(() => Effect11.succeed(false)));
     if (!exists) {
       return false;
     }
     if (item.matchContent != null) {
-      const content = yield* fs.readFileString(filePath).pipe(Effect10.catchAll(() => Effect10.succeed("")));
+      const content = yield* fs.readFileString(filePath).pipe(Effect11.catchAll(() => Effect11.succeed("")));
       let regexMatch = false;
       try {
         regexMatch = new RegExp(item.matchContent).test(content);
@@ -1130,7 +1253,7 @@ var matchesDetectionItem = Effect10.fn("matchesDetectionItem")(function* (item,
   }
   return true;
 });
-var matchesFramework = Effect10.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
+var matchesFramework = Effect11.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
   for (const detector of framework.detectors) {
     const matches = yield* matchesDetectionItem(detector, projectFolder, framework, cachedReadDeps);
     if (!matches) {
@@ -1139,9 +1262,9 @@ var matchesFramework = Effect10.fn("matchesFramework")(function* (framework, pro
   }
   return true;
 });
-var detectFramework = Effect10.fn("detectFramework")(function* (projectFolder) {
-  yield* Effect10.logDebug(`Detecting framework in ${projectFolder}`);
-  const cachedReadDeps = yield* Effect10.cachedFunction((key) => {
+var detectFramework = Effect11.fn("detectFramework")(function* (projectFolder) {
+  yield* Effect11.logDebug(`Detecting framework in ${projectFolder}`);
+  const cachedReadDeps = yield* Effect11.cachedFunction((key) => {
     const sepIndex = key.lastIndexOf("\0");
     const folder = key.slice(0, sepIndex);
     const language = key.slice(sepIndex + 1);
@@ -1150,16 +1273,16 @@ var detectFramework = Effect10.fn("detectFramework")(function* (projectFolder) {
   for (const framework of FRAMEWORK_DEFINITIONS) {
     const matches = yield* matchesFramework(framework, projectFolder, cachedReadDeps);
     if (matches) {
-      yield* Effect10.log(`Detected framework: ${framework.name}`, { slug: framework.slug });
+      yield* Effect11.log(`Detected framework: ${framework.name}`, { slug: framework.slug });
       const detectedPackageManager = yield* detectPackageManager(projectFolder);
       const packageManager = framework.language === "php" ? "composer" : detectedPackageManager;
       const defaults = framework.getDefaultConfig(packageManager);
       const refinedDefaults = framework.refineDefaultConfig ? yield* framework.refineDefaultConfig(defaults, projectFolder) : defaults;
-      const config = yield* generateConfig(framework, packageManager, refinedDefaults);
+      const config = yield* generateConfig(framework, packageManager, projectFolder, refinedDefaults);
       return { framework, packageManager, config };
     }
   }
-  return yield* Effect10.fail(
+  return yield* Effect11.fail(
     new FrameworkNotDetectedError({
       message: `No framework detected in project directory`,
       directory: projectFolder
@@ -1168,9 +1291,9 @@ var detectFramework = Effect10.fn("detectFramework")(function* (projectFolder) {
 });
 
 // src/detection/merge-config.ts
-import { Effect as Effect11 } from "effect";
-var mergeWithFrameworkDefaults = Effect11.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
-  yield* Effect11.logDebug("Merging user config with framework defaults");
+import { Effect as Effect12 } from "effect";
+var mergeWithFrameworkDefaults = Effect12.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
+  yield* Effect12.logDebug("Merging user config with framework defaults");
   const userHasAssets = (userConfig.assets?.paths?.length ?? 0) > 0 || (userConfig.assets?.prefixes?.length ?? 0) > 0 || (userConfig.assets?.manifests?.length ?? 0) > 0;
   const merged = {
     regions: userConfig.regions,
@@ -1252,23 +1375,23 @@ var DEFAULT_FUNCTION_DURATION_SECONDS = 30;
 var MAX_FUNCTION_DURATION_SECONDS = 28800;
 
 // src/parse-config.ts
-import { Effect as Effect17 } from "effect";
+import { Effect as Effect18 } from "effect";
 
 // src/services/raw-config-reader.ts
-import { FileSystem as FileSystem9, Path as Path7 } from "@effect/platform";
-import { Effect as Effect13 } from "effect";
+import { FileSystem as FileSystem10, Path as Path8 } from "@effect/platform";
+import { Effect as Effect14 } from "effect";
 import { parse as parseYaml } from "yaml";
 
 // src/services/config-module-loader.ts
-import { Effect as Effect12 } from "effect";
+import { Effect as Effect13 } 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) {
+var ConfigModuleLoader = class extends Effect13.Service()("ConfigModuleLoader", {
+  effect: Effect13.gen(function* () {
+    const loadConfigModule = Effect13.fn("ConfigModuleLoader.loadConfigModule")(function* (filePath) {
       const extension = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
-      const mod = yield* Effect12.tryPromise({
+      const mod = yield* Effect13.tryPromise({
         try: async () => {
           const jiti = createJiti(filePath, { fsCache: false, interopDefault: true, moduleCache: false });
           const namespace = await jiti.import(filePath);
@@ -1287,7 +1410,7 @@ var ConfigModuleLoader = class extends Effect12.Service()("ConfigModuleLoader",
         })
       });
       if (mod === MISSING_DEFAULT_EXPORT) {
-        return yield* Effect12.fail(
+        return yield* Effect13.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
@@ -1295,7 +1418,7 @@ var ConfigModuleLoader = class extends Effect12.Service()("ConfigModuleLoader",
         );
       }
       if (typeof mod === "function") {
-        return yield* Effect12.fail(
+        return yield* Effect13.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
@@ -1303,7 +1426,7 @@ var ConfigModuleLoader = class extends Effect12.Service()("ConfigModuleLoader",
         );
       }
       if (typeof mod !== "object" || mod === null || Array.isArray(mod)) {
-        return yield* Effect12.fail(
+        return yield* Effect13.fail(
           new ConfigModuleLoadError({
             message: `Config module at ${filePath} must default-export a config object.`,
             filePath
@@ -1333,36 +1456,36 @@ var ALLOWED_CONFIG_NAMES = [
   "nebula.json"
 ];
 var MODULE_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
-var RawConfigReader = class extends Effect13.Service()("RawConfigReader", {
+var RawConfigReader = class extends Effect14.Service()("RawConfigReader", {
   dependencies: [ConfigModuleLoader.Default],
-  effect: Effect13.gen(function* () {
-    const fs = yield* FileSystem9.FileSystem;
-    const pathService = yield* Path7.Path;
+  effect: Effect14.gen(function* () {
+    const fs = yield* FileSystem10.FileSystem;
+    const pathService = yield* Path8.Path;
     const moduleLoader = yield* ConfigModuleLoader;
-    const findConfig = Effect13.fn("RawConfigReader.findConfig")(function* (projectFolder) {
+    const findConfig = Effect14.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(Effect13.catchAll(() => Effect13.succeed(false)));
+        const exists = yield* fs.exists(filePath).pipe(Effect14.catchAll(() => Effect14.succeed(false)));
         if (exists) {
           return filePath;
         }
       }
       return null;
     });
-    const readRawConfig = Effect13.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
-      const exists = yield* fs.exists(filePath).pipe(Effect13.catchAll(() => Effect13.succeed(false)));
+    const readRawConfig = Effect14.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
+      const exists = yield* fs.exists(filePath).pipe(Effect14.catchAll(() => Effect14.succeed(false)));
       if (!exists) {
-        return yield* Effect13.fail(
+        return yield* Effect14.fail(
           new ConfigFileNotFoundError({ message: `Config file not found at ${filePath}`, filePath })
         );
       }
       const fileContents = yield* fs.readFileString(filePath).pipe(
-        Effect13.mapError(
+        Effect14.mapError(
           () => new ConfigFileParseError({ message: `Failed to read config file at ${filePath}`, filePath })
         )
       );
       if (fileContents.length === 0) {
-        return yield* Effect13.fail(
+        return yield* Effect14.fail(
           new ConfigFileEmptyError({ message: `Config file is empty at ${filePath}`, filePath })
         );
       }
@@ -1378,7 +1501,7 @@ var RawConfigReader = class extends Effect13.Service()("RawConfigReader", {
             parsed = parseYaml(fileContents);
           }
         } catch (error) {
-          return yield* Effect13.fail(
+          return yield* Effect14.fail(
             new ConfigFileParseError({
               message: `Failed to parse config file at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
               filePath,
@@ -1388,21 +1511,21 @@ var RawConfigReader = class extends Effect13.Service()("RawConfigReader", {
         }
       }
       if (parsed == null) {
-        return yield* Effect13.fail(
+        return yield* Effect14.fail(
           new ConfigFileParseError({ message: `Config file could not be parsed at ${filePath}`, filePath })
         );
       }
       if (!options?.disableVersionCheck && typeof parsed.version !== "number") {
-        return yield* Effect13.fail(
+        return yield* Effect14.fail(
           new ConfigVersionError({ message: `Config file is missing version at ${filePath}`, filePath })
         );
       }
       return parsed;
     });
     const readConfigFile = (configFilePath) => readRawConfig(configFilePath, { disableVersionCheck: true }).pipe(
-      Effect13.map((parsed) => parsed),
-      Effect13.catchTag("ConfigFileNotFoundError", () => Effect13.succeed(null)),
-      Effect13.withSpan("RawConfigReader.readConfigFile")
+      Effect14.map((parsed) => parsed),
+      Effect14.catchTag("ConfigFileNotFoundError", () => Effect14.succeed(null)),
+      Effect14.withSpan("RawConfigReader.readConfigFile")
     );
     return { findConfig, readRawConfig, readConfigFile };
   })
@@ -1412,17 +1535,17 @@ var RawConfigReader = class extends Effect13.Service()("RawConfigReader", {
 // src/services/schema-validator.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-import { Effect as Effect14 } from "effect";
-var SchemaValidator = class extends Effect14.Service()("SchemaValidator", {
-  effect: Effect14.gen(function* () {
+import { Effect as Effect15 } from "effect";
+var SchemaValidator = class extends Effect15.Service()("SchemaValidator", {
+  effect: Effect15.gen(function* () {
     const ajv = new Ajv();
     addFormats(ajv);
-    const validate = Effect14.fn("SchemaValidator.validate")(function* (config, schema, filePath) {
+    const validate = Effect15.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* Effect14.fail(
+        return yield* Effect15.fail(
           new ConfigSchemaValidationError({
             message: `Config file at ${filePath} is invalid: ${ajv.errorsText(compiledValidate.errors)}`,
             filePath,
@@ -1436,14 +1559,51 @@ var SchemaValidator = class extends Effect14.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 Effect15 } 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 Effect16 } from "effect";
+import { minimatch as minimatch2 } 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: DEFAULT_FUNCTION_DURATION_SECONDS,
@@ -1505,7 +1665,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);
@@ -1545,7 +1705,7 @@ var mapRoute = (route, entrypoints) => ({
   negativeRequirements: route.missing,
   status: route.statusCode
 });
-var parseEntrypoints = Effect15.fn("parseEntrypoints")(function* (config, projectFolder) {
+var parseEntrypoints = Effect16.fn("parseEntrypoints")(function* (config, projectFolder) {
   const entrypoints = [];
   if (config.functions == null) return entrypoints;
   for (const [fnPath, func] of Object.entries(config.functions)) {
@@ -1555,7 +1715,7 @@ var parseEntrypoints = Effect15.fn("parseEntrypoints")(function* (config, projec
         functionPath: fnPath
       });
     }
-    const matchedFiles = yield* Effect15.tryPromise({
+    const matchedFiles = yield* Effect16.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)}`,
@@ -1591,57 +1751,21 @@ var parseEntrypoints = Effect15.fn("parseEntrypoints")(function* (config, projec
   }
   return entrypoints;
 });
-var collectAssets = Effect15.fn("collectAssets")(function* (config, projectFolder) {
+var collectAssets = Effect16.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(Effect15.catchAll(() => Effect15.succeed(false)));
-  if (!assetsExist) return [];
-  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 = [];
-  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;
+  const assetNames = yield* collectAssetFiles(projectFolder, config.assets);
+  return assetNames.filter((assetName) => getFunctionSettings(`${config.assets}/${assetName}`, config) == null).map((assetName) => `${config.assets}/${assetName}`);
 });
-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(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(Effect15.catchAll(() => Effect15.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 Effect15.Service()("V4ConfigParser", {
+var V4ConfigParser = class extends Effect16.Service()("V4ConfigParser", {
   accessors: true,
-  effect: Effect15.succeed({
+  effect: Effect16.succeed({
     /**
      * Parses a ConfigV4 into a NormalizedConfig.
      *
      * @param config - The raw V4 config object
      * @param projectFolder - Absolute path to the project root
      */
-    parse: Effect15.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
+    parse: Effect16.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
       const entrypoints = yield* parseEntrypoints(config, projectFolder);
       const assets = yield* collectAssets(config, projectFolder);
       return {
@@ -1668,9 +1792,35 @@ var V4ConfigParser = class extends Effect15.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 Effect16 } 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 Effect17 } from "effect";
 
 // src/build-output-v3/determine-repo-root.ts
 import path from "path";
@@ -1766,11 +1916,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 Effect16.Service()("VercelBuildOutputParser", {
-  effect: Effect16.gen(function* () {
+var VercelBuildOutputParser = class extends Effect17.Service()("VercelBuildOutputParser", {
+  effect: Effect17.gen(function* () {
     const rawConfigReader = yield* RawConfigReader;
     const pathService = yield* Path9.Path;
-    const parse = Effect16.fn("VercelBuildOutputParser.parse")(function* (parseResult, projectFolder) {
+    const parse = Effect17.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;
@@ -1782,9 +1932,9 @@ var VercelBuildOutputParser = class extends Effect16.Service()("VercelBuildOutpu
       merged.regions = [...new Set(merged.regions)];
       return merged;
     });
-    const loadFunctions = Effect16.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
-      const functionConfigs = yield* Effect16.tryPromise({
-        try: () => getFilesForPattern2(FUNCTION_CONFIGS_PATTERN, projectFolder),
+    const loadFunctions = Effect17.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
+      const functionConfigs = yield* Effect17.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
@@ -2382,7 +2532,7 @@ var schema_default = {
 };
 
 // src/parse-config.ts
-var parseConfigRaw = Effect17.fn("parseConfigRaw")(function* (filePath, projectFolder) {
+var parseConfigRaw = Effect18.fn("parseConfigRaw")(function* (filePath, projectFolder) {
   const rawReader = yield* RawConfigReader;
   const validator = yield* SchemaValidator;
   const v4Parser = yield* V4ConfigParser;
@@ -2393,7 +2543,7 @@ var parseConfigRaw = Effect17.fn("parseConfigRaw")(function* (filePath, projectF
   };
   const schema = schemaMap[version];
   if (!schema) {
-    return yield* Effect17.fail(
+    return yield* Effect18.fail(
       new ConfigVersionError({
         message: `Config file at ${filePath} has an unsupported version: ${version}`,
         filePath,
@@ -2404,11 +2554,11 @@ var parseConfigRaw = Effect17.fn("parseConfigRaw")(function* (filePath, projectF
   yield* validator.validate(parsed, schema, filePath);
   return yield* v4Parser.parse(parsed, projectFolder);
 });
-var parseConfig = Effect17.fn("parseConfig")(function* (filePath, projectFolder) {
+var parseConfig = Effect18.fn("parseConfig")(function* (filePath, projectFolder) {
   const parseResult = yield* parseConfigRaw(filePath, projectFolder);
   return yield* postProcessConfig(parseResult, projectFolder);
 });
-var postProcessConfig = Effect17.fn("postProcessConfig")(function* (config, projectFolder) {
+var postProcessConfig = Effect18.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;
@@ -2464,8 +2614,12 @@ export {
   GigadriveNextBuildManifestV1Schema,
   GigadriveNextBuildManifestV2ExportSchema,
   GigadriveNextBuildManifestV2StandaloneSchema,
+  GigadriveNextMiddlewareDescriptorSchema,
+  GigadriveNextMiddlewareMatcherSchema,
   GigadriveNextPrerenderManifestV1Schema,
   GigadriveNextPrerenderOutputSchema,
+  GigadriveNextPrerenderSeedMethodsSchema,
+  GigadriveNextRouteConditionSchema,
   GigadriveNextServerDescriptorSchema,
   GigadriveNextStaticAssetPrefixSchema,
   MAX_FUNCTION_DURATION_SECONDS,
@@ -2480,6 +2634,7 @@ export {
   StaticAssetManifestV1Schema,
   V4ConfigParser,
   VercelBuildOutputParser,
+  collectAssetFiles,
   defineConfig,
   detectFramework,
   detectPackageManager,