@gigadrive/network-config 4.4.0 → 4.6.0

package/dist/index.d.mts

@@ -1,7 +1,40 @@
-import { FileSystem, Path } from '@effect/platform';
-import { Effect, Schema, Layer } from 'effect';
-import * as _effect_platform_Path from '@effect/platform/Path';
+import { Schema, Effect, Layer } from 'effect';
 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>;
+/** One logical static asset whose source is relative to the project root. */
+declare const StaticAssetManifestEntrySchema: Schema.mutable<Schema.Struct<{
+    source: Schema.filter<typeof Schema.String>;
+    path: Schema.filter<typeof Schema.String>;
+    status: Schema.optional<Schema.filter<typeof Schema.Int>>;
+    headers: 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>>>]>>>>>;
+    immutable: Schema.optional<typeof Schema.Boolean>;
+}>>;
+type StaticAssetManifestEntry = Schema.Schema.Type<typeof StaticAssetManifestEntrySchema>;
+/** Portable manifest for declaring many logical assets without expanding deployment configuration. */
+declare const StaticAssetManifestV1Schema: Schema.filter<Schema.mutable<Schema.Struct<{
+    version: Schema.Literal<[1]>;
+    assets: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+        source: Schema.filter<typeof Schema.String>;
+        path: Schema.filter<typeof Schema.String>;
+        status: Schema.optional<Schema.filter<typeof Schema.Int>>;
+        headers: 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>>>]>>>>>;
+        immutable: Schema.optional<typeof Schema.Boolean>;
+    }>>>>;
+}>>>;
+type StaticAssetManifestV1 = Schema.Schema.Type<typeof StaticAssetManifestV1Schema>;
+type StaticAssetManifest = StaticAssetManifestV1;
+/**
+ * Parses and validates a portable static asset manifest.
+ *
+ * @param content JSON manifest content.
+ * @returns The validated manifest, or `undefined` when malformed.
+ */
+declare const parseStaticAssetManifest: (content: string) => StaticAssetManifest | undefined;
 
 interface NormalizedImageLocalPattern {
     pathname?: string;
@@ -41,112 +74,255 @@ interface NormalizedImagePolicy {
 type JsonValue = null | boolean | number | string | JsonValue[] | {
     [key: string]: JsonValue;
 };
-interface GigadriveNextPrerenderOutput {
-    id: string;
-    type: 'PRERENDER';
-    pathname: string;
-    parentOutputId: string;
-    groupId: number;
-    pprChain?: {
-        headers: Record<string, string>;
-    };
-    parentFallbackMode?: JsonValue;
-    fallback?: {
-        filePath?: string;
-        initialStatus?: number;
-        initialHeaders?: Record<string, string | string[]>;
-        initialExpiration?: number;
-        initialRevalidate?: number | false;
-        postponedState?: string;
-    };
-    config: {
-        allowQuery?: string[];
-        allowHeader?: string[];
-        bypassFor?: JsonValue[];
-        renderingMode?: string;
-        partialFallback?: boolean;
-        bypassToken?: string;
-    };
-}
-/**
- * A directory subtree published under a single URL prefix, registered as one
- * descriptor instead of enumerating every file. Used to collapse `.next/static`
- * (thousands of content-hashed chunks) into a single edge-served prefix.
- */
-interface GigadriveNextStaticAssetPrefix {
-    /** Project-relative source directory (e.g. `.next/static`). */
-    sourceDir: string;
-    /** Public URL prefix the subtree is served under (e.g. `_next/static`). */
-    urlPrefix: string;
-    /** Entries are content-hashed and safe to serve with immutable cache-control. */
-    immutable: boolean;
-}
-interface GigadriveNextBuildManifestV1 {
-    version: 1;
-    output: 'standalone' | 'export';
-    distDir: string;
-    repoRootToProject: string;
-    nextVersion: string;
-    buildId: string;
-}
-/** Aggregated runtime configuration collapsed onto the single standalone server. */
-interface GigadriveNextServerDescriptor {
-    maxDuration?: number;
-    preferredRegion?: string | string[];
-    env?: Record<string, string>;
-}
-/**
- * Portable runtime plan for the single standalone Next.js server (Next >= 16.2).
- *
- * The whole deployment runs as one `next start` standalone server, so the plan
- * carries only what the platform needs to route around it: prerender/ISR/PPR
- * seeds, the `.next/static` prefix, and the routing/image configuration. It
- * deliberately omits per-route outputs and entrypoints — the server owns
- * routing, middleware, edge routes, and PPR resume in-process.
- */
-interface GigadriveNextBuildManifestV2Standalone {
-    version: 2;
-    mode: 'standalone-v2';
-    distDir: string;
-    repoRootToProject: string;
-    nextVersion: string;
-    buildId: string;
-    server: GigadriveNextServerDescriptor;
-    config: {
-        basePath: string;
-        trailingSlash: boolean;
-        cacheComponents: boolean;
-        i18n?: JsonValue;
-        images?: NormalizedImagePolicy;
-    };
-    routing: {
-        beforeMiddleware: JsonValue[];
-        beforeFiles: JsonValue[];
-        afterFiles: JsonValue[];
-        dynamicRoutes: JsonValue[];
-        onMatch: JsonValue[];
-        fallback: JsonValue[];
-        shouldNormalizeNextData: boolean;
-        rsc: JsonValue;
-    };
-    outputs: {
-        prerenders: GigadriveNextPrerenderOutput[];
-        staticAssets: GigadriveNextStaticAssetPrefix[];
-    };
-}
-/** Minimal plan for static-export builds (Next >= 16.2). */
-interface GigadriveNextBuildManifestV2Export {
-    version: 2;
-    mode: 'export';
-    distDir: string;
-    repoRootToProject: string;
-    nextVersion: string;
-    buildId: string;
-}
+declare const GigadriveNextPrerenderOutputSchema: Schema.mutable<Schema.Struct<{
+    id: typeof Schema.String;
+    type: Schema.Literal<["PRERENDER"]>;
+    pathname: 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<{
+    sourceDir: Schema.filter<typeof Schema.String>;
+    urlPrefix: Schema.filter<typeof Schema.String>;
+    immutable: typeof Schema.Boolean;
+}>>;
+type GigadriveNextStaticAssetPrefix = Schema.Schema.Type<typeof GigadriveNextStaticAssetPrefixSchema>;
+/** Aggregated runtime configuration for the standalone server. */
+declare const GigadriveNextServerDescriptorSchema: Schema.mutable<Schema.Struct<{
+    maxDuration: Schema.optional<typeof Schema.Number>;
+    preferredRegion: Schema.optional<Schema.Union<[typeof Schema.String, Schema.mutable<Schema.Array$<typeof Schema.String>>]>>;
+    env: Schema.optional<Schema.mutable<Schema.Record$<typeof Schema.String, typeof Schema.String>>>;
+}>>;
+type GigadriveNextServerDescriptor = Schema.Schema.Type<typeof GigadriveNextServerDescriptorSchema>;
+declare const GigadriveNextBuildManifestV1Schema: Schema.mutable<Schema.Struct<{
+    version: Schema.Literal<[1]>;
+    output: Schema.Literal<["standalone", "export"]>;
+    distDir: Schema.filter<typeof Schema.String>;
+    repoRootToProject: Schema.filter<typeof Schema.String>;
+    nextVersion: typeof Schema.String;
+    buildId: typeof Schema.String;
+}>>;
+type GigadriveNextBuildManifestV1 = Schema.Schema.Type<typeof GigadriveNextBuildManifestV1Schema>;
+/** Minimal plan for static-export builds. */
+declare const GigadriveNextBuildManifestV2ExportSchema: Schema.mutable<Schema.Struct<{
+    version: Schema.Literal<[2]>;
+    mode: Schema.Literal<["export"]>;
+    distDir: Schema.filter<typeof Schema.String>;
+    repoRootToProject: Schema.filter<typeof Schema.String>;
+    nextVersion: typeof Schema.String;
+    buildId: typeof Schema.String;
+}>>;
+type GigadriveNextBuildManifestV2Export = Schema.Schema.Type<typeof GigadriveNextBuildManifestV2ExportSchema>;
+/** Portable runtime plan for a standalone Next.js server. */
+declare const GigadriveNextBuildManifestV2StandaloneSchema: Schema.mutable<Schema.Struct<{
+    version: Schema.Literal<[2]>;
+    mode: Schema.Literal<["standalone-v2"]>;
+    distDir: Schema.filter<typeof Schema.String>;
+    repoRootToProject: Schema.filter<typeof Schema.String>;
+    nextVersion: typeof Schema.String;
+    buildId: typeof Schema.String;
+    server: Schema.mutable<Schema.Struct<{
+        maxDuration: Schema.optional<typeof Schema.Number>;
+        preferredRegion: Schema.optional<Schema.Union<[typeof Schema.String, Schema.mutable<Schema.Array$<typeof Schema.String>>]>>;
+        env: Schema.optional<Schema.mutable<Schema.Record$<typeof Schema.String, typeof Schema.String>>>;
+    }>>;
+    config: Schema.mutable<Schema.Struct<{
+        basePath: typeof Schema.String;
+        trailingSlash: typeof Schema.Boolean;
+        cacheComponents: typeof Schema.Boolean;
+        i18n: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+        images: Schema.optional<Schema.Schema<NormalizedImagePolicy, NormalizedImagePolicy, never>>;
+    }>>;
+    routing: Schema.mutable<Schema.Struct<{
+        beforeMiddleware: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        beforeFiles: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        afterFiles: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        dynamicRoutes: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        onMatch: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        fallback: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        shouldNormalizeNextData: typeof Schema.Boolean;
+        rsc: Schema.Schema<JsonValue, JsonValue, never>;
+    }>>;
+    outputs: Schema.mutable<Schema.Struct<{
+        prerenders: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+            id: typeof Schema.String;
+            type: Schema.Literal<["PRERENDER"]>;
+            pathname: 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>>>>;
+        staticAssets: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+            sourceDir: Schema.filter<typeof Schema.String>;
+            urlPrefix: Schema.filter<typeof Schema.String>;
+            immutable: typeof Schema.Boolean;
+        }>>>>;
+    }>>;
+}>>;
+type GigadriveNextBuildManifestV2Standalone = Schema.Schema.Type<typeof GigadriveNextBuildManifestV2StandaloneSchema>;
+declare const GigadriveNextBuildManifestSchema: Schema.Union<[Schema.mutable<Schema.Struct<{
+    version: Schema.Literal<[1]>;
+    output: Schema.Literal<["standalone", "export"]>;
+    distDir: Schema.filter<typeof Schema.String>;
+    repoRootToProject: Schema.filter<typeof Schema.String>;
+    nextVersion: typeof Schema.String;
+    buildId: typeof Schema.String;
+}>>, Schema.mutable<Schema.Struct<{
+    version: Schema.Literal<[2]>;
+    mode: Schema.Literal<["export"]>;
+    distDir: Schema.filter<typeof Schema.String>;
+    repoRootToProject: Schema.filter<typeof Schema.String>;
+    nextVersion: typeof Schema.String;
+    buildId: typeof Schema.String;
+}>>, Schema.mutable<Schema.Struct<{
+    version: Schema.Literal<[2]>;
+    mode: Schema.Literal<["standalone-v2"]>;
+    distDir: Schema.filter<typeof Schema.String>;
+    repoRootToProject: Schema.filter<typeof Schema.String>;
+    nextVersion: typeof Schema.String;
+    buildId: typeof Schema.String;
+    server: Schema.mutable<Schema.Struct<{
+        maxDuration: Schema.optional<typeof Schema.Number>;
+        preferredRegion: Schema.optional<Schema.Union<[typeof Schema.String, Schema.mutable<Schema.Array$<typeof Schema.String>>]>>;
+        env: Schema.optional<Schema.mutable<Schema.Record$<typeof Schema.String, typeof Schema.String>>>;
+    }>>;
+    config: Schema.mutable<Schema.Struct<{
+        basePath: typeof Schema.String;
+        trailingSlash: typeof Schema.Boolean;
+        cacheComponents: typeof Schema.Boolean;
+        i18n: Schema.optional<Schema.Schema<JsonValue, JsonValue, never>>;
+        images: Schema.optional<Schema.Schema<NormalizedImagePolicy, NormalizedImagePolicy, never>>;
+    }>>;
+    routing: Schema.mutable<Schema.Struct<{
+        beforeMiddleware: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        beforeFiles: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        afterFiles: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        dynamicRoutes: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        onMatch: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        fallback: Schema.mutable<Schema.Array$<Schema.Schema<JsonValue, JsonValue, never>>>;
+        shouldNormalizeNextData: typeof Schema.Boolean;
+        rsc: Schema.Schema<JsonValue, JsonValue, never>;
+    }>>;
+    outputs: Schema.mutable<Schema.Struct<{
+        prerenders: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+            id: typeof Schema.String;
+            type: Schema.Literal<["PRERENDER"]>;
+            pathname: 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>>>>;
+        staticAssets: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+            sourceDir: Schema.filter<typeof Schema.String>;
+            urlPrefix: Schema.filter<typeof Schema.String>;
+            immutable: typeof Schema.Boolean;
+        }>>>>;
+    }>>;
+}>>]>;
 type GigadriveNextBuildManifestV2 = GigadriveNextBuildManifestV2Standalone | GigadriveNextBuildManifestV2Export;
-type GigadriveNextBuildManifest = GigadriveNextBuildManifestV1 | GigadriveNextBuildManifestV2;
+type GigadriveNextBuildManifest = Schema.Schema.Type<typeof GigadriveNextBuildManifestSchema>;
+/** Portable sidecar containing high-cardinality Next.js prerender metadata. */
+declare const GigadriveNextPrerenderManifestV1Schema: Schema.mutable<Schema.Struct<{
+    version: Schema.Literal<[1]>;
+    prerenders: Schema.mutable<Schema.Array$<Schema.mutable<Schema.Struct<{
+        id: typeof Schema.String;
+        type: Schema.Literal<["PRERENDER"]>;
+        pathname: 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. */
 declare const parseGigadriveNextBuildManifest: (content: string) => GigadriveNextBuildManifest | undefined;
+/** Parses and validates a portable Next.js prerender sidecar. */
+declare const parseGigadriveNextPrerenderManifest: (content: string) => GigadriveNextPrerenderManifestV1 | undefined;
 
 declare const REGION_DEFINITIONS: readonly ["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"];
 type Region = (typeof REGION_DEFINITIONS)[number];
@@ -206,6 +382,14 @@ interface NormalizedConfig {
             /** Optional Content-Type override applied to the whole subtree. */
             contentType?: string;
         }>;
+        /**
+         * Project-relative manifests containing logical static asset entries. A
+         * manifest keeps high-cardinality path mappings out of this configuration.
+         */
+        manifests?: Array<{
+            /** Project-relative path to a {@link StaticAssetManifest}. */
+            source: string;
+        }>;
         /**
          * Whether routes for the assets should be generated during deployment.
          */
@@ -346,7 +530,8 @@ type NormalizedFramework = NormalizedNextjsFramework;
  * discriminators. The whole deployment runs as one standalone server, so this
  * carries prerender/routing/image metadata but no per-route entrypoints.
  */
-type NormalizedNextjsFramework = Omit<GigadriveNextBuildManifestV2Standalone, 'version'> & {
+type NormalizedNextjsFramework = Omit<GigadriveNextBuildManifestV2Standalone, 'version' | 'outputs'> & {
+    outputs: Omit<GigadriveNextBuildManifestV2Standalone['outputs'], 'entryPagePaths'>;
     type: 'nextjs';
     schemaVersion: 2;
     /**
@@ -398,190 +583,6 @@ type NormalizedConfigRouteMatchRequirements = [] | [
     }
 ];
 
-declare const ManifestNotFoundError_base: Schema.TaggedErrorClass<ManifestNotFoundError, "ManifestNotFoundError", {
-    readonly _tag: Schema.tag<"ManifestNotFoundError">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-}>;
-declare class ManifestNotFoundError extends ManifestNotFoundError_base {
-}
-declare const ManifestReadError_base: Schema.TaggedErrorClass<ManifestReadError, "ManifestReadError", {
-    readonly _tag: Schema.tag<"ManifestReadError">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-}>;
-declare class ManifestReadError extends ManifestReadError_base {
-}
-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;
-    }>;
-    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;
-}
-
-/**
- * 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 defined with paths, 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">;
 } & {
@@ -607,6 +608,15 @@ declare const ConfigFileParseError_base: Schema.TaggedErrorClass<ConfigFileParse
 }>;
 declare class ConfigFileParseError extends ConfigFileParseError_base {
 }
+declare const ConfigModuleLoadError_base: Schema.TaggedErrorClass<ConfigModuleLoadError, "ConfigModuleLoadError", {
+    readonly _tag: Schema.tag<"ConfigModuleLoadError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.String>;
+}>;
+declare class ConfigModuleLoadError extends ConfigModuleLoadError_base {
+}
 declare const ConfigVersionError_base: Schema.TaggedErrorClass<ConfigVersionError, "ConfigVersionError", {
     readonly _tag: Schema.tag<"ConfigVersionError">;
 } & {
@@ -634,23 +644,24 @@ declare const FunctionConfigError_base: Schema.TaggedErrorClass<FunctionConfigEr
 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 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 {
+}
 
-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 {
 }
@@ -663,38 +674,135 @@ declare const SchemaValidator_base: Effect.Service.Class<SchemaValidator, "Schem
 declare class SchemaValidator extends SchemaValidator_base {
 }
 
-interface ConfigV4 extends Config {
-    version: 4;
-    /**
-     * A list of presets to apply to the project. Each preset will be applied in order.
-     */
-    presets?: string[] | null;
-    /**
-     * The folder which holds the assets to be deployed to the edge. Defaults to none.
-     */
-    assets?: string | null;
-    /**
-     * If true, the assets will be cached at the edge during deployment. This may increase the deployment time, depending on the size of the assets. Defaults to false.
-     */
-    populateAssetCache?: boolean | null;
-    /** Managed image optimization policy for this deployment. */
-    images?: Partial<NormalizedImagePolicy> | null;
-    /**
-     * The regions to which the project will be deployed. Use "global" to deploy to all regions. More regions will incur higher costs.
-     */
-    regions?: string[] | null;
-    /**
-     * The commands to run to build the project. For example, `bun install` or `npm install`.
-     */
-    build_commands?: string[] | null;
-    /**
-     * The serverless functions to deploy.
-     */
-    functions?: {
-        /**
-         * The pattern to match the file path of the function. May be a glob pattern or a regular expression.
-         */
-        [pattern: string]: ConfigV4FunctionSettings;
+/**
+ * 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;
+    /**
+     * A list of presets to apply to the project. Each preset will be applied in order.
+     */
+    presets?: string[] | null;
+    /**
+     * The folder which holds the assets to be deployed to the edge. Defaults to none.
+     */
+    assets?: string | null;
+    /**
+     * If true, the assets will be cached at the edge during deployment. This may increase the deployment time, depending on the size of the assets. Defaults to false.
+     */
+    populateAssetCache?: boolean | null;
+    /** Managed image optimization policy for this deployment. */
+    images?: Partial<NormalizedImagePolicy> | null;
+    /**
+     * The regions to which the project will be deployed. Use "global" to deploy to all regions. More regions will incur higher costs.
+     */
+    regions?: string[] | null;
+    /**
+     * The commands to run to build the project. For example, `bun install` or `npm install`.
+     */
+    build_commands?: string[] | null;
+    /**
+     * The serverless functions to deploy.
+     */
+    functions?: {
+        /**
+         * The pattern to match the file path of the function. May be a glob pattern or a regular expression.
+         */
+        [pattern: string]: ConfigV4FunctionSettings;
     } | null;
     /**
      * A list of route definitions.
@@ -866,102 +974,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 postProcessConfig: (config: NormalizedConfig, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path | VercelBuildOutputParser>;
+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 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, type GigadriveNextBuildManifestV1, type GigadriveNextBuildManifestV2, type GigadriveNextBuildManifestV2Export, type GigadriveNextBuildManifestV2Standalone, type GigadriveNextPrerenderOutput, type GigadriveNextServerDescriptor, type GigadriveNextStaticAssetPrefix, 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 UpstashAWSRegion, V4ConfigParser, VercelBuildOutputParser, detectFramework, detectPackageManager, filterFunctionsFromAssets, generateConfig, getFunctionSettings, mergeWithFrameworkDefaults, parseConfig, parseConfigRaw, parseGigadriveNextBuildManifest, 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 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, defineConfig, detectFramework, detectPackageManager, filterFunctionsFromAssets, generateConfig, getFunctionSettings, mergeWithFrameworkDefaults, parseConfig, parseConfigRaw, parseGigadriveNextBuildManifest, parseGigadriveNextPrerenderManifest, parseStaticAssetManifest, postProcessConfig, readDependencies };