@gigadrive/network-config 4.6.0 → 5.0.0

package/dist/index.js

@@ -48,8 +48,12 @@ __export(src_exports, {
   GigadriveNextBuildManifestV1Schema: () => GigadriveNextBuildManifestV1Schema,
   GigadriveNextBuildManifestV2ExportSchema: () => GigadriveNextBuildManifestV2ExportSchema,
   GigadriveNextBuildManifestV2StandaloneSchema: () => GigadriveNextBuildManifestV2StandaloneSchema,
+  GigadriveNextMiddlewareDescriptorSchema: () => GigadriveNextMiddlewareDescriptorSchema,
+  GigadriveNextMiddlewareMatcherSchema: () => GigadriveNextMiddlewareMatcherSchema,
   GigadriveNextPrerenderManifestV1Schema: () => GigadriveNextPrerenderManifestV1Schema,
   GigadriveNextPrerenderOutputSchema: () => GigadriveNextPrerenderOutputSchema,
+  GigadriveNextPrerenderSeedMethodsSchema: () => GigadriveNextPrerenderSeedMethodsSchema,
+  GigadriveNextRouteConditionSchema: () => GigadriveNextRouteConditionSchema,
   GigadriveNextServerDescriptorSchema: () => GigadriveNextServerDescriptorSchema,
   GigadriveNextStaticAssetPrefixSchema: () => GigadriveNextStaticAssetPrefixSchema,
   MAX_FUNCTION_DURATION_SECONDS: () => MAX_FUNCTION_DURATION_SECONDS,
@@ -64,6 +68,7 @@ __export(src_exports, {
   StaticAssetManifestV1Schema: () => StaticAssetManifestV1Schema,
   V4ConfigParser: () => V4ConfigParser,
   VercelBuildOutputParser: () => VercelBuildOutputParser,
+  collectAssetFiles: () => collectAssetFiles,
   defineConfig: () => defineConfig,
   detectFramework: () => detectFramework,
   detectPackageManager: () => detectPackageManager,
@@ -138,16 +143,54 @@ var StaticAssetManifestV1Schema = import_effect2.Schema.mutable(
 ).pipe(import_effect2.Schema.filter(({ assets }) => new Set(assets.map(({ path: path2 }) => path2)).size === assets.length));
 var parseStaticAssetManifest = (content) => decodeJson(StaticAssetManifestV1Schema, content);
 
+// src/collect-asset-files.ts
+var import_platform = require("@effect/platform");
+var import_effect3 = require("effect");
+var MAX_ASSET_DEPTH = 100;
+var DISALLOWED_ASSET_EXTENSIONS = [".htaccess", ".htpasswd"];
+var collectFilesRecursively = import_effect3.Effect.fn("collectFilesRecursively")(
+  function* (basePath, relativePath = "", depth = 0) {
+    if (depth > MAX_ASSET_DEPTH) return [];
+    const fs = yield* import_platform.FileSystem.FileSystem;
+    const pathSvc = yield* import_platform.Path.Path;
+    const currentPath = relativePath ? pathSvc.join(basePath, relativePath) : basePath;
+    const entries = yield* fs.readDirectory(currentPath).pipe(import_effect3.Effect.catchAll(() => import_effect3.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(import_effect3.Effect.catchAll(() => import_effect3.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 = import_effect3.Effect.fn("collectAssetFiles")(function* (projectFolder, assetsDir) {
+  const fs = yield* import_platform.FileSystem.FileSystem;
+  const pathService = yield* import_platform.Path.Path;
+  const assetsPath = pathService.join(projectFolder, assetsDir);
+  const stat = yield* fs.stat(assetsPath).pipe(import_effect3.Effect.catchAll(() => import_effect3.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
-var import_platform8 = require("@effect/platform");
-var import_effect13 = require("effect");
+var import_platform9 = require("@effect/platform");
+var import_effect14 = require("effect");
 
 // src/detection/detect-package-manager.ts
-var import_platform = require("@effect/platform");
-var import_effect3 = require("effect");
+var import_platform2 = require("@effect/platform");
+var import_effect4 = require("effect");
 var LOCKFILE_MAP = [
   { files: ["bun.lockb", "bun.lock"], pm: "bun" },
   { files: ["pnpm-lock.yaml"], pm: "pnpm" },
@@ -155,19 +198,19 @@ var LOCKFILE_MAP = [
   { files: ["package-lock.json"], pm: "npm" },
   { files: ["composer.lock"], pm: "composer" }
 ];
-var detectPackageManager = import_effect3.Effect.fn("detectPackageManager")(function* (projectFolder) {
-  const fs = yield* import_platform.FileSystem.FileSystem;
-  const pathService = yield* import_platform.Path.Path;
+var detectPackageManager = import_effect4.Effect.fn("detectPackageManager")(function* (projectFolder) {
+  const fs = yield* import_platform2.FileSystem.FileSystem;
+  const pathService = yield* import_platform2.Path.Path;
   for (const { files, pm } of LOCKFILE_MAP) {
     for (const file of files) {
-      const exists = yield* fs.exists(pathService.join(projectFolder, file)).pipe(import_effect3.Effect.catchAll(() => import_effect3.Effect.succeed(false)));
+      const exists = yield* fs.exists(pathService.join(projectFolder, file)).pipe(import_effect4.Effect.catchAll(() => import_effect4.Effect.succeed(false)));
       if (exists) {
-        yield* import_effect3.Effect.logDebug(`Detected package manager: ${pm} (via ${file})`);
+        yield* import_effect4.Effect.logDebug(`Detected package manager: ${pm} (via ${file})`);
         return pm;
       }
     }
   }
-  yield* import_effect3.Effect.logDebug("No lockfile found, defaulting to npm");
+  yield* import_effect4.Effect.logDebug("No lockfile found, defaulting to npm");
   return "npm";
 });
 
@@ -193,8 +236,8 @@ var astro = {
 };
 
 // src/detection/frameworks/resolve-node-entrypoint.ts
-var import_platform2 = require("@effect/platform");
-var import_effect4 = require("effect");
+var import_platform3 = require("@effect/platform");
+var import_effect5 = require("effect");
 var SCRIPT_RUNNERS = /* @__PURE__ */ new Set(["node", "bun", "tsx", "ts-node"]);
 var COMMON_ENTRYPOINT_CANDIDATES = [
   "index.js",
@@ -242,14 +285,14 @@ var applyEntrypoint = (defaults, entrypoint) => ({
     (route) => route.destination === defaults.entrypoint ? { ...route, destination: entrypoint } : route
   )
 });
-var resolveNodeServerEntrypoint = (defaults, projectFolder) => import_effect4.Effect.gen(function* () {
-  const fs = yield* import_platform2.FileSystem.FileSystem;
-  const pathService = yield* import_platform2.Path.Path;
+var resolveNodeServerEntrypoint = (defaults, projectFolder) => import_effect5.Effect.gen(function* () {
+  const fs = yield* import_platform3.FileSystem.FileSystem;
+  const pathService = yield* import_platform3.Path.Path;
   const isFile = (relativePath) => fs.stat(pathService.join(projectFolder, relativePath)).pipe(
-    import_effect4.Effect.map((info) => info.type === "File"),
-    import_effect4.Effect.catchAll(() => import_effect4.Effect.succeed(false))
+    import_effect5.Effect.map((info) => info.type === "File"),
+    import_effect5.Effect.catchAll(() => import_effect5.Effect.succeed(false))
   );
-  const content = yield* fs.readFileString(pathService.join(projectFolder, "package.json")).pipe(import_effect4.Effect.catchAll(() => import_effect4.Effect.succeed(void 0)));
+  const content = yield* fs.readFileString(pathService.join(projectFolder, "package.json")).pipe(import_effect5.Effect.catchAll(() => import_effect5.Effect.succeed(void 0)));
   const manifest = content ? parsePackageJson(content) : void 0;
   const startScript = typeof manifest?.scripts?.start === "string" ? manifest.scripts.start : void 0;
   const candidates = [
@@ -381,8 +424,8 @@ var laravel = {
 };
 
 // src/detection/frameworks/nestjs.ts
-var import_platform3 = require("@effect/platform");
-var import_effect5 = require("effect");
+var import_platform4 = require("@effect/platform");
+var import_effect6 = require("effect");
 var isRecord2 = (value) => typeof value === "object" && value !== null;
 var parseNestCliJson = (content) => {
   try {
@@ -433,9 +476,9 @@ var nestjs = {
   detectors: [{ matchPackage: "@nestjs/core" }],
   priority: 90,
   getDefaultConfig: () => createNestConfig("dist"),
-  refineDefaultConfig: (defaults, projectFolder) => import_effect5.Effect.gen(function* () {
-    const fs = yield* import_platform3.FileSystem.FileSystem;
-    const content = yield* fs.readFileString(`${projectFolder}/nest-cli.json`).pipe(import_effect5.Effect.catchAll(() => import_effect5.Effect.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => import_effect6.Effect.gen(function* () {
+    const fs = yield* import_platform4.FileSystem.FileSystem;
+    const content = yield* fs.readFileString(`${projectFolder}/nest-cli.json`).pipe(import_effect6.Effect.catchAll(() => import_effect6.Effect.succeed(void 0)));
     if (!content) return defaults;
     const nestConfig = parseNestCliJson(content);
     const outputPath = nestConfig ? getProjectOutputPath(nestConfig) : void 0;
@@ -444,28 +487,28 @@ var nestjs = {
 };
 
 // src/detection/frameworks/nextjs.ts
-var import_platform5 = require("@effect/platform");
-var import_effect8 = require("effect");
+var import_platform6 = require("@effect/platform");
+var import_effect9 = require("effect");
 
 // src/build-output-v3/get-default-path-map.ts
-var import_platform4 = require("@effect/platform");
-var import_effect6 = require("effect");
-var getDefaultPathMap = import_effect6.Effect.fn("getDefaultPathMap")(function* (directory) {
-  const fs = yield* import_platform4.FileSystem.FileSystem;
-  const pathService = yield* import_platform4.Path.Path;
+var import_platform5 = require("@effect/platform");
+var import_effect7 = require("effect");
+var getDefaultPathMap = import_effect7.Effect.fn("getDefaultPathMap")(function* (directory) {
+  const fs = yield* import_platform5.FileSystem.FileSystem;
+  const pathService = yield* import_platform5.Path.Path;
   const result = {};
-  const exists = yield* fs.exists(directory).pipe(import_effect6.Effect.catchAll(() => import_effect6.Effect.succeed(false)));
+  const exists = yield* fs.exists(directory).pipe(import_effect7.Effect.catchAll(() => import_effect7.Effect.succeed(false)));
   if (!exists) {
     return result;
   }
   const MAX_DEPTH = 100;
-  const processDirectory = (currentPath, basePath = "", depth = 0) => import_effect6.Effect.gen(function* () {
+  const processDirectory = (currentPath, basePath = "", depth = 0) => import_effect7.Effect.gen(function* () {
     if (depth > MAX_DEPTH) return;
-    const entries = yield* fs.readDirectory(currentPath).pipe(import_effect6.Effect.catchAll(() => import_effect6.Effect.succeed([])));
+    const entries = yield* fs.readDirectory(currentPath).pipe(import_effect7.Effect.catchAll(() => import_effect7.Effect.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(import_effect6.Effect.catchAll(() => import_effect6.Effect.succeed(null)));
+      const stat = yield* fs.stat(fullPath).pipe(import_effect7.Effect.catchAll(() => import_effect7.Effect.succeed(null)));
       if (!stat) continue;
       if (stat.type === "Directory") {
         yield* processDirectory(fullPath, relativePath, depth + 1);
@@ -482,180 +525,244 @@ var getDefaultPathMap = import_effect6.Effect.fn("getDefaultPathMap")(function*
 var MAXIMUM_ENTRY_PAGE_PATHS = 50;
 
 // src/nextjs-manifest.ts
-var import_effect7 = require("effect");
-var StringArraySchema = import_effect7.Schema.mutable(import_effect7.Schema.Array(import_effect7.Schema.String));
-var StringRecordSchema = import_effect7.Schema.mutable(import_effect7.Schema.Record({ key: import_effect7.Schema.String, value: import_effect7.Schema.String }));
-var JsonValueSchema = import_effect7.Schema.suspend(
-  () => import_effect7.Schema.Union(
-    import_effect7.Schema.Null,
-    import_effect7.Schema.Boolean,
-    import_effect7.Schema.Number,
-    import_effect7.Schema.String,
-    import_effect7.Schema.mutable(import_effect7.Schema.Array(JsonValueSchema)),
-    import_effect7.Schema.mutable(import_effect7.Schema.Record({ key: import_effect7.Schema.String, value: JsonValueSchema }))
+var import_effect8 = require("effect");
+var StringArraySchema = import_effect8.Schema.mutable(import_effect8.Schema.Array(import_effect8.Schema.String));
+var StringRecordSchema = import_effect8.Schema.mutable(import_effect8.Schema.Record({ key: import_effect8.Schema.String, value: import_effect8.Schema.String }));
+var JsonValueSchema = import_effect8.Schema.suspend(
+  () => import_effect8.Schema.Union(
+    import_effect8.Schema.Null,
+    import_effect8.Schema.Boolean,
+    import_effect8.Schema.Number,
+    import_effect8.Schema.String,
+    import_effect8.Schema.mutable(import_effect8.Schema.Array(JsonValueSchema)),
+    import_effect8.Schema.mutable(import_effect8.Schema.Record({ key: import_effect8.Schema.String, value: JsonValueSchema }))
   )
 );
-var ImageLocalPatternSchema = import_effect7.Schema.mutable(
-  import_effect7.Schema.Struct({
-    pathname: import_effect7.Schema.optional(import_effect7.Schema.String),
-    search: import_effect7.Schema.optional(import_effect7.Schema.String)
+var ImageLocalPatternSchema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Struct({
+    pathname: import_effect8.Schema.optional(import_effect8.Schema.String),
+    search: import_effect8.Schema.optional(import_effect8.Schema.String)
   })
 );
-var ImageRemotePatternSchema = import_effect7.Schema.mutable(
-  import_effect7.Schema.Struct({
-    protocol: import_effect7.Schema.optional(import_effect7.Schema.Literal("http", "https")),
-    hostname: import_effect7.Schema.String,
-    port: import_effect7.Schema.optional(import_effect7.Schema.String),
-    pathname: import_effect7.Schema.optional(import_effect7.Schema.String),
-    search: import_effect7.Schema.optional(import_effect7.Schema.String)
+var ImageRemotePatternSchema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Struct({
+    protocol: import_effect8.Schema.optional(import_effect8.Schema.Literal("http", "https")),
+    hostname: import_effect8.Schema.String,
+    port: import_effect8.Schema.optional(import_effect8.Schema.String),
+    pathname: import_effect8.Schema.optional(import_effect8.Schema.String),
+    search: import_effect8.Schema.optional(import_effect8.Schema.String)
   })
 );
-var ImageVariantSchema = import_effect7.Schema.mutable(
-  import_effect7.Schema.Struct({
-    width: import_effect7.Schema.optional(import_effect7.Schema.Number),
-    height: import_effect7.Schema.optional(import_effect7.Schema.Number),
-    quality: import_effect7.Schema.optional(import_effect7.Schema.Number),
-    format: import_effect7.Schema.optional(import_effect7.Schema.Literal("image/avif", "image/webp", "image/jpeg", "image/png")),
-    fit: import_effect7.Schema.optional(import_effect7.Schema.Literal("contain", "cover", "fill", "inside", "outside"))
+var ImageVariantSchema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Struct({
+    width: import_effect8.Schema.optional(import_effect8.Schema.Number),
+    height: import_effect8.Schema.optional(import_effect8.Schema.Number),
+    quality: import_effect8.Schema.optional(import_effect8.Schema.Number),
+    format: import_effect8.Schema.optional(import_effect8.Schema.Literal("image/avif", "image/webp", "image/jpeg", "image/png")),
+    fit: import_effect8.Schema.optional(import_effect8.Schema.Literal("contain", "cover", "fill", "inside", "outside"))
   })
 );
-var PositiveIntSchema = import_effect7.Schema.Int.pipe(import_effect7.Schema.greaterThan(0));
-var ImagePolicySchema = import_effect7.Schema.mutable(
-  import_effect7.Schema.Struct({
-    localPatterns: import_effect7.Schema.mutable(import_effect7.Schema.Array(ImageLocalPatternSchema)),
-    remotePatterns: import_effect7.Schema.mutable(import_effect7.Schema.Array(ImageRemotePatternSchema)),
-    widths: import_effect7.Schema.mutable(import_effect7.Schema.Array(PositiveIntSchema)),
-    heights: import_effect7.Schema.mutable(import_effect7.Schema.Array(PositiveIntSchema)),
-    qualities: import_effect7.Schema.mutable(import_effect7.Schema.Array(import_effect7.Schema.Number.pipe(import_effect7.Schema.between(1, 100)))),
-    formats: import_effect7.Schema.mutable(import_effect7.Schema.Array(import_effect7.Schema.Literal("image/avif", "image/webp", "image/jpeg", "image/png"))),
-    minimumCacheTTL: import_effect7.Schema.Number,
-    dangerouslyAllowSVG: import_effect7.Schema.Boolean,
-    contentSecurityPolicy: import_effect7.Schema.String,
-    contentDispositionType: import_effect7.Schema.Literal("inline", "attachment"),
-    maximumRedirects: import_effect7.Schema.Number,
-    maximumResponseBody: import_effect7.Schema.Number,
-    variants: import_effect7.Schema.mutable(import_effect7.Schema.Record({ key: import_effect7.Schema.String, value: ImageVariantSchema }))
+var PositiveIntSchema = import_effect8.Schema.Int.pipe(import_effect8.Schema.greaterThan(0));
+var ImagePolicySchema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Struct({
+    localPatterns: import_effect8.Schema.mutable(import_effect8.Schema.Array(ImageLocalPatternSchema)),
+    remotePatterns: import_effect8.Schema.mutable(import_effect8.Schema.Array(ImageRemotePatternSchema)),
+    widths: import_effect8.Schema.mutable(import_effect8.Schema.Array(PositiveIntSchema)),
+    heights: import_effect8.Schema.mutable(import_effect8.Schema.Array(PositiveIntSchema)),
+    qualities: import_effect8.Schema.mutable(import_effect8.Schema.Array(import_effect8.Schema.Number.pipe(import_effect8.Schema.between(1, 100)))),
+    formats: import_effect8.Schema.mutable(import_effect8.Schema.Array(import_effect8.Schema.Literal("image/avif", "image/webp", "image/jpeg", "image/png"))),
+    minimumCacheTTL: import_effect8.Schema.Number,
+    dangerouslyAllowSVG: import_effect8.Schema.Boolean,
+    contentSecurityPolicy: import_effect8.Schema.String,
+    contentDispositionType: import_effect8.Schema.Literal("inline", "attachment"),
+    maximumRedirects: import_effect8.Schema.Number,
+    maximumResponseBody: import_effect8.Schema.Number,
+    variants: import_effect8.Schema.mutable(import_effect8.Schema.Record({ key: import_effect8.Schema.String, value: ImageVariantSchema }))
   })
 );
-var GigadriveNextPrerenderOutputSchema = import_effect7.Schema.mutable(
-  import_effect7.Schema.Struct({
-    id: import_effect7.Schema.String,
-    type: import_effect7.Schema.Literal("PRERENDER"),
-    pathname: UrlPathnameSchema,
-    parentOutputId: import_effect7.Schema.String,
-    groupId: import_effect7.Schema.Number,
-    pprChain: import_effect7.Schema.optional(import_effect7.Schema.mutable(import_effect7.Schema.Struct({ headers: HttpSingleValueHeadersSchema }))),
-    parentFallbackMode: import_effect7.Schema.optional(JsonValueSchema),
-    fallback: import_effect7.Schema.optional(
-      import_effect7.Schema.mutable(
-        import_effect7.Schema.Struct({
-          filePath: import_effect7.Schema.optional(PortableRelativePathSchema),
-          initialStatus: import_effect7.Schema.optional(import_effect7.Schema.Int.pipe(import_effect7.Schema.between(100, 599))),
-          initialHeaders: import_effect7.Schema.optional(HttpHeadersSchema),
-          initialExpiration: import_effect7.Schema.optional(import_effect7.Schema.Number),
-          initialRevalidate: import_effect7.Schema.optional(import_effect7.Schema.Union(import_effect7.Schema.Number, import_effect7.Schema.Literal(false))),
-          postponedState: import_effect7.Schema.optional(import_effect7.Schema.String)
-        })
-      )
-    ),
-    config: import_effect7.Schema.mutable(
-      import_effect7.Schema.Struct({
-        allowQuery: import_effect7.Schema.optional(StringArraySchema),
-        allowHeader: import_effect7.Schema.optional(StringArraySchema),
-        bypassFor: import_effect7.Schema.optional(import_effect7.Schema.mutable(import_effect7.Schema.Array(JsonValueSchema))),
-        renderingMode: import_effect7.Schema.optional(import_effect7.Schema.String),
-        partialFallback: import_effect7.Schema.optional(import_effect7.Schema.Boolean),
-        bypassToken: import_effect7.Schema.optional(import_effect7.Schema.String)
+var GigadriveNextPrerenderOutputFields = {
+  id: import_effect8.Schema.String,
+  type: import_effect8.Schema.Literal("PRERENDER"),
+  pathname: UrlPathnameSchema,
+  route: import_effect8.Schema.optional(UrlPathnameSchema),
+  parentOutputId: import_effect8.Schema.String,
+  groupId: import_effect8.Schema.Number,
+  pprChain: import_effect8.Schema.optional(import_effect8.Schema.mutable(import_effect8.Schema.Struct({ headers: HttpSingleValueHeadersSchema }))),
+  parentFallbackMode: import_effect8.Schema.optional(JsonValueSchema),
+  fallback: import_effect8.Schema.optional(
+    import_effect8.Schema.mutable(
+      import_effect8.Schema.Struct({
+        filePath: import_effect8.Schema.optional(PortableRelativePathSchema),
+        initialStatus: import_effect8.Schema.optional(import_effect8.Schema.Int.pipe(import_effect8.Schema.between(100, 599))),
+        initialHeaders: import_effect8.Schema.optional(HttpHeadersSchema),
+        initialExpiration: import_effect8.Schema.optional(import_effect8.Schema.Number),
+        initialRevalidate: import_effect8.Schema.optional(import_effect8.Schema.Union(import_effect8.Schema.Number, import_effect8.Schema.Literal(false))),
+        postponedState: import_effect8.Schema.optional(import_effect8.Schema.String)
       })
     )
-  })
+  ),
+  config: import_effect8.Schema.mutable(
+    import_effect8.Schema.Struct({
+      allowQuery: import_effect8.Schema.optional(StringArraySchema),
+      allowHeader: import_effect8.Schema.optional(StringArraySchema),
+      bypassFor: import_effect8.Schema.optional(import_effect8.Schema.mutable(import_effect8.Schema.Array(JsonValueSchema))),
+      renderingMode: import_effect8.Schema.optional(import_effect8.Schema.String),
+      partialFallback: import_effect8.Schema.optional(import_effect8.Schema.Boolean),
+      bypassToken: import_effect8.Schema.optional(import_effect8.Schema.String)
+    })
+  )
+};
+var GigadriveNextPrerenderClassificationSchema = import_effect8.Schema.Struct({
+  routeType: import_effect8.Schema.Literal("route", "fallback", "shell", "page"),
+  response: import_effect8.Schema.Literal("empty", "initial", "complete"),
+  compute: import_effect8.Schema.Literal("blocking", "resuming", "static"),
+  htmlSize: import_effect8.Schema.optional(import_effect8.Schema.Number)
+});
+var GigadriveNextPrerenderWithoutClassificationSchema = import_effect8.Schema.Struct({
+  routeType: import_effect8.Schema.optional(import_effect8.Schema.Never),
+  response: import_effect8.Schema.optional(import_effect8.Schema.Never),
+  compute: import_effect8.Schema.optional(import_effect8.Schema.Never),
+  htmlSize: import_effect8.Schema.optional(import_effect8.Schema.Never)
+});
+var GigadriveNextPrerenderOutputSchema = import_effect8.Schema.Union(
+  import_effect8.Schema.mutable(
+    import_effect8.Schema.Struct({ ...GigadriveNextPrerenderOutputFields, ...GigadriveNextPrerenderClassificationSchema.fields })
+  ),
+  import_effect8.Schema.mutable(
+    import_effect8.Schema.Struct({
+      ...GigadriveNextPrerenderOutputFields,
+      ...GigadriveNextPrerenderWithoutClassificationSchema.fields
+    })
+  )
 );
-var GigadriveNextStaticAssetPrefixSchema = import_effect7.Schema.mutable(
-  import_effect7.Schema.Struct({
+var GigadriveNextStaticAssetPrefixSchema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Struct({
     sourceDir: PortableRelativePathSchema,
     urlPrefix: PortableRelativePathSchema,
-    immutable: import_effect7.Schema.Boolean
+    immutable: import_effect8.Schema.Boolean
   })
 );
-var GigadriveNextServerDescriptorSchema = import_effect7.Schema.mutable(
-  import_effect7.Schema.Struct({
-    maxDuration: import_effect7.Schema.optional(import_effect7.Schema.Number),
-    preferredRegion: import_effect7.Schema.optional(import_effect7.Schema.Union(import_effect7.Schema.String, StringArraySchema)),
-    env: import_effect7.Schema.optional(StringRecordSchema)
+var GigadriveNextRouteConditionSchema = import_effect8.Schema.Union(
+  import_effect8.Schema.mutable(
+    import_effect8.Schema.Struct({
+      type: import_effect8.Schema.Literal("header", "cookie", "query"),
+      key: import_effect8.Schema.String,
+      value: import_effect8.Schema.optional(import_effect8.Schema.String)
+    })
+  ),
+  import_effect8.Schema.mutable(
+    import_effect8.Schema.Struct({
+      type: import_effect8.Schema.Literal("host"),
+      value: import_effect8.Schema.String
+    })
+  )
+);
+var GigadriveNextMiddlewareMatcherSchema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Struct({
+    source: import_effect8.Schema.String,
+    sourceRegex: import_effect8.Schema.String,
+    has: import_effect8.Schema.optional(import_effect8.Schema.mutable(import_effect8.Schema.Array(GigadriveNextRouteConditionSchema))),
+    missing: import_effect8.Schema.optional(import_effect8.Schema.mutable(import_effect8.Schema.Array(GigadriveNextRouteConditionSchema)))
   })
 );
-var PrerenderArraySchema = import_effect7.Schema.mutable(import_effect7.Schema.Array(GigadriveNextPrerenderOutputSchema));
-var StaticAssetArraySchema = import_effect7.Schema.mutable(import_effect7.Schema.Array(GigadriveNextStaticAssetPrefixSchema));
-var JsonValueArraySchema = import_effect7.Schema.mutable(import_effect7.Schema.Array(JsonValueSchema));
-var GigadriveNextBuildManifestV1Schema = import_effect7.Schema.mutable(
-  import_effect7.Schema.Struct({
-    version: import_effect7.Schema.Literal(1),
-    output: import_effect7.Schema.Literal("standalone", "export"),
+var GigadriveNextMiddlewareDescriptorSchema = import_effect8.Schema.Union(
+  import_effect8.Schema.mutable(
+    import_effect8.Schema.Struct({
+      present: import_effect8.Schema.Literal(true),
+      matchers: import_effect8.Schema.mutable(import_effect8.Schema.Array(GigadriveNextMiddlewareMatcherSchema))
+    })
+  ),
+  import_effect8.Schema.mutable(
+    import_effect8.Schema.Struct({
+      present: import_effect8.Schema.Literal(false),
+      matchers: import_effect8.Schema.mutable(import_effect8.Schema.Tuple())
+    })
+  )
+);
+var GigadriveNextServerDescriptorSchema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Struct({
+    maxDuration: import_effect8.Schema.optional(import_effect8.Schema.Number),
+    preferredRegion: import_effect8.Schema.optional(import_effect8.Schema.Union(import_effect8.Schema.String, StringArraySchema)),
+    env: import_effect8.Schema.optional(StringRecordSchema)
+  })
+);
+var PrerenderArraySchema = import_effect8.Schema.mutable(import_effect8.Schema.Array(GigadriveNextPrerenderOutputSchema));
+var StaticAssetArraySchema = import_effect8.Schema.mutable(import_effect8.Schema.Array(GigadriveNextStaticAssetPrefixSchema));
+var JsonValueArraySchema = import_effect8.Schema.mutable(import_effect8.Schema.Array(JsonValueSchema));
+var GigadriveNextPrerenderSeedMethodsSchema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Tuple(import_effect8.Schema.Literal("GET"), import_effect8.Schema.Literal("HEAD"))
+);
+var GigadriveNextBuildManifestV1Schema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Struct({
+    version: import_effect8.Schema.Literal(1),
+    output: import_effect8.Schema.Literal("standalone", "export"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: import_effect7.Schema.String,
-    buildId: import_effect7.Schema.String
+    nextVersion: import_effect8.Schema.String,
+    buildId: import_effect8.Schema.String
   })
 );
-var GigadriveNextBuildManifestV2ExportSchema = import_effect7.Schema.mutable(
-  import_effect7.Schema.Struct({
-    version: import_effect7.Schema.Literal(2),
-    mode: import_effect7.Schema.Literal("export"),
+var GigadriveNextBuildManifestV2ExportSchema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Struct({
+    version: import_effect8.Schema.Literal(2),
+    mode: import_effect8.Schema.Literal("export"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: import_effect7.Schema.String,
-    buildId: import_effect7.Schema.String
+    nextVersion: import_effect8.Schema.String,
+    buildId: import_effect8.Schema.String
   })
 );
-var GigadriveNextBuildManifestV2StandaloneSchema = import_effect7.Schema.mutable(
-  import_effect7.Schema.Struct({
-    version: import_effect7.Schema.Literal(2),
-    mode: import_effect7.Schema.Literal("standalone-v2"),
+var GigadriveNextBuildManifestV2StandaloneSchema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Struct({
+    version: import_effect8.Schema.Literal(2),
+    mode: import_effect8.Schema.Literal("standalone-v2"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: import_effect7.Schema.String,
-    buildId: import_effect7.Schema.String,
+    nextVersion: import_effect8.Schema.String,
+    buildId: import_effect8.Schema.String,
     server: GigadriveNextServerDescriptorSchema,
-    config: import_effect7.Schema.mutable(
-      import_effect7.Schema.Struct({
-        basePath: import_effect7.Schema.String,
-        trailingSlash: import_effect7.Schema.Boolean,
-        cacheComponents: import_effect7.Schema.Boolean,
-        i18n: import_effect7.Schema.optional(JsonValueSchema),
-        images: import_effect7.Schema.optional(ImagePolicySchema)
+    config: import_effect8.Schema.mutable(
+      import_effect8.Schema.Struct({
+        basePath: import_effect8.Schema.String,
+        trailingSlash: import_effect8.Schema.Boolean,
+        cacheComponents: import_effect8.Schema.Boolean,
+        i18n: import_effect8.Schema.optional(JsonValueSchema),
+        images: import_effect8.Schema.optional(ImagePolicySchema)
       })
     ),
-    routing: import_effect7.Schema.mutable(
-      import_effect7.Schema.Struct({
+    routing: import_effect8.Schema.mutable(
+      import_effect8.Schema.Struct({
         beforeMiddleware: JsonValueArraySchema,
         beforeFiles: JsonValueArraySchema,
         afterFiles: JsonValueArraySchema,
         dynamicRoutes: JsonValueArraySchema,
         onMatch: JsonValueArraySchema,
         fallback: JsonValueArraySchema,
-        shouldNormalizeNextData: import_effect7.Schema.Boolean,
+        shouldNormalizeNextData: import_effect8.Schema.Boolean,
         rsc: JsonValueSchema
       })
     ),
-    outputs: import_effect7.Schema.mutable(
-      import_effect7.Schema.Struct({
+    outputs: import_effect8.Schema.mutable(
+      import_effect8.Schema.Struct({
         prerenders: PrerenderArraySchema,
-        prerenderManifest: import_effect7.Schema.optional(PortableRelativePathSchema),
-        assetManifest: import_effect7.Schema.optional(PortableRelativePathSchema),
-        entryPagePaths: import_effect7.Schema.optional(import_effect7.Schema.mutable(import_effect7.Schema.Array(UrlPathnameSchema))),
-        staticAssets: StaticAssetArraySchema
+        prerenderManifest: import_effect8.Schema.optional(PortableRelativePathSchema),
+        assetManifest: import_effect8.Schema.optional(PortableRelativePathSchema),
+        entryPagePaths: import_effect8.Schema.optional(import_effect8.Schema.mutable(import_effect8.Schema.Array(UrlPathnameSchema))),
+        staticAssets: StaticAssetArraySchema,
+        middleware: import_effect8.Schema.optional(GigadriveNextMiddlewareDescriptorSchema)
       })
     )
   })
 );
-var GigadriveNextBuildManifestSchema = import_effect7.Schema.Union(
+var GigadriveNextBuildManifestSchema = import_effect8.Schema.Union(
   GigadriveNextBuildManifestV1Schema,
   GigadriveNextBuildManifestV2ExportSchema,
   GigadriveNextBuildManifestV2StandaloneSchema
 );
-var GigadriveNextPrerenderManifestV1Schema = import_effect7.Schema.mutable(
-  import_effect7.Schema.Struct({
-    version: import_effect7.Schema.Literal(1),
+var GigadriveNextPrerenderManifestV1Schema = import_effect8.Schema.mutable(
+  import_effect8.Schema.Struct({
+    version: import_effect8.Schema.Literal(1),
+    seedMethods: import_effect8.Schema.optional(GigadriveNextPrerenderSeedMethodsSchema),
     prerenders: PrerenderArraySchema
   })
 );
@@ -687,22 +794,22 @@ var AVAILABLE_REGIONS = [...REGION_DEFINITIONS];
 // src/detection/frameworks/nextjs.ts
 var toPortablePath = (value) => value.replaceAll("\\", "/");
 var STANDALONE_SERVER_MEMORY_MB = 1024;
-var resolveStandaloneServer = import_effect8.Effect.fn("nextjs.resolveStandaloneServer")(function* (projectFolder, distDir, repoRootToProject) {
-  const fs = yield* import_platform5.FileSystem.FileSystem;
-  const pathService = yield* import_platform5.Path.Path;
+var resolveStandaloneServer = import_effect9.Effect.fn("nextjs.resolveStandaloneServer")(function* (projectFolder, distDir, repoRootToProject) {
+  const fs = yield* import_platform6.FileSystem.FileSystem;
+  const pathService = yield* import_platform6.Path.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(import_effect8.Effect.catchAll(() => import_effect8.Effect.succeed(false)));
+  const monorepoServerExists = yield* fs.exists(monorepoServer).pipe(import_effect9.Effect.catchAll(() => import_effect9.Effect.succeed(false)));
   const serverPath = monorepoServerExists ? monorepoServer : rootServer;
-  const serverExists = yield* fs.exists(serverPath).pipe(import_effect8.Effect.catchAll(() => import_effect8.Effect.succeed(false)));
+  const serverExists = yield* fs.exists(serverPath).pipe(import_effect9.Effect.catchAll(() => import_effect9.Effect.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 = import_effect8.Effect.fn("nextjs.buildStandalonePublicAssets")(function* (projectFolder, standaloneRoot, serverDirectory) {
-  const pathService = yield* import_platform5.Path.Path;
+var buildStandalonePublicAssets = import_effect9.Effect.fn("nextjs.buildStandalonePublicAssets")(function* (projectFolder, standaloneRoot, serverDirectory) {
+  const pathService = yield* import_platform6.Path.Path;
   const publicFiles = yield* getDefaultPathMap(pathService.join(projectFolder, "public"));
   const assetPaths = [];
   const assetOverrides = {};
@@ -718,8 +825,8 @@ var buildStandalonePublicAssets = import_effect8.Effect.fn("nextjs.buildStandalo
   }
   return { assetPaths, assetOverrides, filePathMap };
 });
-var createStaticExportConfig = import_effect8.Effect.fn("nextjs.createStaticExportConfig")(function* (defaults, projectFolder) {
-  const pathService = yield* import_platform5.Path.Path;
+var createStaticExportConfig = import_effect9.Effect.fn("nextjs.createStaticExportConfig")(function* (defaults, projectFolder) {
+  const pathService = yield* import_platform6.Path.Path;
   const outputDirectory = pathService.join(projectFolder, "out");
   const files = yield* getDefaultPathMap(outputDirectory);
   const assetPaths = [];
@@ -742,8 +849,8 @@ var createStaticExportConfig = import_effect8.Effect.fn("nextjs.createStaticExpo
     package: void 0
   };
 });
-var createStandaloneConfig = import_effect8.Effect.fn("nextjs.createStandaloneConfig")(function* (defaults, projectFolder, manifest) {
-  const pathService = yield* import_platform5.Path.Path;
+var createStandaloneConfig = import_effect9.Effect.fn("nextjs.createStandaloneConfig")(function* (defaults, projectFolder, manifest) {
+  const pathService = yield* import_platform6.Path.Path;
   const resolved = yield* resolveStandaloneServer(projectFolder, manifest.distDir, manifest.repoRootToProject);
   if (!resolved) return defaults;
   const { standaloneRoot, serverDirectory, entrypoint } = resolved;
@@ -776,7 +883,7 @@ var createStandaloneConfig = import_effect8.Effect.fn("nextjs.createStandaloneCo
     }
   };
 });
-var createStandaloneV2Config = import_effect8.Effect.fn("nextjs.createStandaloneV2Config")(function* (defaults, projectFolder, manifest) {
+var createStandaloneV2Config = import_effect9.Effect.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;
@@ -874,14 +981,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) => import_effect8.Effect.gen(function* () {
-    const fs = yield* import_platform5.FileSystem.FileSystem;
-    const manifestContent = yield* fs.readFileString(`${projectFolder}/.gigadrive/nextjs.json`).pipe(import_effect8.Effect.catchAll(() => import_effect8.Effect.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => import_effect9.Effect.gen(function* () {
+    const fs = yield* import_platform6.FileSystem.FileSystem;
+    const manifestContent = yield* fs.readFileString(`${projectFolder}/.gigadrive/nextjs.json`).pipe(import_effect9.Effect.catchAll(() => import_effect9.Effect.succeed(void 0)));
     const manifest = manifestContent ? parseGigadriveNextBuildManifest(manifestContent) : void 0;
     if (!manifest) return defaults;
     if (manifest.version === 2) {
@@ -892,8 +1004,8 @@ var nextjs = {
 };
 
 // src/detection/frameworks/nuxt.ts
-var import_platform6 = require("@effect/platform");
-var import_effect9 = require("effect");
+var import_platform7 = require("@effect/platform");
+var import_effect10 = require("effect");
 var isVercelBuildOutputV3 = (content) => {
   try {
     const config = JSON.parse(content);
@@ -920,9 +1032,9 @@ var nuxt = {
     routes: [{ source: "/*", destination: ".output/server/index.mjs" }],
     environmentVariables: { NODE_ENV: "production", NITRO_PRESET: "node-server" }
   }),
-  refineDefaultConfig: (defaults, projectFolder) => import_effect9.Effect.gen(function* () {
-    const fs = yield* import_platform6.FileSystem.FileSystem;
-    const buildOutputConfig = yield* fs.readFileString(`${projectFolder}/.vercel/output/config.json`).pipe(import_effect9.Effect.catchAll(() => import_effect9.Effect.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => import_effect10.Effect.gen(function* () {
+    const fs = yield* import_platform7.FileSystem.FileSystem;
+    const buildOutputConfig = yield* fs.readFileString(`${projectFolder}/.vercel/output/config.json`).pipe(import_effect10.Effect.catchAll(() => import_effect10.Effect.succeed(void 0)));
     if (!buildOutputConfig || !isVercelBuildOutputV3(buildOutputConfig)) {
       return defaults;
     }
@@ -1045,7 +1157,7 @@ var FRAMEWORK_DEFINITIONS = [
 ].sort((a, b) => b.priority - a.priority);
 
 // src/detection/generate-config.ts
-var import_effect10 = require("effect");
+var import_effect11 = require("effect");
 var getInstallCommand = (pm) => {
   switch (pm) {
     case "bun":
@@ -1061,11 +1173,11 @@ var getInstallCommand = (pm) => {
       return "npm install";
   }
 };
-var generateConfig = import_effect10.Effect.fn("generateConfig")(function* (framework, packageManager, refinedDefaults) {
+var generateConfig = import_effect11.Effect.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* import_effect10.Effect.logDebug(`Generating config for ${framework.name}`, {
+  yield* import_effect11.Effect.logDebug(`Generating config for ${framework.name}`, {
     runtime: defaults.runtime,
     entrypoint: defaults.entrypoint,
     commands
@@ -1100,10 +1212,26 @@ var generateConfig = import_effect10.Effect.fn("generateConfig")(function* (fram
     ...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,
@@ -1114,31 +1242,31 @@ var generateConfig = import_effect10.Effect.fn("generateConfig")(function* (fram
 });
 
 // src/detection/read-dependencies.ts
-var import_platform7 = require("@effect/platform");
-var import_effect12 = require("effect");
+var import_platform8 = require("@effect/platform");
+var import_effect13 = require("effect");
 
 // src/detection/types.ts
-var import_effect11 = require("effect");
-var ManifestNotFoundError = class extends import_effect11.Schema.TaggedError()("ManifestNotFoundError", {
-  message: import_effect11.Schema.String,
-  filePath: import_effect11.Schema.String
+var import_effect12 = require("effect");
+var ManifestNotFoundError = class extends import_effect12.Schema.TaggedError()("ManifestNotFoundError", {
+  message: import_effect12.Schema.String,
+  filePath: import_effect12.Schema.String
 }) {
 };
-var ManifestReadError = class extends import_effect11.Schema.TaggedError()("ManifestReadError", {
-  message: import_effect11.Schema.String,
-  filePath: import_effect11.Schema.String
+var ManifestReadError = class extends import_effect12.Schema.TaggedError()("ManifestReadError", {
+  message: import_effect12.Schema.String,
+  filePath: import_effect12.Schema.String
 }) {
 };
-var ManifestParseError = class extends import_effect11.Schema.TaggedError()("ManifestParseError", {
-  message: import_effect11.Schema.String,
-  filePath: import_effect11.Schema.String
+var ManifestParseError = class extends import_effect12.Schema.TaggedError()("ManifestParseError", {
+  message: import_effect12.Schema.String,
+  filePath: import_effect12.Schema.String
 }) {
 };
-var FrameworkNotDetectedError = class extends import_effect11.Schema.TaggedError()(
+var FrameworkNotDetectedError = class extends import_effect12.Schema.TaggedError()(
   "FrameworkNotDetectedError",
   {
-    message: import_effect11.Schema.String,
-    directory: import_effect11.Schema.String
+    message: import_effect12.Schema.String,
+    directory: import_effect12.Schema.String
   }
 ) {
 };
@@ -1148,25 +1276,25 @@ var MANIFEST_CONFIG = {
   node: { file: "package.json", depKeys: ["dependencies", "devDependencies"] },
   php: { file: "composer.json", depKeys: ["require", "require-dev"] }
 };
-var readManifest = import_effect12.Effect.fn("readManifest")(function* (filePath) {
-  const fs = yield* import_platform7.FileSystem.FileSystem;
-  const exists = yield* fs.exists(filePath).pipe(import_effect12.Effect.catchAll(() => import_effect12.Effect.succeed(false)));
+var readManifest = import_effect13.Effect.fn("readManifest")(function* (filePath) {
+  const fs = yield* import_platform8.FileSystem.FileSystem;
+  const exists = yield* fs.exists(filePath).pipe(import_effect13.Effect.catchAll(() => import_effect13.Effect.succeed(false)));
   if (!exists) {
-    return yield* import_effect12.Effect.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
+    return yield* import_effect13.Effect.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
   }
-  const content = yield* fs.readFileString(filePath).pipe(import_effect12.Effect.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
-  const parsed = yield* import_effect12.Effect.try({
+  const content = yield* fs.readFileString(filePath).pipe(import_effect13.Effect.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
+  const parsed = yield* import_effect13.Effect.try({
     try: () => JSON.parse(content),
     catch: () => new ManifestParseError({ message: "Failed to parse manifest JSON", filePath })
   });
   return parsed;
 });
-var readDependencies = import_effect12.Effect.fn("readDependencies")(function* (projectFolder, language) {
-  const pathService = yield* import_platform7.Path.Path;
+var readDependencies = import_effect13.Effect.fn("readDependencies")(function* (projectFolder, language) {
+  const pathService = yield* import_platform8.Path.Path;
   const config = MANIFEST_CONFIG[language];
   const filePath = pathService.join(projectFolder, config.file);
   const manifest = yield* readManifest(filePath).pipe(
-    import_effect12.Effect.catchTag("ManifestNotFoundError", () => import_effect12.Effect.succeed(null))
+    import_effect13.Effect.catchTag("ManifestNotFoundError", () => import_effect13.Effect.succeed(null))
   );
   if (!manifest) {
     return /* @__PURE__ */ new Set();
@@ -1184,9 +1312,9 @@ var readDependencies = import_effect12.Effect.fn("readDependencies")(function* (
 });
 
 // src/detection/detect-framework.ts
-var matchesDetectionItem = import_effect13.Effect.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
-  const fs = yield* import_platform8.FileSystem.FileSystem;
-  const pathService = yield* import_platform8.Path.Path;
+var matchesDetectionItem = import_effect14.Effect.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
+  const fs = yield* import_platform9.FileSystem.FileSystem;
+  const pathService = yield* import_platform9.Path.Path;
   if (item.matchPackage != null) {
     const deps = yield* cachedReadDeps(`${projectFolder}\0${framework.language}`);
     if (!deps.has(item.matchPackage)) {
@@ -1195,12 +1323,12 @@ var matchesDetectionItem = import_effect13.Effect.fn("matchesDetectionItem")(fun
   }
   if (item.path != null) {
     const filePath = pathService.join(projectFolder, item.path);
-    const exists = yield* fs.exists(filePath).pipe(import_effect13.Effect.catchAll(() => import_effect13.Effect.succeed(false)));
+    const exists = yield* fs.exists(filePath).pipe(import_effect14.Effect.catchAll(() => import_effect14.Effect.succeed(false)));
     if (!exists) {
       return false;
     }
     if (item.matchContent != null) {
-      const content = yield* fs.readFileString(filePath).pipe(import_effect13.Effect.catchAll(() => import_effect13.Effect.succeed("")));
+      const content = yield* fs.readFileString(filePath).pipe(import_effect14.Effect.catchAll(() => import_effect14.Effect.succeed("")));
       let regexMatch = false;
       try {
         regexMatch = new RegExp(item.matchContent).test(content);
@@ -1213,7 +1341,7 @@ var matchesDetectionItem = import_effect13.Effect.fn("matchesDetectionItem")(fun
   }
   return true;
 });
-var matchesFramework = import_effect13.Effect.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
+var matchesFramework = import_effect14.Effect.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
   for (const detector of framework.detectors) {
     const matches = yield* matchesDetectionItem(detector, projectFolder, framework, cachedReadDeps);
     if (!matches) {
@@ -1222,9 +1350,9 @@ var matchesFramework = import_effect13.Effect.fn("matchesFramework")(function* (
   }
   return true;
 });
-var detectFramework = import_effect13.Effect.fn("detectFramework")(function* (projectFolder) {
-  yield* import_effect13.Effect.logDebug(`Detecting framework in ${projectFolder}`);
-  const cachedReadDeps = yield* import_effect13.Effect.cachedFunction((key) => {
+var detectFramework = import_effect14.Effect.fn("detectFramework")(function* (projectFolder) {
+  yield* import_effect14.Effect.logDebug(`Detecting framework in ${projectFolder}`);
+  const cachedReadDeps = yield* import_effect14.Effect.cachedFunction((key) => {
     const sepIndex = key.lastIndexOf("\0");
     const folder = key.slice(0, sepIndex);
     const language = key.slice(sepIndex + 1);
@@ -1233,16 +1361,16 @@ var detectFramework = import_effect13.Effect.fn("detectFramework")(function* (pr
   for (const framework of FRAMEWORK_DEFINITIONS) {
     const matches = yield* matchesFramework(framework, projectFolder, cachedReadDeps);
     if (matches) {
-      yield* import_effect13.Effect.log(`Detected framework: ${framework.name}`, { slug: framework.slug });
+      yield* import_effect14.Effect.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* import_effect13.Effect.fail(
+  return yield* import_effect14.Effect.fail(
     new FrameworkNotDetectedError({
       message: `No framework detected in project directory`,
       directory: projectFolder
@@ -1251,9 +1379,9 @@ var detectFramework = import_effect13.Effect.fn("detectFramework")(function* (pr
 });
 
 // src/detection/merge-config.ts
-var import_effect14 = require("effect");
-var mergeWithFrameworkDefaults = import_effect14.Effect.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
-  yield* import_effect14.Effect.logDebug("Merging user config with framework defaults");
+var import_effect15 = require("effect");
+var mergeWithFrameworkDefaults = import_effect15.Effect.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
+  yield* import_effect15.Effect.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,
@@ -1275,47 +1403,47 @@ var mergeWithFrameworkDefaults = import_effect14.Effect.fn("mergeWithFrameworkDe
 });
 
 // src/errors.ts
-var import_effect15 = require("effect");
-var ConfigFileNotFoundError = class extends import_effect15.Schema.TaggedError()("ConfigFileNotFoundError", {
-  message: import_effect15.Schema.String,
-  filePath: import_effect15.Schema.String
+var import_effect16 = require("effect");
+var ConfigFileNotFoundError = class extends import_effect16.Schema.TaggedError()("ConfigFileNotFoundError", {
+  message: import_effect16.Schema.String,
+  filePath: import_effect16.Schema.String
 }) {
 };
-var ConfigFileEmptyError = class extends import_effect15.Schema.TaggedError()("ConfigFileEmptyError", {
-  message: import_effect15.Schema.String,
-  filePath: import_effect15.Schema.String
+var ConfigFileEmptyError = class extends import_effect16.Schema.TaggedError()("ConfigFileEmptyError", {
+  message: import_effect16.Schema.String,
+  filePath: import_effect16.Schema.String
 }) {
 };
-var ConfigFileParseError = class extends import_effect15.Schema.TaggedError()("ConfigFileParseError", {
-  message: import_effect15.Schema.String,
-  filePath: import_effect15.Schema.String,
-  cause: import_effect15.Schema.optional(import_effect15.Schema.String)
+var ConfigFileParseError = class extends import_effect16.Schema.TaggedError()("ConfigFileParseError", {
+  message: import_effect16.Schema.String,
+  filePath: import_effect16.Schema.String,
+  cause: import_effect16.Schema.optional(import_effect16.Schema.String)
 }) {
 };
-var ConfigModuleLoadError = class extends import_effect15.Schema.TaggedError()("ConfigModuleLoadError", {
-  message: import_effect15.Schema.String,
-  filePath: import_effect15.Schema.String,
-  cause: import_effect15.Schema.optional(import_effect15.Schema.String)
+var ConfigModuleLoadError = class extends import_effect16.Schema.TaggedError()("ConfigModuleLoadError", {
+  message: import_effect16.Schema.String,
+  filePath: import_effect16.Schema.String,
+  cause: import_effect16.Schema.optional(import_effect16.Schema.String)
 }) {
 };
-var ConfigVersionError = class extends import_effect15.Schema.TaggedError()("ConfigVersionError", {
-  message: import_effect15.Schema.String,
-  filePath: import_effect15.Schema.String,
-  version: import_effect15.Schema.optional(import_effect15.Schema.Number)
+var ConfigVersionError = class extends import_effect16.Schema.TaggedError()("ConfigVersionError", {
+  message: import_effect16.Schema.String,
+  filePath: import_effect16.Schema.String,
+  version: import_effect16.Schema.optional(import_effect16.Schema.Number)
 }) {
 };
-var ConfigSchemaValidationError = class extends import_effect15.Schema.TaggedError()(
+var ConfigSchemaValidationError = class extends import_effect16.Schema.TaggedError()(
   "ConfigSchemaValidationError",
   {
-    message: import_effect15.Schema.String,
-    filePath: import_effect15.Schema.String,
-    validationErrors: import_effect15.Schema.Array(import_effect15.Schema.String)
+    message: import_effect16.Schema.String,
+    filePath: import_effect16.Schema.String,
+    validationErrors: import_effect16.Schema.Array(import_effect16.Schema.String)
   }
 ) {
 };
-var FunctionConfigError = class extends import_effect15.Schema.TaggedError()("FunctionConfigError", {
-  message: import_effect15.Schema.String,
-  functionPath: import_effect15.Schema.String
+var FunctionConfigError = class extends import_effect16.Schema.TaggedError()("FunctionConfigError", {
+  message: import_effect16.Schema.String,
+  functionPath: import_effect16.Schema.String
 }) {
 };
 
@@ -1335,23 +1463,23 @@ var DEFAULT_FUNCTION_DURATION_SECONDS = 30;
 var MAX_FUNCTION_DURATION_SECONDS = 28800;
 
 // src/parse-config.ts
-var import_effect21 = require("effect");
+var import_effect22 = require("effect");
 
 // src/services/raw-config-reader.ts
-var import_platform9 = require("@effect/platform");
-var import_effect17 = require("effect");
+var import_platform10 = require("@effect/platform");
+var import_effect18 = require("effect");
 var import_yaml = require("yaml");
 
 // src/services/config-module-loader.ts
-var import_effect16 = require("effect");
+var import_effect17 = require("effect");
 var import_jiti = require("jiti");
 var MISSING_DEFAULT_EXPORT = /* @__PURE__ */ Symbol("MissingDefaultExport");
 var STRICT_DEFAULT_EXPORT_EXTENSIONS = [".ts", ".mts", ".mjs"];
-var ConfigModuleLoader = class extends import_effect16.Effect.Service()("ConfigModuleLoader", {
-  effect: import_effect16.Effect.gen(function* () {
-    const loadConfigModule = import_effect16.Effect.fn("ConfigModuleLoader.loadConfigModule")(function* (filePath) {
+var ConfigModuleLoader = class extends import_effect17.Effect.Service()("ConfigModuleLoader", {
+  effect: import_effect17.Effect.gen(function* () {
+    const loadConfigModule = import_effect17.Effect.fn("ConfigModuleLoader.loadConfigModule")(function* (filePath) {
       const extension = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
-      const mod = yield* import_effect16.Effect.tryPromise({
+      const mod = yield* import_effect17.Effect.tryPromise({
         try: async () => {
           const jiti = (0, import_jiti.createJiti)(filePath, { fsCache: false, interopDefault: true, moduleCache: false });
           const namespace = await jiti.import(filePath);
@@ -1370,7 +1498,7 @@ var ConfigModuleLoader = class extends import_effect16.Effect.Service()("ConfigM
         })
       });
       if (mod === MISSING_DEFAULT_EXPORT) {
-        return yield* import_effect16.Effect.fail(
+        return yield* import_effect17.Effect.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
@@ -1378,7 +1506,7 @@ var ConfigModuleLoader = class extends import_effect16.Effect.Service()("ConfigM
         );
       }
       if (typeof mod === "function") {
-        return yield* import_effect16.Effect.fail(
+        return yield* import_effect17.Effect.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
@@ -1386,7 +1514,7 @@ var ConfigModuleLoader = class extends import_effect16.Effect.Service()("ConfigM
         );
       }
       if (typeof mod !== "object" || mod === null || Array.isArray(mod)) {
-        return yield* import_effect16.Effect.fail(
+        return yield* import_effect17.Effect.fail(
           new ConfigModuleLoadError({
             message: `Config module at ${filePath} must default-export a config object.`,
             filePath
@@ -1416,36 +1544,36 @@ var ALLOWED_CONFIG_NAMES = [
   "nebula.json"
 ];
 var MODULE_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
-var RawConfigReader = class extends import_effect17.Effect.Service()("RawConfigReader", {
+var RawConfigReader = class extends import_effect18.Effect.Service()("RawConfigReader", {
   dependencies: [ConfigModuleLoader.Default],
-  effect: import_effect17.Effect.gen(function* () {
-    const fs = yield* import_platform9.FileSystem.FileSystem;
-    const pathService = yield* import_platform9.Path.Path;
+  effect: import_effect18.Effect.gen(function* () {
+    const fs = yield* import_platform10.FileSystem.FileSystem;
+    const pathService = yield* import_platform10.Path.Path;
     const moduleLoader = yield* ConfigModuleLoader;
-    const findConfig = import_effect17.Effect.fn("RawConfigReader.findConfig")(function* (projectFolder) {
+    const findConfig = import_effect18.Effect.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(import_effect17.Effect.catchAll(() => import_effect17.Effect.succeed(false)));
+        const exists = yield* fs.exists(filePath).pipe(import_effect18.Effect.catchAll(() => import_effect18.Effect.succeed(false)));
         if (exists) {
           return filePath;
         }
       }
       return null;
     });
-    const readRawConfig = import_effect17.Effect.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
-      const exists = yield* fs.exists(filePath).pipe(import_effect17.Effect.catchAll(() => import_effect17.Effect.succeed(false)));
+    const readRawConfig = import_effect18.Effect.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
+      const exists = yield* fs.exists(filePath).pipe(import_effect18.Effect.catchAll(() => import_effect18.Effect.succeed(false)));
       if (!exists) {
-        return yield* import_effect17.Effect.fail(
+        return yield* import_effect18.Effect.fail(
           new ConfigFileNotFoundError({ message: `Config file not found at ${filePath}`, filePath })
         );
       }
       const fileContents = yield* fs.readFileString(filePath).pipe(
-        import_effect17.Effect.mapError(
+        import_effect18.Effect.mapError(
           () => new ConfigFileParseError({ message: `Failed to read config file at ${filePath}`, filePath })
         )
       );
       if (fileContents.length === 0) {
-        return yield* import_effect17.Effect.fail(
+        return yield* import_effect18.Effect.fail(
           new ConfigFileEmptyError({ message: `Config file is empty at ${filePath}`, filePath })
         );
       }
@@ -1461,7 +1589,7 @@ var RawConfigReader = class extends import_effect17.Effect.Service()("RawConfigR
             parsed = (0, import_yaml.parse)(fileContents);
           }
         } catch (error) {
-          return yield* import_effect17.Effect.fail(
+          return yield* import_effect18.Effect.fail(
             new ConfigFileParseError({
               message: `Failed to parse config file at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
               filePath,
@@ -1471,21 +1599,21 @@ var RawConfigReader = class extends import_effect17.Effect.Service()("RawConfigR
         }
       }
       if (parsed == null) {
-        return yield* import_effect17.Effect.fail(
+        return yield* import_effect18.Effect.fail(
           new ConfigFileParseError({ message: `Config file could not be parsed at ${filePath}`, filePath })
         );
       }
       if (!options?.disableVersionCheck && typeof parsed.version !== "number") {
-        return yield* import_effect17.Effect.fail(
+        return yield* import_effect18.Effect.fail(
           new ConfigVersionError({ message: `Config file is missing version at ${filePath}`, filePath })
         );
       }
       return parsed;
     });
     const readConfigFile = (configFilePath) => readRawConfig(configFilePath, { disableVersionCheck: true }).pipe(
-      import_effect17.Effect.map((parsed) => parsed),
-      import_effect17.Effect.catchTag("ConfigFileNotFoundError", () => import_effect17.Effect.succeed(null)),
-      import_effect17.Effect.withSpan("RawConfigReader.readConfigFile")
+      import_effect18.Effect.map((parsed) => parsed),
+      import_effect18.Effect.catchTag("ConfigFileNotFoundError", () => import_effect18.Effect.succeed(null)),
+      import_effect18.Effect.withSpan("RawConfigReader.readConfigFile")
     );
     return { findConfig, readRawConfig, readConfigFile };
   })
@@ -1495,17 +1623,17 @@ var RawConfigReader = class extends import_effect17.Effect.Service()("RawConfigR
 // src/services/schema-validator.ts
 var import_ajv = __toESM(require("ajv"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
-var import_effect18 = require("effect");
-var SchemaValidator = class extends import_effect18.Effect.Service()("SchemaValidator", {
-  effect: import_effect18.Effect.gen(function* () {
+var import_effect19 = require("effect");
+var SchemaValidator = class extends import_effect19.Effect.Service()("SchemaValidator", {
+  effect: import_effect19.Effect.gen(function* () {
     const ajv = new import_ajv.default();
     (0, import_ajv_formats.default)(ajv);
-    const validate = import_effect18.Effect.fn("SchemaValidator.validate")(function* (config, schema, filePath) {
+    const validate = import_effect19.Effect.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* import_effect18.Effect.fail(
+        return yield* import_effect19.Effect.fail(
           new ConfigSchemaValidationError({
             message: `Config file at ${filePath} is invalid: ${ajv.errorsText(compiledValidate.errors)}`,
             filePath,
@@ -1519,14 +1647,51 @@ var SchemaValidator = class extends import_effect18.Effect.Service()("SchemaVali
 }) {
 };
 
-// src/services/v4-config-parser.ts
-var import_platform10 = require("@effect/platform");
-var import_build_utils = require("@gigadrive/build-utils");
-var import_effect19 = require("effect");
+// ../build-utils/src/get-files-for-pattern.ts
 var import_minimatch = require("minimatch");
+var import_promises = require("fs/promises");
+var getFilesForPattern = async (pattern, projectFolder, excludeFiles = []) => {
+  const files = [];
+  const filesInFolder = await (0, import_promises.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 ((0, import_minimatch.minimatch)(file, excludeFile)) {
+        return true;
+      }
+      if (!exactFiles.has(excludeFile)) {
+        try {
+          return new RegExp(`^(?:${excludeFile})$`).test(file);
+        } catch {
+          return false;
+        }
+      }
+      return false;
+    })) {
+      continue;
+    }
+    if ((0, import_minimatch.minimatch)(file, pattern) || regex != null && regex.test(file)) {
+      files.push(file);
+    }
+  }
+  return files;
+};
+
+// src/services/v4-config-parser.ts
+var import_effect20 = require("effect");
+var import_minimatch2 = require("minimatch");
 var import_safe_regex2 = __toESM(require("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,
@@ -1588,7 +1753,7 @@ var destinationMatchesEntrypoint = (destination, entrypointPath) => {
   return new RegExp(`^${pattern}$`).test(entrypointPath);
 };
 var matchesPattern = (path2, pattern) => {
-  if ((0, import_minimatch.minimatch)(path2, pattern)) return true;
+  if ((0, import_minimatch2.minimatch)(path2, pattern)) return true;
   try {
     if ((0, import_safe_regex2.default)(pattern)) {
       return new RegExp(pattern).test(path2);
@@ -1628,7 +1793,7 @@ var mapRoute = (route, entrypoints) => ({
   negativeRequirements: route.missing,
   status: route.statusCode
 });
-var parseEntrypoints = import_effect19.Effect.fn("parseEntrypoints")(function* (config, projectFolder) {
+var parseEntrypoints = import_effect20.Effect.fn("parseEntrypoints")(function* (config, projectFolder) {
   const entrypoints = [];
   if (config.functions == null) return entrypoints;
   for (const [fnPath, func] of Object.entries(config.functions)) {
@@ -1638,8 +1803,8 @@ var parseEntrypoints = import_effect19.Effect.fn("parseEntrypoints")(function* (
         functionPath: fnPath
       });
     }
-    const matchedFiles = yield* import_effect19.Effect.tryPromise({
-      try: () => (0, import_build_utils.getFilesForPattern)(fnPath, projectFolder, func.excludeFiles),
+    const matchedFiles = yield* import_effect20.Effect.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
@@ -1674,57 +1839,21 @@ var parseEntrypoints = import_effect19.Effect.fn("parseEntrypoints")(function* (
   }
   return entrypoints;
 });
-var collectAssets = import_effect19.Effect.fn("collectAssets")(function* (config, projectFolder) {
+var collectAssets = import_effect20.Effect.fn("collectAssets")(function* (config, projectFolder) {
   if (config.assets == null) return [];
-  const fs = yield* import_platform10.FileSystem.FileSystem;
-  const pathService = yield* import_platform10.Path.Path;
-  const assetsPath = pathService.join(projectFolder, config.assets);
-  const assetsExist = yield* fs.exists(assetsPath).pipe(import_effect19.Effect.catchAll(() => import_effect19.Effect.succeed(false)));
-  if (!assetsExist) return [];
-  const stat = yield* fs.stat(assetsPath).pipe(import_effect19.Effect.catchAll(() => import_effect19.Effect.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 = import_effect19.Effect.fn("collectFilesRecursively")(
-  function* (basePath, relativePath = "", depth = 0) {
-    if (depth > MAX_ASSET_DEPTH) return [];
-    const fs = yield* import_platform10.FileSystem.FileSystem;
-    const pathSvc = yield* import_platform10.Path.Path;
-    const currentPath = relativePath ? pathSvc.join(basePath, relativePath) : basePath;
-    const entries = yield* fs.readDirectory(currentPath).pipe(import_effect19.Effect.catchAll(() => import_effect19.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(import_effect19.Effect.catchAll(() => import_effect19.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 V4ConfigParser = class extends import_effect19.Effect.Service()("V4ConfigParser", {
+var V4ConfigParser = class extends import_effect20.Effect.Service()("V4ConfigParser", {
   accessors: true,
-  effect: import_effect19.Effect.succeed({
+  effect: import_effect20.Effect.succeed({
     /**
      * Parses a ConfigV4 into a NormalizedConfig.
      *
      * @param config - The raw V4 config object
      * @param projectFolder - Absolute path to the project root
      */
-    parse: import_effect19.Effect.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
+    parse: import_effect20.Effect.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
       const entrypoints = yield* parseEntrypoints(config, projectFolder);
       const assets = yield* collectAssets(config, projectFolder);
       return {
@@ -1751,9 +1880,35 @@ var V4ConfigParser = class extends import_effect19.Effect.Service()("V4ConfigPar
 
 // src/services/vercel-build-output-parser.ts
 var import_platform11 = require("@effect/platform");
-var import_build_utils2 = require("@gigadrive/build-utils");
-var import_commons = require("@gigadrive/commons");
-var import_effect20 = require("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
+var import_effect21 = require("effect");
 
 // src/build-output-v3/determine-repo-root.ts
 var import_path = __toESM(require("path"));
@@ -1849,11 +2004,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 import_effect20.Effect.Service()("VercelBuildOutputParser", {
-  effect: import_effect20.Effect.gen(function* () {
+var VercelBuildOutputParser = class extends import_effect21.Effect.Service()("VercelBuildOutputParser", {
+  effect: import_effect21.Effect.gen(function* () {
     const rawConfigReader = yield* RawConfigReader;
     const pathService = yield* import_platform11.Path.Path;
-    const parse = import_effect20.Effect.fn("VercelBuildOutputParser.parse")(function* (parseResult, projectFolder) {
+    const parse = import_effect21.Effect.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;
@@ -1861,13 +2016,13 @@ var VercelBuildOutputParser = class extends import_effect20.Effect.Service()("Ve
       const functionData = yield* loadFunctions(config, parseResult, projectFolder);
       const assetOverrides = loadAssetOverrides(config, parseResult);
       const imagePolicy = loadImagePolicy(config);
-      const merged = (0, import_commons.deepMerge)(parseResult, functionData, assetOverrides, imagePolicy);
+      const merged = deepMerge(parseResult, functionData, assetOverrides, imagePolicy);
       merged.regions = [...new Set(merged.regions)];
       return merged;
     });
-    const loadFunctions = import_effect20.Effect.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
-      const functionConfigs = yield* import_effect20.Effect.tryPromise({
-        try: () => (0, import_build_utils2.getFilesForPattern)(FUNCTION_CONFIGS_PATTERN, projectFolder),
+    const loadFunctions = import_effect21.Effect.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
+      const functionConfigs = yield* import_effect21.Effect.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
@@ -2465,7 +2620,7 @@ var schema_default = {
 };
 
 // src/parse-config.ts
-var parseConfigRaw = import_effect21.Effect.fn("parseConfigRaw")(function* (filePath, projectFolder) {
+var parseConfigRaw = import_effect22.Effect.fn("parseConfigRaw")(function* (filePath, projectFolder) {
   const rawReader = yield* RawConfigReader;
   const validator = yield* SchemaValidator;
   const v4Parser = yield* V4ConfigParser;
@@ -2476,7 +2631,7 @@ var parseConfigRaw = import_effect21.Effect.fn("parseConfigRaw")(function* (file
   };
   const schema = schemaMap[version];
   if (!schema) {
-    return yield* import_effect21.Effect.fail(
+    return yield* import_effect22.Effect.fail(
       new ConfigVersionError({
         message: `Config file at ${filePath} has an unsupported version: ${version}`,
         filePath,
@@ -2487,11 +2642,11 @@ var parseConfigRaw = import_effect21.Effect.fn("parseConfigRaw")(function* (file
   yield* validator.validate(parsed, schema, filePath);
   return yield* v4Parser.parse(parsed, projectFolder);
 });
-var parseConfig = import_effect21.Effect.fn("parseConfig")(function* (filePath, projectFolder) {
+var parseConfig = import_effect22.Effect.fn("parseConfig")(function* (filePath, projectFolder) {
   const parseResult = yield* parseConfigRaw(filePath, projectFolder);
   return yield* postProcessConfig(parseResult, projectFolder);
 });
-var postProcessConfig = import_effect21.Effect.fn("postProcessConfig")(function* (config, projectFolder) {
+var postProcessConfig = import_effect22.Effect.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;
@@ -2520,14 +2675,14 @@ var RUNTIME_DEFINITIONS = [
 var AVAILABLE_RUNTIMES = [...RUNTIME_DEFINITIONS];
 
 // src/services/index.ts
-var import_effect22 = require("effect");
-var BaseLayers = import_effect22.Layer.mergeAll(
+var import_effect23 = require("effect");
+var BaseLayers = import_effect23.Layer.mergeAll(
   ConfigModuleLoader.Default,
   RawConfigReader.Default,
   SchemaValidator.Default,
   V4ConfigParser.Default
 );
-var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(import_effect22.Layer.provideMerge(BaseLayers));
+var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(import_effect23.Layer.provideMerge(BaseLayers));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALLOWED_CONFIG_NAMES,
@@ -2548,8 +2703,12 @@ var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(import_effect22.Lay
   GigadriveNextBuildManifestV1Schema,
   GigadriveNextBuildManifestV2ExportSchema,
   GigadriveNextBuildManifestV2StandaloneSchema,
+  GigadriveNextMiddlewareDescriptorSchema,
+  GigadriveNextMiddlewareMatcherSchema,
   GigadriveNextPrerenderManifestV1Schema,
   GigadriveNextPrerenderOutputSchema,
+  GigadriveNextPrerenderSeedMethodsSchema,
+  GigadriveNextRouteConditionSchema,
   GigadriveNextServerDescriptorSchema,
   GigadriveNextStaticAssetPrefixSchema,
   MAX_FUNCTION_DURATION_SECONDS,
@@ -2564,6 +2723,7 @@ var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(import_effect22.Lay
   StaticAssetManifestV1Schema,
   V4ConfigParser,
   VercelBuildOutputParser,
+  collectAssetFiles,
   defineConfig,
   detectFramework,
   detectPackageManager,