@gigadrive/network-config 4.4.0 → 4.6.0

package/dist/index.mjs

@@ -1,3 +1,63 @@
+// src/asset-manifest.ts
+import { Schema as Schema2 } from "effect";
+
+// src/manifest-schema.ts
+import { Option, Schema } from "effect";
+var HTTP_HEADER_NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var HTTP_HEADER_VALUE = /^[\t\x20-\x7e\x80-\xff]*$/;
+var URL_PATHNAME_FORBIDDEN_CHARACTER = /[\x00-\x1f\x7f?#\\]/;
+var isUrlDotSegment = (segment) => {
+  const decodedDots = segment.replace(/%2e/gi, ".");
+  return decodedDots === "." || decodedDots === "..";
+};
+var isPortableRelativePath = (value, allowCurrentDirectory = false) => {
+  const normalized = value.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/+$/, "");
+  return (allowCurrentDirectory || normalized !== "" && normalized !== ".") && !normalized.startsWith("/") && !/^[A-Za-z]:/.test(normalized) && !normalized.includes(":") && !normalized.split("/").includes("..");
+};
+var PortableRelativePathSchema = Schema.String.pipe(Schema.filter((value) => isPortableRelativePath(value)));
+var RepositoryRelativePathSchema = Schema.String.pipe(
+  Schema.filter((value) => isPortableRelativePath(value, true))
+);
+var UrlPathnameSchema = Schema.String.pipe(
+  Schema.filter(
+    (value) => value.startsWith("/") && !URL_PATHNAME_FORBIDDEN_CHARACTER.test(value) && !value.split("/").some(isUrlDotSegment)
+  )
+);
+var HttpHeaderValueSchema = Schema.String.pipe(Schema.pattern(HTTP_HEADER_VALUE));
+var HttpHeadersSchema = Schema.mutable(
+  Schema.Record({
+    key: Schema.String,
+    value: Schema.Union(HttpHeaderValueSchema, Schema.mutable(Schema.Array(HttpHeaderValueSchema)))
+  })
+).pipe(Schema.filter((headers) => Object.keys(headers).every((name) => HTTP_HEADER_NAME.test(name))));
+var HttpSingleValueHeadersSchema = Schema.mutable(
+  Schema.Record({ key: Schema.String, value: HttpHeaderValueSchema })
+).pipe(Schema.filter((headers) => Object.keys(headers).every((name) => HTTP_HEADER_NAME.test(name))));
+var decodeUnknown = (schema, value) => Schema.decodeUnknownOption(schema, { onExcessProperty: "preserve" })(value).pipe(Option.getOrUndefined);
+var decodeJson = (schema, content) => decodeUnknown(Schema.parseJson(schema), content);
+
+// src/asset-manifest.ts
+var StaticAssetHeadersSchema = HttpHeadersSchema;
+var StaticAssetManifestEntrySchema = Schema2.mutable(
+  Schema2.Struct({
+    source: PortableRelativePathSchema,
+    path: UrlPathnameSchema,
+    status: Schema2.optional(Schema2.Int.pipe(Schema2.between(100, 599))),
+    headers: Schema2.optional(StaticAssetHeadersSchema),
+    immutable: Schema2.optional(Schema2.Boolean)
+  })
+);
+var StaticAssetManifestV1Schema = Schema2.mutable(
+  Schema2.Struct({
+    version: Schema2.Literal(1),
+    assets: Schema2.mutable(Schema2.Array(StaticAssetManifestEntrySchema))
+  })
+).pipe(Schema2.filter(({ assets }) => new Set(assets.map(({ path: path2 }) => path2)).size === assets.length));
+var parseStaticAssetManifest = (content) => decodeJson(StaticAssetManifestV1Schema, content);
+
+// src/define-config.ts
+var defineConfig = (config) => config;
+
 // src/detection/detect-framework.ts
 import { FileSystem as FileSystem8, Path as Path6 } from "@effect/platform";
 import { Effect as Effect10 } from "effect";
@@ -335,54 +395,189 @@ var getDefaultPathMap = Effect4.fn("getDefaultPathMap")(function* (directory) {
   return result;
 });
 
+// src/nextjs-constants.ts
+var MAXIMUM_ENTRY_PAGE_PATHS = 50;
+
 // src/nextjs-manifest.ts
-var isRecord3 = (value) => typeof value === "object" && value !== null;
-var isPortableRelativePath = (value, allowCurrentDirectory = false) => {
-  if (typeof value !== "string") return false;
-  const normalized = value.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/+$/, "");
-  return (allowCurrentDirectory || normalized !== "" && normalized !== ".") && !normalized.startsWith("/") && !/^[A-Za-z]:/.test(normalized) && !normalized.includes(":") && !normalized.split("/").some((segment) => segment === "..");
-};
-var isStringRecord = (value) => isRecord3(value) && Object.values(value).every((item) => typeof item === "string");
-var isJsonValue = (value) => {
-  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
-  if (typeof value === "number") return Number.isFinite(value);
-  if (Array.isArray(value)) return value.every(isJsonValue);
-  return isRecord3(value) && Object.values(value).every(isJsonValue);
-};
-var isPrerenderOutput = (value) => isRecord3(value) && value.type === "PRERENDER" && typeof value.id === "string" && typeof value.pathname === "string" && typeof value.parentOutputId === "string" && typeof value.groupId === "number" && isRecord3(value.config) && (value.fallback === void 0 || isRecord3(value.fallback) && (value.fallback.filePath === void 0 || isPortableRelativePath(value.fallback.filePath)));
-var isStaticAssetPrefix = (value) => isRecord3(value) && isPortableRelativePath(value.sourceDir) && isPortableRelativePath(value.urlPrefix) && typeof value.immutable === "boolean";
-var isServerDescriptor = (value) => isRecord3(value) && (value.maxDuration === void 0 || typeof value.maxDuration === "number") && (value.preferredRegion === void 0 || typeof value.preferredRegion === "string" || Array.isArray(value.preferredRegion) && value.preferredRegion.every((region) => typeof region === "string")) && (value.env === void 0 || isStringRecord(value.env));
-var isImagePolicy = (value) => isRecord3(value) && Array.isArray(value.localPatterns) && Array.isArray(value.remotePatterns) && value.remotePatterns.every((pattern) => isRecord3(pattern) && typeof pattern.hostname === "string") && Array.isArray(value.widths) && value.widths.every((item) => typeof item === "number" && Number.isInteger(item) && item > 0) && Array.isArray(value.heights) && value.heights.every((item) => typeof item === "number" && Number.isInteger(item) && item > 0) && Array.isArray(value.qualities) && value.qualities.every((item) => typeof item === "number" && item >= 1 && item <= 100) && Array.isArray(value.formats) && value.formats.every((item) => ["image/avif", "image/webp", "image/jpeg", "image/png"].includes(String(item))) && typeof value.minimumCacheTTL === "number" && typeof value.dangerouslyAllowSVG === "boolean" && typeof value.contentSecurityPolicy === "string" && (value.contentDispositionType === "inline" || value.contentDispositionType === "attachment") && typeof value.maximumRedirects === "number" && typeof value.maximumResponseBody === "number" && isRecord3(value.variants);
-var parseGigadriveNextBuildManifest = (content) => {
-  try {
-    const value = JSON.parse(content);
-    if (!isRecord3(value)) return void 0;
-    if (value.version === 1) {
-      if (value.output !== "standalone" && value.output !== "export" || !isPortableRelativePath(value.distDir) || !isPortableRelativePath(value.repoRootToProject, true) || typeof value.nextVersion !== "string" || typeof value.buildId !== "string") {
-        return void 0;
-      }
-      return value;
-    }
-    if (value.version === 2) {
-      if (!isPortableRelativePath(value.distDir) || !isPortableRelativePath(value.repoRootToProject, true) || typeof value.nextVersion !== "string" || typeof value.buildId !== "string") {
-        return void 0;
-      }
-      if (value.mode === "export") {
-        return value;
-      }
-      if (value.mode === "standalone-v2") {
-        if (!isServerDescriptor(value.server) || !isRecord3(value.config) || typeof value.config.basePath !== "string" || typeof value.config.trailingSlash !== "boolean" || typeof value.config.cacheComponents !== "boolean" || value.config.images !== void 0 && !isImagePolicy(value.config.images) || !isRecord3(value.routing) || !isJsonValue(value.routing) || !isRecord3(value.outputs) || !Array.isArray(value.outputs.prerenders) || !value.outputs.prerenders.every(isPrerenderOutput) || !Array.isArray(value.outputs.staticAssets) || !value.outputs.staticAssets.every(isStaticAssetPrefix)) {
-          return void 0;
-        }
-        return value;
-      }
-      return void 0;
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
-};
+import { Schema as Schema3 } from "effect";
+var StringArraySchema = Schema3.mutable(Schema3.Array(Schema3.String));
+var StringRecordSchema = Schema3.mutable(Schema3.Record({ key: Schema3.String, value: Schema3.String }));
+var JsonValueSchema = Schema3.suspend(
+  () => Schema3.Union(
+    Schema3.Null,
+    Schema3.Boolean,
+    Schema3.Number,
+    Schema3.String,
+    Schema3.mutable(Schema3.Array(JsonValueSchema)),
+    Schema3.mutable(Schema3.Record({ key: Schema3.String, value: JsonValueSchema }))
+  )
+);
+var ImageLocalPatternSchema = Schema3.mutable(
+  Schema3.Struct({
+    pathname: Schema3.optional(Schema3.String),
+    search: Schema3.optional(Schema3.String)
+  })
+);
+var ImageRemotePatternSchema = Schema3.mutable(
+  Schema3.Struct({
+    protocol: Schema3.optional(Schema3.Literal("http", "https")),
+    hostname: Schema3.String,
+    port: Schema3.optional(Schema3.String),
+    pathname: Schema3.optional(Schema3.String),
+    search: Schema3.optional(Schema3.String)
+  })
+);
+var ImageVariantSchema = Schema3.mutable(
+  Schema3.Struct({
+    width: Schema3.optional(Schema3.Number),
+    height: Schema3.optional(Schema3.Number),
+    quality: Schema3.optional(Schema3.Number),
+    format: Schema3.optional(Schema3.Literal("image/avif", "image/webp", "image/jpeg", "image/png")),
+    fit: Schema3.optional(Schema3.Literal("contain", "cover", "fill", "inside", "outside"))
+  })
+);
+var PositiveIntSchema = Schema3.Int.pipe(Schema3.greaterThan(0));
+var ImagePolicySchema = Schema3.mutable(
+  Schema3.Struct({
+    localPatterns: Schema3.mutable(Schema3.Array(ImageLocalPatternSchema)),
+    remotePatterns: Schema3.mutable(Schema3.Array(ImageRemotePatternSchema)),
+    widths: Schema3.mutable(Schema3.Array(PositiveIntSchema)),
+    heights: Schema3.mutable(Schema3.Array(PositiveIntSchema)),
+    qualities: Schema3.mutable(Schema3.Array(Schema3.Number.pipe(Schema3.between(1, 100)))),
+    formats: Schema3.mutable(Schema3.Array(Schema3.Literal("image/avif", "image/webp", "image/jpeg", "image/png"))),
+    minimumCacheTTL: Schema3.Number,
+    dangerouslyAllowSVG: Schema3.Boolean,
+    contentSecurityPolicy: Schema3.String,
+    contentDispositionType: Schema3.Literal("inline", "attachment"),
+    maximumRedirects: Schema3.Number,
+    maximumResponseBody: Schema3.Number,
+    variants: Schema3.mutable(Schema3.Record({ key: Schema3.String, value: ImageVariantSchema }))
+  })
+);
+var GigadriveNextPrerenderOutputSchema = Schema3.mutable(
+  Schema3.Struct({
+    id: Schema3.String,
+    type: Schema3.Literal("PRERENDER"),
+    pathname: UrlPathnameSchema,
+    parentOutputId: Schema3.String,
+    groupId: Schema3.Number,
+    pprChain: Schema3.optional(Schema3.mutable(Schema3.Struct({ headers: HttpSingleValueHeadersSchema }))),
+    parentFallbackMode: Schema3.optional(JsonValueSchema),
+    fallback: Schema3.optional(
+      Schema3.mutable(
+        Schema3.Struct({
+          filePath: Schema3.optional(PortableRelativePathSchema),
+          initialStatus: Schema3.optional(Schema3.Int.pipe(Schema3.between(100, 599))),
+          initialHeaders: Schema3.optional(HttpHeadersSchema),
+          initialExpiration: Schema3.optional(Schema3.Number),
+          initialRevalidate: Schema3.optional(Schema3.Union(Schema3.Number, Schema3.Literal(false))),
+          postponedState: Schema3.optional(Schema3.String)
+        })
+      )
+    ),
+    config: Schema3.mutable(
+      Schema3.Struct({
+        allowQuery: Schema3.optional(StringArraySchema),
+        allowHeader: Schema3.optional(StringArraySchema),
+        bypassFor: Schema3.optional(Schema3.mutable(Schema3.Array(JsonValueSchema))),
+        renderingMode: Schema3.optional(Schema3.String),
+        partialFallback: Schema3.optional(Schema3.Boolean),
+        bypassToken: Schema3.optional(Schema3.String)
+      })
+    )
+  })
+);
+var GigadriveNextStaticAssetPrefixSchema = Schema3.mutable(
+  Schema3.Struct({
+    sourceDir: PortableRelativePathSchema,
+    urlPrefix: PortableRelativePathSchema,
+    immutable: Schema3.Boolean
+  })
+);
+var GigadriveNextServerDescriptorSchema = Schema3.mutable(
+  Schema3.Struct({
+    maxDuration: Schema3.optional(Schema3.Number),
+    preferredRegion: Schema3.optional(Schema3.Union(Schema3.String, StringArraySchema)),
+    env: Schema3.optional(StringRecordSchema)
+  })
+);
+var PrerenderArraySchema = Schema3.mutable(Schema3.Array(GigadriveNextPrerenderOutputSchema));
+var StaticAssetArraySchema = Schema3.mutable(Schema3.Array(GigadriveNextStaticAssetPrefixSchema));
+var JsonValueArraySchema = Schema3.mutable(Schema3.Array(JsonValueSchema));
+var GigadriveNextBuildManifestV1Schema = Schema3.mutable(
+  Schema3.Struct({
+    version: Schema3.Literal(1),
+    output: Schema3.Literal("standalone", "export"),
+    distDir: PortableRelativePathSchema,
+    repoRootToProject: RepositoryRelativePathSchema,
+    nextVersion: Schema3.String,
+    buildId: Schema3.String
+  })
+);
+var GigadriveNextBuildManifestV2ExportSchema = Schema3.mutable(
+  Schema3.Struct({
+    version: Schema3.Literal(2),
+    mode: Schema3.Literal("export"),
+    distDir: PortableRelativePathSchema,
+    repoRootToProject: RepositoryRelativePathSchema,
+    nextVersion: Schema3.String,
+    buildId: Schema3.String
+  })
+);
+var GigadriveNextBuildManifestV2StandaloneSchema = Schema3.mutable(
+  Schema3.Struct({
+    version: Schema3.Literal(2),
+    mode: Schema3.Literal("standalone-v2"),
+    distDir: PortableRelativePathSchema,
+    repoRootToProject: RepositoryRelativePathSchema,
+    nextVersion: Schema3.String,
+    buildId: Schema3.String,
+    server: GigadriveNextServerDescriptorSchema,
+    config: Schema3.mutable(
+      Schema3.Struct({
+        basePath: Schema3.String,
+        trailingSlash: Schema3.Boolean,
+        cacheComponents: Schema3.Boolean,
+        i18n: Schema3.optional(JsonValueSchema),
+        images: Schema3.optional(ImagePolicySchema)
+      })
+    ),
+    routing: Schema3.mutable(
+      Schema3.Struct({
+        beforeMiddleware: JsonValueArraySchema,
+        beforeFiles: JsonValueArraySchema,
+        afterFiles: JsonValueArraySchema,
+        dynamicRoutes: JsonValueArraySchema,
+        onMatch: JsonValueArraySchema,
+        fallback: JsonValueArraySchema,
+        shouldNormalizeNextData: Schema3.Boolean,
+        rsc: JsonValueSchema
+      })
+    ),
+    outputs: Schema3.mutable(
+      Schema3.Struct({
+        prerenders: PrerenderArraySchema,
+        prerenderManifest: Schema3.optional(PortableRelativePathSchema),
+        assetManifest: Schema3.optional(PortableRelativePathSchema),
+        entryPagePaths: Schema3.optional(Schema3.mutable(Schema3.Array(UrlPathnameSchema))),
+        staticAssets: StaticAssetArraySchema
+      })
+    )
+  })
+);
+var GigadriveNextBuildManifestSchema = Schema3.Union(
+  GigadriveNextBuildManifestV1Schema,
+  GigadriveNextBuildManifestV2ExportSchema,
+  GigadriveNextBuildManifestV2StandaloneSchema
+);
+var GigadriveNextPrerenderManifestV1Schema = Schema3.mutable(
+  Schema3.Struct({
+    version: Schema3.Literal(1),
+    prerenders: PrerenderArraySchema
+  })
+);
+var parseGigadriveNextBuildManifest = (content) => decodeJson(GigadriveNextBuildManifestSchema, content);
+var parseGigadriveNextPrerenderManifest = (content) => decodeJson(GigadriveNextPrerenderManifestV1Schema, content);
 
 // src/regions.ts
 var REGION_DEFINITIONS = [
@@ -408,7 +603,6 @@ var AVAILABLE_REGIONS = [...REGION_DEFINITIONS];
 
 // src/detection/frameworks/nextjs.ts
 var toPortablePath = (value) => value.replaceAll("\\", "/");
-var MAXIMUM_ENTRY_PAGE_PATHS = 50;
 var STANDALONE_SERVER_MEMORY_MB = 1024;
 var resolveStandaloneServer = Effect5.fn("nextjs.resolveStandaloneServer")(function* (projectFolder, distDir, repoRootToProject) {
   const fs = yield* FileSystem5.FileSystem;
@@ -513,9 +707,11 @@ var createStandaloneV2Config = Effect5.fn("nextjs.createStandaloneV2Config")(fun
     immutable: staticAsset.immutable,
     populateCache: true
   }));
-  const entryPagePaths = [
+  const assetManifests = manifest.outputs.assetManifest ? [{ source: manifest.outputs.assetManifest }] : void 0;
+  const { entryPagePaths: manifestEntryPagePaths, ...manifestOutputs } = manifest.outputs;
+  const entryPagePaths = manifestEntryPagePaths?.slice(0, MAXIMUM_ENTRY_PAGE_PATHS) ?? [
     ...new Set(
-      manifest.outputs.prerenders.filter((output) => !output.fallback?.postponedState).map((output) => output.pathname).filter((pathname) => pathname.startsWith("/") && !pathname.includes("["))
+      manifest.outputs.prerenders.filter((output) => output.fallback?.postponedState === void 0).map((output) => output.pathname).filter((pathname) => pathname.startsWith("/") && !pathname.includes("["))
     )
   ].sort((left, right) => left.split("/").length - right.split("/").length || left.localeCompare(right)).slice(0, MAXIMUM_ENTRY_PAGE_PATHS);
   const singleEntrypoint = {
@@ -544,10 +740,9 @@ var createStandaloneV2Config = Effect5.fn("nextjs.createStandaloneV2Config")(fun
     server: manifest.server,
     config: manifest.config,
     routing: manifest.routing,
-    // The prerender table is deliberately not forwarded: the standalone server
-    // serves build-time prerenders from its own bundle, so the platform only
-    // needs the warming sample below.
-    outputs: { prerenders: [], staticAssets: manifest.outputs.staticAssets },
+    // Keep high-cardinality output metadata in portable sidecars rather than
+    // expanding it into normalized deployment configuration.
+    outputs: { ...manifestOutputs, prerenders: [] },
     entryPagePaths,
     type: "nextjs",
     schemaVersion: 2
@@ -559,6 +754,7 @@ var createStandaloneV2Config = Effect5.fn("nextjs.createStandaloneV2Config")(fun
     assetPaths,
     assetOverrides,
     assetPrefixes,
+    assetManifests,
     assetsDir: manifest.distDir,
     assetsPrefixToStrip: "",
     populateAssetCache: true,
@@ -820,12 +1016,13 @@ var generateConfig = Effect7.fn("generateConfig")(function* (framework, packageM
     errors: [],
     ...defaults.normalizedConfig
   };
-  if (defaults.assetsDir || defaults.assetPaths || defaults.assetPrefixes) {
+  if (defaults.assetsDir || defaults.assetPaths || defaults.assetPrefixes || defaults.assetManifests) {
     config.assets = {
       paths: defaults.assetPaths ? [...defaults.assetPaths] : [],
       prefixToStrip: defaults.assetsPrefixToStrip ?? (defaults.assetsDir ? defaults.assetsDir + "/" : ""),
       overrides: defaults.assetOverrides ? { ...defaults.assetOverrides } : void 0,
       prefixes: defaults.assetPrefixes ? defaults.assetPrefixes.map((prefix) => ({ ...prefix })) : void 0,
+      manifests: defaults.assetManifests ? defaults.assetManifests.map((manifest) => ({ ...manifest })) : void 0,
       dynamicRoutes: true,
       populateCache: defaults.populateAssetCache ?? false
     };
@@ -838,27 +1035,27 @@ import { FileSystem as FileSystem7, Path as Path5 } from "@effect/platform";
 import { Effect as Effect9 } from "effect";
 
 // src/detection/types.ts
-import { Schema } from "effect";
-var ManifestNotFoundError = class extends Schema.TaggedError()("ManifestNotFoundError", {
-  message: Schema.String,
-  filePath: Schema.String
+import { Schema as Schema4 } from "effect";
+var ManifestNotFoundError = class extends Schema4.TaggedError()("ManifestNotFoundError", {
+  message: Schema4.String,
+  filePath: Schema4.String
 }) {
 };
-var ManifestReadError = class extends Schema.TaggedError()("ManifestReadError", {
-  message: Schema.String,
-  filePath: Schema.String
+var ManifestReadError = class extends Schema4.TaggedError()("ManifestReadError", {
+  message: Schema4.String,
+  filePath: Schema4.String
 }) {
 };
-var ManifestParseError = class extends Schema.TaggedError()("ManifestParseError", {
-  message: Schema.String,
-  filePath: Schema.String
+var ManifestParseError = class extends Schema4.TaggedError()("ManifestParseError", {
+  message: Schema4.String,
+  filePath: Schema4.String
 }) {
 };
-var FrameworkNotDetectedError = class extends Schema.TaggedError()(
+var FrameworkNotDetectedError = class extends Schema4.TaggedError()(
   "FrameworkNotDetectedError",
   {
-    message: Schema.String,
-    directory: Schema.String
+    message: Schema4.String,
+    directory: Schema4.String
   }
 ) {
 };
@@ -974,12 +1171,13 @@ var detectFramework = Effect10.fn("detectFramework")(function* (projectFolder) {
 import { Effect as Effect11 } from "effect";
 var mergeWithFrameworkDefaults = Effect11.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
   yield* Effect11.logDebug("Merging user config with framework defaults");
+  const userHasAssets = (userConfig.assets?.paths?.length ?? 0) > 0 || (userConfig.assets?.prefixes?.length ?? 0) > 0 || (userConfig.assets?.manifests?.length ?? 0) > 0;
   const merged = {
     regions: userConfig.regions,
     commands: userConfig.commands.length > 0 ? userConfig.commands : frameworkConfig.commands,
     entrypoints: userConfig.entrypoints.length > 0 ? userConfig.entrypoints : frameworkConfig.entrypoints,
     routes: userConfig.routes.length > 0 ? userConfig.routes : frameworkConfig.routes,
-    assets: userConfig.assets?.paths && userConfig.assets.paths.length > 0 ? userConfig.assets : frameworkConfig.assets,
+    assets: userHasAssets ? userConfig.assets : frameworkConfig.assets,
     environmentVariables: {
       ...frameworkConfig.environmentVariables,
       ...userConfig.environmentVariables
@@ -994,41 +1192,47 @@ var mergeWithFrameworkDefaults = Effect11.fn("mergeWithFrameworkDefaults")(funct
 });
 
 // src/errors.ts
-import { Schema as Schema2 } from "effect";
-var ConfigFileNotFoundError = class extends Schema2.TaggedError()("ConfigFileNotFoundError", {
-  message: Schema2.String,
-  filePath: Schema2.String
+import { Schema as Schema5 } from "effect";
+var ConfigFileNotFoundError = class extends Schema5.TaggedError()("ConfigFileNotFoundError", {
+  message: Schema5.String,
+  filePath: Schema5.String
+}) {
+};
+var ConfigFileEmptyError = class extends Schema5.TaggedError()("ConfigFileEmptyError", {
+  message: Schema5.String,
+  filePath: Schema5.String
 }) {
 };
-var ConfigFileEmptyError = class extends Schema2.TaggedError()("ConfigFileEmptyError", {
-  message: Schema2.String,
-  filePath: Schema2.String
+var ConfigFileParseError = class extends Schema5.TaggedError()("ConfigFileParseError", {
+  message: Schema5.String,
+  filePath: Schema5.String,
+  cause: Schema5.optional(Schema5.String)
 }) {
 };
-var ConfigFileParseError = class extends Schema2.TaggedError()("ConfigFileParseError", {
-  message: Schema2.String,
-  filePath: Schema2.String,
-  cause: Schema2.optional(Schema2.String)
+var ConfigModuleLoadError = class extends Schema5.TaggedError()("ConfigModuleLoadError", {
+  message: Schema5.String,
+  filePath: Schema5.String,
+  cause: Schema5.optional(Schema5.String)
 }) {
 };
-var ConfigVersionError = class extends Schema2.TaggedError()("ConfigVersionError", {
-  message: Schema2.String,
-  filePath: Schema2.String,
-  version: Schema2.optional(Schema2.Number)
+var ConfigVersionError = class extends Schema5.TaggedError()("ConfigVersionError", {
+  message: Schema5.String,
+  filePath: Schema5.String,
+  version: Schema5.optional(Schema5.Number)
 }) {
 };
-var ConfigSchemaValidationError = class extends Schema2.TaggedError()(
+var ConfigSchemaValidationError = class extends Schema5.TaggedError()(
   "ConfigSchemaValidationError",
   {
-    message: Schema2.String,
-    filePath: Schema2.String,
-    validationErrors: Schema2.Array(Schema2.String)
+    message: Schema5.String,
+    filePath: Schema5.String,
+    validationErrors: Schema5.Array(Schema5.String)
   }
 ) {
 };
-var FunctionConfigError = class extends Schema2.TaggedError()("FunctionConfigError", {
-  message: Schema2.String,
-  functionPath: Schema2.String
+var FunctionConfigError = class extends Schema5.TaggedError()("FunctionConfigError", {
+  message: Schema5.String,
+  functionPath: Schema5.String
 }) {
 };
 
@@ -1048,85 +1252,157 @@ var DEFAULT_FUNCTION_DURATION_SECONDS = 30;
 var MAX_FUNCTION_DURATION_SECONDS = 28800;
 
 // src/parse-config.ts
-import { Effect as Effect16 } from "effect";
+import { Effect as Effect17 } from "effect";
 
 // src/services/raw-config-reader.ts
 import { FileSystem as FileSystem9, Path as Path7 } from "@effect/platform";
-import { Effect as Effect12 } from "effect";
+import { Effect as Effect13 } from "effect";
 import { parse as parseYaml } from "yaml";
+
+// src/services/config-module-loader.ts
+import { Effect as Effect12 } from "effect";
+import { createJiti } from "jiti";
+var MISSING_DEFAULT_EXPORT = /* @__PURE__ */ Symbol("MissingDefaultExport");
+var STRICT_DEFAULT_EXPORT_EXTENSIONS = [".ts", ".mts", ".mjs"];
+var ConfigModuleLoader = class extends Effect12.Service()("ConfigModuleLoader", {
+  effect: Effect12.gen(function* () {
+    const loadConfigModule = Effect12.fn("ConfigModuleLoader.loadConfigModule")(function* (filePath) {
+      const extension = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+      const mod = yield* Effect12.tryPromise({
+        try: async () => {
+          const jiti = createJiti(filePath, { fsCache: false, interopDefault: true, moduleCache: false });
+          const namespace = await jiti.import(filePath);
+          if (typeof namespace === "object" && namespace !== null && "default" in namespace) {
+            return namespace.default;
+          }
+          if (!STRICT_DEFAULT_EXPORT_EXTENSIONS.includes(extension)) {
+            return namespace.default ?? MISSING_DEFAULT_EXPORT;
+          }
+          return MISSING_DEFAULT_EXPORT;
+        },
+        catch: (error) => new ConfigModuleLoadError({
+          message: `Failed to load config module at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
+          filePath,
+          cause: error instanceof Error ? error.message : void 0
+        })
+      });
+      if (mod === MISSING_DEFAULT_EXPORT) {
+        return yield* Effect12.fail(
+          new ConfigModuleLoadError({
+            message: `Config module at ${filePath} does not have a default export. Export the config object as the default export (or via module.exports for CommonJS files), optionally wrapped in defineConfig.`,
+            filePath
+          })
+        );
+      }
+      if (typeof mod === "function") {
+        return yield* Effect12.fail(
+          new ConfigModuleLoadError({
+            message: `Config module at ${filePath} default-exports a function; config factories are not supported. Export a config object instead (optionally wrapped in defineConfig).`,
+            filePath
+          })
+        );
+      }
+      if (typeof mod !== "object" || mod === null || Array.isArray(mod)) {
+        return yield* Effect12.fail(
+          new ConfigModuleLoadError({
+            message: `Config module at ${filePath} must default-export a config object.`,
+            filePath
+          })
+        );
+      }
+      return mod;
+    });
+    return { loadConfigModule };
+  })
+}) {
+};
+
+// src/services/raw-config-reader.ts
 var ALLOWED_CONFIG_NAMES = [
+  "gigadrive.ts",
+  "gigadrive.mts",
+  "gigadrive.cts",
+  "gigadrive.js",
+  "gigadrive.mjs",
+  "gigadrive.cjs",
   "gigadrive.yaml",
   "gigadrive.yml",
+  "gigadrive.json",
   "nebula.yaml",
   "nebula.yml",
   "nebula.json"
 ];
-var RawConfigReader = class extends Effect12.Service()("RawConfigReader", {
-  effect: Effect12.gen(function* () {
+var MODULE_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+var RawConfigReader = class extends Effect13.Service()("RawConfigReader", {
+  dependencies: [ConfigModuleLoader.Default],
+  effect: Effect13.gen(function* () {
     const fs = yield* FileSystem9.FileSystem;
     const pathService = yield* Path7.Path;
-    const findConfig = Effect12.fn("RawConfigReader.findConfig")(function* (projectFolder) {
+    const moduleLoader = yield* ConfigModuleLoader;
+    const findConfig = Effect13.fn("RawConfigReader.findConfig")(function* (projectFolder) {
       for (const name of ALLOWED_CONFIG_NAMES) {
         const filePath = pathService.join(projectFolder, name);
-        const exists = yield* fs.exists(filePath).pipe(Effect12.catchAll(() => Effect12.succeed(false)));
+        const exists = yield* fs.exists(filePath).pipe(Effect13.catchAll(() => Effect13.succeed(false)));
         if (exists) {
           return filePath;
         }
       }
       return null;
     });
-    const readRawConfig = Effect12.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
-      const exists = yield* fs.exists(filePath).pipe(Effect12.catchAll(() => Effect12.succeed(false)));
+    const readRawConfig = Effect13.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
+      const exists = yield* fs.exists(filePath).pipe(Effect13.catchAll(() => Effect13.succeed(false)));
       if (!exists) {
-        return yield* Effect12.fail(
+        return yield* Effect13.fail(
           new ConfigFileNotFoundError({ message: `Config file not found at ${filePath}`, filePath })
         );
       }
       const fileContents = yield* fs.readFileString(filePath).pipe(
-        Effect12.mapError(
+        Effect13.mapError(
           () => new ConfigFileParseError({ message: `Failed to read config file at ${filePath}`, filePath })
         )
       );
       if (fileContents.length === 0) {
-        return yield* Effect12.fail(
+        return yield* Effect13.fail(
           new ConfigFileEmptyError({ message: `Config file is empty at ${filePath}`, filePath })
         );
       }
       const fileExtension = pathService.extname(filePath).toLowerCase();
       let parsed;
-      try {
-        if (fileExtension === ".json") {
-          parsed = JSON.parse(fileContents);
-        } else if ([".yml", ".yaml"].includes(fileExtension)) {
-          parsed = parseYaml(fileContents);
-        } else {
-          parsed = parseYaml(fileContents);
+      if (MODULE_EXTENSIONS.includes(fileExtension)) {
+        parsed = yield* moduleLoader.loadConfigModule(filePath);
+      } else {
+        try {
+          if (fileExtension === ".json") {
+            parsed = JSON.parse(fileContents);
+          } else {
+            parsed = parseYaml(fileContents);
+          }
+        } catch (error) {
+          return yield* Effect13.fail(
+            new ConfigFileParseError({
+              message: `Failed to parse config file at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
+              filePath,
+              cause: error instanceof Error ? error.message : void 0
+            })
+          );
         }
-      } catch (error) {
-        return yield* Effect12.fail(
-          new ConfigFileParseError({
-            message: `Failed to parse config file at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
-            filePath,
-            cause: error instanceof Error ? error.message : void 0
-          })
-        );
       }
       if (parsed == null) {
-        return yield* Effect12.fail(
+        return yield* Effect13.fail(
           new ConfigFileParseError({ message: `Config file could not be parsed at ${filePath}`, filePath })
         );
       }
       if (!options?.disableVersionCheck && typeof parsed.version !== "number") {
-        return yield* Effect12.fail(
+        return yield* Effect13.fail(
           new ConfigVersionError({ message: `Config file is missing version at ${filePath}`, filePath })
         );
       }
       return parsed;
     });
     const readConfigFile = (configFilePath) => readRawConfig(configFilePath, { disableVersionCheck: true }).pipe(
-      Effect12.map((parsed) => parsed),
-      Effect12.catchTag("ConfigFileNotFoundError", () => Effect12.succeed(null)),
-      Effect12.withSpan("RawConfigReader.readConfigFile")
+      Effect13.map((parsed) => parsed),
+      Effect13.catchTag("ConfigFileNotFoundError", () => Effect13.succeed(null)),
+      Effect13.withSpan("RawConfigReader.readConfigFile")
     );
     return { findConfig, readRawConfig, readConfigFile };
   })
@@ -1136,17 +1412,17 @@ var RawConfigReader = class extends Effect12.Service()("RawConfigReader", {
 // src/services/schema-validator.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-import { Effect as Effect13 } from "effect";
-var SchemaValidator = class extends Effect13.Service()("SchemaValidator", {
-  effect: Effect13.gen(function* () {
+import { Effect as Effect14 } from "effect";
+var SchemaValidator = class extends Effect14.Service()("SchemaValidator", {
+  effect: Effect14.gen(function* () {
     const ajv = new Ajv();
     addFormats(ajv);
-    const validate = Effect13.fn("SchemaValidator.validate")(function* (config, schema, filePath) {
+    const validate = Effect14.fn("SchemaValidator.validate")(function* (config, schema, filePath) {
       const compiledValidate = ajv.compile(schema);
       const valid = compiledValidate(config);
       if (!valid) {
         const errors = compiledValidate.errors?.map((e) => `${e.instancePath || "/"} ${e.message ?? ""}`.trim()) ?? [];
-        return yield* Effect13.fail(
+        return yield* Effect14.fail(
           new ConfigSchemaValidationError({
             message: `Config file at ${filePath} is invalid: ${ajv.errorsText(compiledValidate.errors)}`,
             filePath,
@@ -1163,7 +1439,7 @@ var SchemaValidator = class extends Effect13.Service()("SchemaValidator", {
 // src/services/v4-config-parser.ts
 import { FileSystem as FileSystem10, Path as Path8 } from "@effect/platform";
 import { getFilesForPattern } from "@gigadrive/build-utils";
-import { Effect as Effect14 } from "effect";
+import { Effect as Effect15 } from "effect";
 import { minimatch } from "minimatch";
 import safeRegex from "safe-regex2";
 var MAX_ASSET_DEPTH = 100;
@@ -1269,7 +1545,7 @@ var mapRoute = (route, entrypoints) => ({
   negativeRequirements: route.missing,
   status: route.statusCode
 });
-var parseEntrypoints = Effect14.fn("parseEntrypoints")(function* (config, projectFolder) {
+var parseEntrypoints = Effect15.fn("parseEntrypoints")(function* (config, projectFolder) {
   const entrypoints = [];
   if (config.functions == null) return entrypoints;
   for (const [fnPath, func] of Object.entries(config.functions)) {
@@ -1279,7 +1555,7 @@ var parseEntrypoints = Effect14.fn("parseEntrypoints")(function* (config, projec
         functionPath: fnPath
       });
     }
-    const matchedFiles = yield* Effect14.tryPromise({
+    const matchedFiles = yield* Effect15.tryPromise({
       try: () => getFilesForPattern(fnPath, projectFolder, func.excludeFiles),
       catch: (error) => new FunctionConfigError({
         message: `Failed to resolve files for function pattern '${fnPath}': ${error instanceof Error ? error.message : String(error)}`,
@@ -1315,14 +1591,14 @@ var parseEntrypoints = Effect14.fn("parseEntrypoints")(function* (config, projec
   }
   return entrypoints;
 });
-var collectAssets = Effect14.fn("collectAssets")(function* (config, projectFolder) {
+var collectAssets = Effect15.fn("collectAssets")(function* (config, projectFolder) {
   if (config.assets == null) return [];
   const fs = yield* FileSystem10.FileSystem;
   const pathService = yield* Path8.Path;
   const assetsPath = pathService.join(projectFolder, config.assets);
-  const assetsExist = yield* fs.exists(assetsPath).pipe(Effect14.catchAll(() => Effect14.succeed(false)));
+  const assetsExist = yield* fs.exists(assetsPath).pipe(Effect15.catchAll(() => Effect15.succeed(false)));
   if (!assetsExist) return [];
-  const stat = yield* fs.stat(assetsPath).pipe(Effect14.catchAll(() => Effect14.succeed(null)));
+  const stat = yield* fs.stat(assetsPath).pipe(Effect15.catchAll(() => Effect15.succeed(null)));
   if (!stat || stat.type !== "Directory") return [];
   const allFiles = yield* collectFilesRecursively(assetsPath);
   const assets = [];
@@ -1333,18 +1609,18 @@ var collectAssets = Effect14.fn("collectAssets")(function* (config, projectFolde
   }
   return assets;
 });
-var collectFilesRecursively = Effect14.fn("collectFilesRecursively")(
+var collectFilesRecursively = Effect15.fn("collectFilesRecursively")(
   function* (basePath, relativePath = "", depth = 0) {
     if (depth > MAX_ASSET_DEPTH) return [];
     const fs = yield* FileSystem10.FileSystem;
     const pathSvc = yield* Path8.Path;
     const currentPath = relativePath ? pathSvc.join(basePath, relativePath) : basePath;
-    const entries = yield* fs.readDirectory(currentPath).pipe(Effect14.catchAll(() => Effect14.succeed([])));
+    const entries = yield* fs.readDirectory(currentPath).pipe(Effect15.catchAll(() => Effect15.succeed([])));
     const result = [];
     for (const name of entries) {
       const fullPath = pathSvc.join(currentPath, name);
       const entryRelative = relativePath ? pathSvc.join(relativePath, name) : name;
-      const stat = yield* fs.stat(fullPath).pipe(Effect14.catchAll(() => Effect14.succeed(null)));
+      const stat = yield* fs.stat(fullPath).pipe(Effect15.catchAll(() => Effect15.succeed(null)));
       if (!stat) continue;
       if (stat.type === "Directory") {
         const nested = yield* collectFilesRecursively(basePath, entryRelative, depth + 1);
@@ -1356,16 +1632,16 @@ var collectFilesRecursively = Effect14.fn("collectFilesRecursively")(
     return result;
   }
 );
-var V4ConfigParser = class extends Effect14.Service()("V4ConfigParser", {
+var V4ConfigParser = class extends Effect15.Service()("V4ConfigParser", {
   accessors: true,
-  effect: Effect14.succeed({
+  effect: Effect15.succeed({
     /**
      * Parses a ConfigV4 into a NormalizedConfig.
      *
      * @param config - The raw V4 config object
      * @param projectFolder - Absolute path to the project root
      */
-    parse: Effect14.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
+    parse: Effect15.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
       const entrypoints = yield* parseEntrypoints(config, projectFolder);
       const assets = yield* collectAssets(config, projectFolder);
       return {
@@ -1394,7 +1670,7 @@ var V4ConfigParser = class extends Effect14.Service()("V4ConfigParser", {
 import { Path as Path9 } from "@effect/platform";
 import { getFilesForPattern as getFilesForPattern2 } from "@gigadrive/build-utils";
 import { deepMerge } from "@gigadrive/commons";
-import { Effect as Effect15 } from "effect";
+import { Effect as Effect16 } from "effect";
 
 // src/build-output-v3/determine-repo-root.ts
 import path from "path";
@@ -1490,11 +1766,11 @@ var translateVercelRuntime = (runtime) => {
 var CONFIG_PATH = ".vercel/output/config.json";
 var FUNCTIONS_FOLDER = ".vercel/output/functions";
 var FUNCTION_CONFIGS_PATTERN = `${FUNCTIONS_FOLDER}/**/*.func/.vc-config.json`;
-var VercelBuildOutputParser = class extends Effect15.Service()("VercelBuildOutputParser", {
-  effect: Effect15.gen(function* () {
+var VercelBuildOutputParser = class extends Effect16.Service()("VercelBuildOutputParser", {
+  effect: Effect16.gen(function* () {
     const rawConfigReader = yield* RawConfigReader;
     const pathService = yield* Path9.Path;
-    const parse = Effect15.fn("VercelBuildOutputParser.parse")(function* (parseResult, projectFolder) {
+    const parse = Effect16.fn("VercelBuildOutputParser.parse")(function* (parseResult, projectFolder) {
       const config = yield* rawConfigReader.readConfigFile(pathService.join(projectFolder, CONFIG_PATH));
       if (!config || typeof config.version !== "number" || config.version < 3) {
         return parseResult;
@@ -1506,8 +1782,8 @@ var VercelBuildOutputParser = class extends Effect15.Service()("VercelBuildOutpu
       merged.regions = [...new Set(merged.regions)];
       return merged;
     });
-    const loadFunctions = Effect15.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
-      const functionConfigs = yield* Effect15.tryPromise({
+    const loadFunctions = Effect16.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
+      const functionConfigs = yield* Effect16.tryPromise({
         try: () => getFilesForPattern2(FUNCTION_CONFIGS_PATTERN, projectFolder),
         catch: (error) => new ConfigFileParseError({
           message: `Failed to scan for function configs: ${error instanceof Error ? error.message : String(error)}`,
@@ -2106,7 +2382,7 @@ var schema_default = {
 };
 
 // src/parse-config.ts
-var parseConfigRaw = Effect16.fn("parseConfigRaw")(function* (filePath, projectFolder) {
+var parseConfigRaw = Effect17.fn("parseConfigRaw")(function* (filePath, projectFolder) {
   const rawReader = yield* RawConfigReader;
   const validator = yield* SchemaValidator;
   const v4Parser = yield* V4ConfigParser;
@@ -2117,7 +2393,7 @@ var parseConfigRaw = Effect16.fn("parseConfigRaw")(function* (filePath, projectF
   };
   const schema = schemaMap[version];
   if (!schema) {
-    return yield* Effect16.fail(
+    return yield* Effect17.fail(
       new ConfigVersionError({
         message: `Config file at ${filePath} has an unsupported version: ${version}`,
         filePath,
@@ -2128,18 +2404,19 @@ var parseConfigRaw = Effect16.fn("parseConfigRaw")(function* (filePath, projectF
   yield* validator.validate(parsed, schema, filePath);
   return yield* v4Parser.parse(parsed, projectFolder);
 });
-var parseConfig = Effect16.fn("parseConfig")(function* (filePath, projectFolder) {
+var parseConfig = Effect17.fn("parseConfig")(function* (filePath, projectFolder) {
   const parseResult = yield* parseConfigRaw(filePath, projectFolder);
   return yield* postProcessConfig(parseResult, projectFolder);
 });
-var postProcessConfig = Effect16.fn("postProcessConfig")(function* (config, projectFolder) {
+var postProcessConfig = Effect17.fn("postProcessConfig")(function* (config, projectFolder) {
   const vercelParser = yield* VercelBuildOutputParser;
   let result = yield* vercelParser.parse(config, projectFolder);
-  if (result.entrypoints.length === 0 && (result.assets?.paths?.length || 0) === 0 && result.routes.length === 0) {
+  const hasAssets = (result.assets?.paths?.length ?? 0) > 0 || (result.assets?.prefixes?.length ?? 0) > 0 || (result.assets?.manifests?.length ?? 0) > 0;
+  if (result.entrypoints.length === 0 && !hasAssets && result.routes.length === 0) {
     result.errors.push(
       "The current project config does not resolve to any functions, assets or routes and can not be deployed."
     );
-  } else if (result.entrypoints.length === 0 && (result.assets?.paths?.length || 0) === 0) {
+  } else if (result.entrypoints.length === 0 && !hasAssets) {
     result.warnings.push("The current project does not have any functions or assets to deploy.");
   }
   result = filterFunctionsFromAssets(result);
@@ -2161,7 +2438,12 @@ var AVAILABLE_RUNTIMES = [...RUNTIME_DEFINITIONS];
 
 // src/services/index.ts
 import { Layer } from "effect";
-var BaseLayers = Layer.mergeAll(RawConfigReader.Default, SchemaValidator.Default, V4ConfigParser.Default);
+var BaseLayers = Layer.mergeAll(
+  ConfigModuleLoader.Default,
+  RawConfigReader.Default,
+  SchemaValidator.Default,
+  V4ConfigParser.Default
+);
 var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(Layer.provideMerge(BaseLayers));
 export {
   ALLOWED_CONFIG_NAMES,
@@ -2170,12 +2452,22 @@ export {
   ConfigFileEmptyError,
   ConfigFileNotFoundError,
   ConfigFileParseError,
+  ConfigModuleLoadError,
+  ConfigModuleLoader,
   ConfigSchemaValidationError,
   ConfigVersionError,
   DEFAULT_FUNCTION_DURATION_SECONDS,
   FRAMEWORK_DEFINITIONS,
   FrameworkNotDetectedError,
   FunctionConfigError,
+  GigadriveNextBuildManifestSchema,
+  GigadriveNextBuildManifestV1Schema,
+  GigadriveNextBuildManifestV2ExportSchema,
+  GigadriveNextBuildManifestV2StandaloneSchema,
+  GigadriveNextPrerenderManifestV1Schema,
+  GigadriveNextPrerenderOutputSchema,
+  GigadriveNextServerDescriptorSchema,
+  GigadriveNextStaticAssetPrefixSchema,
   MAX_FUNCTION_DURATION_SECONDS,
   ManifestNotFoundError,
   ManifestParseError,
@@ -2183,8 +2475,12 @@ export {
   NetworkConfigLive,
   RawConfigReader,
   SchemaValidator,
+  StaticAssetHeadersSchema,
+  StaticAssetManifestEntrySchema,
+  StaticAssetManifestV1Schema,
   V4ConfigParser,
   VercelBuildOutputParser,
+  defineConfig,
   detectFramework,
   detectPackageManager,
   filterFunctionsFromAssets,
@@ -2194,6 +2490,8 @@ export {
   parseConfig,
   parseConfigRaw,
   parseGigadriveNextBuildManifest,
+  parseGigadriveNextPrerenderManifest,
+  parseStaticAssetManifest,
   postProcessConfig,
   readDependencies
 };