@gigadrive/network-config 4.5.0 → 4.6.1

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { Schema, Effect, Layer } from 'effect';
-import { FileSystem, Path } from '@effect/platform';
-import * as _effect_platform_Path from '@effect/platform/Path';
 import * as _effect_platform_FileSystem from '@effect/platform/FileSystem';
+import * as _effect_platform_Path from '@effect/platform/Path';
+import * as effect_Layer from 'effect/Layer';
+import { Path, FileSystem } from '@effect/platform';
 
 declare const StaticAssetHeadersSchema: Schema.filter<Schema.mutable<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.filter<typeof Schema.String>, Schema.mutable<Schema.Array$<Schema.filter<typeof Schema.String>>>]>>>>;
 type StaticAssetHeaders = Schema.Schema.Type<typeof StaticAssetHeadersSchema>;
@@ -73,10 +74,23 @@ interface NormalizedImagePolicy {
 type JsonValue = null | boolean | number | string | JsonValue[] | {
     [key: string]: JsonValue;
 };
-declare const GigadriveNextPrerenderOutputSchema: Schema.mutable<Schema.Struct<{
+/**
+ * Portable Next.js prerender metadata.
+ *
+ * A fallback file is a mutable incremental-cache build seed, not a permanently
+ * authoritative static asset. Consumers must evaluate bypass, preview,
+ * revalidation, and PPR metadata before using it, and may only short-circuit
+ * ordinary GET and HEAD requests.
+ */
+declare const GigadriveNextPrerenderOutputSchema: Schema.Union<[Schema.mutable<Schema.Struct<{
+    routeType: Schema.Literal<["route", "fallback", "shell", "page"]>;
+    response: Schema.Literal<["empty", "initial", "complete"]>;
+    compute: Schema.Literal<["blocking", "resuming", "static"]>;
+    htmlSize: Schema.optional<typeof Schema.Number>;
     id: typeof Schema.String;
     type: Schema.Literal<["PRERENDER"]>;
     pathname: Schema.filter<typeof Schema.String>;
+    route: Schema.optional<Schema.filter<typeof Schema.String>>;
     parentOutputId: typeof Schema.String;
     groupId: typeof Schema.Number;
     pprChain: Schema.optional<Schema.mutable<Schema.Struct<{
@@ -99,7 +113,38 @@ declare const GigadriveNextPrerenderOutputSchema: Schema.mutable<Schema.Struct<{
         partialFallback: Schema.optional<typeof Schema.Boolean>;
         bypassToken: Schema.optional<typeof Schema.String>;
     }>>;
-}>>;
+}>>, Schema.mutable<Schema.Struct<{
+    routeType: Schema.optional<typeof Schema.Never>;
+    response: Schema.optional<typeof Schema.Never>;
+    compute: Schema.optional<typeof Schema.Never>;
+    htmlSize: Schema.optional<typeof Schema.Never>;
+    id: typeof Schema.String;
+    type: Schema.Literal<["PRERENDER"]>;
+    pathname: Schema.filter<typeof Schema.String>;
+    route: Schema.optional<Schema.filter<typeof Schema.String>>;
+    parentOutputId: typeof Schema.String;
+    groupId: typeof Schema.Number;
+    pprChain: Schema.optional<Schema.mutable<Schema.Struct<{
+        headers: Schema.filter<Schema.mutable<Schema.Record$<typeof Schema.String, Schema.filter<typeof Schema.String>>>>;
+    }>>>;
+    parentFallbackMode: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+    fallback: Schema.optional<Schema.mutable<Schema.Struct<{
+        filePath: Schema.optional<Schema.filter<typeof Schema.String>>;
+        initialStatus: Schema.optional<Schema.filter<typeof Schema.Int>>;
+        initialHeaders: Schema.optional<Schema.filter<Schema.mutable<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.filter<typeof Schema.String>, Schema.mutable<Schema.Array$<Schema.filter<typeof Schema.String>>>]>>>>>;
+        initialExpiration: Schema.optional<typeof Schema.Number>;
+        initialRevalidate: Schema.optional<Schema.Union<[typeof Schema.Number, Schema.Literal<[false]>]>>;
+        postponedState: Schema.optional<typeof Schema.String>;
+    }>>>;
+    config: Schema.mutable<Schema.Struct<{
+        allowQuery: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
+        allowHeader: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
+        bypassFor: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+        renderingMode: Schema.optional<typeof Schema.String>;
+        partialFallback: Schema.optional<typeof Schema.Boolean>;
+        bypassToken: Schema.optional<typeof Schema.String>;
+    }>>;
+}>>]>;
 type GigadriveNextPrerenderOutput = Schema.Schema.Type<typeof GigadriveNextPrerenderOutputSchema>;
 /** A directory subtree published under one URL prefix. */
 declare const GigadriveNextStaticAssetPrefixSchema: Schema.mutable<Schema.Struct<{
@@ -108,6 +153,72 @@ declare const GigadriveNextStaticAssetPrefixSchema: Schema.mutable<Schema.Struct
     immutable: typeof Schema.Boolean;
 }>>;
 type GigadriveNextStaticAssetPrefix = Schema.Schema.Type<typeof GigadriveNextStaticAssetPrefixSchema>;
+/** Portable request condition used by a Next.js middleware/Proxy matcher. */
+declare const GigadriveNextRouteConditionSchema: Schema.Union<[Schema.mutable<Schema.Struct<{
+    type: Schema.Literal<["header", "cookie", "query"]>;
+    key: typeof Schema.String;
+    value: Schema.optional<typeof Schema.String>;
+}>>, Schema.mutable<Schema.Struct<{
+    type: Schema.Literal<["host"]>;
+    value: typeof Schema.String;
+}>>]>;
+type GigadriveNextRouteCondition = Schema.Schema.Type<typeof GigadriveNextRouteConditionSchema>;
+/** Validated public matcher metadata for a Next.js middleware or Proxy entrypoint. */
+declare const GigadriveNextMiddlewareMatcherSchema: Schema.mutable<Schema.Struct<{
+    source: typeof Schema.String;
+    sourceRegex: typeof Schema.String;
+    has: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.Struct<{
+        type: Schema.Literal<["header", "cookie", "query"]>;
+        key: typeof Schema.String;
+        value: Schema.optional<typeof Schema.String>;
+    }>>, Schema.mutable<Schema.Struct<{
+        type: Schema.Literal<["host"]>;
+        value: typeof Schema.String;
+    }>>]>>>>;
+    missing: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.Struct<{
+        type: Schema.Literal<["header", "cookie", "query"]>;
+        key: typeof Schema.String;
+        value: Schema.optional<typeof Schema.String>;
+    }>>, Schema.mutable<Schema.Struct<{
+        type: Schema.Literal<["host"]>;
+        value: typeof Schema.String;
+    }>>]>>>>;
+}>>;
+type GigadriveNextMiddlewareMatcher = Schema.Schema.Type<typeof GigadriveNextMiddlewareMatcherSchema>;
+/**
+ * Portable middleware/Proxy discovery result.
+ *
+ * The object is emitted for every new standalone build. Its optional position
+ * in the containing manifest preserves parsing of manifests written by older
+ * SDK releases, where absence means that middleware presence is unknown.
+ */
+declare const GigadriveNextMiddlewareDescriptorSchema: Schema.Union<[Schema.mutable<Schema.Struct<{
+    present: Schema.Literal<[true]>;
+    matchers: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+        source: typeof Schema.String;
+        sourceRegex: typeof Schema.String;
+        has: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.Struct<{
+            type: Schema.Literal<["header", "cookie", "query"]>;
+            key: typeof Schema.String;
+            value: Schema.optional<typeof Schema.String>;
+        }>>, Schema.mutable<Schema.Struct<{
+            type: Schema.Literal<["host"]>;
+            value: typeof Schema.String;
+        }>>]>>>>;
+        missing: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.Struct<{
+            type: Schema.Literal<["header", "cookie", "query"]>;
+            key: typeof Schema.String;
+            value: Schema.optional<typeof Schema.String>;
+        }>>, Schema.mutable<Schema.Struct<{
+            type: Schema.Literal<["host"]>;
+            value: typeof Schema.String;
+        }>>]>>>>;
+    }>>>>;
+}>>, Schema.mutable<Schema.Struct<{
+    present: Schema.Literal<[false]>;
+    matchers: Schema.mutable<Schema.Tuple<[]>>;
+}>>]>;
+type GigadriveNextMiddlewareDescriptor = Schema.Schema.Type<typeof GigadriveNextMiddlewareDescriptorSchema>;
 /** Aggregated runtime configuration for the standalone server. */
 declare const GigadriveNextServerDescriptorSchema: Schema.mutable<Schema.Struct<{
     maxDuration: Schema.optional<typeof Schema.Number>;
@@ -115,6 +226,9 @@ declare const GigadriveNextServerDescriptorSchema: Schema.mutable<Schema.Struct<
     env: Schema.optional<Schema.mutable<Schema.Record$<typeof Schema.String, typeof Schema.String>>>;
 }>>;
 type GigadriveNextServerDescriptor = Schema.Schema.Type<typeof GigadriveNextServerDescriptorSchema>;
+/** Methods for which a validated prerender seed may participate in response lookup. */
+declare const GigadriveNextPrerenderSeedMethodsSchema: Schema.mutable<Schema.Tuple2<Schema.Literal<["GET"]>, Schema.Literal<["HEAD"]>>>;
+type GigadriveNextPrerenderSeedMethods = Schema.Schema.Type<typeof GigadriveNextPrerenderSeedMethodsSchema>;
 declare const GigadriveNextBuildManifestV1Schema: Schema.mutable<Schema.Struct<{
     version: Schema.Literal<[1]>;
     output: Schema.Literal<["standalone", "export"]>;
@@ -165,10 +279,15 @@ declare const GigadriveNextBuildManifestV2StandaloneSchema: Schema.mutable<Schem
         rsc: Schema.Schema<JsonValue, JsonValue, never>;
     }>>;
     outputs: Schema.mutable<Schema.Struct<{
-        prerenders: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+        prerenders: Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.Struct<{
+            routeType: Schema.Literal<["route", "fallback", "shell", "page"]>;
+            response: Schema.Literal<["empty", "initial", "complete"]>;
+            compute: Schema.Literal<["blocking", "resuming", "static"]>;
+            htmlSize: Schema.optional<typeof Schema.Number>;
             id: typeof Schema.String;
             type: Schema.Literal<["PRERENDER"]>;
             pathname: Schema.filter<typeof Schema.String>;
+            route: Schema.optional<Schema.filter<typeof Schema.String>>;
             parentOutputId: typeof Schema.String;
             groupId: typeof Schema.Number;
             pprChain: Schema.optional<Schema.mutable<Schema.Struct<{
@@ -191,7 +310,38 @@ declare const GigadriveNextBuildManifestV2StandaloneSchema: Schema.mutable<Schem
                 partialFallback: Schema.optional<typeof Schema.Boolean>;
                 bypassToken: Schema.optional<typeof Schema.String>;
             }>>;
-        }>>>>;
+        }>>, Schema.mutable<Schema.Struct<{
+            routeType: Schema.optional<typeof Schema.Never>;
+            response: Schema.optional<typeof Schema.Never>;
+            compute: Schema.optional<typeof Schema.Never>;
+            htmlSize: Schema.optional<typeof Schema.Never>;
+            id: typeof Schema.String;
+            type: Schema.Literal<["PRERENDER"]>;
+            pathname: Schema.filter<typeof Schema.String>;
+            route: Schema.optional<Schema.filter<typeof Schema.String>>;
+            parentOutputId: typeof Schema.String;
+            groupId: typeof Schema.Number;
+            pprChain: Schema.optional<Schema.mutable<Schema.Struct<{
+                headers: Schema.filter<Schema.mutable<Schema.Record$<typeof Schema.String, Schema.filter<typeof Schema.String>>>>;
+            }>>>;
+            parentFallbackMode: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+            fallback: Schema.optional<Schema.mutable<Schema.Struct<{
+                filePath: Schema.optional<Schema.filter<typeof Schema.String>>;
+                initialStatus: Schema.optional<Schema.filter<typeof Schema.Int>>;
+                initialHeaders: Schema.optional<Schema.filter<Schema.mutable<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.filter<typeof Schema.String>, Schema.mutable<Schema.Array$<Schema.filter<typeof Schema.String>>>]>>>>>;
+                initialExpiration: Schema.optional<typeof Schema.Number>;
+                initialRevalidate: Schema.optional<Schema.Union<[typeof Schema.Number, Schema.Literal<[false]>]>>;
+                postponedState: Schema.optional<typeof Schema.String>;
+            }>>>;
+            config: Schema.mutable<Schema.Struct<{
+                allowQuery: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
+                allowHeader: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
+                bypassFor: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+                renderingMode: Schema.optional<typeof Schema.String>;
+                partialFallback: Schema.optional<typeof Schema.Boolean>;
+                bypassToken: Schema.optional<typeof Schema.String>;
+            }>>;
+        }>>]>>>;
         prerenderManifest: Schema.optional<Schema.filter<typeof Schema.String>>;
         assetManifest: Schema.optional<Schema.filter<typeof Schema.String>>;
         entryPagePaths: Schema.optional<Schema.mutable<Schema.Array$<Schema.filter<typeof Schema.String>>>>;
@@ -200,6 +350,32 @@ declare const GigadriveNextBuildManifestV2StandaloneSchema: Schema.mutable<Schem
             urlPrefix: Schema.filter<typeof Schema.String>;
             immutable: typeof Schema.Boolean;
         }>>>>;
+        middleware: Schema.optional<Schema.Union<[Schema.mutable<Schema.Struct<{
+            present: Schema.Literal<[true]>;
+            matchers: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+                source: typeof Schema.String;
+                sourceRegex: typeof Schema.String;
+                has: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.Struct<{
+                    type: Schema.Literal<["header", "cookie", "query"]>;
+                    key: typeof Schema.String;
+                    value: Schema.optional<typeof Schema.String>;
+                }>>, Schema.mutable<Schema.Struct<{
+                    type: Schema.Literal<["host"]>;
+                    value: typeof Schema.String;
+                }>>]>>>>;
+                missing: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.Struct<{
+                    type: Schema.Literal<["header", "cookie", "query"]>;
+                    key: typeof Schema.String;
+                    value: Schema.optional<typeof Schema.String>;
+                }>>, Schema.mutable<Schema.Struct<{
+                    type: Schema.Literal<["host"]>;
+                    value: typeof Schema.String;
+                }>>]>>>>;
+            }>>>>;
+        }>>, Schema.mutable<Schema.Struct<{
+            present: Schema.Literal<[false]>;
+            matchers: Schema.mutable<Schema.Tuple<[]>>;
+        }>>]>>;
     }>>;
 }>>;
 type GigadriveNextBuildManifestV2Standalone = Schema.Schema.Type<typeof GigadriveNextBuildManifestV2StandaloneSchema>;
@@ -247,10 +423,15 @@ declare const GigadriveNextBuildManifestSchema: Schema.Union<[Schema.mutable<Sch
         rsc: Schema.Schema<JsonValue, JsonValue, never>;
     }>>;
     outputs: Schema.mutable<Schema.Struct<{
-        prerenders: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+        prerenders: Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.Struct<{
+            routeType: Schema.Literal<["route", "fallback", "shell", "page"]>;
+            response: Schema.Literal<["empty", "initial", "complete"]>;
+            compute: Schema.Literal<["blocking", "resuming", "static"]>;
+            htmlSize: Schema.optional<typeof Schema.Number>;
             id: typeof Schema.String;
             type: Schema.Literal<["PRERENDER"]>;
             pathname: Schema.filter<typeof Schema.String>;
+            route: Schema.optional<Schema.filter<typeof Schema.String>>;
             parentOutputId: typeof Schema.String;
             groupId: typeof Schema.Number;
             pprChain: Schema.optional<Schema.mutable<Schema.Struct<{
@@ -273,7 +454,38 @@ declare const GigadriveNextBuildManifestSchema: Schema.Union<[Schema.mutable<Sch
                 partialFallback: Schema.optional<typeof Schema.Boolean>;
                 bypassToken: Schema.optional<typeof Schema.String>;
             }>>;
-        }>>>>;
+        }>>, Schema.mutable<Schema.Struct<{
+            routeType: Schema.optional<typeof Schema.Never>;
+            response: Schema.optional<typeof Schema.Never>;
+            compute: Schema.optional<typeof Schema.Never>;
+            htmlSize: Schema.optional<typeof Schema.Never>;
+            id: typeof Schema.String;
+            type: Schema.Literal<["PRERENDER"]>;
+            pathname: Schema.filter<typeof Schema.String>;
+            route: Schema.optional<Schema.filter<typeof Schema.String>>;
+            parentOutputId: typeof Schema.String;
+            groupId: typeof Schema.Number;
+            pprChain: Schema.optional<Schema.mutable<Schema.Struct<{
+                headers: Schema.filter<Schema.mutable<Schema.Record$<typeof Schema.String, Schema.filter<typeof Schema.String>>>>;
+            }>>>;
+            parentFallbackMode: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+            fallback: Schema.optional<Schema.mutable<Schema.Struct<{
+                filePath: Schema.optional<Schema.filter<typeof Schema.String>>;
+                initialStatus: Schema.optional<Schema.filter<typeof Schema.Int>>;
+                initialHeaders: Schema.optional<Schema.filter<Schema.mutable<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.filter<typeof Schema.String>, Schema.mutable<Schema.Array$<Schema.filter<typeof Schema.String>>>]>>>>>;
+                initialExpiration: Schema.optional<typeof Schema.Number>;
+                initialRevalidate: Schema.optional<Schema.Union<[typeof Schema.Number, Schema.Literal<[false]>]>>;
+                postponedState: Schema.optional<typeof Schema.String>;
+            }>>>;
+            config: Schema.mutable<Schema.Struct<{
+                allowQuery: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
+                allowHeader: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
+                bypassFor: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+                renderingMode: Schema.optional<typeof Schema.String>;
+                partialFallback: Schema.optional<typeof Schema.Boolean>;
+                bypassToken: Schema.optional<typeof Schema.String>;
+            }>>;
+        }>>]>>>;
         prerenderManifest: Schema.optional<Schema.filter<typeof Schema.String>>;
         assetManifest: Schema.optional<Schema.filter<typeof Schema.String>>;
         entryPagePaths: Schema.optional<Schema.mutable<Schema.Array$<Schema.filter<typeof Schema.String>>>>;
@@ -282,17 +494,54 @@ declare const GigadriveNextBuildManifestSchema: Schema.Union<[Schema.mutable<Sch
             urlPrefix: Schema.filter<typeof Schema.String>;
             immutable: typeof Schema.Boolean;
         }>>>>;
+        middleware: Schema.optional<Schema.Union<[Schema.mutable<Schema.Struct<{
+            present: Schema.Literal<[true]>;
+            matchers: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+                source: typeof Schema.String;
+                sourceRegex: typeof Schema.String;
+                has: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.Struct<{
+                    type: Schema.Literal<["header", "cookie", "query"]>;
+                    key: typeof Schema.String;
+                    value: Schema.optional<typeof Schema.String>;
+                }>>, Schema.mutable<Schema.Struct<{
+                    type: Schema.Literal<["host"]>;
+                    value: typeof Schema.String;
+                }>>]>>>>;
+                missing: Schema.optional<Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.Struct<{
+                    type: Schema.Literal<["header", "cookie", "query"]>;
+                    key: typeof Schema.String;
+                    value: Schema.optional<typeof Schema.String>;
+                }>>, Schema.mutable<Schema.Struct<{
+                    type: Schema.Literal<["host"]>;
+                    value: typeof Schema.String;
+                }>>]>>>>;
+            }>>>>;
+        }>>, Schema.mutable<Schema.Struct<{
+            present: Schema.Literal<[false]>;
+            matchers: Schema.mutable<Schema.Tuple<[]>>;
+        }>>]>>;
     }>>;
 }>>]>;
 type GigadriveNextBuildManifestV2 = GigadriveNextBuildManifestV2Standalone | GigadriveNextBuildManifestV2Export;
 type GigadriveNextBuildManifest = Schema.Schema.Type<typeof GigadriveNextBuildManifestSchema>;
-/** Portable sidecar containing high-cardinality Next.js prerender metadata. */
+/**
+ * Portable sidecar containing high-cardinality Next.js prerender build seeds.
+ *
+ * `seedMethods` is optional only for parsing sidecars emitted by older SDK
+ * releases. New adapters always emit the explicit GET/HEAD method scope.
+ */
 declare const GigadriveNextPrerenderManifestV1Schema: Schema.mutable<Schema.Struct<{
     version: Schema.Literal<[1]>;
-    prerenders: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+    seedMethods: Schema.optional<Schema.mutable<Schema.Tuple2<Schema.Literal<["GET"]>, Schema.Literal<["HEAD"]>>>>;
+    prerenders: Schema.mutable<Schema.Array$<Schema.Union<[Schema.mutable<Schema.Struct<{
+        routeType: Schema.Literal<["route", "fallback", "shell", "page"]>;
+        response: Schema.Literal<["empty", "initial", "complete"]>;
+        compute: Schema.Literal<["blocking", "resuming", "static"]>;
+        htmlSize: Schema.optional<typeof Schema.Number>;
         id: typeof Schema.String;
         type: Schema.Literal<["PRERENDER"]>;
         pathname: Schema.filter<typeof Schema.String>;
+        route: Schema.optional<Schema.filter<typeof Schema.String>>;
         parentOutputId: typeof Schema.String;
         groupId: typeof Schema.Number;
         pprChain: Schema.optional<Schema.mutable<Schema.Struct<{
@@ -315,7 +564,38 @@ declare const GigadriveNextPrerenderManifestV1Schema: Schema.mutable<Schema.Stru
             partialFallback: Schema.optional<typeof Schema.Boolean>;
             bypassToken: Schema.optional<typeof Schema.String>;
         }>>;
-    }>>>>;
+    }>>, Schema.mutable<Schema.Struct<{
+        routeType: Schema.optional<typeof Schema.Never>;
+        response: Schema.optional<typeof Schema.Never>;
+        compute: Schema.optional<typeof Schema.Never>;
+        htmlSize: Schema.optional<typeof Schema.Never>;
+        id: typeof Schema.String;
+        type: Schema.Literal<["PRERENDER"]>;
+        pathname: Schema.filter<typeof Schema.String>;
+        route: Schema.optional<Schema.filter<typeof Schema.String>>;
+        parentOutputId: typeof Schema.String;
+        groupId: typeof Schema.Number;
+        pprChain: Schema.optional<Schema.mutable<Schema.Struct<{
+            headers: Schema.filter<Schema.mutable<Schema.Record$<typeof Schema.String, Schema.filter<typeof Schema.String>>>>;
+        }>>>;
+        parentFallbackMode: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+        fallback: Schema.optional<Schema.mutable<Schema.Struct<{
+            filePath: Schema.optional<Schema.filter<typeof Schema.String>>;
+            initialStatus: Schema.optional<Schema.filter<typeof Schema.Int>>;
+            initialHeaders: Schema.optional<Schema.filter<Schema.mutable<Schema.Record$<typeof Schema.String, Schema.Union<[Schema.filter<typeof Schema.String>, Schema.mutable<Schema.Array$<Schema.filter<typeof Schema.String>>>]>>>>>;
+            initialExpiration: Schema.optional<typeof Schema.Number>;
+            initialRevalidate: Schema.optional<Schema.Union<[typeof Schema.Number, Schema.Literal<[false]>]>>;
+            postponedState: Schema.optional<typeof Schema.String>;
+        }>>>;
+        config: Schema.mutable<Schema.Struct<{
+            allowQuery: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
+            allowHeader: Schema.optional<Schema.mutable<Schema.Array$<typeof Schema.String>>>;
+            bypassFor: Schema.optional<Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>>;
+            renderingMode: Schema.optional<typeof Schema.String>;
+            partialFallback: Schema.optional<typeof Schema.Boolean>;
+            bypassToken: Schema.optional<typeof Schema.String>;
+        }>>;
+    }>>]>>>;
 }>>;
 type GigadriveNextPrerenderManifestV1 = Schema.Schema.Type<typeof GigadriveNextPrerenderManifestV1Schema>;
 /** Parses and structurally validates adapter metadata before deployment code consumes it. */
@@ -582,263 +862,85 @@ type NormalizedConfigRouteMatchRequirements = [] | [
     }
 ];
 
-declare const ManifestNotFoundError_base: Schema.TaggedErrorClass<ManifestNotFoundError, "ManifestNotFoundError", {
-    readonly _tag: Schema.tag<"ManifestNotFoundError">;
+declare const ConfigFileNotFoundError_base: Schema.TaggedErrorClass<ConfigFileNotFoundError, "ConfigFileNotFoundError", {
+    readonly _tag: Schema.tag<"ConfigFileNotFoundError">;
 } & {
     message: typeof Schema.String;
     filePath: typeof Schema.String;
 }>;
-declare class ManifestNotFoundError extends ManifestNotFoundError_base {
+declare class ConfigFileNotFoundError extends ConfigFileNotFoundError_base {
 }
-declare const ManifestReadError_base: Schema.TaggedErrorClass<ManifestReadError, "ManifestReadError", {
-    readonly _tag: Schema.tag<"ManifestReadError">;
+declare const ConfigFileEmptyError_base: Schema.TaggedErrorClass<ConfigFileEmptyError, "ConfigFileEmptyError", {
+    readonly _tag: Schema.tag<"ConfigFileEmptyError">;
 } & {
     message: typeof Schema.String;
     filePath: typeof Schema.String;
 }>;
-declare class ManifestReadError extends ManifestReadError_base {
+declare class ConfigFileEmptyError extends ConfigFileEmptyError_base {
 }
-declare const ManifestParseError_base: Schema.TaggedErrorClass<ManifestParseError, "ManifestParseError", {
-    readonly _tag: Schema.tag<"ManifestParseError">;
+declare const ConfigFileParseError_base: Schema.TaggedErrorClass<ConfigFileParseError, "ConfigFileParseError", {
+    readonly _tag: Schema.tag<"ConfigFileParseError">;
 } & {
     message: typeof Schema.String;
     filePath: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.String>;
 }>;
-declare class ManifestParseError extends ManifestParseError_base {
+declare class ConfigFileParseError extends ConfigFileParseError_base {
 }
-declare const FrameworkNotDetectedError_base: Schema.TaggedErrorClass<FrameworkNotDetectedError, "FrameworkNotDetectedError", {
-    readonly _tag: Schema.tag<"FrameworkNotDetectedError">;
+declare const ConfigModuleLoadError_base: Schema.TaggedErrorClass<ConfigModuleLoadError, "ConfigModuleLoadError", {
+    readonly _tag: Schema.tag<"ConfigModuleLoadError">;
 } & {
     message: typeof Schema.String;
-    directory: typeof Schema.String;
+    filePath: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.String>;
 }>;
-declare class FrameworkNotDetectedError extends FrameworkNotDetectedError_base {
+declare class ConfigModuleLoadError extends ConfigModuleLoadError_base {
 }
-interface FrameworkDetectionItem {
-    /** Check manifest dependencies for this package (routed by framework language) */
-    matchPackage?: string;
-    /** Check if this file exists (relative to project root) */
-    path?: string;
-    /** If path is set, also check file content matches this regex */
-    matchContent?: string;
+declare const ConfigVersionError_base: Schema.TaggedErrorClass<ConfigVersionError, "ConfigVersionError", {
+    readonly _tag: Schema.tag<"ConfigVersionError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+    version: Schema.optional<typeof Schema.Number>;
+}>;
+declare class ConfigVersionError extends ConfigVersionError_base {
 }
-type FrameworkLanguage = 'node' | 'php';
-type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'composer';
-interface FrameworkDefinition {
-    slug: string;
-    name: string;
-    language: FrameworkLanguage;
-    /** ALL items must match for the framework to be detected */
-    detectors: FrameworkDetectionItem[];
-    /** Higher = higher priority (specific frameworks beat generic ones) */
-    priority: number;
-    /** Generates deployment defaults for this framework */
-    getDefaultConfig: (packageManager: PackageManager) => FrameworkDefaultConfig;
-    /** Refines defaults with project files after a framework match, e.g. framework CLI config. */
-    refineDefaultConfig?: (defaults: FrameworkDefaultConfig, projectFolder: string) => Effect.Effect<FrameworkDefaultConfig, never, FileSystem.FileSystem | Path.Path>;
+declare const ConfigSchemaValidationError_base: Schema.TaggedErrorClass<ConfigSchemaValidationError, "ConfigSchemaValidationError", {
+    readonly _tag: Schema.tag<"ConfigSchemaValidationError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+    validationErrors: Schema.Array$<typeof Schema.String>;
+}>;
+declare class ConfigSchemaValidationError extends ConfigSchemaValidationError_base {
 }
-interface FrameworkDefaultConfig {
-    runtime: Runtime;
-    memory: number;
-    maxDuration: number;
-    streaming: boolean;
-    /** Overrides the auto-generated install command (e.g. for custom composer flags) */
-    installCommand?: string;
-    /** Build commands (install command is auto-prepended by generateConfig) */
-    commands: string[];
-    entrypoint?: string;
-    assetsDir?: string;
-    assetsPrefixToStrip?: string;
-    /** Explicit project-relative files to publish as static assets. */
-    assetPaths?: string[];
-    /** Public path overrides keyed by project-relative asset path. */
-    assetOverrides?: Record<string, {
-        path?: string;
-        contentType?: string;
-    }>;
-    /** Directory subtrees to publish under a URL prefix without per-file enumeration. */
-    assetPrefixes?: Array<{
-        source: string;
-        destination: string;
-        immutable?: boolean;
-        populateCache?: boolean;
-        contentType?: string;
-    }>;
-    /** Project-relative manifests containing logical static asset entries. */
-    assetManifests?: Array<{
-        source: string;
-    }>;
-    populateAssetCache?: boolean;
-    routes: Array<{
-        source: string;
-        destination: string;
-    }>;
-    environmentVariables: Record<string, string>;
-    symlinks?: Record<string, string>;
-    excludeFiles?: string[];
-    package?: {
-        trace?: boolean;
-        includeProjectFiles?: boolean;
-        preserveSymlinks?: boolean;
-        rootOverwrite?: string;
-        filePathMap?: Record<string, string>;
-        includeFiles?: string[];
-        excludeFiles?: string[];
-    };
-    /** Advanced framework output that replaces the one-entrypoint defaults. */
-    normalizedConfig?: Partial<NormalizedConfig>;
+declare const FunctionConfigError_base: Schema.TaggedErrorClass<FunctionConfigError, "FunctionConfigError", {
+    readonly _tag: Schema.tag<"FunctionConfigError">;
+} & {
+    message: typeof Schema.String;
+    functionPath: typeof Schema.String;
+}>;
+declare class FunctionConfigError extends FunctionConfigError_base {
 }
-interface DetectionResult {
-    framework: FrameworkDefinition;
-    packageManager: PackageManager;
-    config: NormalizedConfig;
+
+declare const ConfigModuleLoader_base: Effect.Service.Class<ConfigModuleLoader, "ConfigModuleLoader", {
+    readonly effect: Effect.Effect<{
+        loadConfigModule: (filePath: string) => Effect.Effect<Record<string, unknown>, ConfigModuleLoadError, never>;
+    }, never, never>;
+}>;
+declare class ConfigModuleLoader extends ConfigModuleLoader_base {
 }
 
-/**
- * Detects the framework used in a project by checking framework definitions
- * against the project's dependencies and file structure.
- *
- * Framework definitions are checked in priority order (highest first).
- * All detectors for a framework must match for it to be selected.
- *
- * @param projectFolder - Absolute path to the project root
- * @returns DetectionResult with framework, package manager, and generated config
- */
-declare const detectFramework: (projectFolder: string) => Effect.Effect<{
-    framework: FrameworkDefinition;
-    packageManager: PackageManager;
-    config: NormalizedConfig;
-}, ManifestReadError | ManifestParseError | FrameworkNotDetectedError, FileSystem.FileSystem | Path.Path>;
-
-/**
- * Detects the package manager by checking for lockfiles in the project folder.
- * Falls back to `npm` if no lockfile is found.
- *
- * @param projectFolder - Absolute path to the project root
- * @returns The detected package manager
- */
-declare const detectPackageManager: (projectFolder: string) => Effect.Effect<PackageManager, never, FileSystem.FileSystem | Path.Path>;
-
-/**
- * All supported framework definitions, sorted by priority descending.
- * Higher priority frameworks are checked first during detection.
- */
-declare const FRAMEWORK_DEFINITIONS: FrameworkDefinition[];
-
-/**
- * Generates a NormalizedConfig from a framework definition and detected package manager.
- * Prepends the install command and builds a complete deployment configuration.
- *
- * @param framework - The detected framework definition
- * @param packageManager - The detected package manager
- * @returns A complete NormalizedConfig with framework defaults
- */
-declare const generateConfig: (framework: FrameworkDefinition, packageManager: PackageManager, refinedDefaults?: FrameworkDefaultConfig | undefined) => Effect.Effect<NormalizedConfig, never, never>;
-
-/**
- * Merges framework defaults with a user-provided config.
- * User config always takes precedence; framework defaults fill gaps.
- *
- * - commands: use user's if non-empty, otherwise framework's
- * - entrypoints: use user's if non-empty, otherwise framework's
- * - routes: use user's if non-empty, otherwise framework's
- * - assets: use user's if it declares any sources, otherwise framework's
- * - excludeFiles: use user's if non-empty, otherwise framework's
- * - regions: always use user's (always populated from parsing)
- * - environmentVariables: deep merge (framework base, user overrides)
- * - services: always use user's (frameworks don't define services)
- * - warnings/errors: concatenate both
- *
- * @param userConfig - The config parsed from the user's config file
- * @param frameworkConfig - The config generated from framework detection
- * @returns The merged config
- */
-declare const mergeWithFrameworkDefaults: (userConfig: NormalizedConfig, frameworkConfig: NormalizedConfig) => Effect.Effect<NormalizedConfig, never, never>;
-
-/**
- * Reads dependency names from the appropriate manifest file for a language.
- * Returns a set of all dependency names (production + dev).
- *
- * If the manifest file does not exist, returns an empty set (graceful).
- * If the file exists but cannot be read (`ManifestReadError`) or parsed
- * (`ManifestParseError`), the error propagates — this indicates a real
- * problem the user should know about.
- *
- * @param projectFolder - Absolute path to the project root
- * @param language - The framework language to determine which manifest to read
- * @returns A set of dependency package names
- */
-declare const readDependencies: (projectFolder: string, language: FrameworkLanguage) => Effect.Effect<Set<string>, ManifestReadError | ManifestParseError, FileSystem.FileSystem | Path.Path>;
-
-declare const ConfigFileNotFoundError_base: Schema.TaggedErrorClass<ConfigFileNotFoundError, "ConfigFileNotFoundError", {
-    readonly _tag: Schema.tag<"ConfigFileNotFoundError">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-}>;
-declare class ConfigFileNotFoundError extends ConfigFileNotFoundError_base {
-}
-declare const ConfigFileEmptyError_base: Schema.TaggedErrorClass<ConfigFileEmptyError, "ConfigFileEmptyError", {
-    readonly _tag: Schema.tag<"ConfigFileEmptyError">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-}>;
-declare class ConfigFileEmptyError extends ConfigFileEmptyError_base {
-}
-declare const ConfigFileParseError_base: Schema.TaggedErrorClass<ConfigFileParseError, "ConfigFileParseError", {
-    readonly _tag: Schema.tag<"ConfigFileParseError">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-    cause: Schema.optional<typeof Schema.String>;
-}>;
-declare class ConfigFileParseError extends ConfigFileParseError_base {
-}
-declare const ConfigVersionError_base: Schema.TaggedErrorClass<ConfigVersionError, "ConfigVersionError", {
-    readonly _tag: Schema.tag<"ConfigVersionError">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-    version: Schema.optional<typeof Schema.Number>;
-}>;
-declare class ConfigVersionError extends ConfigVersionError_base {
-}
-declare const ConfigSchemaValidationError_base: Schema.TaggedErrorClass<ConfigSchemaValidationError, "ConfigSchemaValidationError", {
-    readonly _tag: Schema.tag<"ConfigSchemaValidationError">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-    validationErrors: Schema.Array$<typeof Schema.String>;
-}>;
-declare class ConfigSchemaValidationError extends ConfigSchemaValidationError_base {
-}
-declare const FunctionConfigError_base: Schema.TaggedErrorClass<FunctionConfigError, "FunctionConfigError", {
-    readonly _tag: Schema.tag<"FunctionConfigError">;
-} & {
-    message: typeof Schema.String;
-    functionPath: typeof Schema.String;
-}>;
-declare class FunctionConfigError extends FunctionConfigError_base {
-}
-
-/**
- * Ensure a normalized config has no function files that are also defined as assets.
- * For example, a file `public/index.php` should not be defined as an asset, when it is a function and `public` is an asset folder.
- * @param config The normalized config to filter.
- * @returns A promise that resolves to the filtered config.
- */
-declare const filterFunctionsFromAssets: (config: NormalizedConfig) => NormalizedConfig;
-
-declare const ALLOWED_CONFIG_NAMES: readonly ["gigadrive.yaml", "gigadrive.yml", "nebula.yaml", "nebula.yml", "nebula.json"];
+declare const ALLOWED_CONFIG_NAMES: readonly ["gigadrive.ts", "gigadrive.mts", "gigadrive.cts", "gigadrive.js", "gigadrive.mjs", "gigadrive.cjs", "gigadrive.yaml", "gigadrive.yml", "gigadrive.json", "nebula.yaml", "nebula.yml", "nebula.json"];
 declare const RawConfigReader_base: Effect.Service.Class<RawConfigReader, "RawConfigReader", {
+    readonly dependencies: readonly [effect_Layer.Layer<ConfigModuleLoader, never, never>];
     readonly effect: Effect.Effect<{
         findConfig: (projectFolder: string) => Effect.Effect<string | null, never, never>;
         readRawConfig: (filePath: string, options?: {
             disableVersionCheck?: boolean;
-        } | undefined) => Effect.Effect<Record<string, unknown>, ConfigFileNotFoundError | ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError, never>;
-        readConfigFile: <T>(configFilePath: string) => Effect.Effect<T | null, ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError, never>;
-    }, never, FileSystem.FileSystem | Path.Path>;
+        } | undefined) => Effect.Effect<Record<string, unknown>, ConfigFileNotFoundError | ConfigFileEmptyError | ConfigFileParseError | ConfigModuleLoadError | ConfigVersionError, never>;
+        readConfigFile: <T>(configFilePath: string) => Effect.Effect<T | null, ConfigFileEmptyError | ConfigFileParseError | ConfigModuleLoadError | ConfigVersionError, never>;
+    }, never, ConfigModuleLoader | Path.Path | FileSystem.FileSystem>;
 }>;
 declare class RawConfigReader extends RawConfigReader_base {
 }
@@ -851,6 +953,103 @@ declare const SchemaValidator_base: Effect.Service.Class<SchemaValidator, "Schem
 declare class SchemaValidator extends SchemaValidator_base {
 }
 
+/**
+ * Resolves merged function settings for a given path by iterating all function
+ * patterns in the config. Later patterns override earlier ones.
+ *
+ * @returns The merged settings, or undefined when no pattern matches the path.
+ */
+declare const getFunctionSettings: (path: string, config: ConfigV4) => ConfigV4FunctionSettings | undefined;
+declare const V4ConfigParser_base: Effect.Service.Class<V4ConfigParser, "V4ConfigParser", {
+    readonly accessors: true;
+    readonly effect: Effect.Effect<{
+        /**
+         * Parses a ConfigV4 into a NormalizedConfig.
+         *
+         * @param config - The raw V4 config object
+         * @param projectFolder - Absolute path to the project root
+         */
+        parse: (config: ConfigV4, projectFolder: string) => Effect.Effect<{
+            regions: ("us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "ap-south-1" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-northeast-1" | "ca-central-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "eu-north-1" | "sa-east-1")[];
+            assets: {
+                paths: string[];
+                prefixToStrip: string;
+                dynamicRoutes: boolean;
+                populateCache: boolean;
+            };
+            environmentVariables: Record<string, string>;
+            commands: string[];
+            images: NormalizedImagePolicy | undefined;
+            services: NormalizedConfigServiceDefinition[] | undefined;
+            entrypoints: NormalizedConfigEntrypoint[];
+            errors: never[];
+            warnings: never[];
+            routes: NormalizedConfigRoute[];
+        }, FunctionConfigError, Path.Path | FileSystem.FileSystem>;
+    }, never, never>;
+}>;
+declare class V4ConfigParser extends V4ConfigParser_base {
+}
+
+declare const VercelBuildOutputParser_base: Effect.Service.Class<VercelBuildOutputParser, "VercelBuildOutputParser", {
+    readonly effect: Effect.Effect<{
+        parse: (parseResult: NormalizedConfig, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileEmptyError | ConfigFileParseError | ConfigModuleLoadError | ConfigVersionError, Path.Path | _effect_platform_FileSystem.FileSystem>;
+    }, never, RawConfigReader | Path.Path>;
+}>;
+declare class VercelBuildOutputParser extends VercelBuildOutputParser_base {
+}
+
+interface Config {
+    version: number;
+    env?: Record<string, string>;
+}
+/**
+ * Parses a config file at the given path and validates it against the appropriate
+ * JSON Schema, returning a NormalizedConfig **without** post-processing.
+ *
+ * Use {@link parseConfig} when you also want Vercel BOv3 merging, empty-deployment
+ * checks, and function/asset deduplication applied automatically.
+ *
+ * @param filePath - Absolute path to the config file
+ * @param projectFolder - Absolute path to the project root
+ */
+declare const parseConfigRaw: (filePath: string, projectFolder: string) => Effect.Effect<{
+    regions: ("us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "ap-south-1" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-northeast-1" | "ca-central-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "eu-north-1" | "sa-east-1")[];
+    assets: {
+        paths: string[];
+        prefixToStrip: string;
+        dynamicRoutes: boolean;
+        populateCache: boolean;
+    };
+    environmentVariables: Record<string, string>;
+    commands: string[];
+    images: NormalizedImagePolicy | undefined;
+    services: NormalizedConfigServiceDefinition[] | undefined;
+    entrypoints: NormalizedConfigEntrypoint[];
+    errors: never[];
+    warnings: never[];
+    routes: NormalizedConfigRoute[];
+}, ConfigFileNotFoundError | ConfigFileEmptyError | ConfigFileParseError | ConfigModuleLoadError | ConfigVersionError | ConfigSchemaValidationError | FunctionConfigError, RawConfigReader | _effect_platform_Path.Path | _effect_platform_FileSystem.FileSystem | SchemaValidator | V4ConfigParser>;
+/**
+ * Parses a config file at the given path, validates it against the appropriate
+ * JSON Schema, converts it to a NormalizedConfig, and applies post-processing.
+ *
+ * @param filePath - Absolute path to the config file
+ * @param projectFolder - Absolute path to the project root
+ */
+declare const parseConfig: (filePath: string, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileNotFoundError | ConfigFileEmptyError | ConfigFileParseError | ConfigModuleLoadError | ConfigVersionError | ConfigSchemaValidationError | FunctionConfigError, RawConfigReader | _effect_platform_Path.Path | _effect_platform_FileSystem.FileSystem | SchemaValidator | V4ConfigParser | VercelBuildOutputParser>;
+/**
+ * Applies post-processing transformers to a NormalizedConfig:
+ * - Vercel Build Output v3 (merges functions/routes from .vercel/output if present)
+ * - Empty deployment validation
+ * - Filter functions from assets
+ *
+ * @param config - The parsed NormalizedConfig
+ * @param projectFolder - Absolute path to the project root
+ * @returns The post-processed NormalizedConfig
+ */
+declare const postProcessConfig: (config: NormalizedConfig, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileEmptyError | ConfigFileParseError | ConfigModuleLoadError | ConfigVersionError, _effect_platform_Path.Path | _effect_platform_FileSystem.FileSystem | VercelBuildOutputParser>;
+
 interface ConfigV4 extends Config {
     version: 4;
     /**
@@ -1054,102 +1253,231 @@ interface ConfigV4FunctionSettings {
 }
 
 /**
- * Resolves merged function settings for a given path by iterating all function
- * patterns in the config. Later patterns override earlier ones.
+ * Identity helper providing type inference and checking for `gigadrive.ts`
+ * config files. Using it is optional — a plain object default export works the
+ * same, but `defineConfig` gives editor autocompletion without a type
+ * annotation. Requires `@gigadrive/network-config` to be installed in the
+ * project (e.g. as a devDependency).
  *
- * @returns The merged settings, or undefined when no pattern matches the path.
+ * Prefer importing from the `@gigadrive/network-config/define-config` subpath:
+ * it is dependency-free, whereas the package root eagerly imports peer
+ * dependencies (`effect`, `@effect/platform`) that package managers which do
+ * not auto-install peers (e.g. Yarn) will not have installed.
+ *
+ * Note that a `gigadrive.ts` config is executed as code when the config is
+ * read — the same trust model as `build_commands`.
+ *
+ * @param config - The deployment configuration
+ * @returns The configuration, unchanged
+ * @example
+ * ```ts
+ * // gigadrive.ts
+ * import { defineConfig } from '@gigadrive/network-config/define-config';
+ *
+ * export default defineConfig({
+ *   version: 4,
+ *   regions: ['eu-central-1'],
+ * });
+ * ```
  */
-declare const getFunctionSettings: (path: string, config: ConfigV4) => ConfigV4FunctionSettings | undefined;
-declare const V4ConfigParser_base: Effect.Service.Class<V4ConfigParser, "V4ConfigParser", {
-    readonly accessors: true;
-    readonly effect: Effect.Effect<{
-        /**
-         * Parses a ConfigV4 into a NormalizedConfig.
-         *
-         * @param config - The raw V4 config object
-         * @param projectFolder - Absolute path to the project root
-         */
-        parse: (config: ConfigV4, projectFolder: string) => Effect.Effect<{
-            regions: ("us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "ap-south-1" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-northeast-1" | "ca-central-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "eu-north-1" | "sa-east-1")[];
-            assets: {
-                paths: string[];
-                prefixToStrip: string;
-                dynamicRoutes: boolean;
-                populateCache: boolean;
-            };
-            environmentVariables: Record<string, string>;
-            commands: string[];
-            images: NormalizedImagePolicy | undefined;
-            services: NormalizedConfigServiceDefinition[] | undefined;
-            entrypoints: NormalizedConfigEntrypoint[];
-            errors: never[];
-            warnings: never[];
-            routes: NormalizedConfigRoute[];
-        }, FunctionConfigError, FileSystem.FileSystem | Path.Path>;
-    }, never, never>;
+declare const defineConfig: (config: ConfigV4) => ConfigV4;
+
+declare const ManifestNotFoundError_base: Schema.TaggedErrorClass<ManifestNotFoundError, "ManifestNotFoundError", {
+    readonly _tag: Schema.tag<"ManifestNotFoundError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
 }>;
-declare class V4ConfigParser extends V4ConfigParser_base {
+declare class ManifestNotFoundError extends ManifestNotFoundError_base {
 }
-
-declare const VercelBuildOutputParser_base: Effect.Service.Class<VercelBuildOutputParser, "VercelBuildOutputParser", {
-    readonly effect: Effect.Effect<{
-        parse: (parseResult: NormalizedConfig, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError, _effect_platform_FileSystem.FileSystem | Path.Path>;
-    }, never, Path.Path | RawConfigReader>;
+declare const ManifestReadError_base: Schema.TaggedErrorClass<ManifestReadError, "ManifestReadError", {
+    readonly _tag: Schema.tag<"ManifestReadError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
 }>;
-declare class VercelBuildOutputParser extends VercelBuildOutputParser_base {
+declare class ManifestReadError extends ManifestReadError_base {
 }
-
-interface Config {
-    version: number;
-    env?: Record<string, string>;
+declare const ManifestParseError_base: Schema.TaggedErrorClass<ManifestParseError, "ManifestParseError", {
+    readonly _tag: Schema.tag<"ManifestParseError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+}>;
+declare class ManifestParseError extends ManifestParseError_base {
+}
+declare const FrameworkNotDetectedError_base: Schema.TaggedErrorClass<FrameworkNotDetectedError, "FrameworkNotDetectedError", {
+    readonly _tag: Schema.tag<"FrameworkNotDetectedError">;
+} & {
+    message: typeof Schema.String;
+    directory: typeof Schema.String;
+}>;
+declare class FrameworkNotDetectedError extends FrameworkNotDetectedError_base {
+}
+interface FrameworkDetectionItem {
+    /** Check manifest dependencies for this package (routed by framework language) */
+    matchPackage?: string;
+    /** Check if this file exists (relative to project root) */
+    path?: string;
+    /** If path is set, also check file content matches this regex */
+    matchContent?: string;
+}
+type FrameworkLanguage = 'node' | 'php';
+type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'composer';
+interface FrameworkDefinition {
+    slug: string;
+    name: string;
+    language: FrameworkLanguage;
+    /** ALL items must match for the framework to be detected */
+    detectors: FrameworkDetectionItem[];
+    /** Higher = higher priority (specific frameworks beat generic ones) */
+    priority: number;
+    /** Generates deployment defaults for this framework */
+    getDefaultConfig: (packageManager: PackageManager) => FrameworkDefaultConfig;
+    /** Refines defaults with project files after a framework match, e.g. framework CLI config. */
+    refineDefaultConfig?: (defaults: FrameworkDefaultConfig, projectFolder: string) => Effect.Effect<FrameworkDefaultConfig, never, FileSystem.FileSystem | Path.Path>;
+}
+interface FrameworkDefaultConfig {
+    runtime: Runtime;
+    memory: number;
+    maxDuration: number;
+    streaming: boolean;
+    /** Overrides the auto-generated install command (e.g. for custom composer flags) */
+    installCommand?: string;
+    /** Build commands (install command is auto-prepended by generateConfig) */
+    commands: string[];
+    entrypoint?: string;
+    assetsDir?: string;
+    assetsPrefixToStrip?: string;
+    /** Explicit project-relative files to publish as static assets. */
+    assetPaths?: string[];
+    /** Public path overrides keyed by project-relative asset path. */
+    assetOverrides?: Record<string, {
+        path?: string;
+        contentType?: string;
+    }>;
+    /** Directory subtrees to publish under a URL prefix without per-file enumeration. */
+    assetPrefixes?: Array<{
+        source: string;
+        destination: string;
+        immutable?: boolean;
+        populateCache?: boolean;
+        contentType?: string;
+    }>;
+    /** Project-relative manifests containing logical static asset entries. */
+    assetManifests?: Array<{
+        source: string;
+    }>;
+    populateAssetCache?: boolean;
+    routes: Array<{
+        source: string;
+        destination: string;
+    }>;
+    environmentVariables: Record<string, string>;
+    symlinks?: Record<string, string>;
+    excludeFiles?: string[];
+    package?: {
+        trace?: boolean;
+        includeProjectFiles?: boolean;
+        preserveSymlinks?: boolean;
+        rootOverwrite?: string;
+        filePathMap?: Record<string, string>;
+        includeFiles?: string[];
+        excludeFiles?: string[];
+    };
+    /** Advanced framework output that replaces the one-entrypoint defaults. */
+    normalizedConfig?: Partial<NormalizedConfig>;
 }
+interface DetectionResult {
+    framework: FrameworkDefinition;
+    packageManager: PackageManager;
+    config: NormalizedConfig;
+}
+
 /**
- * Parses a config file at the given path and validates it against the appropriate
- * JSON Schema, returning a NormalizedConfig **without** post-processing.
+ * Detects the framework used in a project by checking framework definitions
+ * against the project's dependencies and file structure.
  *
- * Use {@link parseConfig} when you also want Vercel BOv3 merging, empty-deployment
- * checks, and function/asset deduplication applied automatically.
+ * Framework definitions are checked in priority order (highest first).
+ * All detectors for a framework must match for it to be selected.
  *
- * @param filePath - Absolute path to the config file
  * @param projectFolder - Absolute path to the project root
+ * @returns DetectionResult with framework, package manager, and generated config
  */
-declare const parseConfigRaw: (filePath: string, projectFolder: string) => Effect.Effect<{
-    regions: ("us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "ap-south-1" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-northeast-1" | "ca-central-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "eu-north-1" | "sa-east-1")[];
-    assets: {
-        paths: string[];
-        prefixToStrip: string;
-        dynamicRoutes: boolean;
-        populateCache: boolean;
-    };
-    environmentVariables: Record<string, string>;
-    commands: string[];
-    images: NormalizedImagePolicy | undefined;
-    services: NormalizedConfigServiceDefinition[] | undefined;
-    entrypoints: NormalizedConfigEntrypoint[];
-    errors: never[];
-    warnings: never[];
-    routes: NormalizedConfigRoute[];
-}, ConfigFileNotFoundError | ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError | ConfigSchemaValidationError | FunctionConfigError, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path | RawConfigReader | SchemaValidator | V4ConfigParser>;
+declare const detectFramework: (projectFolder: string) => Effect.Effect<{
+    framework: FrameworkDefinition;
+    packageManager: PackageManager;
+    config: NormalizedConfig;
+}, ManifestReadError | ManifestParseError | FrameworkNotDetectedError, Path.Path | FileSystem.FileSystem>;
+
 /**
- * Parses a config file at the given path, validates it against the appropriate
- * JSON Schema, converts it to a NormalizedConfig, and applies post-processing.
+ * Detects the package manager by checking for lockfiles in the project folder.
+ * Falls back to `npm` if no lockfile is found.
  *
- * @param filePath - Absolute path to the config file
  * @param projectFolder - Absolute path to the project root
+ * @returns The detected package manager
  */
-declare const parseConfig: (filePath: string, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileNotFoundError | ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError | ConfigSchemaValidationError | FunctionConfigError, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path | RawConfigReader | SchemaValidator | V4ConfigParser | VercelBuildOutputParser>;
+declare const detectPackageManager: (projectFolder: string) => Effect.Effect<PackageManager, never, Path.Path | FileSystem.FileSystem>;
+
 /**
- * Applies post-processing transformers to a NormalizedConfig:
- * - Vercel Build Output v3 (merges functions/routes from .vercel/output if present)
- * - Empty deployment validation
- * - Filter functions from assets
+ * All supported framework definitions, sorted by priority descending.
+ * Higher priority frameworks are checked first during detection.
+ */
+declare const FRAMEWORK_DEFINITIONS: FrameworkDefinition[];
+
+/**
+ * Generates a NormalizedConfig from a framework definition and detected package manager.
+ * Prepends the install command and builds a complete deployment configuration.
+ *
+ * @param framework - The detected framework definition
+ * @param packageManager - The detected package manager
+ * @returns A complete NormalizedConfig with framework defaults
+ */
+declare const generateConfig: (framework: FrameworkDefinition, packageManager: PackageManager, refinedDefaults?: FrameworkDefaultConfig | undefined) => Effect.Effect<NormalizedConfig, never, never>;
+
+/**
+ * Merges framework defaults with a user-provided config.
+ * User config always takes precedence; framework defaults fill gaps.
+ *
+ * - commands: use user's if non-empty, otherwise framework's
+ * - entrypoints: use user's if non-empty, otherwise framework's
+ * - routes: use user's if non-empty, otherwise framework's
+ * - assets: use user's if it declares any sources, otherwise framework's
+ * - excludeFiles: use user's if non-empty, otherwise framework's
+ * - regions: always use user's (always populated from parsing)
+ * - environmentVariables: deep merge (framework base, user overrides)
+ * - services: always use user's (frameworks don't define services)
+ * - warnings/errors: concatenate both
+ *
+ * @param userConfig - The config parsed from the user's config file
+ * @param frameworkConfig - The config generated from framework detection
+ * @returns The merged config
+ */
+declare const mergeWithFrameworkDefaults: (userConfig: NormalizedConfig, frameworkConfig: NormalizedConfig) => Effect.Effect<NormalizedConfig, never, never>;
+
+/**
+ * Reads dependency names from the appropriate manifest file for a language.
+ * Returns a set of all dependency names (production + dev).
+ *
+ * If the manifest file does not exist, returns an empty set (graceful).
+ * If the file exists but cannot be read (`ManifestReadError`) or parsed
+ * (`ManifestParseError`), the error propagates — this indicates a real
+ * problem the user should know about.
  *
- * @param config - The parsed NormalizedConfig
  * @param projectFolder - Absolute path to the project root
- * @returns The post-processed NormalizedConfig
+ * @param language - The framework language to determine which manifest to read
+ * @returns A set of dependency package names
+ */
+declare const readDependencies: (projectFolder: string, language: FrameworkLanguage) => Effect.Effect<Set<string>, ManifestReadError | ManifestParseError, Path.Path | FileSystem.FileSystem>;
+
+/**
+ * Ensure a normalized config has no function files that are also defined as assets.
+ * For example, a file `public/index.php` should not be defined as an asset, when it is a function and `public` is an asset folder.
+ * @param config The normalized config to filter.
+ * @returns A promise that resolves to the filtered config.
  */
-declare const postProcessConfig: (config: NormalizedConfig, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path | VercelBuildOutputParser>;
+declare const filterFunctionsFromAssets: (config: NormalizedConfig) => NormalizedConfig;
 
-declare const NetworkConfigLive: Layer.Layer<RawConfigReader | SchemaValidator | V4ConfigParser | VercelBuildOutputParser, never, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path>;
+declare const NetworkConfigLive: Layer.Layer<ConfigModuleLoader | RawConfigReader | SchemaValidator | V4ConfigParser | VercelBuildOutputParser, never, _effect_platform_Path.Path | _effect_platform_FileSystem.FileSystem>;
 
-export { ALLOWED_CONFIG_NAMES, AVAILABLE_REGIONS, AVAILABLE_RUNTIMES, type Config, ConfigFileEmptyError, ConfigFileNotFoundError, ConfigFileParseError, ConfigSchemaValidationError, type ConfigV4, type ConfigV4FunctionSettings, type ConfigV4Service, type ConfigV4ServicePostgres, type ConfigV4ServiceRedis, type ConfigV4ServiceStorage, type ConfigV4Services, type ConfigV4StorageBucket, ConfigVersionError, DEFAULT_FUNCTION_DURATION_SECONDS, type DetectionResult, FRAMEWORK_DEFINITIONS, type FilePathMap, type FrameworkDefaultConfig, type FrameworkDefinition, type FrameworkDetectionItem, type FrameworkLanguage, FrameworkNotDetectedError, FunctionConfigError, type GigadriveNextBuildManifest, GigadriveNextBuildManifestSchema, type GigadriveNextBuildManifestV1, GigadriveNextBuildManifestV1Schema, type GigadriveNextBuildManifestV2, type GigadriveNextBuildManifestV2Export, GigadriveNextBuildManifestV2ExportSchema, type GigadriveNextBuildManifestV2Standalone, GigadriveNextBuildManifestV2StandaloneSchema, type GigadriveNextPrerenderManifestV1, GigadriveNextPrerenderManifestV1Schema, type GigadriveNextPrerenderOutput, GigadriveNextPrerenderOutputSchema, type GigadriveNextServerDescriptor, GigadriveNextServerDescriptorSchema, type GigadriveNextStaticAssetPrefix, GigadriveNextStaticAssetPrefixSchema, type JsonValue, MAX_FUNCTION_DURATION_SECONDS, ManifestNotFoundError, ManifestParseError, ManifestReadError, type NeonAWSRegion, NetworkConfigLive, type NormalizedConfig, type NormalizedConfigEntrypoint, type NormalizedConfigRoute, type NormalizedConfigRouteHandler, type NormalizedConfigRouteMatchRequirements, type NormalizedConfigRouteMethod, type NormalizedConfigService, type NormalizedConfigServiceDefinition, type NormalizedConfigServicePostgres, type NormalizedConfigServiceRedis, type NormalizedConfigServiceStorage, type NormalizedConfigServiceType, type NormalizedConfigStorageBucket, type NormalizedFramework, type NormalizedImageFit, type NormalizedImageFormat, type NormalizedImageLocalPattern, type NormalizedImagePolicy, type NormalizedImageRemotePattern, type NormalizedImageVariant, type NormalizedNextjsFramework, type NormalizedSharedArtifact, type PackageManager, RawConfigReader, type Region, type Runtime, SchemaValidator, type StaticAssetHeaders, StaticAssetHeadersSchema, type StaticAssetManifest, type StaticAssetManifestEntry, StaticAssetManifestEntrySchema, type StaticAssetManifestV1, StaticAssetManifestV1Schema, type UpstashAWSRegion, V4ConfigParser, VercelBuildOutputParser, detectFramework, detectPackageManager, filterFunctionsFromAssets, generateConfig, getFunctionSettings, mergeWithFrameworkDefaults, parseConfig, parseConfigRaw, parseGigadriveNextBuildManifest, parseGigadriveNextPrerenderManifest, parseStaticAssetManifest, postProcessConfig, readDependencies };
+export { ALLOWED_CONFIG_NAMES, AVAILABLE_REGIONS, AVAILABLE_RUNTIMES, type Config, ConfigFileEmptyError, ConfigFileNotFoundError, ConfigFileParseError, ConfigModuleLoadError, ConfigModuleLoader, ConfigSchemaValidationError, type ConfigV4, type ConfigV4FunctionSettings, type ConfigV4Service, type ConfigV4ServicePostgres, type ConfigV4ServiceRedis, type ConfigV4ServiceStorage, type ConfigV4Services, type ConfigV4StorageBucket, ConfigVersionError, DEFAULT_FUNCTION_DURATION_SECONDS, type DetectionResult, FRAMEWORK_DEFINITIONS, type FilePathMap, type FrameworkDefaultConfig, type FrameworkDefinition, type FrameworkDetectionItem, type FrameworkLanguage, FrameworkNotDetectedError, FunctionConfigError, type GigadriveNextBuildManifest, GigadriveNextBuildManifestSchema, type GigadriveNextBuildManifestV1, GigadriveNextBuildManifestV1Schema, type GigadriveNextBuildManifestV2, type GigadriveNextBuildManifestV2Export, GigadriveNextBuildManifestV2ExportSchema, type GigadriveNextBuildManifestV2Standalone, GigadriveNextBuildManifestV2StandaloneSchema, type GigadriveNextMiddlewareDescriptor, GigadriveNextMiddlewareDescriptorSchema, type GigadriveNextMiddlewareMatcher, GigadriveNextMiddlewareMatcherSchema, type GigadriveNextPrerenderManifestV1, GigadriveNextPrerenderManifestV1Schema, type GigadriveNextPrerenderOutput, GigadriveNextPrerenderOutputSchema, type GigadriveNextPrerenderSeedMethods, GigadriveNextPrerenderSeedMethodsSchema, type GigadriveNextRouteCondition, GigadriveNextRouteConditionSchema, type GigadriveNextServerDescriptor, GigadriveNextServerDescriptorSchema, type GigadriveNextStaticAssetPrefix, GigadriveNextStaticAssetPrefixSchema, type JsonValue, MAX_FUNCTION_DURATION_SECONDS, ManifestNotFoundError, ManifestParseError, ManifestReadError, type NeonAWSRegion, NetworkConfigLive, type NormalizedConfig, type NormalizedConfigEntrypoint, type NormalizedConfigRoute, type NormalizedConfigRouteHandler, type NormalizedConfigRouteMatchRequirements, type NormalizedConfigRouteMethod, type NormalizedConfigService, type NormalizedConfigServiceDefinition, type NormalizedConfigServicePostgres, type NormalizedConfigServiceRedis, type NormalizedConfigServiceStorage, type NormalizedConfigServiceType, type NormalizedConfigStorageBucket, type NormalizedFramework, type NormalizedImageFit, type NormalizedImageFormat, type NormalizedImageLocalPattern, type NormalizedImagePolicy, type NormalizedImageRemotePattern, type NormalizedImageVariant, type NormalizedNextjsFramework, type NormalizedSharedArtifact, type PackageManager, RawConfigReader, type Region, type Runtime, SchemaValidator, type StaticAssetHeaders, StaticAssetHeadersSchema, type StaticAssetManifest, type StaticAssetManifestEntry, StaticAssetManifestEntrySchema, type StaticAssetManifestV1, StaticAssetManifestV1Schema, type UpstashAWSRegion, V4ConfigParser, VercelBuildOutputParser, defineConfig, detectFramework, detectPackageManager, filterFunctionsFromAssets, generateConfig, getFunctionSettings, mergeWithFrameworkDefaults, parseConfig, parseConfigRaw, parseGigadriveNextBuildManifest, parseGigadriveNextPrerenderManifest, parseStaticAssetManifest, postProcessConfig, readDependencies };