@gigadrive/network-config 5.0.0 → 5.1.0

package/dist/index.mjs

@@ -93,16 +93,824 @@ var collectAssetFiles = Effect.fn("collectAssetFiles")(function* (projectFolder,
   return files.map((file) => file.replaceAll("\\", "/")).filter((file) => !DISALLOWED_ASSET_EXTENSIONS.some((extension) => file.toLowerCase().endsWith(extension))).sort();
 });
 
+// src/containers.ts
+import { FileSystem as FileSystem2, Path as Path2 } from "@effect/platform";
+import { Effect as Effect2, Option as Option2 } from "effect";
+import { posix } from "path";
+import { parse as parseYaml, YAMLError } from "yaml";
+
+// src/errors.ts
+import { Schema as Schema3 } from "effect";
+var ConfigFileNotFoundError = class extends Schema3.TaggedError()("ConfigFileNotFoundError", {
+  message: Schema3.String,
+  filePath: Schema3.String
+}) {
+};
+var ConfigFileEmptyError = class extends Schema3.TaggedError()("ConfigFileEmptyError", {
+  message: Schema3.String,
+  filePath: Schema3.String
+}) {
+};
+var ConfigFileParseError = class extends Schema3.TaggedError()("ConfigFileParseError", {
+  message: Schema3.String,
+  filePath: Schema3.String,
+  cause: Schema3.optional(Schema3.String)
+}) {
+};
+var ConfigModuleLoadError = class extends Schema3.TaggedError()("ConfigModuleLoadError", {
+  message: Schema3.String,
+  filePath: Schema3.String,
+  cause: Schema3.optional(Schema3.String)
+}) {
+};
+var ConfigVersionError = class extends Schema3.TaggedError()("ConfigVersionError", {
+  message: Schema3.String,
+  filePath: Schema3.String,
+  version: Schema3.optional(Schema3.Number)
+}) {
+};
+var ConfigSchemaValidationError = class extends Schema3.TaggedError()(
+  "ConfigSchemaValidationError",
+  {
+    message: Schema3.String,
+    filePath: Schema3.String,
+    validationErrors: Schema3.Array(Schema3.String)
+  }
+) {
+};
+var FunctionConfigError = class extends Schema3.TaggedError()("FunctionConfigError", {
+  message: Schema3.String,
+  functionPath: Schema3.String
+}) {
+};
+var ContainerConfigError = class extends Schema3.TaggedError()("ContainerConfigError", {
+  message: Schema3.String,
+  containerName: Schema3.optional(Schema3.String),
+  filePath: Schema3.optional(Schema3.String)
+}) {
+};
+
+// src/normalized-config.ts
+var DEFAULT_FUNCTION_DURATION_SECONDS = 30;
+var MAX_FUNCTION_DURATION_SECONDS = 28800;
+var CONTAINER_RUNTIME = "docker";
+var CONTAINER_ENTRYPOINT_PREFIX = "container:";
+var DEFAULT_CONTAINER_MEMORY_MB = 512;
+var DEFAULT_SIDECAR_MEMORY_MB = 256;
+var MAX_SIDECARS = 4;
+
+// src/containers.ts
+var COMPOSE_FILE_NAMES = ["compose.yaml", "compose.yml", "docker-compose.yaml", "docker-compose.yml"];
+var CONTAINER_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,62}$/;
+var CONTAINER_NAME_RULES = "1 to 63 lowercase letters, digits, '-' or '_', starting with a letter, and not 'localhost'";
+var MIN_CONTAINER_MEMORY_MB = 128;
+var MAX_CONTAINER_MEMORY_MB = 3009;
+var MAX_CONTAINER_ENV_VARS = 100;
+var MAX_CONTAINER_ENV_VALUE_LENGTH = 65536;
+var containerEntrypointPath = (name) => `${CONTAINER_ENTRYPOINT_PREFIX}${name}`;
+var toContainerName = (raw) => {
+  const cleaned = raw.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^[^a-z0-9]+/, "");
+  const name = (cleaned === "" || /^[a-z]/.test(cleaned) ? cleaned : `app-${cleaned}`).slice(0, 63);
+  return name === "" || name === "localhost" ? "app" : name;
+};
+var dockerFunctionContainerName = (file) => {
+  const { dir, base } = posix.parse(file);
+  const variant = base.replace(/^Dockerfile[.-]?/i, "").replace(/[.-]?Dockerfile$/i, "");
+  const raw = [posix.basename(dir), variant === base ? posix.parse(base).name : variant].filter((part) => part !== "").join("-");
+  return toContainerName(raw);
+};
+var splitCommandWords = (input) => {
+  const words = [];
+  let current = "";
+  let inWord = false;
+  let quote;
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    if (quote === "'") {
+      if (char === "'") quote = void 0;
+      else current += char;
+    } else if (char === "\\" && index + 1 < input.length) {
+      index += 1;
+      current += input[index];
+      inWord = true;
+    } else if (quote === '"') {
+      if (char === '"') quote = void 0;
+      else current += char;
+    } else if (char === "'" || char === '"') {
+      quote = char;
+      inWord = true;
+    } else if (/\s/.test(char)) {
+      if (inWord) words.push(current);
+      current = "";
+      inWord = false;
+    } else {
+      current += char;
+      inWord = true;
+    }
+  }
+  if (quote) throw new Error(`Unterminated ${quote} quote`);
+  if (inWord) words.push(current);
+  return words;
+};
+var normalizeProjectPath = (input) => {
+  if (posix.isAbsolute(input)) return void 0;
+  const normalized = posix.normalize(input.replace(/\\/g, "/")).replace(/\/+$/, "") || ".";
+  if (normalized === ".." || normalized.startsWith("../")) return void 0;
+  return normalized;
+};
+var resolveProjectRoot = (projectFolder) => Effect2.flatMap(
+  FileSystem2.FileSystem,
+  (fs) => fs.realPath(projectFolder).pipe(Effect2.orElseSucceed(() => projectFolder))
+);
+var resolveInsideProject = (projectRoot, projectRelative, subject, context) => Effect2.gen(function* () {
+  const fs = yield* FileSystem2.FileSystem;
+  const pathSvc = yield* Path2.Path;
+  const resolved = yield* fs.realPath(pathSvc.join(projectRoot, projectRelative)).pipe(Effect2.option);
+  if (Option2.isNone(resolved)) return resolved;
+  const relative = pathSvc.relative(projectRoot, resolved.value);
+  if (relative === ".." || relative.startsWith(`..${pathSvc.sep}`) || pathSvc.isAbsolute(relative)) {
+    return yield* new ContainerConfigError({
+      message: `${subject} leads through a symbolic link to a location outside the project. Only files inside the project can be deployed.`,
+      ...context
+    });
+  }
+  return resolved;
+});
+var readInsideProject = (projectRoot, projectRelative, subject, context) => Effect2.gen(function* () {
+  const fs = yield* FileSystem2.FileSystem;
+  const resolved = yield* resolveInsideProject(projectRoot, projectRelative, subject, context);
+  if (Option2.isNone(resolved)) return Option2.none();
+  return yield* fs.readFileString(resolved.value).pipe(Effect2.option);
+});
+var toArgv = (name, key, value) => value === void 0 ? Effect2.succeed(void 0) : Array.isArray(value) ? Effect2.succeed(value) : Effect2.try({
+  try: () => splitCommandWords(value),
+  catch: (error) => new ContainerConfigError({
+    message: `Container '${name}' has an invalid ${key}: ${error instanceof Error ? error.message : String(error)}`,
+    containerName: name
+  })
+});
+var isIntegerBetween = (value, min, max) => Number.isInteger(value) && value >= min && value <= max;
+var validateContainer = (name, container) => {
+  const build = typeof container.build === "object" ? container.build : void 0;
+  const buildArgs = Object.values(build?.args ?? {});
+  const env = Object.entries(container.env ?? {});
+  const user = container.user === void 0 ? void 0 : String(container.user);
+  const badEnvKey = env.find(([key]) => key === "" || key.includes("=") || key.includes("\0"))?.[0];
+  const longEnvKey = env.find(([, value]) => value.length > MAX_CONTAINER_ENV_VALUE_LENGTH)?.[0];
+  const problem = [
+    [
+      container.image !== void 0 && !/^\S{1,512}$/.test(container.image),
+      "has an invalid image reference. Use 1 to 512 characters without whitespace."
+    ],
+    [
+      container.port !== void 0 && !isIntegerBetween(container.port, 1, 65535),
+      `listens on port ${container.port}. Use a whole number from 1 to 65535.`
+    ],
+    [
+      container.memory !== void 0 && !isIntegerBetween(container.memory, MIN_CONTAINER_MEMORY_MB, MAX_CONTAINER_MEMORY_MB),
+      `asks for ${container.memory} MB of memory. Use a whole number from ${MIN_CONTAINER_MEMORY_MB} to ${MAX_CONTAINER_MEMORY_MB}.`
+    ],
+    [
+      container.working_dir !== void 0 && !(container.working_dir.startsWith("/") && container.working_dir.length <= 1024),
+      `sets working_dir '${container.working_dir}', which must be an absolute path of at most 1024 characters.`
+    ],
+    [
+      typeof container.user === "number" && !isIntegerBetween(container.user, 0, Number.MAX_SAFE_INTEGER),
+      `sets user ${container.user}. A numeric user must be a non-negative whole number.`
+    ],
+    [
+      user !== void 0 && (user.length === 0 || user.length > 256),
+      "sets an empty or overlong user. Use 1 to 256 characters: a name, a uid, name:group or uid:gid."
+    ],
+    [
+      build?.target !== void 0 && (build.target.length === 0 || build.target.length > 128),
+      "has an empty build target or one longer than 128 characters."
+    ],
+    [
+      buildArgs.length > MAX_CONTAINER_ENV_VARS || buildArgs.some((value) => value.length > MAX_CONTAINER_ENV_VALUE_LENGTH),
+      `sets more than ${MAX_CONTAINER_ENV_VARS} build args, or one longer than ${MAX_CONTAINER_ENV_VALUE_LENGTH} characters.`
+    ],
+    [
+      env.length > MAX_CONTAINER_ENV_VARS,
+      `sets ${env.length} environment variables. At most ${MAX_CONTAINER_ENV_VARS} are allowed.`
+    ],
+    [
+      badEnvKey !== void 0,
+      `sets an environment variable named '${badEnvKey}'. Names must be non-empty and contain no '='.`
+    ],
+    [
+      longEnvKey !== void 0,
+      `sets environment variable '${longEnvKey}' to a value longer than ${MAX_CONTAINER_ENV_VALUE_LENGTH} characters.`
+    ]
+  ].find(([failed]) => failed)?.[1];
+  return problem === void 0 ? Effect2.void : Effect2.fail(new ContainerConfigError({ message: `Container '${name}' ${problem}`, containerName: name }));
+};
+var toContainerSpec = Effect2.fn("toContainerSpec")(function* (name, container, projectFolder) {
+  yield* validateContainer(name, container);
+  let source;
+  if (container.image !== void 0 && container.build === void 0) {
+    source = { type: "registry", reference: container.image };
+  } else if (container.build !== void 0 && container.image === void 0) {
+    const build = typeof container.build === "string" ? { context: container.build } : container.build;
+    const dockerfile = build.dockerfile ?? "Dockerfile";
+    const context = normalizeProjectPath(build.context ?? ".");
+    const dockerfilePath = context === void 0 || posix.isAbsolute(dockerfile) ? void 0 : normalizeProjectPath(posix.join(context, dockerfile));
+    if (context === void 0 || dockerfilePath === void 0) {
+      return yield* new ContainerConfigError({
+        message: `Container '${name}' has a build context or Dockerfile outside the project.`,
+        containerName: name
+      });
+    }
+    const projectRoot = yield* resolveProjectRoot(projectFolder);
+    yield* resolveInsideProject(projectRoot, context, `The build context '${context}' of container '${name}'`, {
+      containerName: name
+    });
+    const dockerfileReal = yield* resolveInsideProject(
+      projectRoot,
+      dockerfilePath,
+      `The Dockerfile '${dockerfilePath}' of container '${name}'`,
+      { containerName: name }
+    );
+    if (Option2.isNone(dockerfileReal)) {
+      return yield* new ContainerConfigError({
+        message: `Container '${name}' builds '${dockerfilePath}', which does not exist.`,
+        containerName: name
+      });
+    }
+    source = {
+      type: "dockerfile",
+      context,
+      dockerfile: posix.relative(context, dockerfilePath),
+      ...build.target !== void 0 && { target: build.target },
+      ...build.args !== void 0 && Object.keys(build.args).length > 0 && { buildArgs: { ...build.args } }
+    };
+  } else {
+    return yield* new ContainerConfigError({
+      message: `Container '${name}' must set exactly one of 'image' and 'build'.`,
+      containerName: name
+    });
+  }
+  const entrypoint = yield* toArgv(name, "entrypoint", container.entrypoint);
+  const command = yield* toArgv(name, "command", container.command);
+  const spec = {
+    name,
+    source,
+    ...container.port !== void 0 && { port: container.port },
+    ...entrypoint !== void 0 && { entrypoint },
+    ...command !== void 0 && { command },
+    ...container.working_dir !== void 0 && { workingDirectory: container.working_dir },
+    ...container.user !== void 0 && { user: String(container.user) },
+    ...container.env !== void 0 && Object.keys(container.env).length > 0 && { environmentVariables: { ...container.env } }
+  };
+  return spec;
+});
+var normalizeContainers = Effect2.fn("normalizeContainers")(function* (containers, projectFolder) {
+  const entrypoints = [];
+  const sidecars = [];
+  const warnings = [];
+  for (const [name, container] of Object.entries(containers)) {
+    if (!CONTAINER_NAME_PATTERN.test(name) || name === "localhost") {
+      return yield* new ContainerConfigError({
+        message: `Container name '${name}' is invalid. The name is also the hostname the function reaches the container by, so it must be ${CONTAINER_NAME_RULES}. Try '${toContainerName(name)}'.`,
+        containerName: name
+      });
+    }
+    const spec = yield* toContainerSpec(name, container, projectFolder);
+    if (container.sidecar === true) {
+      const ignored = ["max_duration", "streaming", "schedule"].filter(
+        (key) => container[key] !== void 0
+      );
+      if (ignored.length > 0) {
+        warnings.push(
+          `Sidecar '${name}' ignores ${ignored.join(", ")}: those settings apply to container functions only.`
+        );
+      }
+      sidecars.push({ ...spec, memory: container.memory ?? DEFAULT_SIDECAR_MEMORY_MB });
+      continue;
+    }
+    entrypoints.push({
+      path: containerEntrypointPath(name),
+      displayName: name,
+      runtime: CONTAINER_RUNTIME,
+      memory: container.memory ?? DEFAULT_CONTAINER_MEMORY_MB,
+      maxDuration: container.max_duration ?? DEFAULT_FUNCTION_DURATION_SECONDS,
+      streaming: container.streaming ?? true,
+      ...container.schedule !== void 0 && { schedule: container.schedule },
+      container: spec
+    });
+  }
+  if (sidecars.length > MAX_SIDECARS) {
+    return yield* new ContainerConfigError({
+      message: `A deployment may declare at most ${MAX_SIDECARS} sidecars; this one declares ${sidecars.length}.`
+    });
+  }
+  const sidecarPorts = /* @__PURE__ */ new Map();
+  for (const sidecar of sidecars) {
+    if (sidecar.port === void 0) continue;
+    const owner = sidecarPorts.get(sidecar.port);
+    if (owner !== void 0) {
+      return yield* new ContainerConfigError({
+        message: `Sidecars '${owner}' and '${sidecar.name}' both listen on port ${sidecar.port}. Sidecars share one network namespace, so their ports must differ.`,
+        containerName: sidecar.name
+      });
+    }
+    sidecarPorts.set(sidecar.port, sidecar.name);
+  }
+  for (const entrypoint of entrypoints) {
+    const port = entrypoint.container?.port;
+    const sidecar = port === void 0 ? void 0 : sidecarPorts.get(port);
+    if (sidecar !== void 0) {
+      return yield* new ContainerConfigError({
+        message: `Container '${entrypoint.displayName}' and sidecar '${sidecar}' both listen on port ${port}. Sidecars run inside the function's microVM, so their ports must differ.`,
+        containerName: sidecar
+      });
+    }
+  }
+  return { entrypoints, sidecars, warnings };
+});
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+var scalarToString = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : void 0;
+var gigadriveExtension = (service) => isRecord(service["x-gigadrive"]) ? service["x-gigadrive"] : {};
+var COMPOSE_OVERRIDE_FILE_NAMES = [
+  "compose.override.yaml",
+  "compose.override.yml",
+  "docker-compose.override.yaml",
+  "docker-compose.override.yml"
+];
+var findClosingQuote = (body, quote) => {
+  for (let index = 0; index < body.length; index += 1) {
+    if (quote === '"' && body[index] === "\\") index += 1;
+    else if (body[index] === quote) return index;
+  }
+  return -1;
+};
+var DOUBLE_QUOTE_ESCAPES = { n: "\n", r: "\r", t: "	" };
+var parseDotEnv = (content) => {
+  const values = {};
+  const lines = content.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_.-]*)\s*=(.*)$/.exec(lines[index]);
+    if (!match) continue;
+    const [, key, rest] = match;
+    const quote = rest.trimStart()[0];
+    if (quote === '"' || quote === "'") {
+      let body = rest.trimStart().slice(1);
+      let end = index;
+      let close = findClosingQuote(body, quote);
+      while (close === -1 && end + 1 < lines.length) {
+        end += 1;
+        body += `
+${lines[end]}`;
+        close = findClosingQuote(body, quote);
+      }
+      if (close !== -1) {
+        const raw = body.slice(0, close);
+        values[key] = quote === '"' ? raw.replace(/\\([nrt"\\])/g, (_match, char) => DOUBLE_QUOTE_ESCAPES[char] ?? char) : raw;
+        index = end;
+        continue;
+      }
+    }
+    values[key] = rest.replace(/\s+#.*$/, "").trim();
+  }
+  return values;
+};
+var InterpolationError = class extends Error {
+};
+var findClosingBrace = (value, start) => {
+  let depth = 0;
+  for (let index = start; index < value.length; index += 1) {
+    if (value[index] === "$" && (value[index + 1] === "$" || value[index + 1] === "{")) {
+      if (value[index + 1] === "{") depth += 1;
+      index += 1;
+    } else if (value[index] === "}") {
+      if (depth === 0) return index;
+      depth -= 1;
+    }
+  }
+  return -1;
+};
+var interpolate = (value, variables, missing, where) => {
+  let result = "";
+  let index = 0;
+  while (index < value.length) {
+    const dollar = value.indexOf("$", index);
+    if (dollar === -1) {
+      result += value.slice(index);
+      break;
+    }
+    result += value.slice(index, dollar);
+    const next = value[dollar + 1];
+    if (next === "$") {
+      result += "$";
+      index = dollar + 2;
+      continue;
+    }
+    if (next === "{") {
+      const close = findClosingBrace(value, dollar + 2);
+      const expression = close === -1 ? null : /^([A-Za-z_][A-Za-z0-9_]*)(?:(:?[-?+])([\s\S]*))?$/.exec(value.slice(dollar + 2, close));
+      if (expression === null) {
+        throw new InterpolationError(`has an invalid variable reference in ${where}. Write '$$' for a literal '$'.`);
+      }
+      const [, name, operator, operand = ""] = expression;
+      const current = variables[name];
+      const isSet = current !== void 0 && !(operator?.startsWith(":") === true && current === "");
+      if (operator === void 0) {
+        if (current === void 0) missing.add(name);
+        result += current ?? "";
+      } else if (operator.endsWith("-")) {
+        result += isSet ? current : interpolate(operand, variables, missing, where);
+      } else if (operator.endsWith("+")) {
+        result += isSet ? interpolate(operand, variables, missing, where) : "";
+      } else if (isSet) {
+        result += current;
+      } else {
+        const reason = interpolate(operand, variables, missing, where);
+        throw new InterpolationError(
+          `needs variable '${name}' in ${where}, which is ${current === void 0 ? "not set" : "empty"}${reason === "" ? "" : `: ${reason}`}. Compose variables come only from the .env file next to the Compose file.`
+        );
+      }
+      index = close + 1;
+      continue;
+    }
+    const bare = /^[A-Za-z_][A-Za-z0-9_]*/.exec(value.slice(dollar + 1))?.[0];
+    if (bare === void 0) {
+      result += "$";
+      index = dollar + 1;
+      continue;
+    }
+    if (variables[bare] === void 0) missing.add(bare);
+    result += variables[bare] ?? "";
+    index = dollar + 1 + bare.length;
+  }
+  return result;
+};
+var interpolateDeep = (value, variables, missing, where) => {
+  if (typeof value === "string") return interpolate(value, variables, missing, where);
+  if (Array.isArray(value)) {
+    return value.map((item, index) => interpolateDeep(item, variables, missing, `${where}[${index}]`));
+  }
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        interpolateDeep(item, variables, missing, where === "" ? key : `${where}.${key}`)
+      ])
+    );
+  }
+  return value;
+};
+var parseComposeMemory = (value) => {
+  if (typeof value === "number") {
+    return Number.isFinite(value) && value >= 0 ? Math.ceil(value / 1024 ** 2) : void 0;
+  }
+  if (typeof value !== "string") return void 0;
+  const match = /^(\d+(?:\.\d+)?) ?([kmgtp])?i?b?$/i.exec(value.trim());
+  if (!match) return void 0;
+  const exponent = " kmgtp".indexOf((match[2] ?? " ").toLowerCase());
+  return Math.ceil(Number(match[1]) * 1024 ** exponent / 1024 ** 2);
+};
+var parseComposePort = (entry) => {
+  let port = entry;
+  if (isRecord(entry)) {
+    if (typeof entry.protocol === "string" && entry.protocol.toLowerCase() !== "tcp") return void 0;
+    port = entry.target;
+  } else if (typeof entry === "string") {
+    const [withoutProtocol, protocol] = entry.split("/");
+    if (protocol !== void 0 && protocol.toLowerCase() !== "tcp") return void 0;
+    port = (withoutProtocol.split(":").at(-1) ?? "").split("-")[0];
+  }
+  const number = typeof port === "number" ? port : typeof port === "string" && /^\d+$/.test(port) ? Number(port) : NaN;
+  return isIntegerBetween(number, 1, 65535) ? number : void 0;
+};
+var parseComposeEnvironment = (serviceName, value, warnings) => {
+  if (value === void 0 || value === null) return void 0;
+  const environment = {};
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (typeof item !== "string") continue;
+      const separator = item.indexOf("=");
+      if (separator === -1) {
+        warnings.push(
+          `Compose service '${serviceName}' takes '${item}' from the host environment, which deployments do not have. Set it in the console instead.`
+        );
+        continue;
+      }
+      environment[item.slice(0, separator)] = item.slice(separator + 1);
+    }
+  } else if (isRecord(value)) {
+    for (const [key, item] of Object.entries(value)) {
+      const scalar = scalarToString(item);
+      if (scalar === void 0) {
+        warnings.push(
+          `Compose service '${serviceName}' takes '${key}' from the host environment, which deployments do not have. Set it in the console instead.`
+        );
+        continue;
+      }
+      environment[key] = scalar;
+    }
+  }
+  return environment;
+};
+var isPublicMarked = (service) => gigadriveExtension(service).public === true;
+var buildsFromSource = (service) => service.build !== void 0 && gigadriveExtension(service).sidecar !== true;
+var loadComposeServices = Effect2.fn("loadComposeServices")(function* (composePath, projectFolder) {
+  const relativePath = normalizeProjectPath(composePath);
+  if (relativePath === void 0) {
+    return yield* new ContainerConfigError({
+      message: `Compose file '${composePath}' is outside the project.`,
+      filePath: composePath
+    });
+  }
+  const projectRoot = yield* resolveProjectRoot(projectFolder);
+  const content = yield* readInsideProject(projectRoot, relativePath, `Compose file '${relativePath}'`, {
+    filePath: relativePath
+  });
+  if (Option2.isNone(content)) {
+    return yield* new ContainerConfigError({
+      message: `Compose file '${relativePath}' could not be read.`,
+      filePath: relativePath
+    });
+  }
+  const document = yield* Effect2.try({
+    try: () => parseYaml(content.value),
+    catch: (error) => {
+      const position = error instanceof YAMLError ? error.linePos?.[0] : void 0;
+      return new ContainerConfigError({
+        message: `Compose file '${relativePath}' is not valid YAML${position ? ` (line ${position.line}, column ${position.col})` : ""}.`,
+        filePath: relativePath
+      });
+    }
+  });
+  if (!isRecord(document) || !isRecord(document.services) || Object.keys(document.services).length === 0) {
+    return yield* new ContainerConfigError({
+      message: `Compose file '${relativePath}' declares no services.`,
+      filePath: relativePath
+    });
+  }
+  const services = Object.entries(document.services).filter(
+    (entry) => isRecord(entry[1]) && !(isStringArray(entry[1].profiles) && entry[1].profiles.length > 0) && gigadriveExtension(entry[1]).skip !== true
+  );
+  return { relativePath, projectRoot, services };
+});
+var composeDeclaresApp = Effect2.fn("composeDeclaresApp")(function* (composePath, projectFolder) {
+  const { services } = yield* loadComposeServices(composePath, projectFolder);
+  return services.some(([, service]) => isPublicMarked(service) || buildsFromSource(service));
+});
+var readComposeContainers = Effect2.fn("readComposeContainers")(function* (composePath, projectFolder) {
+  const fs = yield* FileSystem2.FileSystem;
+  const pathSvc = yield* Path2.Path;
+  const { relativePath, projectRoot, services } = yield* loadComposeServices(composePath, projectFolder);
+  const composeDirectory = posix.dirname(relativePath);
+  const warnings = [];
+  for (const [name] of services) {
+    if (!CONTAINER_NAME_PATTERN.test(name) || name === "localhost") {
+      return yield* new ContainerConfigError({
+        message: `Compose service '${name}' cannot be imported under that name. The service name becomes the hostname the function reaches it by, so it must be ${CONTAINER_NAME_RULES}. Rename the service to '${toContainerName(name)}' in '${relativePath}'.`,
+        containerName: name,
+        filePath: relativePath
+      });
+    }
+  }
+  const marked = services.filter(([, service]) => isPublicMarked(service)).map(([name]) => name);
+  const built = services.filter(([, service]) => buildsFromSource(service)).map(([name]) => name);
+  if (marked.length > 1) {
+    return yield* new ContainerConfigError({
+      message: `Compose file '${relativePath}' marks ${marked.map((name) => `'${name}'`).join(", ")} as public. One service serves HTTP: keep 'x-gigadrive: { public: true }' on that one only.`,
+      filePath: relativePath
+    });
+  }
+  const publicService = marked[0] ?? (built.length === 1 ? built[0] : void 0);
+  if (publicService === void 0) {
+    return yield* new ContainerConfigError({
+      message: built.length === 0 ? `Compose file '${relativePath}' has no service that builds from source, so it is unclear which service serves HTTP. Mark it with 'x-gigadrive: { public: true }'.` : `Compose file '${relativePath}' builds ${built.map((name) => `'${name}'`).join(", ")} from source, so it is unclear which service serves HTTP. Mark it with 'x-gigadrive: { public: true }'.`,
+      filePath: relativePath
+    });
+  }
+  if (COMPOSE_FILE_NAMES.includes(posix.basename(relativePath))) {
+    for (const overrideName of COMPOSE_OVERRIDE_FILE_NAMES) {
+      const overridePath = posix.join(composeDirectory, overrideName);
+      const overrideExists = yield* fs.exists(pathSvc.join(projectRoot, overridePath)).pipe(Effect2.orElseSucceed(() => false));
+      if (overrideExists) {
+        warnings.push(
+          `Compose file '${relativePath}' has the override file '${overridePath}' next to it, which is not merged. Move its settings into '${relativePath}' or gigadrive.yaml.`
+        );
+      }
+    }
+  }
+  const dotEnv = yield* readInsideProject(
+    projectRoot,
+    posix.join(composeDirectory, ".env"),
+    `The .env file next to '${relativePath}'`,
+    { filePath: relativePath }
+  );
+  const variables = Option2.isSome(dotEnv) ? parseDotEnv(dotEnv.value) : {};
+  const missing = /* @__PURE__ */ new Set();
+  const containers = {};
+  for (const [name, rawService] of services) {
+    const isPublic = name === publicService;
+    const service = yield* Effect2.try({
+      try: () => interpolateDeep(rawService, variables, missing, ""),
+      catch: (error) => new ContainerConfigError({
+        message: `Compose service '${name}' ${error instanceof InterpolationError ? error.message : "could not be interpolated."}`,
+        containerName: name,
+        filePath: relativePath
+      })
+    });
+    const container = {};
+    if (service.extends !== void 0) {
+      warnings.push(
+        `Compose service '${name}' uses 'extends', which is not supported. The service is deployed as written, without the settings it would inherit.`
+      );
+    }
+    if (typeof service.image === "string" && service.build === void 0) {
+      container.image = service.image;
+    } else if (typeof service.build === "string" || isRecord(service.build)) {
+      const build = typeof service.build === "string" ? { context: service.build } : service.build;
+      if (build.dockerfile_inline !== void 0) {
+        return yield* new ContainerConfigError({
+          message: `Compose service '${name}' uses build.dockerfile_inline, which is not supported. Commit the Dockerfile and point build.dockerfile at it.`,
+          containerName: name,
+          filePath: relativePath
+        });
+      }
+      const rawContext = typeof build.context === "string" ? build.context : ".";
+      const context = posix.isAbsolute(rawContext) ? rawContext : posix.join(composeDirectory, rawContext);
+      const args = Array.isArray(build.args) ? Object.fromEntries(
+        build.args.filter((item) => typeof item === "string" && item.includes("=")).map((item) => [item.slice(0, item.indexOf("=")), item.slice(item.indexOf("=") + 1)])
+      ) : isRecord(build.args) ? Object.fromEntries(Object.entries(build.args).map(([key, item]) => [key, scalarToString(item) ?? ""])) : void 0;
+      container.build = {
+        context,
+        ...typeof build.dockerfile === "string" && { dockerfile: build.dockerfile },
+        ...typeof build.target === "string" && { target: build.target },
+        ...args !== void 0 && Object.keys(args).length > 0 && { args }
+      };
+    } else {
+      return yield* new ContainerConfigError({
+        message: `Compose service '${name}' has neither an image nor a build.`,
+        containerName: name,
+        filePath: relativePath
+      });
+    }
+    if (!isPublic) container.sidecar = true;
+    const ports = [
+      ...isPublic && Array.isArray(service.ports) ? service.ports : [],
+      ...Array.isArray(service.expose) ? service.expose : [],
+      ...!isPublic && Array.isArray(service.ports) ? service.ports : []
+    ];
+    const port = ports.map(parseComposePort).find((value) => value !== void 0);
+    if (port !== void 0) container.port = port;
+    for (const key of ["entrypoint", "command"]) {
+      const value = service[key];
+      if (typeof value === "string" || isStringArray(value)) container[key] = value;
+    }
+    const environment = {};
+    const envFiles = (typeof service.env_file === "string" ? [service.env_file] : Array.isArray(service.env_file) ? service.env_file : []).flatMap(
+      (entry) => typeof entry === "string" ? [{ path: entry }] : isRecord(entry) && typeof entry.path === "string" ? [{ path: entry.path, ...typeof entry.required === "boolean" && { required: entry.required } }] : []
+    );
+    for (const envFile of envFiles) {
+      const envFilePath = posix.isAbsolute(envFile.path) ? void 0 : normalizeProjectPath(posix.join(composeDirectory, envFile.path));
+      const envContent = envFilePath === void 0 ? Option2.none() : yield* readInsideProject(
+        projectRoot,
+        envFilePath,
+        `The env_file '${envFile.path}' of Compose service '${name}'`,
+        { containerName: name, filePath: relativePath }
+      );
+      if (Option2.isSome(envContent)) {
+        Object.assign(environment, parseDotEnv(envContent.value));
+      } else if (envFile.required === true) {
+        return yield* new ContainerConfigError({
+          message: `Compose service '${name}' requires env_file '${envFile.path}', which is not in the deployed source. Commit it, mark it 'required: false', or set those variables in the console.`,
+          containerName: name,
+          filePath: relativePath
+        });
+      } else if (envFile.required === void 0) {
+        warnings.push(
+          `Compose service '${name}' reads env_file '${envFile.path}', which is not in the deployed source. Set those variables in the console instead.`
+        );
+      }
+    }
+    Object.assign(environment, parseComposeEnvironment(name, service.environment, warnings));
+    if (Object.keys(environment).length > 0) container.env = environment;
+    if (typeof service.working_dir === "string") container.working_dir = service.working_dir;
+    if (typeof service.user === "string" || typeof service.user === "number") container.user = String(service.user);
+    const deploy = isRecord(service.deploy) ? service.deploy : {};
+    const resources = isRecord(deploy.resources) ? deploy.resources : {};
+    const limits = isRecord(resources.limits) ? resources.limits : {};
+    const memoryLimit = limits.memory ?? service.mem_limit;
+    if (memoryLimit !== void 0 && memoryLimit !== null) {
+      const memory = parseComposeMemory(memoryLimit);
+      if (memory === void 0) {
+        warnings.push(
+          `Compose service '${name}' sets the memory limit ${JSON.stringify(memoryLimit)}, which is not a size Docker accepts. The default is used instead.`
+        );
+      } else if (memory >= MIN_CONTAINER_MEMORY_MB && memory <= MAX_CONTAINER_MEMORY_MB) {
+        container.memory = memory;
+      } else if (memory > 0) {
+        warnings.push(
+          `Compose service '${name}' asks for ${memory} MB of memory, outside the supported ${MIN_CONTAINER_MEMORY_MB} to ${MAX_CONTAINER_MEMORY_MB} MB. The default is used instead.`
+        );
+      }
+    }
+    if (service.volumes !== void 0) {
+      warnings.push(
+        `Compose service '${name}' declares volumes. Containers on Gigadrive Network have no persistent volumes, so anything written there is lost when the instance stops.`
+      );
+    }
+    containers[name] = container;
+  }
+  if (missing.size > 0) {
+    warnings.push(
+      `Compose file '${relativePath}' uses ${[...missing].sort().join(", ")}, which ${missing.size === 1 ? "is" : "are"} not set. ${missing.size === 1 ? "It was" : "They were"} replaced with an empty string.`
+    );
+  }
+  return { containers, publicService, warnings };
+});
+
 // src/define-config.ts
 var defineConfig = (config) => config;
 
+// src/detection/detect-container-project.ts
+import { FileSystem as FileSystem3, Path as Path3 } from "@effect/platform";
+import { Effect as Effect3 } from "effect";
+
+// src/regions.ts
+var REGION_DEFINITIONS = [
+  "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"
+];
+var AVAILABLE_REGIONS = [...REGION_DEFINITIONS];
+
+// src/detection/detect-container-project.ts
+var detectContainerProject = Effect3.fn("detectContainerProject")(function* (projectFolder) {
+  const fs = yield* FileSystem3.FileSystem;
+  const pathSvc = yield* Path3.Path;
+  const exists = (file) => fs.exists(pathSvc.join(projectFolder, file)).pipe(Effect3.catchAll(() => Effect3.succeed(false)));
+  let detection;
+  const warnings = [];
+  const composeFile = yield* Effect3.findFirst(COMPOSE_FILE_NAMES, exists);
+  if (composeFile._tag === "Some" && (yield* composeDeclaresApp(composeFile.value, projectFolder))) {
+    const imported = yield* readComposeContainers(composeFile.value, projectFolder);
+    warnings.push(...imported.warnings);
+    detection = { kind: "compose", file: composeFile.value, containers: imported.containers };
+  } else if (yield* exists("Dockerfile")) {
+    detection = { kind: "dockerfile", file: "Dockerfile", containers: { app: { build: "." } } };
+  } else {
+    return void 0;
+  }
+  const {
+    entrypoints,
+    sidecars,
+    warnings: containerWarnings
+  } = yield* normalizeContainers(detection.containers, projectFolder);
+  const [publicContainer] = entrypoints;
+  const config = {
+    regions: [...AVAILABLE_REGIONS],
+    environmentVariables: {},
+    commands: [],
+    entrypoints,
+    ...sidecars.length > 0 && { sidecars },
+    routes: publicContainer ? [
+      {
+        path: "/*",
+        destination: publicContainer.path,
+        handler: "SERVERLESS_FUNCTION_STREAMING",
+        methods: ["ANY"],
+        headers: {}
+      }
+    ] : [],
+    warnings: [
+      `Auto-detected ${detection.kind === "compose" ? "Docker Compose" : "Dockerfile"} project (${detection.file}). Create a gigadrive.yaml to customize.`,
+      ...warnings,
+      ...containerWarnings
+    ],
+    errors: []
+  };
+  return { kind: detection.kind, file: detection.file, config };
+});
+
 // src/detection/detect-framework.ts
-import { FileSystem as FileSystem9, Path as Path7 } from "@effect/platform";
-import { Effect as Effect11 } from "effect";
+import { FileSystem as FileSystem11, Path as Path9 } from "@effect/platform";
+import { Effect as Effect13 } from "effect";
 
 // src/detection/detect-package-manager.ts
-import { FileSystem as FileSystem2, Path as Path2 } from "@effect/platform";
-import { Effect as Effect2 } from "effect";
+import { FileSystem as FileSystem4, Path as Path4 } from "@effect/platform";
+import { Effect as Effect4 } from "effect";
 var LOCKFILE_MAP = [
   { files: ["bun.lockb", "bun.lock"], pm: "bun" },
   { files: ["pnpm-lock.yaml"], pm: "pnpm" },
@@ -110,19 +918,19 @@ var LOCKFILE_MAP = [
   { files: ["package-lock.json"], pm: "npm" },
   { files: ["composer.lock"], pm: "composer" }
 ];
-var detectPackageManager = Effect2.fn("detectPackageManager")(function* (projectFolder) {
-  const fs = yield* FileSystem2.FileSystem;
-  const pathService = yield* Path2.Path;
+var detectPackageManager = Effect4.fn("detectPackageManager")(function* (projectFolder) {
+  const fs = yield* FileSystem4.FileSystem;
+  const pathService = yield* Path4.Path;
   for (const { files, pm } of LOCKFILE_MAP) {
     for (const file of files) {
-      const exists = yield* fs.exists(pathService.join(projectFolder, file)).pipe(Effect2.catchAll(() => Effect2.succeed(false)));
+      const exists = yield* fs.exists(pathService.join(projectFolder, file)).pipe(Effect4.catchAll(() => Effect4.succeed(false)));
       if (exists) {
-        yield* Effect2.logDebug(`Detected package manager: ${pm} (via ${file})`);
+        yield* Effect4.logDebug(`Detected package manager: ${pm} (via ${file})`);
         return pm;
       }
     }
   }
-  yield* Effect2.logDebug("No lockfile found, defaulting to npm");
+  yield* Effect4.logDebug("No lockfile found, defaulting to npm");
   return "npm";
 });
 
@@ -148,8 +956,8 @@ var astro = {
 };
 
 // src/detection/frameworks/resolve-node-entrypoint.ts
-import { FileSystem as FileSystem3, Path as Path3 } from "@effect/platform";
-import { Effect as Effect3 } from "effect";
+import { FileSystem as FileSystem5, Path as Path5 } from "@effect/platform";
+import { Effect as Effect5 } from "effect";
 var SCRIPT_RUNNERS = /* @__PURE__ */ new Set(["node", "bun", "tsx", "ts-node"]);
 var COMMON_ENTRYPOINT_CANDIDATES = [
   "index.js",
@@ -165,11 +973,11 @@ var COMMON_ENTRYPOINT_CANDIDATES = [
   "server.ts",
   "src/server.ts"
 ];
-var isRecord = (value) => typeof value === "object" && value !== null;
+var isRecord2 = (value) => typeof value === "object" && value !== null;
 var parsePackageJson = (content) => {
   try {
     const parsed = JSON.parse(content);
-    if (!isRecord(parsed)) return void 0;
+    if (!isRecord2(parsed)) return void 0;
     return parsed;
   } catch {
     return void 0;
@@ -197,14 +1005,14 @@ var applyEntrypoint = (defaults, entrypoint) => ({
     (route) => route.destination === defaults.entrypoint ? { ...route, destination: entrypoint } : route
   )
 });
-var resolveNodeServerEntrypoint = (defaults, projectFolder) => Effect3.gen(function* () {
-  const fs = yield* FileSystem3.FileSystem;
-  const pathService = yield* Path3.Path;
+var resolveNodeServerEntrypoint = (defaults, projectFolder) => Effect5.gen(function* () {
+  const fs = yield* FileSystem5.FileSystem;
+  const pathService = yield* Path5.Path;
   const isFile = (relativePath) => fs.stat(pathService.join(projectFolder, relativePath)).pipe(
-    Effect3.map((info) => info.type === "File"),
-    Effect3.catchAll(() => Effect3.succeed(false))
+    Effect5.map((info) => info.type === "File"),
+    Effect5.catchAll(() => Effect5.succeed(false))
   );
-  const content = yield* fs.readFileString(pathService.join(projectFolder, "package.json")).pipe(Effect3.catchAll(() => Effect3.succeed(void 0)));
+  const content = yield* fs.readFileString(pathService.join(projectFolder, "package.json")).pipe(Effect5.catchAll(() => Effect5.succeed(void 0)));
   const manifest = content ? parsePackageJson(content) : void 0;
   const startScript = typeof manifest?.scripts?.start === "string" ? manifest.scripts.start : void 0;
   const candidates = [
@@ -336,13 +1144,13 @@ var laravel = {
 };
 
 // src/detection/frameworks/nestjs.ts
-import { FileSystem as FileSystem4 } from "@effect/platform";
-import { Effect as Effect4 } from "effect";
-var isRecord2 = (value) => typeof value === "object" && value !== null;
+import { FileSystem as FileSystem6 } from "@effect/platform";
+import { Effect as Effect6 } from "effect";
+var isRecord3 = (value) => typeof value === "object" && value !== null;
 var parseNestCliJson = (content) => {
   try {
     const parsed = JSON.parse(content);
-    if (!isRecord2(parsed)) return void 0;
+    if (!isRecord3(parsed)) return void 0;
     return parsed;
   } catch {
     return void 0;
@@ -388,9 +1196,9 @@ var nestjs = {
   detectors: [{ matchPackage: "@nestjs/core" }],
   priority: 90,
   getDefaultConfig: () => createNestConfig("dist"),
-  refineDefaultConfig: (defaults, projectFolder) => Effect4.gen(function* () {
-    const fs = yield* FileSystem4.FileSystem;
-    const content = yield* fs.readFileString(`${projectFolder}/nest-cli.json`).pipe(Effect4.catchAll(() => Effect4.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => Effect6.gen(function* () {
+    const fs = yield* FileSystem6.FileSystem;
+    const content = yield* fs.readFileString(`${projectFolder}/nest-cli.json`).pipe(Effect6.catchAll(() => Effect6.succeed(void 0)));
     if (!content) return defaults;
     const nestConfig = parseNestCliJson(content);
     const outputPath = nestConfig ? getProjectOutputPath(nestConfig) : void 0;
@@ -399,28 +1207,28 @@ var nestjs = {
 };
 
 // src/detection/frameworks/nextjs.ts
-import { FileSystem as FileSystem6, Path as Path5 } from "@effect/platform";
-import { Effect as Effect6 } from "effect";
+import { FileSystem as FileSystem8, Path as Path7 } from "@effect/platform";
+import { Effect as Effect8 } from "effect";
 
 // src/build-output-v3/get-default-path-map.ts
-import { FileSystem as FileSystem5, Path as Path4 } from "@effect/platform";
-import { Effect as Effect5 } from "effect";
-var getDefaultPathMap = Effect5.fn("getDefaultPathMap")(function* (directory) {
-  const fs = yield* FileSystem5.FileSystem;
-  const pathService = yield* Path4.Path;
+import { FileSystem as FileSystem7, Path as Path6 } from "@effect/platform";
+import { Effect as Effect7 } from "effect";
+var getDefaultPathMap = Effect7.fn("getDefaultPathMap")(function* (directory) {
+  const fs = yield* FileSystem7.FileSystem;
+  const pathService = yield* Path6.Path;
   const result = {};
-  const exists = yield* fs.exists(directory).pipe(Effect5.catchAll(() => Effect5.succeed(false)));
+  const exists = yield* fs.exists(directory).pipe(Effect7.catchAll(() => Effect7.succeed(false)));
   if (!exists) {
     return result;
   }
   const MAX_DEPTH = 100;
-  const processDirectory = (currentPath, basePath = "", depth = 0) => Effect5.gen(function* () {
+  const processDirectory = (currentPath, basePath = "", depth = 0) => Effect7.gen(function* () {
     if (depth > MAX_DEPTH) return;
-    const entries = yield* fs.readDirectory(currentPath).pipe(Effect5.catchAll(() => Effect5.succeed([])));
+    const entries = yield* fs.readDirectory(currentPath).pipe(Effect7.catchAll(() => Effect7.succeed([])));
     for (const name of entries) {
       const fullPath = pathService.join(currentPath, name);
       const relativePath = basePath ? pathService.join(basePath, name) : name;
-      const stat = yield* fs.stat(fullPath).pipe(Effect5.catchAll(() => Effect5.succeed(null)));
+      const stat = yield* fs.stat(fullPath).pipe(Effect7.catchAll(() => Effect7.succeed(null)));
       if (!stat) continue;
       if (stat.type === "Directory") {
         yield* processDirectory(fullPath, relativePath, depth + 1);
@@ -437,291 +1245,269 @@ var getDefaultPathMap = Effect5.fn("getDefaultPathMap")(function* (directory) {
 var MAXIMUM_ENTRY_PAGE_PATHS = 50;
 
 // src/nextjs-manifest.ts
-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 }))
+import { Schema as Schema4 } from "effect";
+var StringArraySchema = Schema4.mutable(Schema4.Array(Schema4.String));
+var StringRecordSchema = Schema4.mutable(Schema4.Record({ key: Schema4.String, value: Schema4.String }));
+var JsonValueSchema = Schema4.suspend(
+  () => Schema4.Union(
+    Schema4.Null,
+    Schema4.Boolean,
+    Schema4.Number,
+    Schema4.String,
+    Schema4.mutable(Schema4.Array(JsonValueSchema)),
+    Schema4.mutable(Schema4.Record({ key: Schema4.String, value: JsonValueSchema }))
   )
 );
-var ImageLocalPatternSchema = Schema3.mutable(
-  Schema3.Struct({
-    pathname: Schema3.optional(Schema3.String),
-    search: Schema3.optional(Schema3.String)
+var ImageLocalPatternSchema = Schema4.mutable(
+  Schema4.Struct({
+    pathname: Schema4.optional(Schema4.String),
+    search: Schema4.optional(Schema4.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 ImageRemotePatternSchema = Schema4.mutable(
+  Schema4.Struct({
+    protocol: Schema4.optional(Schema4.Literal("http", "https")),
+    hostname: Schema4.String,
+    port: Schema4.optional(Schema4.String),
+    pathname: Schema4.optional(Schema4.String),
+    search: Schema4.optional(Schema4.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 ImageVariantSchema = Schema4.mutable(
+  Schema4.Struct({
+    width: Schema4.optional(Schema4.Number),
+    height: Schema4.optional(Schema4.Number),
+    quality: Schema4.optional(Schema4.Number),
+    format: Schema4.optional(Schema4.Literal("image/avif", "image/webp", "image/jpeg", "image/png")),
+    fit: Schema4.optional(Schema4.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 PositiveIntSchema = Schema4.Int.pipe(Schema4.greaterThan(0));
+var ImagePolicySchema = Schema4.mutable(
+  Schema4.Struct({
+    localPatterns: Schema4.mutable(Schema4.Array(ImageLocalPatternSchema)),
+    remotePatterns: Schema4.mutable(Schema4.Array(ImageRemotePatternSchema)),
+    widths: Schema4.mutable(Schema4.Array(PositiveIntSchema)),
+    heights: Schema4.mutable(Schema4.Array(PositiveIntSchema)),
+    qualities: Schema4.mutable(Schema4.Array(Schema4.Number.pipe(Schema4.between(1, 100)))),
+    formats: Schema4.mutable(Schema4.Array(Schema4.Literal("image/avif", "image/webp", "image/jpeg", "image/png"))),
+    minimumCacheTTL: Schema4.Number,
+    dangerouslyAllowSVG: Schema4.Boolean,
+    contentSecurityPolicy: Schema4.String,
+    contentDispositionType: Schema4.Literal("inline", "attachment"),
+    maximumRedirects: Schema4.Number,
+    maximumResponseBody: Schema4.Number,
+    variants: Schema4.mutable(Schema4.Record({ key: Schema4.String, value: ImageVariantSchema }))
   })
 );
 var GigadriveNextPrerenderOutputFields = {
-  id: Schema3.String,
-  type: Schema3.Literal("PRERENDER"),
+  id: Schema4.String,
+  type: Schema4.Literal("PRERENDER"),
   pathname: UrlPathnameSchema,
-  route: Schema3.optional(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)
+  route: Schema4.optional(UrlPathnameSchema),
+  parentOutputId: Schema4.String,
+  groupId: Schema4.Number,
+  pprChain: Schema4.optional(Schema4.mutable(Schema4.Struct({ headers: HttpSingleValueHeadersSchema }))),
+  parentFallbackMode: Schema4.optional(JsonValueSchema),
+  fallback: Schema4.optional(
+    Schema4.mutable(
+      Schema4.Struct({
+        filePath: Schema4.optional(PortableRelativePathSchema),
+        initialStatus: Schema4.optional(Schema4.Int.pipe(Schema4.between(100, 599))),
+        initialHeaders: Schema4.optional(HttpHeadersSchema),
+        initialExpiration: Schema4.optional(Schema4.Number),
+        initialRevalidate: Schema4.optional(Schema4.Union(Schema4.Number, Schema4.Literal(false))),
+        postponedState: Schema4.optional(Schema4.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)
+  config: Schema4.mutable(
+    Schema4.Struct({
+      allowQuery: Schema4.optional(StringArraySchema),
+      allowHeader: Schema4.optional(StringArraySchema),
+      bypassFor: Schema4.optional(Schema4.mutable(Schema4.Array(JsonValueSchema))),
+      renderingMode: Schema4.optional(Schema4.String),
+      partialFallback: Schema4.optional(Schema4.Boolean),
+      bypassToken: Schema4.optional(Schema4.String)
     })
   )
 };
-var GigadriveNextPrerenderClassificationSchema = Schema3.Struct({
-  routeType: Schema3.Literal("route", "fallback", "shell", "page"),
-  response: Schema3.Literal("empty", "initial", "complete"),
-  compute: Schema3.Literal("blocking", "resuming", "static"),
-  htmlSize: Schema3.optional(Schema3.Number)
+var GigadriveNextPrerenderClassificationSchema = Schema4.Struct({
+  routeType: Schema4.Literal("route", "fallback", "shell", "page"),
+  response: Schema4.Literal("empty", "initial", "complete"),
+  compute: Schema4.Literal("blocking", "resuming", "static"),
+  htmlSize: Schema4.optional(Schema4.Number)
 });
-var GigadriveNextPrerenderWithoutClassificationSchema = Schema3.Struct({
-  routeType: Schema3.optional(Schema3.Never),
-  response: Schema3.optional(Schema3.Never),
-  compute: Schema3.optional(Schema3.Never),
-  htmlSize: Schema3.optional(Schema3.Never)
+var GigadriveNextPrerenderWithoutClassificationSchema = Schema4.Struct({
+  routeType: Schema4.optional(Schema4.Never),
+  response: Schema4.optional(Schema4.Never),
+  compute: Schema4.optional(Schema4.Never),
+  htmlSize: Schema4.optional(Schema4.Never)
 });
-var GigadriveNextPrerenderOutputSchema = Schema3.Union(
-  Schema3.mutable(
-    Schema3.Struct({ ...GigadriveNextPrerenderOutputFields, ...GigadriveNextPrerenderClassificationSchema.fields })
+var GigadriveNextPrerenderOutputSchema = Schema4.Union(
+  Schema4.mutable(
+    Schema4.Struct({ ...GigadriveNextPrerenderOutputFields, ...GigadriveNextPrerenderClassificationSchema.fields })
   ),
-  Schema3.mutable(
-    Schema3.Struct({
+  Schema4.mutable(
+    Schema4.Struct({
       ...GigadriveNextPrerenderOutputFields,
       ...GigadriveNextPrerenderWithoutClassificationSchema.fields
     })
   )
 );
-var GigadriveNextStaticAssetPrefixSchema = Schema3.mutable(
-  Schema3.Struct({
+var GigadriveNextStaticAssetPrefixSchema = Schema4.mutable(
+  Schema4.Struct({
     sourceDir: PortableRelativePathSchema,
     urlPrefix: PortableRelativePathSchema,
-    immutable: Schema3.Boolean
+    immutable: Schema4.Boolean
   })
 );
-var GigadriveNextRouteConditionSchema = Schema3.Union(
-  Schema3.mutable(
-    Schema3.Struct({
-      type: Schema3.Literal("header", "cookie", "query"),
-      key: Schema3.String,
-      value: Schema3.optional(Schema3.String)
+var GigadriveNextRouteConditionSchema = Schema4.Union(
+  Schema4.mutable(
+    Schema4.Struct({
+      type: Schema4.Literal("header", "cookie", "query"),
+      key: Schema4.String,
+      value: Schema4.optional(Schema4.String)
     })
   ),
-  Schema3.mutable(
-    Schema3.Struct({
-      type: Schema3.Literal("host"),
-      value: Schema3.String
+  Schema4.mutable(
+    Schema4.Struct({
+      type: Schema4.Literal("host"),
+      value: Schema4.String
     })
   )
 );
-var GigadriveNextMiddlewareMatcherSchema = Schema3.mutable(
-  Schema3.Struct({
-    source: Schema3.String,
-    sourceRegex: Schema3.String,
-    has: Schema3.optional(Schema3.mutable(Schema3.Array(GigadriveNextRouteConditionSchema))),
-    missing: Schema3.optional(Schema3.mutable(Schema3.Array(GigadriveNextRouteConditionSchema)))
+var GigadriveNextMiddlewareMatcherSchema = Schema4.mutable(
+  Schema4.Struct({
+    source: Schema4.String,
+    sourceRegex: Schema4.String,
+    has: Schema4.optional(Schema4.mutable(Schema4.Array(GigadriveNextRouteConditionSchema))),
+    missing: Schema4.optional(Schema4.mutable(Schema4.Array(GigadriveNextRouteConditionSchema)))
   })
 );
-var GigadriveNextMiddlewareDescriptorSchema = Schema3.Union(
-  Schema3.mutable(
-    Schema3.Struct({
-      present: Schema3.Literal(true),
-      matchers: Schema3.mutable(Schema3.Array(GigadriveNextMiddlewareMatcherSchema))
+var GigadriveNextMiddlewareDescriptorSchema = Schema4.Union(
+  Schema4.mutable(
+    Schema4.Struct({
+      present: Schema4.Literal(true),
+      matchers: Schema4.mutable(Schema4.Array(GigadriveNextMiddlewareMatcherSchema))
     })
   ),
-  Schema3.mutable(
-    Schema3.Struct({
-      present: Schema3.Literal(false),
-      matchers: Schema3.mutable(Schema3.Tuple())
+  Schema4.mutable(
+    Schema4.Struct({
+      present: Schema4.Literal(false),
+      matchers: Schema4.mutable(Schema4.Tuple())
     })
   )
 );
-var GigadriveNextServerDescriptorSchema = Schema3.mutable(
-  Schema3.Struct({
-    maxDuration: Schema3.optional(Schema3.Number),
-    preferredRegion: Schema3.optional(Schema3.Union(Schema3.String, StringArraySchema)),
-    env: Schema3.optional(StringRecordSchema)
+var GigadriveNextServerDescriptorSchema = Schema4.mutable(
+  Schema4.Struct({
+    maxDuration: Schema4.optional(Schema4.Number),
+    preferredRegion: Schema4.optional(Schema4.Union(Schema4.String, StringArraySchema)),
+    env: Schema4.optional(StringRecordSchema)
   })
 );
-var PrerenderArraySchema = Schema3.mutable(Schema3.Array(GigadriveNextPrerenderOutputSchema));
-var StaticAssetArraySchema = Schema3.mutable(Schema3.Array(GigadriveNextStaticAssetPrefixSchema));
-var JsonValueArraySchema = Schema3.mutable(Schema3.Array(JsonValueSchema));
-var GigadriveNextPrerenderSeedMethodsSchema = Schema3.mutable(
-  Schema3.Tuple(Schema3.Literal("GET"), Schema3.Literal("HEAD"))
+var PrerenderArraySchema = Schema4.mutable(Schema4.Array(GigadriveNextPrerenderOutputSchema));
+var StaticAssetArraySchema = Schema4.mutable(Schema4.Array(GigadriveNextStaticAssetPrefixSchema));
+var JsonValueArraySchema = Schema4.mutable(Schema4.Array(JsonValueSchema));
+var GigadriveNextPrerenderSeedMethodsSchema = Schema4.mutable(
+  Schema4.Tuple(Schema4.Literal("GET"), Schema4.Literal("HEAD"))
 );
-var GigadriveNextBuildManifestV1Schema = Schema3.mutable(
-  Schema3.Struct({
-    version: Schema3.Literal(1),
-    output: Schema3.Literal("standalone", "export"),
+var GigadriveNextBuildManifestV1Schema = Schema4.mutable(
+  Schema4.Struct({
+    version: Schema4.Literal(1),
+    output: Schema4.Literal("standalone", "export"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: Schema3.String,
-    buildId: Schema3.String
+    nextVersion: Schema4.String,
+    buildId: Schema4.String
   })
 );
-var GigadriveNextBuildManifestV2ExportSchema = Schema3.mutable(
-  Schema3.Struct({
-    version: Schema3.Literal(2),
-    mode: Schema3.Literal("export"),
+var GigadriveNextBuildManifestV2ExportSchema = Schema4.mutable(
+  Schema4.Struct({
+    version: Schema4.Literal(2),
+    mode: Schema4.Literal("export"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: Schema3.String,
-    buildId: Schema3.String
+    nextVersion: Schema4.String,
+    buildId: Schema4.String
   })
 );
-var GigadriveNextBuildManifestV2StandaloneSchema = Schema3.mutable(
-  Schema3.Struct({
-    version: Schema3.Literal(2),
-    mode: Schema3.Literal("standalone-v2"),
+var GigadriveNextBuildManifestV2StandaloneSchema = Schema4.mutable(
+  Schema4.Struct({
+    version: Schema4.Literal(2),
+    mode: Schema4.Literal("standalone-v2"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: Schema3.String,
-    buildId: Schema3.String,
+    nextVersion: Schema4.String,
+    buildId: Schema4.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)
+    config: Schema4.mutable(
+      Schema4.Struct({
+        basePath: Schema4.String,
+        trailingSlash: Schema4.Boolean,
+        cacheComponents: Schema4.Boolean,
+        i18n: Schema4.optional(JsonValueSchema),
+        images: Schema4.optional(ImagePolicySchema)
       })
     ),
-    routing: Schema3.mutable(
-      Schema3.Struct({
+    routing: Schema4.mutable(
+      Schema4.Struct({
         beforeMiddleware: JsonValueArraySchema,
         beforeFiles: JsonValueArraySchema,
         afterFiles: JsonValueArraySchema,
         dynamicRoutes: JsonValueArraySchema,
         onMatch: JsonValueArraySchema,
         fallback: JsonValueArraySchema,
-        shouldNormalizeNextData: Schema3.Boolean,
+        shouldNormalizeNextData: Schema4.Boolean,
         rsc: JsonValueSchema
       })
     ),
-    outputs: Schema3.mutable(
-      Schema3.Struct({
+    outputs: Schema4.mutable(
+      Schema4.Struct({
         prerenders: PrerenderArraySchema,
-        prerenderManifest: Schema3.optional(PortableRelativePathSchema),
-        assetManifest: Schema3.optional(PortableRelativePathSchema),
-        entryPagePaths: Schema3.optional(Schema3.mutable(Schema3.Array(UrlPathnameSchema))),
+        prerenderManifest: Schema4.optional(PortableRelativePathSchema),
+        assetManifest: Schema4.optional(PortableRelativePathSchema),
+        entryPagePaths: Schema4.optional(Schema4.mutable(Schema4.Array(UrlPathnameSchema))),
         staticAssets: StaticAssetArraySchema,
-        middleware: Schema3.optional(GigadriveNextMiddlewareDescriptorSchema)
+        middleware: Schema4.optional(GigadriveNextMiddlewareDescriptorSchema)
       })
     )
   })
 );
-var GigadriveNextBuildManifestSchema = Schema3.Union(
+var GigadriveNextBuildManifestSchema = Schema4.Union(
   GigadriveNextBuildManifestV1Schema,
   GigadriveNextBuildManifestV2ExportSchema,
   GigadriveNextBuildManifestV2StandaloneSchema
 );
-var GigadriveNextPrerenderManifestV1Schema = Schema3.mutable(
-  Schema3.Struct({
-    version: Schema3.Literal(1),
-    seedMethods: Schema3.optional(GigadriveNextPrerenderSeedMethodsSchema),
+var GigadriveNextPrerenderManifestV1Schema = Schema4.mutable(
+  Schema4.Struct({
+    version: Schema4.Literal(1),
+    seedMethods: Schema4.optional(GigadriveNextPrerenderSeedMethodsSchema),
     prerenders: PrerenderArraySchema
   })
 );
 var parseGigadriveNextBuildManifest = (content) => decodeJson(GigadriveNextBuildManifestSchema, content);
 var parseGigadriveNextPrerenderManifest = (content) => decodeJson(GigadriveNextPrerenderManifestV1Schema, content);
 
-// src/regions.ts
-var REGION_DEFINITIONS = [
-  "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"
-];
-var AVAILABLE_REGIONS = [...REGION_DEFINITIONS];
-
 // src/detection/frameworks/nextjs.ts
 var toPortablePath = (value) => value.replaceAll("\\", "/");
 var STANDALONE_SERVER_MEMORY_MB = 1024;
-var resolveStandaloneServer = Effect6.fn("nextjs.resolveStandaloneServer")(function* (projectFolder, distDir, repoRootToProject) {
-  const fs = yield* FileSystem6.FileSystem;
-  const pathService = yield* Path5.Path;
+var resolveStandaloneServer = Effect8.fn("nextjs.resolveStandaloneServer")(function* (projectFolder, distDir, repoRootToProject) {
+  const fs = yield* FileSystem8.FileSystem;
+  const pathService = yield* Path7.Path;
   const standaloneRoot = pathService.join(projectFolder, distDir, "standalone");
   const monorepoServer = pathService.join(standaloneRoot, repoRootToProject, "server.js");
   const rootServer = pathService.join(standaloneRoot, "server.js");
-  const monorepoServerExists = yield* fs.exists(monorepoServer).pipe(Effect6.catchAll(() => Effect6.succeed(false)));
+  const monorepoServerExists = yield* fs.exists(monorepoServer).pipe(Effect8.catchAll(() => Effect8.succeed(false)));
   const serverPath = monorepoServerExists ? monorepoServer : rootServer;
-  const serverExists = yield* fs.exists(serverPath).pipe(Effect6.catchAll(() => Effect6.succeed(false)));
+  const serverExists = yield* fs.exists(serverPath).pipe(Effect8.catchAll(() => Effect8.succeed(false)));
   if (!serverExists) return void 0;
   const serverDirectory = pathService.dirname(serverPath);
   const entrypoint = toPortablePath(pathService.relative(standaloneRoot, serverPath));
   return { standaloneRoot, serverDirectory, entrypoint };
 });
-var buildStandalonePublicAssets = Effect6.fn("nextjs.buildStandalonePublicAssets")(function* (projectFolder, standaloneRoot, serverDirectory) {
-  const pathService = yield* Path5.Path;
+var buildStandalonePublicAssets = Effect8.fn("nextjs.buildStandalonePublicAssets")(function* (projectFolder, standaloneRoot, serverDirectory) {
+  const pathService = yield* Path7.Path;
   const publicFiles = yield* getDefaultPathMap(pathService.join(projectFolder, "public"));
   const assetPaths = [];
   const assetOverrides = {};
@@ -737,8 +1523,8 @@ var buildStandalonePublicAssets = Effect6.fn("nextjs.buildStandalonePublicAssets
   }
   return { assetPaths, assetOverrides, filePathMap };
 });
-var createStaticExportConfig = Effect6.fn("nextjs.createStaticExportConfig")(function* (defaults, projectFolder) {
-  const pathService = yield* Path5.Path;
+var createStaticExportConfig = Effect8.fn("nextjs.createStaticExportConfig")(function* (defaults, projectFolder) {
+  const pathService = yield* Path7.Path;
   const outputDirectory = pathService.join(projectFolder, "out");
   const files = yield* getDefaultPathMap(outputDirectory);
   const assetPaths = [];
@@ -761,8 +1547,8 @@ var createStaticExportConfig = Effect6.fn("nextjs.createStaticExportConfig")(fun
     package: void 0
   };
 });
-var createStandaloneConfig = Effect6.fn("nextjs.createStandaloneConfig")(function* (defaults, projectFolder, manifest) {
-  const pathService = yield* Path5.Path;
+var createStandaloneConfig = Effect8.fn("nextjs.createStandaloneConfig")(function* (defaults, projectFolder, manifest) {
+  const pathService = yield* Path7.Path;
   const resolved = yield* resolveStandaloneServer(projectFolder, manifest.distDir, manifest.repoRootToProject);
   if (!resolved) return defaults;
   const { standaloneRoot, serverDirectory, entrypoint } = resolved;
@@ -795,7 +1581,7 @@ var createStandaloneConfig = Effect6.fn("nextjs.createStandaloneConfig")(functio
     }
   };
 });
-var createStandaloneV2Config = Effect6.fn("nextjs.createStandaloneV2Config")(function* (defaults, projectFolder, manifest) {
+var createStandaloneV2Config = Effect8.fn("nextjs.createStandaloneV2Config")(function* (defaults, projectFolder, manifest) {
   const resolved = yield* resolveStandaloneServer(projectFolder, manifest.distDir, manifest.repoRootToProject);
   if (!resolved) return defaults;
   const { standaloneRoot, serverDirectory, entrypoint } = resolved;
@@ -903,9 +1689,9 @@ var nextjs = {
     routes: [{ source: "/*", destination: ".next/standalone/server.js" }],
     environmentVariables: { NODE_ENV: "production" }
   }),
-  refineDefaultConfig: (defaults, projectFolder) => Effect6.gen(function* () {
-    const fs = yield* FileSystem6.FileSystem;
-    const manifestContent = yield* fs.readFileString(`${projectFolder}/.gigadrive/nextjs.json`).pipe(Effect6.catchAll(() => Effect6.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => Effect8.gen(function* () {
+    const fs = yield* FileSystem8.FileSystem;
+    const manifestContent = yield* fs.readFileString(`${projectFolder}/.gigadrive/nextjs.json`).pipe(Effect8.catchAll(() => Effect8.succeed(void 0)));
     const manifest = manifestContent ? parseGigadriveNextBuildManifest(manifestContent) : void 0;
     if (!manifest) return defaults;
     if (manifest.version === 2) {
@@ -916,8 +1702,8 @@ var nextjs = {
 };
 
 // src/detection/frameworks/nuxt.ts
-import { FileSystem as FileSystem7 } from "@effect/platform";
-import { Effect as Effect7 } from "effect";
+import { FileSystem as FileSystem9 } from "@effect/platform";
+import { Effect as Effect9 } from "effect";
 var isVercelBuildOutputV3 = (content) => {
   try {
     const config = JSON.parse(content);
@@ -944,9 +1730,9 @@ var nuxt = {
     routes: [{ source: "/*", destination: ".output/server/index.mjs" }],
     environmentVariables: { NODE_ENV: "production", NITRO_PRESET: "node-server" }
   }),
-  refineDefaultConfig: (defaults, projectFolder) => Effect7.gen(function* () {
-    const fs = yield* FileSystem7.FileSystem;
-    const buildOutputConfig = yield* fs.readFileString(`${projectFolder}/.vercel/output/config.json`).pipe(Effect7.catchAll(() => Effect7.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => Effect9.gen(function* () {
+    const fs = yield* FileSystem9.FileSystem;
+    const buildOutputConfig = yield* fs.readFileString(`${projectFolder}/.vercel/output/config.json`).pipe(Effect9.catchAll(() => Effect9.succeed(void 0)));
     if (!buildOutputConfig || !isVercelBuildOutputV3(buildOutputConfig)) {
       return defaults;
     }
@@ -1069,7 +1855,7 @@ var FRAMEWORK_DEFINITIONS = [
 ].sort((a, b) => b.priority - a.priority);
 
 // src/detection/generate-config.ts
-import { Effect as Effect8 } from "effect";
+import { Effect as Effect10 } from "effect";
 var getInstallCommand = (pm) => {
   switch (pm) {
     case "bun":
@@ -1085,11 +1871,11 @@ var getInstallCommand = (pm) => {
       return "npm install";
   }
 };
-var generateConfig = Effect8.fn("generateConfig")(function* (framework, packageManager, projectFolder, refinedDefaults) {
+var generateConfig = Effect10.fn("generateConfig")(function* (framework, packageManager, projectFolder, refinedDefaults) {
   const defaults = refinedDefaults ?? framework.getDefaultConfig(packageManager);
   const installCmd = defaults.installCommand ?? getInstallCommand(packageManager);
   const commands = [installCmd, ...defaults.commands];
-  yield* Effect8.logDebug(`Generating config for ${framework.name}`, {
+  yield* Effect10.logDebug(`Generating config for ${framework.name}`, {
     runtime: defaults.runtime,
     entrypoint: defaults.entrypoint,
     commands
@@ -1154,31 +1940,31 @@ var generateConfig = Effect8.fn("generateConfig")(function* (framework, packageM
 });
 
 // src/detection/read-dependencies.ts
-import { FileSystem as FileSystem8, Path as Path6 } from "@effect/platform";
-import { Effect as Effect10 } from "effect";
+import { FileSystem as FileSystem10, Path as Path8 } from "@effect/platform";
+import { Effect as Effect12 } from "effect";
 
 // src/detection/types.ts
-import { Schema as Schema4 } from "effect";
-var ManifestNotFoundError = class extends Schema4.TaggedError()("ManifestNotFoundError", {
-  message: Schema4.String,
-  filePath: Schema4.String
+import { Schema as Schema5 } from "effect";
+var ManifestNotFoundError = class extends Schema5.TaggedError()("ManifestNotFoundError", {
+  message: Schema5.String,
+  filePath: Schema5.String
 }) {
 };
-var ManifestReadError = class extends Schema4.TaggedError()("ManifestReadError", {
-  message: Schema4.String,
-  filePath: Schema4.String
+var ManifestReadError = class extends Schema5.TaggedError()("ManifestReadError", {
+  message: Schema5.String,
+  filePath: Schema5.String
 }) {
 };
-var ManifestParseError = class extends Schema4.TaggedError()("ManifestParseError", {
-  message: Schema4.String,
-  filePath: Schema4.String
+var ManifestParseError = class extends Schema5.TaggedError()("ManifestParseError", {
+  message: Schema5.String,
+  filePath: Schema5.String
 }) {
 };
-var FrameworkNotDetectedError = class extends Schema4.TaggedError()(
+var FrameworkNotDetectedError = class extends Schema5.TaggedError()(
   "FrameworkNotDetectedError",
   {
-    message: Schema4.String,
-    directory: Schema4.String
+    message: Schema5.String,
+    directory: Schema5.String
   }
 ) {
 };
@@ -1188,25 +1974,25 @@ var MANIFEST_CONFIG = {
   node: { file: "package.json", depKeys: ["dependencies", "devDependencies"] },
   php: { file: "composer.json", depKeys: ["require", "require-dev"] }
 };
-var readManifest = Effect10.fn("readManifest")(function* (filePath) {
-  const fs = yield* FileSystem8.FileSystem;
-  const exists = yield* fs.exists(filePath).pipe(Effect10.catchAll(() => Effect10.succeed(false)));
+var readManifest = Effect12.fn("readManifest")(function* (filePath) {
+  const fs = yield* FileSystem10.FileSystem;
+  const exists = yield* fs.exists(filePath).pipe(Effect12.catchAll(() => Effect12.succeed(false)));
   if (!exists) {
-    return yield* Effect10.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
+    return yield* Effect12.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
   }
-  const content = yield* fs.readFileString(filePath).pipe(Effect10.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
-  const parsed = yield* Effect10.try({
+  const content = yield* fs.readFileString(filePath).pipe(Effect12.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
+  const parsed = yield* Effect12.try({
     try: () => JSON.parse(content),
     catch: () => new ManifestParseError({ message: "Failed to parse manifest JSON", filePath })
   });
   return parsed;
 });
-var readDependencies = Effect10.fn("readDependencies")(function* (projectFolder, language) {
-  const pathService = yield* Path6.Path;
+var readDependencies = Effect12.fn("readDependencies")(function* (projectFolder, language) {
+  const pathService = yield* Path8.Path;
   const config = MANIFEST_CONFIG[language];
   const filePath = pathService.join(projectFolder, config.file);
   const manifest = yield* readManifest(filePath).pipe(
-    Effect10.catchTag("ManifestNotFoundError", () => Effect10.succeed(null))
+    Effect12.catchTag("ManifestNotFoundError", () => Effect12.succeed(null))
   );
   if (!manifest) {
     return /* @__PURE__ */ new Set();
@@ -1224,9 +2010,9 @@ var readDependencies = Effect10.fn("readDependencies")(function* (projectFolder,
 });
 
 // src/detection/detect-framework.ts
-var matchesDetectionItem = Effect11.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
-  const fs = yield* FileSystem9.FileSystem;
-  const pathService = yield* Path7.Path;
+var matchesDetectionItem = Effect13.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
+  const fs = yield* FileSystem11.FileSystem;
+  const pathService = yield* Path9.Path;
   if (item.matchPackage != null) {
     const deps = yield* cachedReadDeps(`${projectFolder}\0${framework.language}`);
     if (!deps.has(item.matchPackage)) {
@@ -1235,12 +2021,12 @@ var matchesDetectionItem = Effect11.fn("matchesDetectionItem")(function* (item,
   }
   if (item.path != null) {
     const filePath = pathService.join(projectFolder, item.path);
-    const exists = yield* fs.exists(filePath).pipe(Effect11.catchAll(() => Effect11.succeed(false)));
+    const exists = yield* fs.exists(filePath).pipe(Effect13.catchAll(() => Effect13.succeed(false)));
     if (!exists) {
       return false;
     }
     if (item.matchContent != null) {
-      const content = yield* fs.readFileString(filePath).pipe(Effect11.catchAll(() => Effect11.succeed("")));
+      const content = yield* fs.readFileString(filePath).pipe(Effect13.catchAll(() => Effect13.succeed("")));
       let regexMatch = false;
       try {
         regexMatch = new RegExp(item.matchContent).test(content);
@@ -1253,7 +2039,7 @@ var matchesDetectionItem = Effect11.fn("matchesDetectionItem")(function* (item,
   }
   return true;
 });
-var matchesFramework = Effect11.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
+var matchesFramework = Effect13.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
   for (const detector of framework.detectors) {
     const matches = yield* matchesDetectionItem(detector, projectFolder, framework, cachedReadDeps);
     if (!matches) {
@@ -1262,9 +2048,9 @@ var matchesFramework = Effect11.fn("matchesFramework")(function* (framework, pro
   }
   return true;
 });
-var detectFramework = Effect11.fn("detectFramework")(function* (projectFolder) {
-  yield* Effect11.logDebug(`Detecting framework in ${projectFolder}`);
-  const cachedReadDeps = yield* Effect11.cachedFunction((key) => {
+var detectFramework = Effect13.fn("detectFramework")(function* (projectFolder) {
+  yield* Effect13.logDebug(`Detecting framework in ${projectFolder}`);
+  const cachedReadDeps = yield* Effect13.cachedFunction((key) => {
     const sepIndex = key.lastIndexOf("\0");
     const folder = key.slice(0, sepIndex);
     const language = key.slice(sepIndex + 1);
@@ -1273,7 +2059,7 @@ var detectFramework = Effect11.fn("detectFramework")(function* (projectFolder) {
   for (const framework of FRAMEWORK_DEFINITIONS) {
     const matches = yield* matchesFramework(framework, projectFolder, cachedReadDeps);
     if (matches) {
-      yield* Effect11.log(`Detected framework: ${framework.name}`, { slug: framework.slug });
+      yield* Effect13.log(`Detected framework: ${framework.name}`, { slug: framework.slug });
       const detectedPackageManager = yield* detectPackageManager(projectFolder);
       const packageManager = framework.language === "php" ? "composer" : detectedPackageManager;
       const defaults = framework.getDefaultConfig(packageManager);
@@ -1282,7 +2068,7 @@ var detectFramework = Effect11.fn("detectFramework")(function* (projectFolder) {
       return { framework, packageManager, config };
     }
   }
-  return yield* Effect11.fail(
+  return yield* Effect13.fail(
     new FrameworkNotDetectedError({
       message: `No framework detected in project directory`,
       directory: projectFolder
@@ -1291,15 +2077,22 @@ var detectFramework = Effect11.fn("detectFramework")(function* (projectFolder) {
 });
 
 // src/detection/merge-config.ts
-import { Effect as Effect12 } from "effect";
-var mergeWithFrameworkDefaults = Effect12.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
-  yield* Effect12.logDebug("Merging user config with framework defaults");
+import { Effect as Effect14 } from "effect";
+var mergeWithFrameworkDefaults = Effect14.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
+  yield* Effect14.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 isContainer = (entrypoint) => entrypoint.runtime === CONTAINER_RUNTIME;
+  const userFileFunctions = userConfig.entrypoints.filter((entrypoint) => !isContainer(entrypoint));
+  const containerPaths = new Set(userConfig.entrypoints.filter(isContainer).map((entrypoint) => entrypoint.path));
+  const targetsContainer = (route) => containerPaths.has(route.destination.replace(/^\/+/, ""));
   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,
+    entrypoints: [
+      ...userFileFunctions.length > 0 ? userFileFunctions : frameworkConfig.entrypoints,
+      ...userConfig.entrypoints.filter(isContainer)
+    ],
+    routes: containerPaths.size > 0 && userConfig.routes.every(targetsContainer) ? [...userConfig.routes, ...frameworkConfig.routes] : userConfig.routes.length > 0 ? userConfig.routes : frameworkConfig.routes,
     assets: userHasAssets ? userConfig.assets : frameworkConfig.assets,
     environmentVariables: {
       ...frameworkConfig.environmentVariables,
@@ -1307,6 +2100,7 @@ var mergeWithFrameworkDefaults = Effect12.fn("mergeWithFrameworkDefaults")(funct
     },
     excludeFiles: userConfig.excludeFiles && userConfig.excludeFiles.length > 0 ? userConfig.excludeFiles : frameworkConfig.excludeFiles,
     services: userConfig.services,
+    ...userConfig.sidecars !== void 0 && { sidecars: userConfig.sidecars },
     userArchive: userConfig.userArchive,
     warnings: [...frameworkConfig.warnings, ...userConfig.warnings],
     errors: [...frameworkConfig.errors, ...userConfig.errors]
@@ -1314,51 +2108,6 @@ var mergeWithFrameworkDefaults = Effect12.fn("mergeWithFrameworkDefaults")(funct
   return merged;
 });
 
-// src/errors.ts
-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 ConfigFileParseError = class extends Schema5.TaggedError()("ConfigFileParseError", {
-  message: Schema5.String,
-  filePath: Schema5.String,
-  cause: Schema5.optional(Schema5.String)
-}) {
-};
-var ConfigModuleLoadError = class extends Schema5.TaggedError()("ConfigModuleLoadError", {
-  message: Schema5.String,
-  filePath: Schema5.String,
-  cause: Schema5.optional(Schema5.String)
-}) {
-};
-var ConfigVersionError = class extends Schema5.TaggedError()("ConfigVersionError", {
-  message: Schema5.String,
-  filePath: Schema5.String,
-  version: Schema5.optional(Schema5.Number)
-}) {
-};
-var ConfigSchemaValidationError = class extends Schema5.TaggedError()(
-  "ConfigSchemaValidationError",
-  {
-    message: Schema5.String,
-    filePath: Schema5.String,
-    validationErrors: Schema5.Array(Schema5.String)
-  }
-) {
-};
-var FunctionConfigError = class extends Schema5.TaggedError()("FunctionConfigError", {
-  message: Schema5.String,
-  functionPath: Schema5.String
-}) {
-};
-
 // src/filter-functions-from-assets.ts
 var filterFunctionsFromAssets = (config) => {
   return {
@@ -1370,28 +2119,24 @@ var filterFunctionsFromAssets = (config) => {
   };
 };
 
-// src/normalized-config.ts
-var DEFAULT_FUNCTION_DURATION_SECONDS = 30;
-var MAX_FUNCTION_DURATION_SECONDS = 28800;
-
 // src/parse-config.ts
-import { Effect as Effect18 } from "effect";
+import { Effect as Effect20 } from "effect";
 
 // src/services/raw-config-reader.ts
-import { FileSystem as FileSystem10, Path as Path8 } from "@effect/platform";
-import { Effect as Effect14 } from "effect";
-import { parse as parseYaml } from "yaml";
+import { FileSystem as FileSystem12, Path as Path10 } from "@effect/platform";
+import { Effect as Effect16 } from "effect";
+import { parse as parseYaml2 } from "yaml";
 
 // src/services/config-module-loader.ts
-import { Effect as Effect13 } from "effect";
+import { Effect as Effect15 } 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 Effect13.Service()("ConfigModuleLoader", {
-  effect: Effect13.gen(function* () {
-    const loadConfigModule = Effect13.fn("ConfigModuleLoader.loadConfigModule")(function* (filePath) {
+var ConfigModuleLoader = class extends Effect15.Service()("ConfigModuleLoader", {
+  effect: Effect15.gen(function* () {
+    const loadConfigModule = Effect15.fn("ConfigModuleLoader.loadConfigModule")(function* (filePath) {
       const extension = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
-      const mod = yield* Effect13.tryPromise({
+      const mod = yield* Effect15.tryPromise({
         try: async () => {
           const jiti = createJiti(filePath, { fsCache: false, interopDefault: true, moduleCache: false });
           const namespace = await jiti.import(filePath);
@@ -1410,7 +2155,7 @@ var ConfigModuleLoader = class extends Effect13.Service()("ConfigModuleLoader",
         })
       });
       if (mod === MISSING_DEFAULT_EXPORT) {
-        return yield* Effect13.fail(
+        return yield* Effect15.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
@@ -1418,7 +2163,7 @@ var ConfigModuleLoader = class extends Effect13.Service()("ConfigModuleLoader",
         );
       }
       if (typeof mod === "function") {
-        return yield* Effect13.fail(
+        return yield* Effect15.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
@@ -1426,7 +2171,7 @@ var ConfigModuleLoader = class extends Effect13.Service()("ConfigModuleLoader",
         );
       }
       if (typeof mod !== "object" || mod === null || Array.isArray(mod)) {
-        return yield* Effect13.fail(
+        return yield* Effect15.fail(
           new ConfigModuleLoadError({
             message: `Config module at ${filePath} must default-export a config object.`,
             filePath
@@ -1456,36 +2201,36 @@ var ALLOWED_CONFIG_NAMES = [
   "nebula.json"
 ];
 var MODULE_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
-var RawConfigReader = class extends Effect14.Service()("RawConfigReader", {
+var RawConfigReader = class extends Effect16.Service()("RawConfigReader", {
   dependencies: [ConfigModuleLoader.Default],
-  effect: Effect14.gen(function* () {
-    const fs = yield* FileSystem10.FileSystem;
-    const pathService = yield* Path8.Path;
+  effect: Effect16.gen(function* () {
+    const fs = yield* FileSystem12.FileSystem;
+    const pathService = yield* Path10.Path;
     const moduleLoader = yield* ConfigModuleLoader;
-    const findConfig = Effect14.fn("RawConfigReader.findConfig")(function* (projectFolder) {
+    const findConfig = Effect16.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(Effect14.catchAll(() => Effect14.succeed(false)));
+        const exists = yield* fs.exists(filePath).pipe(Effect16.catchAll(() => Effect16.succeed(false)));
         if (exists) {
           return filePath;
         }
       }
       return null;
     });
-    const readRawConfig = Effect14.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
-      const exists = yield* fs.exists(filePath).pipe(Effect14.catchAll(() => Effect14.succeed(false)));
+    const readRawConfig = Effect16.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
+      const exists = yield* fs.exists(filePath).pipe(Effect16.catchAll(() => Effect16.succeed(false)));
       if (!exists) {
-        return yield* Effect14.fail(
+        return yield* Effect16.fail(
           new ConfigFileNotFoundError({ message: `Config file not found at ${filePath}`, filePath })
         );
       }
       const fileContents = yield* fs.readFileString(filePath).pipe(
-        Effect14.mapError(
+        Effect16.mapError(
           () => new ConfigFileParseError({ message: `Failed to read config file at ${filePath}`, filePath })
         )
       );
       if (fileContents.length === 0) {
-        return yield* Effect14.fail(
+        return yield* Effect16.fail(
           new ConfigFileEmptyError({ message: `Config file is empty at ${filePath}`, filePath })
         );
       }
@@ -1498,10 +2243,10 @@ var RawConfigReader = class extends Effect14.Service()("RawConfigReader", {
           if (fileExtension === ".json") {
             parsed = JSON.parse(fileContents);
           } else {
-            parsed = parseYaml(fileContents);
+            parsed = parseYaml2(fileContents);
           }
         } catch (error) {
-          return yield* Effect14.fail(
+          return yield* Effect16.fail(
             new ConfigFileParseError({
               message: `Failed to parse config file at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
               filePath,
@@ -1511,21 +2256,21 @@ var RawConfigReader = class extends Effect14.Service()("RawConfigReader", {
         }
       }
       if (parsed == null) {
-        return yield* Effect14.fail(
+        return yield* Effect16.fail(
           new ConfigFileParseError({ message: `Config file could not be parsed at ${filePath}`, filePath })
         );
       }
       if (!options?.disableVersionCheck && typeof parsed.version !== "number") {
-        return yield* Effect14.fail(
+        return yield* Effect16.fail(
           new ConfigVersionError({ message: `Config file is missing version at ${filePath}`, filePath })
         );
       }
       return parsed;
     });
     const readConfigFile = (configFilePath) => readRawConfig(configFilePath, { disableVersionCheck: true }).pipe(
-      Effect14.map((parsed) => parsed),
-      Effect14.catchTag("ConfigFileNotFoundError", () => Effect14.succeed(null)),
-      Effect14.withSpan("RawConfigReader.readConfigFile")
+      Effect16.map((parsed) => parsed),
+      Effect16.catchTag("ConfigFileNotFoundError", () => Effect16.succeed(null)),
+      Effect16.withSpan("RawConfigReader.readConfigFile")
     );
     return { findConfig, readRawConfig, readConfigFile };
   })
@@ -1535,17 +2280,17 @@ var RawConfigReader = class extends Effect14.Service()("RawConfigReader", {
 // src/services/schema-validator.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-import { Effect as Effect15 } from "effect";
-var SchemaValidator = class extends Effect15.Service()("SchemaValidator", {
-  effect: Effect15.gen(function* () {
+import { Effect as Effect17 } from "effect";
+var SchemaValidator = class extends Effect17.Service()("SchemaValidator", {
+  effect: Effect17.gen(function* () {
     const ajv = new Ajv();
     addFormats(ajv);
-    const validate = Effect15.fn("SchemaValidator.validate")(function* (config, schema, filePath) {
+    const validate = Effect17.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* Effect15.fail(
+        return yield* Effect17.fail(
           new ConfigSchemaValidationError({
             message: `Config file at ${filePath} is invalid: ${ajv.errorsText(compiledValidate.errors)}`,
             filePath,
@@ -1601,8 +2346,9 @@ var getFilesForPattern = async (pattern, projectFolder, excludeFiles = []) => {
 };
 
 // src/services/v4-config-parser.ts
-import { Effect as Effect16 } from "effect";
+import { Effect as Effect18 } from "effect";
 import { minimatch as minimatch2 } from "minimatch";
+import { posix as posix2 } from "path";
 import safeRegex from "safe-regex2";
 var DEFAULT_FUNCTION_SETTINGS = {
   memory: 128,
@@ -1635,6 +2381,46 @@ var normalizeImagePolicy = (images) => {
     variants: images.variants ?? {}
   };
 };
+var DURATION_UNIT_SECONDS = { s: 1, m: 60, h: 3600, d: 86400 };
+var queueDurationSeconds = (value) => {
+  if (value === void 0) return void 0;
+  if (typeof value === "number") return value;
+  const match = /^(\d+(?:\.\d+)?)(s|m|h|d)$/.exec(value);
+  if (!match)
+    throw new Error(`Invalid queue duration "${value}". Use seconds or a string such as 30s, 10m, 1.5h or 4d.`);
+  return Math.ceil(Number(match[1]) * DURATION_UNIT_SECONDS[match[2]]);
+};
+var byName = (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+var definedOnly = (value) => Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+var normalizeQueue = (name, queue) => {
+  if (queue === null) return { name };
+  const schedules = queue.schedules ? Object.entries(queue.schedules).map(
+    ([scheduleName, schedule]) => definedOnly({
+      name: scheduleName,
+      cron: schedule.cron,
+      timezone: schedule.timezone,
+      body: schedule.body === void 0 || typeof schedule.body === "string" ? schedule.body : JSON.stringify(schedule.body),
+      // A plain-text body labelled JSON would fail to decode on every fire.
+      contentType: schedule.contentType ?? (typeof schedule.body === "string" ? "text/plain; charset=utf-8" : void 0),
+      headers: schedule.headers,
+      enabled: schedule.enabled
+    })
+  ).sort(byName) : void 0;
+  return definedOnly({
+    name,
+    consumer: queue.consumer,
+    visibilityTimeoutSeconds: queueDurationSeconds(queue.visibilityTimeout),
+    retentionSeconds: queueDurationSeconds(queue.retention),
+    maxAttempts: queue.maxAttempts,
+    retryBackoffMinSeconds: queueDurationSeconds(queue.retryBackoff?.min),
+    retryBackoffMaxSeconds: queueDurationSeconds(queue.retryBackoff?.max),
+    deduplicationWindowSeconds: queueDurationSeconds(queue.deduplicationWindow),
+    concurrency: queue.concurrency,
+    rateLimit: queue.rateLimit == null ? queue.rateLimit : { count: queue.rateLimit.count, periodSeconds: queueDurationSeconds(queue.rateLimit.period) ?? 1 },
+    deadLetter: queue.deadLetter,
+    schedules
+  });
+};
 var normalizeServices = (services) => {
   if (services == null) return void 0;
   const normalized = [];
@@ -1647,7 +2433,13 @@ var normalizeServices = (services) => {
   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)
+      buckets: Object.entries(services.storage.buckets).map(([name, bucket]) => ({ name, visibility: bucket?.visibility ?? "private" })).sort(byName)
+    });
+  }
+  if (services.queues !== void 0) {
+    normalized.push({
+      type: "queues",
+      queues: Object.entries(services.queues).map(([name, queue]) => normalizeQueue(name, queue)).sort(byName)
     });
   }
   return normalized.length > 0 ? normalized : void 0;
@@ -1705,9 +2497,10 @@ var mapRoute = (route, entrypoints) => ({
   negativeRequirements: route.missing,
   status: route.statusCode
 });
-var parseEntrypoints = Effect16.fn("parseEntrypoints")(function* (config, projectFolder) {
+var parseEntrypoints = Effect18.fn("parseEntrypoints")(function* (config, projectFolder) {
   const entrypoints = [];
-  if (config.functions == null) return entrypoints;
+  const dockerFunctions = [];
+  if (config.functions == null) return { entrypoints, dockerFunctions };
   for (const [fnPath, func] of Object.entries(config.functions)) {
     if (getFunctionSettings(fnPath, config) == null) {
       return yield* new FunctionConfigError({
@@ -1715,7 +2508,7 @@ var parseEntrypoints = Effect16.fn("parseEntrypoints")(function* (config, projec
         functionPath: fnPath
       });
     }
-    const matchedFiles = yield* Effect16.tryPromise({
+    const matchedFiles = yield* Effect18.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)}`,
@@ -1732,6 +2525,35 @@ var parseEntrypoints = Effect16.fn("parseEntrypoints")(function* (config, projec
           functionPath: file
         });
       }
+      if (settings.runtime === CONTAINER_RUNTIME) {
+        const unsupported = ["symlinks", "includeFiles"].filter((key) => settings[key] !== void 0);
+        if (unsupported.length > 0) {
+          return yield* new FunctionConfigError({
+            message: `Function '${file}' runs a Dockerfile, so ${unsupported.join(" and ")} do not apply. Copy files in the Dockerfile instead.`,
+            functionPath: file
+          });
+        }
+        const declared = Object.entries(config.functions).filter(([pattern]) => matchesPattern(file, pattern)).reduce((merged, [, value]) => ({ ...merged, ...value }), {});
+        dockerFunctions.push({
+          file,
+          name: dockerFunctionContainerName(file),
+          container: {
+            build: { context: posix2.dirname(file), dockerfile: posix2.basename(file) },
+            ...declared.port !== void 0 && { port: declared.port },
+            ...declared.memory !== void 0 && { memory: declared.memory },
+            ...declared.max_duration !== void 0 && { max_duration: declared.max_duration },
+            ...declared.streaming !== void 0 && { streaming: declared.streaming },
+            ...func.schedule !== void 0 && { schedule: func.schedule }
+          }
+        });
+        continue;
+      }
+      if (settings.port !== void 0) {
+        return yield* new FunctionConfigError({
+          message: `Function '${file}' sets port, which only applies to 'runtime: docker'.`,
+          functionPath: file
+        });
+      }
       const runtime = settings.runtime ?? "node-20";
       const streaming = settings.streaming ?? runtimeStreamsByDefault(runtime);
       entrypoints.push({
@@ -1749,25 +2571,84 @@ var parseEntrypoints = Effect16.fn("parseEntrypoints")(function* (config, projec
       });
     }
   }
-  return entrypoints;
+  dockerFunctions.sort((left, right) => left.file < right.file ? -1 : left.file > right.file ? 1 : 0);
+  for (const [index, { file, name }] of dockerFunctions.entries()) {
+    const clash = dockerFunctions.slice(0, index).find((candidate) => candidate.name === name);
+    if (clash !== void 0) {
+      return yield* new FunctionConfigError({
+        message: `Functions '${clash.file}' and '${file}' would both be named '${name}'. Declare one of them under 'containers' with an explicit name.`,
+        functionPath: file
+      });
+    }
+  }
+  return { entrypoints, dockerFunctions };
 });
-var collectAssets = Effect16.fn("collectAssets")(function* (config, projectFolder) {
+var collectAssets = Effect18.fn("collectAssets")(function* (config, projectFolder) {
   if (config.assets == null) return [];
   const assetNames = yield* collectAssetFiles(projectFolder, config.assets);
   return assetNames.filter((assetName) => getFunctionSettings(`${config.assets}/${assetName}`, config) == null).map((assetName) => `${config.assets}/${assetName}`);
 });
-var V4ConfigParser = class extends Effect16.Service()("V4ConfigParser", {
+var reservedRuntimePorts = (entrypoint) => entrypoint.runtime === CONTAINER_RUNTIME ? [] : entrypoint.runtime.startsWith("php-") ? [8080, 9e3] : [8080];
+var parseContainers = Effect18.fn("parseContainers")(function* (config, projectFolder, fileEntrypoints, dockerFunctions) {
+  const warnings = [];
+  let containers = {};
+  if (config.compose != null) {
+    const imported = yield* readComposeContainers(config.compose, projectFolder);
+    containers = imported.containers;
+    warnings.push(...imported.warnings);
+  }
+  containers = { ...containers, ...config.containers ?? {} };
+  for (const { file, name, container } of dockerFunctions) {
+    if (containers[name] !== void 0) {
+      return yield* new ContainerConfigError({
+        message: `Function '${file}' runs as container '${name}', which 'containers' or the Compose file already declares. Rename one of them.`,
+        containerName: name
+      });
+    }
+    containers[name] = container;
+  }
+  const result = yield* normalizeContainers(containers, projectFolder);
+  warnings.push(...result.warnings);
+  for (const entrypoint of fileEntrypoints) {
+    for (const port of reservedRuntimePorts(entrypoint)) {
+      const sidecar = result.sidecars.find((candidate) => candidate.port === port);
+      if (sidecar !== void 0) {
+        return yield* new ContainerConfigError({
+          message: `Sidecar '${sidecar.name}' listens on port ${port}, which the ${entrypoint.runtime} runtime of '${entrypoint.path}' uses inside the same microVM. Choose another port.`,
+          containerName: sidecar.name
+        });
+      }
+    }
+  }
+  return { ...result, warnings };
+});
+var V4ConfigParser = class extends Effect18.Service()("V4ConfigParser", {
   accessors: true,
-  effect: Effect16.succeed({
+  effect: Effect18.succeed({
     /**
      * Parses a ConfigV4 into a NormalizedConfig.
      *
      * @param config - The raw V4 config object
      * @param projectFolder - Absolute path to the project root
      */
-    parse: Effect16.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
-      const entrypoints = yield* parseEntrypoints(config, projectFolder);
+    parse: Effect18.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
+      const { entrypoints: fileEntrypoints, dockerFunctions } = yield* parseEntrypoints(config, projectFolder);
+      const containers = yield* parseContainers(config, projectFolder, fileEntrypoints, dockerFunctions);
+      const entrypoints = [...fileEntrypoints, ...containers.entrypoints];
       const assets = yield* collectAssets(config, projectFolder);
+      const dockerFunctionPaths = new Map(
+        dockerFunctions.map(({ file, name }) => [file, containerEntrypointPath(name)])
+      );
+      const routes = (config.routes ?? []).map(
+        (route) => mapRoute(
+          {
+            ...route,
+            destination: dockerFunctionPaths.get(normalizeRouteDestination(route.destination)) ?? route.destination
+          },
+          entrypoints
+        )
+      );
+      const warnings = [...containers.warnings];
       return {
         regions: resolveRegions(config.regions),
         assets: {
@@ -1780,10 +2661,11 @@ var V4ConfigParser = class extends Effect16.Service()("V4ConfigParser", {
         commands: config.build_commands ?? [],
         images: normalizeImagePolicy(config.images),
         services: normalizeServices(config.services),
+        ...containers.sidecars.length > 0 && { sidecars: containers.sidecars },
         entrypoints,
         errors: [],
-        warnings: [],
-        routes: (config.routes ?? []).map((route) => mapRoute(route, entrypoints))
+        warnings,
+        routes
       };
     })
   })
@@ -1791,7 +2673,7 @@ var V4ConfigParser = class extends Effect16.Service()("V4ConfigParser", {
 };
 
 // src/services/vercel-build-output-parser.ts
-import { Path as Path9 } from "@effect/platform";
+import { Path as Path11 } from "@effect/platform";
 
 // ../commons/src/deep-merge.ts
 var deepMerge = (target, ...partials) => {
@@ -1820,7 +2702,7 @@ var deepMerge = (target, ...partials) => {
 };
 
 // src/services/vercel-build-output-parser.ts
-import { Effect as Effect17 } from "effect";
+import { Effect as Effect19 } from "effect";
 
 // src/build-output-v3/determine-repo-root.ts
 import path from "path";
@@ -1916,11 +2798,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 Effect17.Service()("VercelBuildOutputParser", {
-  effect: Effect17.gen(function* () {
+var VercelBuildOutputParser = class extends Effect19.Service()("VercelBuildOutputParser", {
+  effect: Effect19.gen(function* () {
     const rawConfigReader = yield* RawConfigReader;
-    const pathService = yield* Path9.Path;
-    const parse = Effect17.fn("VercelBuildOutputParser.parse")(function* (parseResult, projectFolder) {
+    const pathService = yield* Path11.Path;
+    const parse = Effect19.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;
@@ -1932,8 +2814,8 @@ var VercelBuildOutputParser = class extends Effect17.Service()("VercelBuildOutpu
       merged.regions = [...new Set(merged.regions)];
       return merged;
     });
-    const loadFunctions = Effect17.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
-      const functionConfigs = yield* Effect17.tryPromise({
+    const loadFunctions = Effect19.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
+      const functionConfigs = yield* Effect19.tryPromise({
         try: () => getFilesForPattern(FUNCTION_CONFIGS_PATTERN, projectFolder),
         catch: (error) => new ConfigFileParseError({
           message: `Failed to scan for function configs: ${error instanceof Error ? error.message : String(error)}`,
@@ -2219,17 +3101,22 @@ var schema_default = {
             minimum: 1
           },
           runtime: {
-            $ref: "#/$defs/runtimes",
-            description: "The runtime to use for the function."
+            anyOf: [{ $ref: "#/$defs/runtimes" }, { const: "docker" }],
+            description: "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."
+          },
+          port: {
+            type: "integer",
+            minimum: 1,
+            maximum: 65535,
+            description: "TCP port the image listens on. Only for `runtime: docker`. Defaults to the first exposed port of the image, then 8080."
           },
           streaming: {
             type: "boolean",
             description: "Enable function response streaming. When omitted, Node and Bun runtimes stream by default."
           },
           schedule: {
-            type: "string",
-            description: "An expression to schedule the function to run at specific times.",
-            pattern: "^(?:rate[(](?:(?:1[ ]+(hour|minute|day))|(?:[0-9]+[ ]+(hours|minutes|days)))[)])|(?:cron[(](?:(?:(?:[0-5]?[0-9])|[*])(?:(?:[-](?:(?:[0-5]?[0-9])|[*]))|(?:[/][0-9]+))?(?:[,](?:(?:[0-5]?[0-9])|[*])(?:(?:[-](?:(?:[0-5]?[0-9])|[*]))|(?:[/][0-9]+))?)*)[ ]+(?:(?:(?:[0-2]?[0-9])|[*])(?:(?:[-](?:(?:[0-2]?[0-9])|[*]))|(?:[/][0-9]+))?(?:[,](?:(?:[0-2]?[0-9])|[*])(?:(?:[-](?:(?:[0-2]?[0-9])|[*]))|(?:[/][0-9]+))?)*)[ ]+(?:(?:[?][ ]+(?:(?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:(?:[-](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:[/][0-9]+)?)|(?:[/][0-9]+))?(?:[,](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:(?:[-](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:[/][0-9]+)?)|(?:[/][0-9]+))?)*)[ ]+(?:(?:(?:[1-7]|(?:SUN|MON|TUE|WED|THU|FRI|SAT))[#][0-5])|(?:(?:(?:(?:[1-7]|(?:SUN|MON|TUE|WED|THU|FRI|SAT))L?)|[L*])(?:(?:[-](?:(?:(?:[1-7]|(?:SUN|MON|TUE|WED|THU|FRI|SAT))L?)|[L*]))|(?:[/][0-9]+))?(?:[,](?:(?:(?:[1-7]|(?:SUN|MON|TUE|WED|THU|FRI|SAT))L?)|[L*])(?:(?:[-](?:(?:(?:[1-7]|(?:SUN|MON|TUE|WED|THU|FRI|SAT))L?)|[L*]))|(?:[/][0-9]+))?)*)))|(?:(?:(?:(?:(?:[1-3]?[0-9])W?)|LW|[L*])(?:(?:[-](?:(?:(?:[1-3]?[0-9])W?)|LW|[L*]))|(?:[/][0-9]+))?(?:[,](?:(?:(?:[1-3]?[0-9])W?)|LW|[L*])(?:(?:[-](?:(?:(?:[1-3]?[0-9])W?)|LW|[L*]))|(?:[/][0-9]+))?)*)[ ]+(?:(?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:(?:[-](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:[/][0-9]+)?)|(?:[/][0-9]+))?(?:[,](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:(?:[-](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:[/][0-9]+)?)|(?:[/][0-9]+))?)*)[ ]+[?]))[ ]+(?:(?:(?:[12][0-9]{3})|[*])(?:(?:[-](?:(?:[12][0-9]{3})|[*]))|(?:[/][0-9]+))?(?:[,](?:(?:[12][0-9]{3})|[*])(?:(?:[-](?:(?:[12][0-9]{3})|[*]))|(?:[/][0-9]+))?)*)[)])$"
+            $ref: "#/$defs/schedule",
+            description: "An expression to schedule the function to run at specific times."
           },
           symlinks: {
             type: "object",
@@ -2321,6 +3208,151 @@ var schema_default = {
         }
       }
     },
+    compose: {
+      type: ["string", "null"],
+      minLength: 1,
+      maxLength: 1024,
+      description: "Project-relative path of a Compose file whose services are imported as containers. Entries in `containers` win over imported services of the same name."
+    },
+    containers: {
+      type: ["object", "null"],
+      description: "Container images to run, keyed by name. A container runs as a function unless `sidecar` is true; routes target it with `destination: container:<name>`. A sidecar runs next to every function instance and answers at `<name>:<port>`.",
+      maxProperties: 16,
+      propertyNames: {
+        pattern: "^[a-z][a-z0-9_-]{0,62}$",
+        not: {
+          enum: ["localhost"]
+        }
+      },
+      additionalProperties: {
+        type: "object",
+        additionalProperties: false,
+        oneOf: [
+          {
+            required: ["image"]
+          },
+          {
+            required: ["build"]
+          }
+        ],
+        properties: {
+          image: {
+            type: "string",
+            minLength: 1,
+            maxLength: 512,
+            pattern: "^[^\\s]+$",
+            description: "Registry image reference, e.g. `redis:7-alpine` or `ghcr.io/acme/api:1.4`."
+          },
+          build: {
+            description: "Build context directory, or the full build settings, for a Dockerfile in the repository.",
+            oneOf: [
+              {
+                type: "string",
+                minLength: 1,
+                maxLength: 1024
+              },
+              {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  context: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 1024
+                  },
+                  dockerfile: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 1024
+                  },
+                  target: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 128
+                  },
+                  args: {
+                    type: "object",
+                    maxProperties: 100,
+                    additionalProperties: {
+                      type: "string",
+                      maxLength: 65536
+                    }
+                  }
+                }
+              }
+            ]
+          },
+          sidecar: {
+            type: "boolean",
+            description: "Run next to every function instance instead of serving routes. Defaults to false."
+          },
+          port: {
+            type: "integer",
+            minimum: 1,
+            maximum: 65535,
+            description: "TCP port the container listens on. Defaults to the first exposed port of the image, then 8080."
+          },
+          entrypoint: {
+            $ref: "#/$defs/stringOrStringArray",
+            description: "Replaces the image ENTRYPOINT. A string is split into words the way Compose splits it."
+          },
+          command: {
+            $ref: "#/$defs/stringOrStringArray",
+            description: "Replaces the image CMD. A string is split into words the way Compose splits it."
+          },
+          env: {
+            type: "object",
+            maxProperties: 100,
+            additionalProperties: {
+              type: "string",
+              maxLength: 65536
+            },
+            description: "Environment variables baked into the container, merged over the image ENV."
+          },
+          working_dir: {
+            type: "string",
+            minLength: 1,
+            maxLength: 1024,
+            pattern: "^/",
+            description: "Replaces the image WORKDIR. Must be absolute."
+          },
+          user: {
+            oneOf: [
+              {
+                type: "string",
+                minLength: 1,
+                maxLength: 256
+              },
+              {
+                type: "integer",
+                minimum: 0
+              }
+            ],
+            description: "Replaces the image USER: a name, a uid, `name:group` or `uid:gid`. A bare uid may be a number."
+          },
+          memory: {
+            type: "integer",
+            minimum: 128,
+            maximum: 3009,
+            description: "Memory in MB. Defaults to 512 for a container function and 256 for a sidecar."
+          },
+          max_duration: {
+            type: "number",
+            minimum: 1,
+            maximum: 28800,
+            description: "Maximum lifetime in seconds of one request. Container functions only."
+          },
+          streaming: {
+            type: "boolean",
+            description: "Stream responses. Defaults to true. Container functions only."
+          },
+          schedule: {
+            $ref: "#/$defs/schedule",
+            description: "An expression to run the container function at specific times. Container functions only."
+          }
+        }
+      }
+    },
     services: {
       type: "object",
       description: "Managed services to provision for the deployment environment.",
@@ -2471,11 +3503,179 @@ var schema_default = {
               }
             }
           }
+        },
+        queues: {
+          type: "object",
+          description: "Queues to provision in the deployment environment, keyed by name. Use null for a pull queue with default settings. Queues you stop declaring are kept, with their messages.",
+          propertyNames: {
+            maxLength: 255,
+            pattern: "^[A-Za-z0-9_][A-Za-z0-9_.~:@+=-]*$"
+          },
+          additionalProperties: {
+            oneOf: [
+              {
+                type: "null"
+              },
+              {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  consumer: {
+                    type: ["string", "null"],
+                    pattern: "^/(?!/)\\S*$",
+                    maxLength: 2048,
+                    description: "Deployment-relative path that receives each message as a signed POST, for example /api/queues/emails. Omit it for a pull queue that you drain with receive."
+                  },
+                  visibilityTimeout: {
+                    $ref: "#/$defs/queueDuration",
+                    description: "How long a push delivery may run, or how long a received message stays leased. Defaults to 60 seconds, at most 12 hours."
+                  },
+                  retention: {
+                    $ref: "#/$defs/queueDuration",
+                    description: "How long an undelivered message is kept. Defaults to 4 days, at most 14 days."
+                  },
+                  maxAttempts: {
+                    type: "integer",
+                    minimum: 1,
+                    maximum: 100,
+                    description: "Deliveries per message before it moves to the dead-letter list. Defaults to 10."
+                  },
+                  retryBackoff: {
+                    type: "object",
+                    additionalProperties: false,
+                    description: "Exponential backoff between failed deliveries. Defaults to 5 seconds, doubling up to 15 minutes.",
+                    properties: {
+                      min: {
+                        $ref: "#/$defs/queueDuration"
+                      },
+                      max: {
+                        $ref: "#/$defs/queueDuration"
+                      }
+                    }
+                  },
+                  deduplicationWindow: {
+                    $ref: "#/$defs/queueDuration",
+                    description: "How long a deduplication key is remembered. Defaults to 24 hours, at most 7 days."
+                  },
+                  concurrency: {
+                    type: ["integer", "null"],
+                    minimum: 1,
+                    maximum: 1e3,
+                    description: "Most push deliveries in flight at once. Defaults to 100."
+                  },
+                  rateLimit: {
+                    oneOf: [
+                      {
+                        type: "null"
+                      },
+                      {
+                        type: "object",
+                        required: ["count"],
+                        additionalProperties: false,
+                        properties: {
+                          count: {
+                            type: "integer",
+                            minimum: 1,
+                            maximum: 1e6
+                          },
+                          period: {
+                            $ref: "#/$defs/queueDuration"
+                          }
+                        }
+                      }
+                    ],
+                    description: "Most deliveries started per period. The period defaults to one second."
+                  },
+                  deadLetter: {
+                    type: "boolean",
+                    description: "Keep messages that run out of attempts so you can inspect and redrive them. Defaults to true."
+                  },
+                  schedules: {
+                    type: "object",
+                    description: "Cron schedules that send a message into this queue, keyed by schedule name.",
+                    propertyNames: {
+                      maxLength: 128,
+                      pattern: "^[A-Za-z0-9_][A-Za-z0-9_.-]*$"
+                    },
+                    additionalProperties: {
+                      type: "object",
+                      required: ["cron"],
+                      additionalProperties: false,
+                      properties: {
+                        cron: {
+                          type: "string",
+                          minLength: 1,
+                          maxLength: 255,
+                          description: "Five-field cron expression, or a macro such as @hourly or @daily."
+                        },
+                        timezone: {
+                          type: "string",
+                          description: "IANA time zone the expression is evaluated in. Defaults to UTC."
+                        },
+                        body: {
+                          description: "Message body. Strings are sent as is; any other value is sent as JSON."
+                        },
+                        contentType: {
+                          type: "string",
+                          description: "Content type of the body. Defaults to text/plain for a string body and application/json otherwise."
+                        },
+                        headers: {
+                          type: "object",
+                          additionalProperties: {
+                            type: "string"
+                          },
+                          description: "Headers delivered with every message from this schedule."
+                        },
+                        enabled: {
+                          type: "boolean",
+                          description: "Set to false to keep the schedule without sending. Defaults to true."
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            ]
+          }
         }
       }
     }
   },
   $defs: {
+    schedule: {
+      type: "string",
+      pattern: "^(?:rate[(](?:(?:1[ ]+(hour|minute|day))|(?:[0-9]+[ ]+(hours|minutes|days)))[)])|(?:cron[(](?:(?:(?:[0-5]?[0-9])|[*])(?:(?:[-](?:(?:[0-5]?[0-9])|[*]))|(?:[/][0-9]+))?(?:[,](?:(?:[0-5]?[0-9])|[*])(?:(?:[-](?:(?:[0-5]?[0-9])|[*]))|(?:[/][0-9]+))?)*)[ ]+(?:(?:(?:[0-2]?[0-9])|[*])(?:(?:[-](?:(?:[0-2]?[0-9])|[*]))|(?:[/][0-9]+))?(?:[,](?:(?:[0-2]?[0-9])|[*])(?:(?:[-](?:(?:[0-2]?[0-9])|[*]))|(?:[/][0-9]+))?)*)[ ]+(?:(?:[?][ ]+(?:(?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:(?:[-](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:[/][0-9]+)?)|(?:[/][0-9]+))?(?:[,](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:(?:[-](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:[/][0-9]+)?)|(?:[/][0-9]+))?)*)[ ]+(?:(?:(?:[1-7]|(?:SUN|MON|TUE|WED|THU|FRI|SAT))[#][0-5])|(?:(?:(?:(?:[1-7]|(?:SUN|MON|TUE|WED|THU|FRI|SAT))L?)|[L*])(?:(?:[-](?:(?:(?:[1-7]|(?:SUN|MON|TUE|WED|THU|FRI|SAT))L?)|[L*]))|(?:[/][0-9]+))?(?:[,](?:(?:(?:[1-7]|(?:SUN|MON|TUE|WED|THU|FRI|SAT))L?)|[L*])(?:(?:[-](?:(?:(?:[1-7]|(?:SUN|MON|TUE|WED|THU|FRI|SAT))L?)|[L*]))|(?:[/][0-9]+))?)*)))|(?:(?:(?:(?:(?:[1-3]?[0-9])W?)|LW|[L*])(?:(?:[-](?:(?:(?:[1-3]?[0-9])W?)|LW|[L*]))|(?:[/][0-9]+))?(?:[,](?:(?:(?:[1-3]?[0-9])W?)|LW|[L*])(?:(?:[-](?:(?:(?:[1-3]?[0-9])W?)|LW|[L*]))|(?:[/][0-9]+))?)*)[ ]+(?:(?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:(?:[-](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:[/][0-9]+)?)|(?:[/][0-9]+))?(?:[,](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:(?:[-](?:(?:[1]?[0-9])|(?:JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)|[*])(?:[/][0-9]+)?)|(?:[/][0-9]+))?)*)[ ]+[?]))[ ]+(?:(?:(?:[12][0-9]{3})|[*])(?:(?:[-](?:(?:[12][0-9]{3})|[*]))|(?:[/][0-9]+))?(?:[,](?:(?:[12][0-9]{3})|[*])(?:(?:[-](?:(?:[12][0-9]{3})|[*]))|(?:[/][0-9]+))?)*)[)])$"
+    },
+    stringOrStringArray: {
+      oneOf: [
+        {
+          type: "string",
+          minLength: 1,
+          maxLength: 4096
+        },
+        {
+          type: "array",
+          maxItems: 256,
+          items: {
+            type: "string",
+            maxLength: 4096
+          }
+        }
+      ]
+    },
+    queueDuration: {
+      oneOf: [
+        {
+          type: "integer",
+          minimum: 0
+        },
+        {
+          type: "string",
+          pattern: "^[0-9]+(\\.[0-9]+)?(s|m|h|d)$"
+        }
+      ],
+      description: "A duration in seconds, or a string such as 30s, 10m, 1.5h or 4d."
+    },
     runtimes: {
       type: "string",
       enum: ["php-84", "php-83", "php-81", "node-22", "node-20", "node-18", "node-16", "bun-1"]
@@ -2532,7 +3732,7 @@ var schema_default = {
 };
 
 // src/parse-config.ts
-var parseConfigRaw = Effect18.fn("parseConfigRaw")(function* (filePath, projectFolder) {
+var parseConfigRaw = Effect20.fn("parseConfigRaw")(function* (filePath, projectFolder) {
   const rawReader = yield* RawConfigReader;
   const validator = yield* SchemaValidator;
   const v4Parser = yield* V4ConfigParser;
@@ -2543,7 +3743,7 @@ var parseConfigRaw = Effect18.fn("parseConfigRaw")(function* (filePath, projectF
   };
   const schema = schemaMap[version];
   if (!schema) {
-    return yield* Effect18.fail(
+    return yield* Effect20.fail(
       new ConfigVersionError({
         message: `Config file at ${filePath} has an unsupported version: ${version}`,
         filePath,
@@ -2554,14 +3754,42 @@ var parseConfigRaw = Effect18.fn("parseConfigRaw")(function* (filePath, projectF
   yield* validator.validate(parsed, schema, filePath);
   return yield* v4Parser.parse(parsed, projectFolder);
 });
-var parseConfig = Effect18.fn("parseConfig")(function* (filePath, projectFolder) {
+var parseConfig = Effect20.fn("parseConfig")(function* (filePath, projectFolder) {
   const parseResult = yield* parseConfigRaw(filePath, projectFolder);
   return yield* postProcessConfig(parseResult, projectFolder);
 });
-var postProcessConfig = Effect18.fn("postProcessConfig")(function* (config, projectFolder) {
+var postProcessConfig = Effect20.fn("postProcessConfig")(function* (config, projectFolder) {
   const vercelParser = yield* VercelBuildOutputParser;
   let result = yield* vercelParser.parse(config, projectFolder);
   const hasAssets = (result.assets?.paths?.length ?? 0) > 0 || (result.assets?.prefixes?.length ?? 0) > 0 || (result.assets?.manifests?.length ?? 0) > 0;
+  const containerFunctions = result.entrypoints.filter((entrypoint) => entrypoint.runtime === CONTAINER_RUNTIME);
+  const [onlyFunction] = result.entrypoints;
+  if (onlyFunction !== void 0 && onlyFunction.runtime === CONTAINER_RUNTIME && result.entrypoints.length === 1 && result.routes.length === 0 && !hasAssets) {
+    result = {
+      ...result,
+      routes: [
+        {
+          path: "/*",
+          destination: onlyFunction.path,
+          handler: onlyFunction.streaming === true ? "SERVERLESS_FUNCTION_STREAMING" : "SERVERLESS_FUNCTION",
+          methods: ["ANY"],
+          headers: {}
+        }
+      ]
+    };
+  } else {
+    for (const entrypoint of containerFunctions) {
+      const routed = result.routes.some((route) => route.destination.replace(/^\/+/, "") === entrypoint.path);
+      if (!routed && entrypoint.schedule === void 0) {
+        result.warnings.push(
+          `Container function '${entrypoint.displayName ?? entrypoint.path}' has no route and no schedule, so nothing reaches it. Add a route with destination '${entrypoint.path}'.`
+        );
+      }
+    }
+  }
+  if ((result.sidecars?.length ?? 0) > 0 && result.entrypoints.length === 0) {
+    result.warnings.push("Sidecars run next to functions, and this deployment has none, so no sidecar will start.");
+  }
   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."
@@ -2599,6 +3827,9 @@ export {
   ALLOWED_CONFIG_NAMES,
   AVAILABLE_REGIONS,
   AVAILABLE_RUNTIMES,
+  COMPOSE_FILE_NAMES,
+  CONTAINER_ENTRYPOINT_PREFIX,
+  CONTAINER_RUNTIME,
   ConfigFileEmptyError,
   ConfigFileNotFoundError,
   ConfigFileParseError,
@@ -2606,7 +3837,10 @@ export {
   ConfigModuleLoader,
   ConfigSchemaValidationError,
   ConfigVersionError,
+  ContainerConfigError,
+  DEFAULT_CONTAINER_MEMORY_MB,
   DEFAULT_FUNCTION_DURATION_SECONDS,
+  DEFAULT_SIDECAR_MEMORY_MB,
   FRAMEWORK_DEFINITIONS,
   FrameworkNotDetectedError,
   FunctionConfigError,
@@ -2623,6 +3857,7 @@ export {
   GigadriveNextServerDescriptorSchema,
   GigadriveNextStaticAssetPrefixSchema,
   MAX_FUNCTION_DURATION_SECONDS,
+  MAX_SIDECARS,
   ManifestNotFoundError,
   ManifestParseError,
   ManifestReadError,
@@ -2635,19 +3870,26 @@ export {
   V4ConfigParser,
   VercelBuildOutputParser,
   collectAssetFiles,
+  composeDeclaresApp,
+  containerEntrypointPath,
   defineConfig,
+  detectContainerProject,
   detectFramework,
   detectPackageManager,
+  dockerFunctionContainerName,
   filterFunctionsFromAssets,
   generateConfig,
   getFunctionSettings,
   mergeWithFrameworkDefaults,
+  normalizeContainers,
   parseConfig,
   parseConfigRaw,
   parseGigadriveNextBuildManifest,
   parseGigadriveNextPrerenderManifest,
   parseStaticAssetManifest,
   postProcessConfig,
-  readDependencies
+  readComposeContainers,
+  readDependencies,
+  splitCommandWords
 };
 //# sourceMappingURL=index.mjs.map