@gigadrive/network-config 4.6.1 → 5.1.0

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { Schema, Effect, Layer } from 'effect';
-import * as _effect_platform_FileSystem from '@effect/platform/FileSystem';
+import { FileSystem, Path } from '@effect/platform';
 import * as _effect_platform_Path from '@effect/platform/Path';
+import * as _effect_platform_FileSystem from '@effect/platform/FileSystem';
 import * as effect_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>;
@@ -36,6 +36,92 @@ type StaticAssetManifest = StaticAssetManifestV1;
  */
 declare const parseStaticAssetManifest: (content: string) => StaticAssetManifest | undefined;
 
+/**
+ * Lists every publishable file inside a static asset directory.
+ *
+ * Both the `assets:` key of a user config and a framework's `assetsDir` mean
+ * "publish this directory to the edge", and both resolve that declaration into
+ * concrete file paths through this walker.
+ *
+ * @param projectFolder - Absolute path to the project root
+ * @param assetsDir - Project-relative asset directory (e.g. `dist`, `.output/public`)
+ * @returns Sorted forward-slash paths relative to `assetsDir`. Empty when the
+ * directory is missing or is not a directory, so a project that never produced
+ * the expected build output fails config validation instead of the walker.
+ */
+declare const collectAssetFiles: (projectFolder: string, assetsDir: string) => Effect.Effect<string[], never, FileSystem.FileSystem | Path.Path>;
+
+declare const ConfigFileNotFoundError_base: Schema.TaggedErrorClass<ConfigFileNotFoundError, "ConfigFileNotFoundError", {
+    readonly _tag: Schema.tag<"ConfigFileNotFoundError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+}>;
+declare class ConfigFileNotFoundError extends ConfigFileNotFoundError_base {
+}
+declare const ConfigFileEmptyError_base: Schema.TaggedErrorClass<ConfigFileEmptyError, "ConfigFileEmptyError", {
+    readonly _tag: Schema.tag<"ConfigFileEmptyError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+}>;
+declare class ConfigFileEmptyError extends ConfigFileEmptyError_base {
+}
+declare const ConfigFileParseError_base: Schema.TaggedErrorClass<ConfigFileParseError, "ConfigFileParseError", {
+    readonly _tag: Schema.tag<"ConfigFileParseError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.String>;
+}>;
+declare class ConfigFileParseError extends ConfigFileParseError_base {
+}
+declare const 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">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+    version: Schema.optional<typeof Schema.Number>;
+}>;
+declare class ConfigVersionError extends ConfigVersionError_base {
+}
+declare const ConfigSchemaValidationError_base: Schema.TaggedErrorClass<ConfigSchemaValidationError, "ConfigSchemaValidationError", {
+    readonly _tag: Schema.tag<"ConfigSchemaValidationError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+    validationErrors: Schema.Array$<typeof Schema.String>;
+}>;
+declare class ConfigSchemaValidationError extends ConfigSchemaValidationError_base {
+}
+declare const FunctionConfigError_base: Schema.TaggedErrorClass<FunctionConfigError, "FunctionConfigError", {
+    readonly _tag: Schema.tag<"FunctionConfigError">;
+} & {
+    message: typeof Schema.String;
+    functionPath: typeof Schema.String;
+}>;
+declare class FunctionConfigError extends FunctionConfigError_base {
+}
+declare const ContainerConfigError_base: Schema.TaggedErrorClass<ContainerConfigError, "ContainerConfigError", {
+    readonly _tag: Schema.tag<"ContainerConfigError">;
+} & {
+    message: typeof Schema.String;
+    containerName: Schema.optional<typeof Schema.String>;
+    filePath: Schema.optional<typeof Schema.String>;
+}>;
+/** A `containers` entry, or a Compose file imported into one, cannot be deployed as written. */
+declare class ContainerConfigError extends ContainerConfigError_base {
+}
+
 interface NormalizedImageLocalPattern {
     pathname?: string;
     search?: string;
@@ -696,6 +782,15 @@ interface NormalizedConfig {
     routes: Array<NormalizedConfigRoute>;
     /** Managed infrastructure declarations supplied through `gigadrive.yaml`. */
     services?: NormalizedConfigService[];
+    /**
+     * Container images that run inside the microVM of every function instance of
+     * the deployment, next to the function. Each one is reachable from the
+     * function, and from every other sidecar, at `<name>:<port>`.
+     *
+     * Sidecar state belongs to one instance: it is lost when the instance is
+     * retired, and two replicas of a function never share a sidecar.
+     */
+    sidecars?: NormalizedSidecar[];
     /**
      * Settings related to the archive the user uploads to the build workers.
      */
@@ -730,9 +825,9 @@ interface NormalizedConfigService {
     type: NormalizedConfigServiceType;
 }
 /** Service kinds supported by the normalized deployment configuration. */
-type NormalizedConfigServiceType = 'redis' | 'postgres' | 'storage';
+type NormalizedConfigServiceType = 'redis' | 'postgres' | 'storage' | 'queues';
 /** Fully normalized managed-service declaration consumed by provisioning. */
-type NormalizedConfigServiceDefinition = NormalizedConfigServiceRedis | NormalizedConfigServicePostgres | NormalizedConfigServiceStorage;
+type NormalizedConfigServiceDefinition = NormalizedConfigServiceRedis | NormalizedConfigServicePostgres | NormalizedConfigServiceStorage | NormalizedConfigServiceQueues;
 type UpstashAWSRegion = 'us-east-1' | 'us-east-2' | 'us-west-1' | 'us-west-2' | 'eu-central-1' | 'eu-west-1' | 'eu-west-2' | 'sa-east-1' | 'ap-south-1' | 'ap-northeast-1' | 'ap-southeast-1' | 'ap-southeast-2';
 interface NormalizedConfigServiceRedis extends NormalizedConfigService {
     type: 'redis';
@@ -767,14 +862,123 @@ interface NormalizedConfigStorageBucket {
     /** Access policy to apply when the bucket is first provisioned. */
     visibility: 'public' | 'private';
 }
+/**
+ * Declarative queues provisioned in the deployment environment.
+ *
+ * Durations are resolved to seconds and schedule bodies to strings, so the
+ * platform receives one canonical shape. Settings the config omits stay
+ * absent and keep the platform's defaults.
+ */
+interface NormalizedConfigServiceQueues extends NormalizedConfigService {
+    type: 'queues';
+    /** Queues sorted by name for deterministic deployment plans. */
+    queues: NormalizedConfigQueue[];
+}
+/** Desired state for one environment-scoped queue. */
+interface NormalizedConfigQueue {
+    name: string;
+    /** Push consumer path; absent or `null` declares a pull queue. */
+    consumer?: string | null;
+    visibilityTimeoutSeconds?: number;
+    retentionSeconds?: number;
+    maxAttempts?: number;
+    retryBackoffMinSeconds?: number;
+    retryBackoffMaxSeconds?: number;
+    deduplicationWindowSeconds?: number;
+    concurrency?: number | null;
+    rateLimit?: {
+        count: number;
+        periodSeconds: number;
+    } | null;
+    deadLetter?: boolean;
+    /** Schedules sorted by name. */
+    schedules?: NormalizedConfigQueueSchedule[];
+}
+/** One cron schedule that sends into a declared queue. */
+interface NormalizedConfigQueueSchedule {
+    name: string;
+    cron: string;
+    timezone?: string;
+    body?: string;
+    contentType?: string;
+    headers?: Record<string, string>;
+    enabled?: boolean;
+}
 /** Default maximum lifetime of one function invocation, in seconds. */
 declare const DEFAULT_FUNCTION_DURATION_SECONDS = 30;
 /** Maximum configurable lifetime of one function invocation, in seconds (eight hours). */
 declare const MAX_FUNCTION_DURATION_SECONDS = 28800;
+/**
+ * Runtime tag of an entrypoint that runs a container image instead of a
+ * managed language runtime. Such an entrypoint always carries a
+ * {@link NormalizedConfigEntrypoint.container} spec.
+ */
+declare const CONTAINER_RUNTIME = "docker";
+/** Runtime tag of a container entrypoint. */
+type ContainerRuntime = typeof CONTAINER_RUNTIME;
+/**
+ * Prefix of the synthetic `path` a container entrypoint carries. Routes target a
+ * container function with `destination: container:<name>`.
+ */
+declare const CONTAINER_ENTRYPOINT_PREFIX = "container:";
+/** Default memory of a container function, in MB. */
+declare const DEFAULT_CONTAINER_MEMORY_MB = 512;
+/** Default memory of a sidecar, in MB. It is added to the memory of every function it runs next to. */
+declare const DEFAULT_SIDECAR_MEMORY_MB = 256;
+/** Most sidecars one deployment may declare. */
+declare const MAX_SIDECARS = 4;
+/** Where the root filesystem of a container comes from. */
+type NormalizedContainerImageSource = {
+    type: 'registry';
+    /** Image reference as written, e.g. `redis:7-alpine` or `ghcr.io/acme/api@sha256:...`. */
+    reference: string;
+} | {
+    type: 'dockerfile';
+    /** Project-relative build context directory, `.` for the project root. */
+    context: string;
+    /** Dockerfile path relative to {@link context}. */
+    dockerfile: string;
+    /** Build stage to stop at, for multi-stage Dockerfiles. */
+    target?: string;
+    /** `--build-arg` values. */
+    buildArgs?: Record<string, string>;
+};
+/**
+ * A container image plus the settings that override its image config. The
+ * overrides are baked into the signed launch metadata at build time.
+ */
+interface NormalizedContainerSpec {
+    /** Name from the `containers` map. Also the hostname a sidecar answers to. */
+    name: string;
+    source: NormalizedContainerImageSource;
+    /** TCP port the process listens on. Defaults to the image's first exposed port, then 8080. */
+    port?: number;
+    /** Replaces the image `ENTRYPOINT`. */
+    entrypoint?: string[];
+    /** Replaces the image `CMD`. */
+    command?: string[];
+    /** Replaces the image `WORKDIR`. */
+    workingDirectory?: string;
+    /** Replaces the image `USER`: a name, a uid, `name:group` or `uid:gid`. */
+    user?: string;
+    /** Merged over the image `ENV`. */
+    environmentVariables?: Record<string, string>;
+}
+/** A container that runs next to every function instance of the deployment. */
+interface NormalizedSidecar extends NormalizedContainerSpec {
+    /** Memory reserved for the sidecar, in MB. Added to each function's memory. */
+    memory: number;
+}
 interface NormalizedConfigEntrypoint {
     displayName?: string;
+    /**
+     * Project-relative file of the function, or `container:<name>` for a
+     * container function.
+     */
     path: string;
-    runtime: Runtime;
+    runtime: Runtime | ContainerRuntime;
+    /** Image to run, present exactly when {@link runtime} is `docker`. */
+    container?: NormalizedContainerSpec;
     memory: number;
     /**
      * Maximum lifetime of one HTTP request, response stream, or WebSocket connection, in seconds.
@@ -862,67 +1066,6 @@ type NormalizedConfigRouteMatchRequirements = [] | [
     }
 ];
 
-declare const ConfigFileNotFoundError_base: Schema.TaggedErrorClass<ConfigFileNotFoundError, "ConfigFileNotFoundError", {
-    readonly _tag: Schema.tag<"ConfigFileNotFoundError">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-}>;
-declare class ConfigFileNotFoundError extends ConfigFileNotFoundError_base {
-}
-declare const ConfigFileEmptyError_base: Schema.TaggedErrorClass<ConfigFileEmptyError, "ConfigFileEmptyError", {
-    readonly _tag: Schema.tag<"ConfigFileEmptyError">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-}>;
-declare class ConfigFileEmptyError extends ConfigFileEmptyError_base {
-}
-declare const ConfigFileParseError_base: Schema.TaggedErrorClass<ConfigFileParseError, "ConfigFileParseError", {
-    readonly _tag: Schema.tag<"ConfigFileParseError">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-    cause: Schema.optional<typeof Schema.String>;
-}>;
-declare class ConfigFileParseError extends ConfigFileParseError_base {
-}
-declare const 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">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-    version: Schema.optional<typeof Schema.Number>;
-}>;
-declare class ConfigVersionError extends ConfigVersionError_base {
-}
-declare const ConfigSchemaValidationError_base: Schema.TaggedErrorClass<ConfigSchemaValidationError, "ConfigSchemaValidationError", {
-    readonly _tag: Schema.tag<"ConfigSchemaValidationError">;
-} & {
-    message: typeof Schema.String;
-    filePath: typeof Schema.String;
-    validationErrors: Schema.Array$<typeof Schema.String>;
-}>;
-declare class ConfigSchemaValidationError extends ConfigSchemaValidationError_base {
-}
-declare const FunctionConfigError_base: Schema.TaggedErrorClass<FunctionConfigError, "FunctionConfigError", {
-    readonly _tag: Schema.tag<"FunctionConfigError">;
-} & {
-    message: typeof Schema.String;
-    functionPath: typeof Schema.String;
-}>;
-declare class FunctionConfigError extends FunctionConfigError_base {
-}
-
 declare const ConfigModuleLoader_base: Effect.Service.Class<ConfigModuleLoader, "ConfigModuleLoader", {
     readonly effect: Effect.Effect<{
         loadConfigModule: (filePath: string) => Effect.Effect<Record<string, unknown>, ConfigModuleLoadError, never>;
@@ -940,7 +1083,7 @@ declare const RawConfigReader_base: Effect.Service.Class<RawConfigReader, "RawCo
             disableVersionCheck?: boolean;
         } | 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>;
+    }, never, FileSystem.FileSystem | Path.Path | ConfigModuleLoader>;
 }>;
 declare class RawConfigReader extends RawConfigReader_base {
 }
@@ -970,6 +1113,11 @@ declare const V4ConfigParser_base: Effect.Service.Class<V4ConfigParser, "V4Confi
          * @param projectFolder - Absolute path to the project root
          */
         parse: (config: ConfigV4, projectFolder: string) => Effect.Effect<{
+            entrypoints: NormalizedConfigEntrypoint[];
+            errors: never[];
+            warnings: string[];
+            routes: NormalizedConfigRoute[];
+            sidecars?: NormalizedSidecar[] | undefined;
             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[];
@@ -981,11 +1129,7 @@ declare const V4ConfigParser_base: Effect.Service.Class<V4ConfigParser, "V4Confi
             commands: string[];
             images: NormalizedImagePolicy | undefined;
             services: NormalizedConfigServiceDefinition[] | undefined;
-            entrypoints: NormalizedConfigEntrypoint[];
-            errors: never[];
-            warnings: never[];
-            routes: NormalizedConfigRoute[];
-        }, FunctionConfigError, Path.Path | FileSystem.FileSystem>;
+        }, FunctionConfigError | ContainerConfigError, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path>;
     }, never, never>;
 }>;
 declare class V4ConfigParser extends V4ConfigParser_base {
@@ -993,8 +1137,8 @@ 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>;
+        parse: (parseResult: NormalizedConfig, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileEmptyError | ConfigFileParseError | ConfigModuleLoadError | ConfigVersionError, _effect_platform_FileSystem.FileSystem | Path.Path>;
+    }, never, Path.Path | RawConfigReader>;
 }>;
 declare class VercelBuildOutputParser extends VercelBuildOutputParser_base {
 }
@@ -1014,6 +1158,11 @@ interface Config {
  * @param projectFolder - Absolute path to the project root
  */
 declare const parseConfigRaw: (filePath: string, projectFolder: string) => Effect.Effect<{
+    entrypoints: NormalizedConfigEntrypoint[];
+    errors: never[];
+    warnings: string[];
+    routes: NormalizedConfigRoute[];
+    sidecars?: NormalizedSidecar[] | undefined;
     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[];
@@ -1025,11 +1174,7 @@ declare const parseConfigRaw: (filePath: string, projectFolder: string) => Effec
     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>;
+}, ConfigFileNotFoundError | ConfigFileEmptyError | ConfigFileParseError | ConfigModuleLoadError | ConfigVersionError | ConfigSchemaValidationError | FunctionConfigError | ContainerConfigError, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path | RawConfigReader | 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.
@@ -1037,7 +1182,7 @@ declare const parseConfigRaw: (filePath: string, projectFolder: string) => Effec
  * @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>;
+declare const parseConfig: (filePath: string, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileNotFoundError | ConfigFileEmptyError | ConfigFileParseError | ConfigModuleLoadError | ConfigVersionError | ConfigSchemaValidationError | FunctionConfigError | ContainerConfigError, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path | RawConfigReader | SchemaValidator | V4ConfigParser | VercelBuildOutputParser>;
 /**
  * Applies post-processing transformers to a NormalizedConfig:
  * - Vercel Build Output v3 (merges functions/routes from .vercel/output if present)
@@ -1048,7 +1193,7 @@ declare const parseConfig: (filePath: string, projectFolder: string) => Effect.E
  * @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>;
+declare const postProcessConfig: (config: NormalizedConfig, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileEmptyError | ConfigFileParseError | ConfigModuleLoadError | ConfigVersionError, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path | VercelBuildOutputParser>;
 
 interface ConfigV4 extends Config {
     version: 4;
@@ -1134,6 +1279,75 @@ interface ConfigV4 extends Config {
     env?: Record<string, string>;
     /** Declares managed services to provision for the deployment environment. */
     services?: ConfigV4Services;
+    /**
+     * Container images to run, keyed by name. A container without `sidecar: true`
+     * runs as a function that routes target with `destination: container:<name>`.
+     * A sidecar runs next to every function instance and answers at `<name>:<port>`.
+     * A name is 1 to 63 lowercase letters, digits, `-` or `_`, starts with a
+     * letter (so it never reads as an IP address), and is not `localhost`.
+     *
+     * @example
+     * ```yaml
+     * containers:
+     *   web:
+     *     build: .
+     *     port: 3000
+     *   redis:
+     *     image: redis:7-alpine
+     *     sidecar: true
+     * ```
+     */
+    containers?: Record<string, ConfigV4Container> | null;
+    /**
+     * Project-relative path of a Compose file whose services are imported as
+     * `containers`. Entries in `containers` win over imported services of the
+     * same name.
+     */
+    compose?: string | null;
+}
+/** One entry of the v4 `containers` map. Exactly one of `image` and `build` is required. */
+interface ConfigV4Container {
+    /** Registry image reference, e.g. `redis:7-alpine` or `ghcr.io/acme/api:1.4`. */
+    image?: string;
+    /** Build context directory, or the full build settings, for a Dockerfile in the repository. */
+    build?: string | ConfigV4ContainerBuild;
+    /** Run next to every function instance instead of serving routes. Defaults to `false`. */
+    sidecar?: boolean;
+    /** TCP port the container listens on. Defaults to the image's first exposed port, then 8080. */
+    port?: number;
+    /** Replaces the image `ENTRYPOINT`. A string is split into words the way Compose splits it. */
+    entrypoint?: string | string[];
+    /** Replaces the image `CMD`. A string is split into words the way Compose splits it. */
+    command?: string | string[];
+    /** Environment variables baked into the container, merged over the image `ENV`. */
+    env?: Record<string, string>;
+    /** Replaces the image `WORKDIR`. Must be absolute. */
+    working_dir?: string;
+    /**
+     * Replaces the image `USER`: a name, a uid, `name:group` or `uid:gid`. A bare
+     * uid may be written as a number. Root is never used: a root image runs as a
+     * dedicated non-root user.
+     */
+    user?: string | number;
+    /** Memory in MB, a whole number from 128 to 3009. Defaults to 512 for a container function and 256 for a sidecar. */
+    memory?: number;
+    /** Maximum lifetime of one request, in seconds. Container functions only. */
+    max_duration?: number;
+    /** Stream responses. Defaults to `true`. Container functions only. */
+    streaming?: boolean;
+    /** Run on a timer, like a function `schedule`. Container functions only. */
+    schedule?: string;
+}
+/** Dockerfile build settings for a container. */
+interface ConfigV4ContainerBuild {
+    /** Project-relative build context. Defaults to `.`. */
+    context?: string;
+    /** Dockerfile path relative to the context. Defaults to `Dockerfile`. */
+    dockerfile?: string;
+    /** Build stage to stop at. */
+    target?: string;
+    /** Build arguments. */
+    args?: Record<string, string>;
 }
 interface ConfigV4Service {
 }
@@ -1181,6 +1395,75 @@ interface ConfigV4Services {
     postgres?: ConfigV4ServicePostgres | null;
     /** Declarative File Storage buckets for the deployment environment. */
     storage?: ConfigV4ServiceStorage;
+    /**
+     * Queues for the deployment environment, keyed by name. `null` declares a
+     * pull queue with default settings.
+     *
+     * @example
+     * ```yaml
+     * services:
+     *   queues:
+     *     emails:
+     *       consumer: /api/queues/emails
+     *       maxAttempts: 5
+     *       schedules:
+     *         daily-digest:
+     *           cron: '0 8 * * MON-FRI'
+     *           timezone: Europe/Berlin
+     *           body: { kind: digest }
+     *     jobs: null
+     * ```
+     */
+    queues?: Record<string, ConfigV4Queue | null>;
+}
+/** A duration in seconds, or a string such as `30s`, `10m`, `1.5h` or `4d`. */
+type ConfigV4QueueDuration = number | `${number}${'s' | 'm' | 'h' | 'd'}`;
+/** Settings for a declaratively provisioned queue. Omitted settings keep the platform defaults. */
+interface ConfigV4Queue {
+    /**
+     * Deployment-relative path that receives each message as a signed POST, for
+     * example `/api/queues/emails`. Omit it for a pull queue.
+     */
+    consumer?: string | null;
+    /** How long a push delivery may run, or how long a received message stays leased. Defaults to 60 seconds. */
+    visibilityTimeout?: ConfigV4QueueDuration;
+    /** How long an undelivered message is kept. Defaults to 4 days, at most 14 days. */
+    retention?: ConfigV4QueueDuration;
+    /** Deliveries per message before it moves to the dead-letter list. Defaults to 10. */
+    maxAttempts?: number;
+    /** Exponential backoff between failed deliveries. Defaults to 5 seconds up to 15 minutes. */
+    retryBackoff?: {
+        min?: ConfigV4QueueDuration;
+        max?: ConfigV4QueueDuration;
+    };
+    /** How long a deduplication key is remembered. Defaults to 24 hours. */
+    deduplicationWindow?: ConfigV4QueueDuration;
+    /** Most push deliveries in flight at once. Defaults to 100. */
+    concurrency?: number | null;
+    /** Most deliveries started per period. The period defaults to one second. */
+    rateLimit?: {
+        count: number;
+        period?: ConfigV4QueueDuration;
+    } | null;
+    /** Keep messages that run out of attempts for inspection and redrive. Defaults to `true`. */
+    deadLetter?: boolean;
+    /** Cron schedules that send a message into this queue, keyed by schedule name. */
+    schedules?: Record<string, ConfigV4QueueSchedule>;
+}
+/** A recurring send into a queue. */
+interface ConfigV4QueueSchedule {
+    /** Five-field cron expression, or a macro such as `@hourly`. */
+    cron: string;
+    /** IANA time zone the expression is evaluated in. Defaults to `UTC`. */
+    timezone?: string;
+    /** Message body. Strings are sent as is; any other value is serialized as JSON. */
+    body?: unknown;
+    /** Content type of the body. Defaults to `text/plain` for a string body and `application/json` otherwise. */
+    contentType?: string;
+    /** Headers delivered with every message from this schedule. */
+    headers?: Record<string, string>;
+    /** Set to `false` to keep the schedule without sending. Defaults to `true`. */
+    enabled?: boolean;
 }
 /** Declarative File Storage configuration for one deployment environment. */
 interface ConfigV4ServiceStorage extends ConfigV4Service {
@@ -1222,9 +1505,17 @@ interface ConfigV4FunctionSettings {
      */
     max_duration?: number;
     /**
-     * The runtime to use for the function.
+     * The runtime to use for the function. `docker` builds the matched file as a
+     * Dockerfile, with its directory as the build context, and runs the image as
+     * the function. Routes target it by the Dockerfile's path, like any other
+     * function file.
+     */
+    runtime?: Runtime | ContainerRuntime;
+    /**
+     * TCP port the image listens on. Only for `runtime: docker`. Defaults to the
+     * image's first exposed port, then 8080.
      */
-    runtime?: Runtime;
+    port?: number;
     /**
      * Enable function response streaming. When omitted, Node and Bun runtimes stream by default.
      */
@@ -1252,6 +1543,98 @@ interface ConfigV4FunctionSettings {
     schedule?: string;
 }
 
+/** Compose file names, in the order `docker compose` looks for them. */
+declare const COMPOSE_FILE_NAMES: readonly ["compose.yaml", "compose.yml", "docker-compose.yaml", "docker-compose.yml"];
+/**
+ * Returns the synthetic entrypoint path of a container function, which routes
+ * use as their `destination`.
+ *
+ * @example
+ * ```ts
+ * containerEntrypointPath('web'); // 'container:web'
+ * ```
+ */
+declare const containerEntrypointPath: (name: string) => string;
+/**
+ * Derives the container name of a `functions` entry that runs a Dockerfile
+ * (`runtime: docker`): the directory the Dockerfile sits in, plus any suffix
+ * or prefix around `Dockerfile` in its file name. A root `Dockerfile` is `app`,
+ * and a name that would not start with a letter gets an `app-` prefix.
+ *
+ * @param file - Project-relative path of the Dockerfile
+ * @returns A valid container name
+ * @example
+ * ```ts
+ * dockerFunctionContainerName('Dockerfile'); // 'app'
+ * dockerFunctionContainerName('services/api/Dockerfile'); // 'api'
+ * dockerFunctionContainerName('docker/worker.Dockerfile'); // 'docker-worker'
+ * dockerFunctionContainerName('services/1/Dockerfile'); // 'app-1'
+ * ```
+ */
+declare const dockerFunctionContainerName: (file: string) => string;
+/**
+ * Splits a command string into words the way Compose does: whitespace
+ * separates words, single and double quotes group them, and a backslash
+ * escapes the next character outside single quotes. No shell runs.
+ *
+ * @param input - Command as written, e.g. `redis-server --save ""`
+ * @returns The argv words
+ * @throws Error when a quote is left open
+ * @example
+ * ```ts
+ * splitCommandWords('sh -c "echo hi"'); // ['sh', '-c', 'echo hi']
+ * ```
+ */
+declare const splitCommandWords: (input: string) => string[];
+/**
+ * Turns the `containers` map into container-function entrypoints and sidecars.
+ *
+ * Validates names, the bounds the v4 schema sets (so Compose-imported entries
+ * fail as early as written ones), the sidecar count, and explicitly declared
+ * ports that would collide inside one microVM. Ports an image only exposes are
+ * checked later, once the image config is known.
+ *
+ * @param containers - The `containers` map, after any Compose import
+ * @param projectFolder - Absolute path to the project root
+ */
+declare const normalizeContainers: (containers: Readonly<Record<string, ConfigV4Container>>, projectFolder: string) => Effect.Effect<{
+    entrypoints: NormalizedConfigEntrypoint[];
+    sidecars: NormalizedSidecar[];
+    warnings: string[];
+}, ContainerConfigError, FileSystem.FileSystem | Path.Path>;
+/**
+ * Tells whether a Compose file names an application to deploy: a service
+ * marked `x-gigadrive: { public: true }`, or one that builds from source.
+ * Auto-detection skips a Compose file without one, such as one that only runs
+ * a database for local development.
+ *
+ * @param composePath - Project-relative path of the Compose file
+ * @param projectFolder - Absolute path to the project root
+ */
+declare const composeDeclaresApp: (composePath: string, projectFolder: string) => Effect.Effect<boolean, ContainerConfigError, FileSystem.FileSystem | Path.Path>;
+/**
+ * Reads a Compose file and maps its services onto `containers` entries.
+ *
+ * The container function is the service marked `x-gigadrive: { public: true }`,
+ * or else the only service that builds from source; anything else is
+ * ambiguous and fails. Every other service becomes a sidecar that the function
+ * reaches by its service name, the way Compose's default network resolves it.
+ * Services behind a profile are skipped, as `docker compose up` skips them.
+ * Volumes, networks, health checks and restart policies have no equivalent and
+ * are dropped; volumes, `extends` and override files are reported.
+ *
+ * Every file read (the Compose file, `.env`, `env_file`) must resolve inside
+ * the project after following symbolic links.
+ *
+ * @param composePath - Project-relative path of the Compose file
+ * @param projectFolder - Absolute path to the project root
+ */
+declare const readComposeContainers: (composePath: string, projectFolder: string) => Effect.Effect<{
+    containers: Record<string, ConfigV4Container>;
+    publicService: string;
+    warnings: string[];
+}, ContainerConfigError, FileSystem.FileSystem | Path.Path>;
+
 /**
  * Identity helper providing type inference and checking for `gigadrive.ts`
  * config files. Using it is optional — a plain object default export works the
@@ -1282,6 +1665,36 @@ interface ConfigV4FunctionSettings {
  */
 declare const defineConfig: (config: ConfigV4) => ConfigV4;
 
+/** How a container project was recognized. */
+interface ContainerProjectDetection {
+    /** `compose` for a Compose file, `dockerfile` for a lone root `Dockerfile`. */
+    kind: 'compose' | 'dockerfile';
+    /** Project-relative file the configuration came from. */
+    file: string;
+    /** Deployable configuration: one container function behind a catch-all route, plus any sidecars. */
+    config: NormalizedConfig;
+}
+/**
+ * Recognizes a project that ships as container images: a Compose file first,
+ * then a `Dockerfile` at the project root.
+ *
+ * Callers try this only after finding neither a `gigadrive.yaml` nor a
+ * framework. A framework project often carries a Compose file for local
+ * databases, and deploying that file instead of the framework would change
+ * what an existing project deploys. For the same reason a Compose file counts
+ * only when it names an application: a service that builds from source or is
+ * marked `x-gigadrive: { public: true }`. One that only runs, say, a database
+ * for local development is ignored, and the root `Dockerfile` check follows.
+ *
+ * @param projectFolder - Absolute path to the project root
+ * @returns The detection, or `undefined` when the project has neither file
+ */
+declare const detectContainerProject: (projectFolder: string) => Effect.Effect<{
+    kind: "dockerfile" | "compose";
+    file: string;
+    config: NormalizedConfig;
+} | undefined, ContainerConfigError, FileSystem.FileSystem | Path.Path>;
+
 declare const ManifestNotFoundError_base: Schema.TaggedErrorClass<ManifestNotFoundError, "ManifestNotFoundError", {
     readonly _tag: Schema.tag<"ManifestNotFoundError">;
 } & {
@@ -1408,7 +1821,7 @@ declare const detectFramework: (projectFolder: string) => Effect.Effect<{
     framework: FrameworkDefinition;
     packageManager: PackageManager;
     config: NormalizedConfig;
-}, ManifestReadError | ManifestParseError | FrameworkNotDetectedError, Path.Path | FileSystem.FileSystem>;
+}, ManifestReadError | ManifestParseError | FrameworkNotDetectedError, FileSystem.FileSystem | Path.Path>;
 
 /**
  * Detects the package manager by checking for lockfiles in the project folder.
@@ -1417,7 +1830,7 @@ declare const detectFramework: (projectFolder: string) => Effect.Effect<{
  * @param projectFolder - Absolute path to the project root
  * @returns The detected package manager
  */
-declare const detectPackageManager: (projectFolder: string) => Effect.Effect<PackageManager, never, Path.Path | FileSystem.FileSystem>;
+declare const detectPackageManager: (projectFolder: string) => Effect.Effect<PackageManager, never, FileSystem.FileSystem | Path.Path>;
 
 /**
  * All supported framework definitions, sorted by priority descending.
@@ -1429,24 +1842,33 @@ 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.
  *
+ * Runs after the customer build, so a framework's `assetsDir` is resolved
+ * against real build output.
+ *
  * @param framework - The detected framework definition
  * @param packageManager - The detected package manager
+ * @param projectFolder - Absolute path to the project root, used to enumerate `assetsDir`
  * @returns A complete NormalizedConfig with framework defaults
  */
-declare const generateConfig: (framework: FrameworkDefinition, packageManager: PackageManager, refinedDefaults?: FrameworkDefaultConfig | undefined) => Effect.Effect<NormalizedConfig, never, never>;
+declare const generateConfig: (framework: FrameworkDefinition, packageManager: PackageManager, projectFolder: string, refinedDefaults?: FrameworkDefaultConfig | undefined) => Effect.Effect<NormalizedConfig, never, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path>;
 
 /**
  * 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
+ * - entrypoints: use user's if non-empty, otherwise framework's. Container
+ *   functions (`runtime: docker`) do not count: they are always kept, next to
+ *   whichever file functions win, because a framework never declares them.
+ * - routes: use user's if any of them targets something other than a container
+ *   function, otherwise the framework's, preceded by the user's routes to
+ *   container functions so that e.g. `/api/*` wins over a framework catch-all.
  * - 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)
+ * - sidecars: always use user's (frameworks don't define sidecars)
  * - warnings/errors: concatenate both
  *
  * @param userConfig - The config parsed from the user's config file
@@ -1468,7 +1890,7 @@ declare const mergeWithFrameworkDefaults: (userConfig: NormalizedConfig, framewo
  * @param language - The framework language to determine which manifest to read
  * @returns A set of dependency package names
  */
-declare const readDependencies: (projectFolder: string, language: FrameworkLanguage) => Effect.Effect<Set<string>, ManifestReadError | ManifestParseError, Path.Path | FileSystem.FileSystem>;
+declare const readDependencies: (projectFolder: string, language: FrameworkLanguage) => Effect.Effect<Set<string>, ManifestReadError | ManifestParseError, FileSystem.FileSystem | Path.Path>;
 
 /**
  * Ensure a normalized config has no function files that are also defined as assets.
@@ -1478,6 +1900,6 @@ declare const readDependencies: (projectFolder: string, language: FrameworkLangu
  */
 declare const filterFunctionsFromAssets: (config: NormalizedConfig) => NormalizedConfig;
 
-declare const NetworkConfigLive: Layer.Layer<ConfigModuleLoader | RawConfigReader | SchemaValidator | V4ConfigParser | VercelBuildOutputParser, never, _effect_platform_Path.Path | _effect_platform_FileSystem.FileSystem>;
+declare const NetworkConfigLive: Layer.Layer<ConfigModuleLoader | RawConfigReader | SchemaValidator | V4ConfigParser | VercelBuildOutputParser, never, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path>;
 
-export { ALLOWED_CONFIG_NAMES, AVAILABLE_REGIONS, AVAILABLE_RUNTIMES, type Config, ConfigFileEmptyError, ConfigFileNotFoundError, ConfigFileParseError, ConfigModuleLoadError, ConfigModuleLoader, ConfigSchemaValidationError, type ConfigV4, type ConfigV4FunctionSettings, type ConfigV4Service, type ConfigV4ServicePostgres, type ConfigV4ServiceRedis, type ConfigV4ServiceStorage, type ConfigV4Services, type ConfigV4StorageBucket, ConfigVersionError, DEFAULT_FUNCTION_DURATION_SECONDS, type DetectionResult, FRAMEWORK_DEFINITIONS, type FilePathMap, type FrameworkDefaultConfig, type FrameworkDefinition, type FrameworkDetectionItem, type FrameworkLanguage, FrameworkNotDetectedError, FunctionConfigError, type GigadriveNextBuildManifest, GigadriveNextBuildManifestSchema, type GigadriveNextBuildManifestV1, GigadriveNextBuildManifestV1Schema, type GigadriveNextBuildManifestV2, type GigadriveNextBuildManifestV2Export, GigadriveNextBuildManifestV2ExportSchema, type GigadriveNextBuildManifestV2Standalone, GigadriveNextBuildManifestV2StandaloneSchema, type GigadriveNextMiddlewareDescriptor, GigadriveNextMiddlewareDescriptorSchema, type GigadriveNextMiddlewareMatcher, GigadriveNextMiddlewareMatcherSchema, type GigadriveNextPrerenderManifestV1, GigadriveNextPrerenderManifestV1Schema, type GigadriveNextPrerenderOutput, GigadriveNextPrerenderOutputSchema, type GigadriveNextPrerenderSeedMethods, GigadriveNextPrerenderSeedMethodsSchema, type GigadriveNextRouteCondition, GigadriveNextRouteConditionSchema, type GigadriveNextServerDescriptor, GigadriveNextServerDescriptorSchema, type GigadriveNextStaticAssetPrefix, GigadriveNextStaticAssetPrefixSchema, type JsonValue, MAX_FUNCTION_DURATION_SECONDS, ManifestNotFoundError, ManifestParseError, ManifestReadError, type NeonAWSRegion, NetworkConfigLive, type NormalizedConfig, type NormalizedConfigEntrypoint, type NormalizedConfigRoute, type NormalizedConfigRouteHandler, type NormalizedConfigRouteMatchRequirements, type NormalizedConfigRouteMethod, type NormalizedConfigService, type NormalizedConfigServiceDefinition, type NormalizedConfigServicePostgres, type NormalizedConfigServiceRedis, type NormalizedConfigServiceStorage, type NormalizedConfigServiceType, type NormalizedConfigStorageBucket, type NormalizedFramework, type NormalizedImageFit, type NormalizedImageFormat, type NormalizedImageLocalPattern, type NormalizedImagePolicy, type NormalizedImageRemotePattern, type NormalizedImageVariant, type NormalizedNextjsFramework, type NormalizedSharedArtifact, type PackageManager, RawConfigReader, type Region, type Runtime, SchemaValidator, type StaticAssetHeaders, StaticAssetHeadersSchema, type StaticAssetManifest, type StaticAssetManifestEntry, StaticAssetManifestEntrySchema, type StaticAssetManifestV1, StaticAssetManifestV1Schema, type UpstashAWSRegion, V4ConfigParser, VercelBuildOutputParser, defineConfig, detectFramework, detectPackageManager, filterFunctionsFromAssets, generateConfig, getFunctionSettings, mergeWithFrameworkDefaults, parseConfig, parseConfigRaw, parseGigadriveNextBuildManifest, parseGigadriveNextPrerenderManifest, parseStaticAssetManifest, postProcessConfig, readDependencies };
+export { ALLOWED_CONFIG_NAMES, AVAILABLE_REGIONS, AVAILABLE_RUNTIMES, COMPOSE_FILE_NAMES, CONTAINER_ENTRYPOINT_PREFIX, CONTAINER_RUNTIME, type Config, ConfigFileEmptyError, ConfigFileNotFoundError, ConfigFileParseError, ConfigModuleLoadError, ConfigModuleLoader, ConfigSchemaValidationError, type ConfigV4, type ConfigV4Container, type ConfigV4ContainerBuild, type ConfigV4FunctionSettings, type ConfigV4Queue, type ConfigV4QueueDuration, type ConfigV4QueueSchedule, type ConfigV4Service, type ConfigV4ServicePostgres, type ConfigV4ServiceRedis, type ConfigV4ServiceStorage, type ConfigV4Services, type ConfigV4StorageBucket, ConfigVersionError, ContainerConfigError, type ContainerProjectDetection, type ContainerRuntime, DEFAULT_CONTAINER_MEMORY_MB, DEFAULT_FUNCTION_DURATION_SECONDS, DEFAULT_SIDECAR_MEMORY_MB, type DetectionResult, FRAMEWORK_DEFINITIONS, type FilePathMap, type FrameworkDefaultConfig, type FrameworkDefinition, type FrameworkDetectionItem, type FrameworkLanguage, FrameworkNotDetectedError, FunctionConfigError, type GigadriveNextBuildManifest, GigadriveNextBuildManifestSchema, type GigadriveNextBuildManifestV1, GigadriveNextBuildManifestV1Schema, type GigadriveNextBuildManifestV2, type GigadriveNextBuildManifestV2Export, GigadriveNextBuildManifestV2ExportSchema, type GigadriveNextBuildManifestV2Standalone, GigadriveNextBuildManifestV2StandaloneSchema, type GigadriveNextMiddlewareDescriptor, GigadriveNextMiddlewareDescriptorSchema, type GigadriveNextMiddlewareMatcher, GigadriveNextMiddlewareMatcherSchema, type GigadriveNextPrerenderManifestV1, GigadriveNextPrerenderManifestV1Schema, type GigadriveNextPrerenderOutput, GigadriveNextPrerenderOutputSchema, type GigadriveNextPrerenderSeedMethods, GigadriveNextPrerenderSeedMethodsSchema, type GigadriveNextRouteCondition, GigadriveNextRouteConditionSchema, type GigadriveNextServerDescriptor, GigadriveNextServerDescriptorSchema, type GigadriveNextStaticAssetPrefix, GigadriveNextStaticAssetPrefixSchema, type JsonValue, MAX_FUNCTION_DURATION_SECONDS, MAX_SIDECARS, ManifestNotFoundError, ManifestParseError, ManifestReadError, type NeonAWSRegion, NetworkConfigLive, type NormalizedConfig, type NormalizedConfigEntrypoint, type NormalizedConfigQueue, type NormalizedConfigQueueSchedule, type NormalizedConfigRoute, type NormalizedConfigRouteHandler, type NormalizedConfigRouteMatchRequirements, type NormalizedConfigRouteMethod, type NormalizedConfigService, type NormalizedConfigServiceDefinition, type NormalizedConfigServicePostgres, type NormalizedConfigServiceQueues, type NormalizedConfigServiceRedis, type NormalizedConfigServiceStorage, type NormalizedConfigServiceType, type NormalizedConfigStorageBucket, type NormalizedContainerImageSource, type NormalizedContainerSpec, type NormalizedFramework, type NormalizedImageFit, type NormalizedImageFormat, type NormalizedImageLocalPattern, type NormalizedImagePolicy, type NormalizedImageRemotePattern, type NormalizedImageVariant, type NormalizedNextjsFramework, type NormalizedSharedArtifact, type NormalizedSidecar, type PackageManager, RawConfigReader, type Region, type Runtime, SchemaValidator, type StaticAssetHeaders, StaticAssetHeadersSchema, type StaticAssetManifest, type StaticAssetManifestEntry, StaticAssetManifestEntrySchema, type StaticAssetManifestV1, StaticAssetManifestV1Schema, type UpstashAWSRegion, V4ConfigParser, VercelBuildOutputParser, collectAssetFiles, composeDeclaresApp, containerEntrypointPath, defineConfig, detectContainerProject, detectFramework, detectPackageManager, dockerFunctionContainerName, filterFunctionsFromAssets, generateConfig, getFunctionSettings, mergeWithFrameworkDefaults, normalizeContainers, parseConfig, parseConfigRaw, parseGigadriveNextBuildManifest, parseGigadriveNextPrerenderManifest, parseStaticAssetManifest, postProcessConfig, readComposeContainers, readDependencies, splitCommandWords };