@gigadrive/network-config 4.3.7 → 4.5.0

package/dist/index.mjs

@@ -1,3 +1,60 @@
+// 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/detection/detect-framework.ts
 import { FileSystem as FileSystem8, Path as Path6 } from "@effect/platform";
 import { Effect as Effect10 } from "effect";
@@ -335,54 +392,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 +600,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 +704,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 +737,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 +751,7 @@ var createStandaloneV2Config = Effect5.fn("nextjs.createStandaloneV2Config")(fun
     assetPaths,
     assetOverrides,
     assetPrefixes,
+    assetManifests,
     assetsDir: manifest.distDir,
     assetsPrefixToStrip: "",
     populateAssetCache: true,
@@ -820,12 +1013,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 +1032,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 +1168,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 +1189,41 @@ 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 Schema2.TaggedError()("ConfigFileEmptyError", {
-  message: Schema2.String,
-  filePath: Schema2.String
+var ConfigFileEmptyError = class extends Schema5.TaggedError()("ConfigFileEmptyError", {
+  message: Schema5.String,
+  filePath: Schema5.String
 }) {
 };
-var ConfigFileParseError = class extends Schema2.TaggedError()("ConfigFileParseError", {
-  message: Schema2.String,
-  filePath: Schema2.String,
-  cause: Schema2.optional(Schema2.String)
+var ConfigFileParseError = class extends Schema5.TaggedError()("ConfigFileParseError", {
+  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
 }) {
 };
 
@@ -1199,6 +1394,23 @@ var normalizeImagePolicy = (images) => {
     variants: images.variants ?? {}
   };
 };
+var normalizeServices = (services) => {
+  if (services == null) return void 0;
+  const normalized = [];
+  if (services.redis !== void 0) {
+    normalized.push({ type: "redis", ...services.redis ?? {} });
+  }
+  if (services.postgres !== void 0) {
+    normalized.push({ type: "postgres", ...services.postgres ?? {} });
+  }
+  if (services.storage !== void 0) {
+    normalized.push({
+      type: "storage",
+      buckets: Object.entries(services.storage.buckets).map(([name, bucket]) => ({ name, visibility: bucket?.visibility ?? "private" })).sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0)
+    });
+  }
+  return normalized.length > 0 ? normalized : void 0;
+};
 var normalizeRouteDestination = (destination) => {
   const [withoutHash] = destination.split("#", 1);
   const [withoutQuery] = withoutHash.split("?", 1);
@@ -1362,6 +1574,7 @@ var V4ConfigParser = class extends Effect14.Service()("V4ConfigParser", {
         environmentVariables: config.env ?? {},
         commands: config.build_commands ?? [],
         images: normalizeImagePolicy(config.images),
+        services: normalizeServices(config.services),
         entrypoints,
         errors: [],
         warnings: [],
@@ -1879,7 +2092,8 @@ var schema_default = {
     },
     services: {
       type: "object",
-      description: "Optionally, specify additional services like databases to deploy.",
+      description: "Managed services to provision for the deployment environment.",
+      additionalProperties: false,
       properties: {
         redis: {
           oneOf: [
@@ -1993,6 +2207,39 @@ var schema_default = {
               }
             }
           ]
+        },
+        storage: {
+          type: "object",
+          required: ["buckets"],
+          additionalProperties: false,
+          description: "File Storage buckets to provision in the deployment environment. The environment and global delivery/S3 slug are assigned by the platform.",
+          properties: {
+            buckets: {
+              type: "object",
+              description: "Buckets keyed by immutable environment-scoped name. Use null or an empty object for the default private visibility.",
+              propertyNames: {
+                minLength: 3,
+                maxLength: 63,
+                pattern: "^(?![0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$)[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$"
+              },
+              additionalProperties: {
+                oneOf: [
+                  { type: "null" },
+                  {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                      visibility: {
+                        type: "string",
+                        enum: ["public", "private"],
+                        description: "Bucket access policy. Defaults to private when omitted. Public buckets can serve objects through their CDN hostname."
+                      }
+                    }
+                  }
+                ]
+              }
+            }
+          }
         }
       }
     }
@@ -2083,11 +2330,12 @@ var parseConfig = Effect16.fn("parseConfig")(function* (filePath, projectFolder)
 var postProcessConfig = Effect16.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);
@@ -2124,6 +2372,14 @@ export {
   FRAMEWORK_DEFINITIONS,
   FrameworkNotDetectedError,
   FunctionConfigError,
+  GigadriveNextBuildManifestSchema,
+  GigadriveNextBuildManifestV1Schema,
+  GigadriveNextBuildManifestV2ExportSchema,
+  GigadriveNextBuildManifestV2StandaloneSchema,
+  GigadriveNextPrerenderManifestV1Schema,
+  GigadriveNextPrerenderOutputSchema,
+  GigadriveNextServerDescriptorSchema,
+  GigadriveNextStaticAssetPrefixSchema,
   MAX_FUNCTION_DURATION_SECONDS,
   ManifestNotFoundError,
   ManifestParseError,
@@ -2131,6 +2387,9 @@ export {
   NetworkConfigLive,
   RawConfigReader,
   SchemaValidator,
+  StaticAssetHeadersSchema,
+  StaticAssetManifestEntrySchema,
+  StaticAssetManifestV1Schema,
   V4ConfigParser,
   VercelBuildOutputParser,
   detectFramework,
@@ -2142,6 +2401,8 @@ export {
   parseConfig,
   parseConfigRaw,
   parseGigadriveNextBuildManifest,
+  parseGigadriveNextPrerenderManifest,
+  parseStaticAssetManifest,
   postProcessConfig,
   readDependencies
 };