@gigadrive/network-config 5.3.1 → 5.5.0

package/dist/index.js

@@ -46,6 +46,7 @@ __export(src_exports, {
   ContainerConfigError: () => ContainerConfigError,
   DEFAULT_CONTAINER_MEMORY_MB: () => DEFAULT_CONTAINER_MEMORY_MB,
   DEFAULT_FUNCTION_DURATION_SECONDS: () => DEFAULT_FUNCTION_DURATION_SECONDS,
+  DEFAULT_RUBY_RUNTIME: () => DEFAULT_RUBY_RUNTIME,
   DEFAULT_SIDECAR_MEMORY_MB: () => DEFAULT_SIDECAR_MEMORY_MB,
   FRAMEWORK_DEFINITIONS: () => FRAMEWORK_DEFINITIONS,
   FrameworkNotDetectedError: () => FrameworkNotDetectedError,
@@ -82,6 +83,7 @@ __export(src_exports, {
   detectContainerProject: () => detectContainerProject,
   detectFramework: () => detectFramework,
   detectPackageManager: () => detectPackageManager,
+  detectRubyRuntime: () => detectRubyRuntime,
   dockerFunctionContainerName: () => dockerFunctionContainerName,
   filterFunctionsFromAssets: () => filterFunctionsFromAssets,
   generateConfig: () => generateConfig,
@@ -97,6 +99,9 @@ __export(src_exports, {
   postProcessConfig: () => postProcessConfig,
   readComposeContainers: () => readComposeContainers,
   readDependencies: () => readDependencies,
+  rubyRuntimeForRequirement: () => rubyRuntimeForRequirement,
+  rubyRuntimeForVersion: () => rubyRuntimeForVersion,
+  rubyRuntimeFromProjectFiles: () => rubyRuntimeFromProjectFiles,
   splitCommandWords: () => splitCommandWords
 });
 module.exports = __toCommonJS(src_exports);
@@ -1008,8 +1013,8 @@ var detectContainerProject = import_effect6.Effect.fn("detectContainerProject")(
 });
 
 // src/detection/detect-framework.ts
-var import_platform12 = require("@effect/platform");
-var import_effect18 = require("effect");
+var import_platform16 = require("@effect/platform");
+var import_effect24 = require("effect");
 
 // src/detection/detect-package-manager.ts
 var import_platform4 = require("@effect/platform");
@@ -1019,7 +1024,10 @@ var LOCKFILE_MAP = [
   { files: ["pnpm-lock.yaml"], pm: "pnpm" },
   { files: ["yarn.lock"], pm: "yarn" },
   { files: ["package-lock.json"], pm: "npm" },
-  { files: ["composer.lock"], pm: "composer" }
+  { files: ["composer.lock"], pm: "composer" },
+  // A Gemfile is checked last and counts even without its lockfile: Bundler
+  // resolves and writes Gemfile.lock on the first install.
+  { files: ["Gemfile.lock", "Gemfile"], pm: "bundler" }
 ];
 var detectPackageManager = import_effect7.Effect.fn("detectPackageManager")(function* (projectFolder) {
   const fs = yield* import_platform4.FileSystem.FileSystem;
@@ -1058,6 +1066,192 @@ var astro = {
   })
 };
 
+// src/detection/frameworks/ruby-runtime.ts
+var import_platform5 = require("@effect/platform");
+var import_effect8 = require("effect");
+
+// src/detection/frameworks/ruby-requirement.ts
+var RUBY_VERSION = /^(?:ruby-)?(\d+(?:\.\d+)*)(?:p\d+)?(?:[-.]?(?:preview|rc|dev|alpha|beta|pre)\d*)?$/i;
+var REQUIREMENT_ATOM = /^(~>|>=|<=|!=|=|>|<)?\s*(\S+)$/;
+var parseRubyVersion = (text) => {
+  const match = RUBY_VERSION.exec(text);
+  return match ? match[1].split(".").map(Number) : void 0;
+};
+var compareRubyVersions = (a, b) => {
+  for (let index = 0; index < Math.max(a.length, b.length); index++) {
+    const difference = (a[index] ?? 0) - (b[index] ?? 0);
+    if (difference !== 0) {
+      return difference;
+    }
+  }
+  return 0;
+};
+var pessimisticUpperBound = (segments) => {
+  const kept = segments.length > 1 ? segments.slice(0, -1) : [...segments];
+  kept[kept.length - 1] += 1;
+  return kept;
+};
+var parseRubyRequirement = (requirement) => {
+  const parts = requirement.split(",").map((part) => part.trim());
+  const atoms = [];
+  for (const part of parts) {
+    const match = REQUIREMENT_ATOM.exec(part);
+    const segments = match ? parseRubyVersion(match[2]) : void 0;
+    if (!match || !segments) {
+      return void 0;
+    }
+    atoms.push({ operator: match[1] ?? "=", segments });
+  }
+  return atoms;
+};
+var atomAllows = ({ operator, segments }, version) => {
+  const comparison = compareRubyVersions(version, segments);
+  switch (operator) {
+    case "=":
+      return comparison === 0;
+    case "!=":
+      return comparison !== 0;
+    case ">":
+      return comparison > 0;
+    case "<":
+      return comparison < 0;
+    case ">=":
+      return comparison >= 0;
+    case "<=":
+      return comparison <= 0;
+    case "~>":
+      return comparison >= 0 && compareRubyVersions(version, pessimisticUpperBound(segments)) < 0;
+  }
+};
+var rubyRequirementAllows = (requirement, version) => {
+  const atoms = parseRubyRequirement(requirement);
+  const segments = parseRubyVersion(version);
+  if (!atoms || !segments) {
+    return void 0;
+  }
+  return atoms.every((atom) => atomAllows(atom, segments));
+};
+
+// src/detection/frameworks/ruby-runtime.ts
+var DEFAULT_RUBY_RUNTIME = "ruby-34";
+var RUBY_RUNTIME_CANDIDATES = [
+  { runtime: "ruby-40", series: [4, 0], newestVersion: "4.0.9999" },
+  { runtime: "ruby-34", series: [3, 4], newestVersion: "3.4.9999" },
+  { runtime: "ruby-33", series: [3, 3], newestVersion: "3.3.9999" }
+];
+var rubyRuntimeForVersion = (version) => {
+  const segments = parseRubyVersion(version);
+  if (!segments) {
+    return void 0;
+  }
+  const series = [segments[0], segments[1] ?? 0];
+  const candidate = RUBY_RUNTIME_CANDIDATES.find((candidate2) => compareRubyVersions(candidate2.series, series) <= 0);
+  return (candidate ?? RUBY_RUNTIME_CANDIDATES[RUBY_RUNTIME_CANDIDATES.length - 1]).runtime;
+};
+var rubyRuntimeForRequirement = (requirement) => {
+  const atoms = parseRubyRequirement(requirement);
+  if (!atoms) {
+    return void 0;
+  }
+  if (atoms.length === 1 && atoms[0].operator === "=") {
+    return rubyRuntimeForVersion(atoms[0].segments.join("."));
+  }
+  return RUBY_RUNTIME_CANDIDATES.find(({ newestVersion }) => rubyRequirementAllows(requirement, newestVersion) === true)?.runtime;
+};
+var versionFromRubyVersionFile = (content) => content.split(/\r?\n/).map((line) => line.trim()).find((line) => line !== "" && !line.startsWith("#"))?.split(/\s/)[0]?.split("@")[0];
+var versionFromToolVersionsFile = (content) => /^\s*ruby\s+(\S+)/m.exec(content)?.[1];
+var versionFromGemfileLock = (content) => /^RUBY VERSION\r?\n\s+ruby\s+(\S+)/m.exec(content)?.[1];
+var GEMFILE_RUBY_DIRECTIVE = /^\s*ruby[\s(]+(.+)$/m;
+var GEMFILE_RUBY_FILE = /^(?:file:|:file\s*=>|File\.read\s*\(?)\s*(['"])([^'"]+)\1/;
+var LEADING_STRINGS = /^\s*(['"])([^'"]*)\1\s*(?:,|\)|#|$)/;
+var RUBY_VERSION_FILES = [".ruby-version", ".tool-versions", "Gemfile", "Gemfile.lock"];
+var gemfileRubyDirective = (gemfile) => GEMFILE_RUBY_DIRECTIVE.exec(gemfile)?.[1]?.trim();
+var gemfileRubyVersionFile = (gemfile) => {
+  const directive = gemfileRubyDirective(gemfile);
+  return directive === void 0 ? void 0 : GEMFILE_RUBY_FILE.exec(directive)?.[2];
+};
+var runtimeFromVersionFile = (file, content) => {
+  if (content === void 0) {
+    return void 0;
+  }
+  const parse = file.split("/").at(-1) === ".tool-versions" ? versionFromToolVersionsFile : versionFromRubyVersionFile;
+  const version = parse(content);
+  return version === void 0 ? void 0 : rubyRuntimeForVersion(version);
+};
+var runtimeFromGemfile = (gemfile, readFile) => {
+  const directive = gemfile === void 0 ? void 0 : gemfileRubyDirective(gemfile);
+  if (directive === void 0) {
+    return void 0;
+  }
+  const versionFile = GEMFILE_RUBY_FILE.exec(directive)?.[2];
+  if (versionFile !== void 0) {
+    return runtimeFromVersionFile(versionFile, readFile(versionFile));
+  }
+  const requirements = [];
+  let rest = directive;
+  for (let match = LEADING_STRINGS.exec(rest); match; match = LEADING_STRINGS.exec(rest)) {
+    requirements.push(match[2]);
+    rest = rest.slice(match[0].length);
+  }
+  return requirements.length === 0 ? void 0 : rubyRuntimeForRequirement(requirements.join(","));
+};
+var runtimeFromGemfileLock = (lockfile) => {
+  const version = lockfile === void 0 ? void 0 : versionFromGemfileLock(lockfile);
+  return version === void 0 ? void 0 : rubyRuntimeForVersion(version);
+};
+var rubyRuntimeFromProjectFiles = (readFile) => runtimeFromVersionFile(".ruby-version", readFile(".ruby-version")) ?? runtimeFromVersionFile(".tool-versions", readFile(".tool-versions")) ?? runtimeFromGemfile(readFile("Gemfile"), readFile) ?? runtimeFromGemfileLock(readFile("Gemfile.lock"));
+var readProjectFile = import_effect8.Effect.fn("readProjectFile")(
+  function* (projectFolder, file) {
+    const fs = yield* import_platform5.FileSystem.FileSystem;
+    const pathService = yield* import_platform5.Path.Path;
+    return yield* fs.readFileString(pathService.join(projectFolder, file));
+  },
+  import_effect8.Effect.catchAll(() => import_effect8.Effect.succeed(void 0))
+);
+var detectRubyRuntime = import_effect8.Effect.fn("detectRubyRuntime")(function* (projectFolder) {
+  const files = /* @__PURE__ */ new Map();
+  for (const file of RUBY_VERSION_FILES) {
+    files.set(file, yield* readProjectFile(projectFolder, file));
+  }
+  const gemfile = files.get("Gemfile");
+  const versionFile = gemfile === void 0 ? void 0 : gemfileRubyVersionFile(gemfile);
+  if (versionFile !== void 0 && !files.has(versionFile)) {
+    files.set(versionFile, yield* readProjectFile(projectFolder, versionFile));
+  }
+  return rubyRuntimeFromProjectFiles((file) => files.get(file));
+});
+var refineRubyRuntime = import_effect8.Effect.fn("refineRubyRuntime")(function* (defaults, projectFolder) {
+  const runtime = yield* detectRubyRuntime(projectFolder);
+  return runtime ? { ...defaults, runtime } : defaults;
+});
+var withRubyRuntime = (framework) => ({
+  ...framework,
+  refineDefaultConfig: (defaults, projectFolder) => import_effect8.Effect.gen(function* () {
+    const refined = framework.refineDefaultConfig ? yield* framework.refineDefaultConfig(defaults, projectFolder) : defaults;
+    return yield* refineRubyRuntime(refined, projectFolder);
+  })
+});
+
+// src/detection/frameworks/bridgetown.ts
+var bridgetown = {
+  slug: "bridgetown",
+  name: "Bridgetown",
+  language: "ruby",
+  detectors: [{ matchPackage: "bridgetown" }],
+  priority: 70,
+  getDefaultConfig: () => ({
+    runtime: DEFAULT_RUBY_RUNTIME,
+    memory: 128,
+    maxDuration: 30,
+    streaming: false,
+    commands: ["bin/bridgetown deploy"],
+    assetsDir: "output",
+    populateAssetCache: true,
+    routes: [],
+    environmentVariables: { BRIDGETOWN_ENV: "production" }
+  })
+};
+
 // src/detection/generated-secret.ts
 var generatedSecret = (format) => `{{gigadrive.secret:${format}}}`;
 
@@ -1132,8 +1326,8 @@ var codeigniter = {
 };
 
 // src/detection/frameworks/resolve-node-entrypoint.ts
-var import_platform5 = require("@effect/platform");
-var import_effect8 = require("effect");
+var import_platform6 = require("@effect/platform");
+var import_effect9 = require("effect");
 var SCRIPT_RUNNERS = /* @__PURE__ */ new Set(["node", "bun", "tsx", "ts-node"]);
 var COMMON_ENTRYPOINT_CANDIDATES = [
   "index.js",
@@ -1181,14 +1375,14 @@ var applyEntrypoint = (defaults, entrypoint) => ({
     (route) => route.destination === defaults.entrypoint ? { ...route, destination: entrypoint } : route
   )
 });
-var resolveNodeServerEntrypoint = (defaults, projectFolder) => import_effect8.Effect.gen(function* () {
-  const fs = yield* import_platform5.FileSystem.FileSystem;
-  const pathService = yield* import_platform5.Path.Path;
+var resolveNodeServerEntrypoint = (defaults, projectFolder) => import_effect9.Effect.gen(function* () {
+  const fs = yield* import_platform6.FileSystem.FileSystem;
+  const pathService = yield* import_platform6.Path.Path;
   const isFile = (relativePath) => fs.stat(pathService.join(projectFolder, relativePath)).pipe(
-    import_effect8.Effect.map((info) => info.type === "File"),
-    import_effect8.Effect.catchAll(() => import_effect8.Effect.succeed(false))
+    import_effect9.Effect.map((info) => info.type === "File"),
+    import_effect9.Effect.catchAll(() => import_effect9.Effect.succeed(false))
   );
-  const content = yield* fs.readFileString(pathService.join(projectFolder, "package.json")).pipe(import_effect8.Effect.catchAll(() => import_effect8.Effect.succeed(void 0)));
+  const content = yield* fs.readFileString(pathService.join(projectFolder, "package.json")).pipe(import_effect9.Effect.catchAll(() => import_effect9.Effect.succeed(void 0)));
   const manifest = content ? parsePackageJson(content) : void 0;
   const startScript = typeof manifest?.scripts?.start === "string" ? manifest.scripts.start : void 0;
   const candidates = [
@@ -1268,6 +1462,189 @@ var fastify = {
   refineDefaultConfig: resolveNodeServerEntrypoint
 };
 
+// src/detection/frameworks/hanami.ts
+var import_effect13 = require("effect");
+
+// src/detection/read-dependencies.ts
+var import_platform7 = require("@effect/platform");
+var import_effect11 = require("effect");
+
+// src/detection/types.ts
+var import_effect10 = require("effect");
+var ManifestNotFoundError = class extends import_effect10.Schema.TaggedError()("ManifestNotFoundError", {
+  message: import_effect10.Schema.String,
+  filePath: import_effect10.Schema.String
+}) {
+};
+var ManifestReadError = class extends import_effect10.Schema.TaggedError()("ManifestReadError", {
+  message: import_effect10.Schema.String,
+  filePath: import_effect10.Schema.String
+}) {
+};
+var ManifestParseError = class extends import_effect10.Schema.TaggedError()("ManifestParseError", {
+  message: import_effect10.Schema.String,
+  filePath: import_effect10.Schema.String
+}) {
+};
+var FrameworkNotDetectedError = class extends import_effect10.Schema.TaggedError()(
+  "FrameworkNotDetectedError",
+  {
+    message: import_effect10.Schema.String,
+    directory: import_effect10.Schema.String
+  }
+) {
+};
+
+// src/detection/read-dependencies.ts
+var MANIFEST_CONFIG = {
+  node: { file: "package.json", depKeys: ["dependencies", "devDependencies"] },
+  php: { file: "composer.json", depKeys: ["require", "require-dev"] }
+};
+var GEMFILE_LOCK_SOURCE_SECTIONS = /* @__PURE__ */ new Set(["GEM", "GIT", "PATH"]);
+var GEMFILE_LOCK_SPEC = /^ {4}([A-Za-z0-9_.-]+) \(/;
+var GEMFILE_GEM = /^\s*gem[\s(]+['"]([^'"]+)['"]/;
+var parseGemfileLock = (content) => {
+  const gems = /* @__PURE__ */ new Set();
+  let inSourceSection = false;
+  for (const line of content.split(/\r?\n/)) {
+    if (/^\S/.test(line)) {
+      inSourceSection = GEMFILE_LOCK_SOURCE_SECTIONS.has(line.trim());
+      continue;
+    }
+    const match = inSourceSection ? GEMFILE_LOCK_SPEC.exec(line) : null;
+    if (match) {
+      gems.add(match[1]);
+    }
+  }
+  return gems;
+};
+var parseGemfile = (content) => {
+  const gems = /* @__PURE__ */ new Set();
+  for (const line of content.split(/\r?\n/)) {
+    const match = GEMFILE_GEM.exec(line);
+    if (match) {
+      gems.add(match[1]);
+    }
+  }
+  return gems;
+};
+var readOptionalText = import_effect11.Effect.fn("readOptionalText")(function* (filePath) {
+  const fs = yield* import_platform7.FileSystem.FileSystem;
+  const exists = yield* fs.exists(filePath).pipe(import_effect11.Effect.catchAll(() => import_effect11.Effect.succeed(false)));
+  if (!exists) {
+    return void 0;
+  }
+  return yield* fs.readFileString(filePath).pipe(import_effect11.Effect.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
+});
+var readGemNames = import_effect11.Effect.fn("readGemNames")(function* (projectFolder) {
+  const pathService = yield* import_platform7.Path.Path;
+  const lockfile = yield* readOptionalText(pathService.join(projectFolder, "Gemfile.lock"));
+  if (lockfile !== void 0) {
+    return parseGemfileLock(lockfile);
+  }
+  const gemfile = yield* readOptionalText(pathService.join(projectFolder, "Gemfile"));
+  return gemfile === void 0 ? /* @__PURE__ */ new Set() : parseGemfile(gemfile);
+});
+var readManifest = import_effect11.Effect.fn("readManifest")(function* (filePath) {
+  const fs = yield* import_platform7.FileSystem.FileSystem;
+  const exists = yield* fs.exists(filePath).pipe(import_effect11.Effect.catchAll(() => import_effect11.Effect.succeed(false)));
+  if (!exists) {
+    return yield* import_effect11.Effect.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
+  }
+  const content = yield* fs.readFileString(filePath).pipe(import_effect11.Effect.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
+  const parsed = yield* import_effect11.Effect.try({
+    try: () => JSON.parse(content),
+    catch: () => new ManifestParseError({ message: "Failed to parse manifest JSON", filePath })
+  });
+  return parsed;
+});
+var readDependencies = import_effect11.Effect.fn("readDependencies")(function* (projectFolder, language) {
+  if (language === "ruby") {
+    return yield* readGemNames(projectFolder);
+  }
+  const pathService = yield* import_platform7.Path.Path;
+  const config = MANIFEST_CONFIG[language];
+  const filePath = pathService.join(projectFolder, config.file);
+  const manifest = yield* readManifest(filePath).pipe(
+    import_effect11.Effect.catchTag("ManifestNotFoundError", () => import_effect11.Effect.succeed(null))
+  );
+  if (!manifest) {
+    return /* @__PURE__ */ new Set();
+  }
+  const deps = /* @__PURE__ */ new Set();
+  for (const key of config.depKeys) {
+    const section = manifest[key];
+    if (section && typeof section === "object" && !Array.isArray(section)) {
+      for (const name of Object.keys(section)) {
+        deps.add(name);
+      }
+    }
+  }
+  return deps;
+});
+
+// src/detection/frameworks/ruby-server.ts
+var import_platform8 = require("@effect/platform");
+var import_effect12 = require("effect");
+var rubyServerDefaults = ({
+  entrypoint = "config.ru",
+  memory = 256,
+  commands = [],
+  environmentVariables,
+  excludeFiles,
+  writablePaths = []
+}) => ({
+  runtime: DEFAULT_RUBY_RUNTIME,
+  memory,
+  maxDuration: 30,
+  streaming: true,
+  commands,
+  entrypoint,
+  assetsDir: "public",
+  populateAssetCache: true,
+  routes: [{ source: "/*", destination: entrypoint }],
+  environmentVariables,
+  ...excludeFiles ? { excludeFiles } : {},
+  ...writablePaths.length > 0 ? { package: { writablePaths } } : {}
+});
+var refineRubyPublicDirectory = import_effect12.Effect.fn("refineRubyPublicDirectory")(function* (defaults, projectFolder) {
+  if (!defaults.assetsDir) {
+    return defaults;
+  }
+  const fs = yield* import_platform8.FileSystem.FileSystem;
+  const pathService = yield* import_platform8.Path.Path;
+  const exists = yield* fs.exists(pathService.join(projectFolder, defaults.assetsDir)).pipe(import_effect12.Effect.catchAll(() => import_effect12.Effect.succeed(false)));
+  if (exists) {
+    return defaults;
+  }
+  const withoutAssets = { ...defaults };
+  delete withoutAssets.assetsDir;
+  delete withoutAssets.populateAssetCache;
+  return withoutAssets;
+});
+
+// src/detection/frameworks/hanami.ts
+var refineHanamiAssets = import_effect13.Effect.fn("refineHanamiAssets")(function* (defaults, projectFolder) {
+  const gems = yield* readDependencies(projectFolder, "ruby").pipe(
+    import_effect13.Effect.catchAll(() => import_effect13.Effect.succeed(/* @__PURE__ */ new Set()))
+  );
+  const withPublicDirectory = yield* refineRubyPublicDirectory(defaults, projectFolder);
+  return gems.has("hanami-assets") ? { ...withPublicDirectory, commands: [...withPublicDirectory.commands, "bundle exec hanami assets compile"] } : withPublicDirectory;
+});
+var hanami = {
+  slug: "hanami",
+  name: "Hanami",
+  language: "ruby",
+  detectors: [{ matchPackage: "hanami" }, { path: "config.ru" }],
+  priority: 75,
+  getDefaultConfig: () => rubyServerDefaults({
+    excludeFiles: ["tmp/", "log/", "spec/", "node_modules/", ".git/"],
+    writablePaths: ["tmp", "log"],
+    environmentVariables: { HANAMI_ENV: "production", RACK_ENV: "production" }
+  }),
+  refineDefaultConfig: refineHanamiAssets
+};
+
 // src/detection/frameworks/hono.ts
 var hono = {
   slug: "hono",
@@ -1288,6 +1665,30 @@ var hono = {
   refineDefaultConfig: resolveNodeServerEntrypoint
 };
 
+// src/detection/frameworks/jekyll.ts
+var jekyll = {
+  slug: "jekyll",
+  name: "Jekyll",
+  language: "ruby",
+  detectors: [{ matchPackage: "jekyll" }],
+  priority: 70,
+  getDefaultConfig: () => ({
+    runtime: DEFAULT_RUBY_RUNTIME,
+    memory: 128,
+    maxDuration: 30,
+    streaming: false,
+    commands: ["bundle exec jekyll build"],
+    assetsDir: "_site",
+    populateAssetCache: true,
+    routes: [],
+    environmentVariables: { JEKYLL_ENV: "production" }
+  })
+};
+var jekyllPresets = [
+  jekyll,
+  { ...jekyll, detectors: [{ matchPackage: "github-pages" }] }
+];
+
 // src/detection/frameworks/laminas.ts
 var laminas = {
   slug: "laminas",
@@ -1367,8 +1768,8 @@ var mezzio = {
 };
 
 // src/detection/frameworks/nestjs.ts
-var import_platform6 = require("@effect/platform");
-var import_effect9 = require("effect");
+var import_platform9 = require("@effect/platform");
+var import_effect14 = require("effect");
 var isRecord3 = (value) => typeof value === "object" && value !== null;
 var parseNestCliJson = (content) => {
   try {
@@ -1419,9 +1820,9 @@ var nestjs = {
   detectors: [{ matchPackage: "@nestjs/core" }],
   priority: 90,
   getDefaultConfig: () => createNestConfig("dist"),
-  refineDefaultConfig: (defaults, projectFolder) => import_effect9.Effect.gen(function* () {
-    const fs = yield* import_platform6.FileSystem.FileSystem;
-    const content = yield* fs.readFileString(`${projectFolder}/nest-cli.json`).pipe(import_effect9.Effect.catchAll(() => import_effect9.Effect.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => import_effect14.Effect.gen(function* () {
+    const fs = yield* import_platform9.FileSystem.FileSystem;
+    const content = yield* fs.readFileString(`${projectFolder}/nest-cli.json`).pipe(import_effect14.Effect.catchAll(() => import_effect14.Effect.succeed(void 0)));
     if (!content) return defaults;
     const nestConfig = parseNestCliJson(content);
     const outputPath = nestConfig ? getProjectOutputPath(nestConfig) : void 0;
@@ -1430,28 +1831,28 @@ var nestjs = {
 };
 
 // src/detection/frameworks/nextjs.ts
-var import_platform8 = require("@effect/platform");
-var import_effect12 = require("effect");
+var import_platform11 = require("@effect/platform");
+var import_effect17 = require("effect");
 
 // src/build-output-v3/get-default-path-map.ts
-var import_platform7 = require("@effect/platform");
-var import_effect10 = require("effect");
-var getDefaultPathMap = import_effect10.Effect.fn("getDefaultPathMap")(function* (directory) {
-  const fs = yield* import_platform7.FileSystem.FileSystem;
-  const pathService = yield* import_platform7.Path.Path;
+var import_platform10 = require("@effect/platform");
+var import_effect15 = require("effect");
+var getDefaultPathMap = import_effect15.Effect.fn("getDefaultPathMap")(function* (directory) {
+  const fs = yield* import_platform10.FileSystem.FileSystem;
+  const pathService = yield* import_platform10.Path.Path;
   const result = {};
-  const exists = yield* fs.exists(directory).pipe(import_effect10.Effect.catchAll(() => import_effect10.Effect.succeed(false)));
+  const exists = yield* fs.exists(directory).pipe(import_effect15.Effect.catchAll(() => import_effect15.Effect.succeed(false)));
   if (!exists) {
     return result;
   }
   const MAX_DEPTH = 100;
-  const processDirectory = (currentPath, basePath = "", depth = 0) => import_effect10.Effect.gen(function* () {
+  const processDirectory = (currentPath, basePath = "", depth = 0) => import_effect15.Effect.gen(function* () {
     if (depth > MAX_DEPTH) return;
-    const entries = yield* fs.readDirectory(currentPath).pipe(import_effect10.Effect.catchAll(() => import_effect10.Effect.succeed([])));
+    const entries = yield* fs.readDirectory(currentPath).pipe(import_effect15.Effect.catchAll(() => import_effect15.Effect.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(import_effect10.Effect.catchAll(() => import_effect10.Effect.succeed(null)));
+      const stat = yield* fs.stat(fullPath).pipe(import_effect15.Effect.catchAll(() => import_effect15.Effect.succeed(null)));
       if (!stat) continue;
       if (stat.type === "Directory") {
         yield* processDirectory(fullPath, relativePath, depth + 1);
@@ -1468,244 +1869,244 @@ var getDefaultPathMap = import_effect10.Effect.fn("getDefaultPathMap")(function*
 var MAXIMUM_ENTRY_PAGE_PATHS = 50;
 
 // src/nextjs-manifest.ts
-var import_effect11 = require("effect");
-var StringArraySchema = import_effect11.Schema.mutable(import_effect11.Schema.Array(import_effect11.Schema.String));
-var StringRecordSchema = import_effect11.Schema.mutable(import_effect11.Schema.Record({ key: import_effect11.Schema.String, value: import_effect11.Schema.String }));
-var JsonValueSchema = import_effect11.Schema.suspend(
-  () => import_effect11.Schema.Union(
-    import_effect11.Schema.Null,
-    import_effect11.Schema.Boolean,
-    import_effect11.Schema.Number,
-    import_effect11.Schema.String,
-    import_effect11.Schema.mutable(import_effect11.Schema.Array(JsonValueSchema)),
-    import_effect11.Schema.mutable(import_effect11.Schema.Record({ key: import_effect11.Schema.String, value: JsonValueSchema }))
+var import_effect16 = require("effect");
+var StringArraySchema = import_effect16.Schema.mutable(import_effect16.Schema.Array(import_effect16.Schema.String));
+var StringRecordSchema = import_effect16.Schema.mutable(import_effect16.Schema.Record({ key: import_effect16.Schema.String, value: import_effect16.Schema.String }));
+var JsonValueSchema = import_effect16.Schema.suspend(
+  () => import_effect16.Schema.Union(
+    import_effect16.Schema.Null,
+    import_effect16.Schema.Boolean,
+    import_effect16.Schema.Number,
+    import_effect16.Schema.String,
+    import_effect16.Schema.mutable(import_effect16.Schema.Array(JsonValueSchema)),
+    import_effect16.Schema.mutable(import_effect16.Schema.Record({ key: import_effect16.Schema.String, value: JsonValueSchema }))
   )
 );
-var ImageLocalPatternSchema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Struct({
-    pathname: import_effect11.Schema.optional(import_effect11.Schema.String),
-    search: import_effect11.Schema.optional(import_effect11.Schema.String)
+var ImageLocalPatternSchema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Struct({
+    pathname: import_effect16.Schema.optional(import_effect16.Schema.String),
+    search: import_effect16.Schema.optional(import_effect16.Schema.String)
   })
 );
-var ImageRemotePatternSchema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Struct({
-    protocol: import_effect11.Schema.optional(import_effect11.Schema.Literal("http", "https")),
-    hostname: import_effect11.Schema.String,
-    port: import_effect11.Schema.optional(import_effect11.Schema.String),
-    pathname: import_effect11.Schema.optional(import_effect11.Schema.String),
-    search: import_effect11.Schema.optional(import_effect11.Schema.String)
+var ImageRemotePatternSchema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Struct({
+    protocol: import_effect16.Schema.optional(import_effect16.Schema.Literal("http", "https")),
+    hostname: import_effect16.Schema.String,
+    port: import_effect16.Schema.optional(import_effect16.Schema.String),
+    pathname: import_effect16.Schema.optional(import_effect16.Schema.String),
+    search: import_effect16.Schema.optional(import_effect16.Schema.String)
   })
 );
-var ImageVariantSchema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Struct({
-    width: import_effect11.Schema.optional(import_effect11.Schema.Number),
-    height: import_effect11.Schema.optional(import_effect11.Schema.Number),
-    quality: import_effect11.Schema.optional(import_effect11.Schema.Number),
-    format: import_effect11.Schema.optional(import_effect11.Schema.Literal("image/avif", "image/webp", "image/jpeg", "image/png")),
-    fit: import_effect11.Schema.optional(import_effect11.Schema.Literal("contain", "cover", "fill", "inside", "outside"))
+var ImageVariantSchema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Struct({
+    width: import_effect16.Schema.optional(import_effect16.Schema.Number),
+    height: import_effect16.Schema.optional(import_effect16.Schema.Number),
+    quality: import_effect16.Schema.optional(import_effect16.Schema.Number),
+    format: import_effect16.Schema.optional(import_effect16.Schema.Literal("image/avif", "image/webp", "image/jpeg", "image/png")),
+    fit: import_effect16.Schema.optional(import_effect16.Schema.Literal("contain", "cover", "fill", "inside", "outside"))
   })
 );
-var PositiveIntSchema = import_effect11.Schema.Int.pipe(import_effect11.Schema.greaterThan(0));
-var ImagePolicySchema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Struct({
-    localPatterns: import_effect11.Schema.mutable(import_effect11.Schema.Array(ImageLocalPatternSchema)),
-    remotePatterns: import_effect11.Schema.mutable(import_effect11.Schema.Array(ImageRemotePatternSchema)),
-    widths: import_effect11.Schema.mutable(import_effect11.Schema.Array(PositiveIntSchema)),
-    heights: import_effect11.Schema.mutable(import_effect11.Schema.Array(PositiveIntSchema)),
-    qualities: import_effect11.Schema.mutable(import_effect11.Schema.Array(import_effect11.Schema.Number.pipe(import_effect11.Schema.between(1, 100)))),
-    formats: import_effect11.Schema.mutable(import_effect11.Schema.Array(import_effect11.Schema.Literal("image/avif", "image/webp", "image/jpeg", "image/png"))),
-    minimumCacheTTL: import_effect11.Schema.Number,
-    dangerouslyAllowSVG: import_effect11.Schema.Boolean,
-    contentSecurityPolicy: import_effect11.Schema.String,
-    contentDispositionType: import_effect11.Schema.Literal("inline", "attachment"),
-    maximumRedirects: import_effect11.Schema.Number,
-    maximumResponseBody: import_effect11.Schema.Number,
-    variants: import_effect11.Schema.mutable(import_effect11.Schema.Record({ key: import_effect11.Schema.String, value: ImageVariantSchema }))
+var PositiveIntSchema = import_effect16.Schema.Int.pipe(import_effect16.Schema.greaterThan(0));
+var ImagePolicySchema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Struct({
+    localPatterns: import_effect16.Schema.mutable(import_effect16.Schema.Array(ImageLocalPatternSchema)),
+    remotePatterns: import_effect16.Schema.mutable(import_effect16.Schema.Array(ImageRemotePatternSchema)),
+    widths: import_effect16.Schema.mutable(import_effect16.Schema.Array(PositiveIntSchema)),
+    heights: import_effect16.Schema.mutable(import_effect16.Schema.Array(PositiveIntSchema)),
+    qualities: import_effect16.Schema.mutable(import_effect16.Schema.Array(import_effect16.Schema.Number.pipe(import_effect16.Schema.between(1, 100)))),
+    formats: import_effect16.Schema.mutable(import_effect16.Schema.Array(import_effect16.Schema.Literal("image/avif", "image/webp", "image/jpeg", "image/png"))),
+    minimumCacheTTL: import_effect16.Schema.Number,
+    dangerouslyAllowSVG: import_effect16.Schema.Boolean,
+    contentSecurityPolicy: import_effect16.Schema.String,
+    contentDispositionType: import_effect16.Schema.Literal("inline", "attachment"),
+    maximumRedirects: import_effect16.Schema.Number,
+    maximumResponseBody: import_effect16.Schema.Number,
+    variants: import_effect16.Schema.mutable(import_effect16.Schema.Record({ key: import_effect16.Schema.String, value: ImageVariantSchema }))
   })
 );
 var GigadriveNextPrerenderOutputFields = {
-  id: import_effect11.Schema.String,
-  type: import_effect11.Schema.Literal("PRERENDER"),
+  id: import_effect16.Schema.String,
+  type: import_effect16.Schema.Literal("PRERENDER"),
   pathname: UrlPathnameSchema,
-  route: import_effect11.Schema.optional(UrlPathnameSchema),
-  parentOutputId: import_effect11.Schema.String,
-  groupId: import_effect11.Schema.Number,
-  pprChain: import_effect11.Schema.optional(import_effect11.Schema.mutable(import_effect11.Schema.Struct({ headers: HttpSingleValueHeadersSchema }))),
-  parentFallbackMode: import_effect11.Schema.optional(JsonValueSchema),
-  fallback: import_effect11.Schema.optional(
-    import_effect11.Schema.mutable(
-      import_effect11.Schema.Struct({
-        filePath: import_effect11.Schema.optional(PortableRelativePathSchema),
-        initialStatus: import_effect11.Schema.optional(import_effect11.Schema.Int.pipe(import_effect11.Schema.between(100, 599))),
-        initialHeaders: import_effect11.Schema.optional(HttpHeadersSchema),
-        initialExpiration: import_effect11.Schema.optional(import_effect11.Schema.Number),
-        initialRevalidate: import_effect11.Schema.optional(import_effect11.Schema.Union(import_effect11.Schema.Number, import_effect11.Schema.Literal(false))),
-        postponedState: import_effect11.Schema.optional(import_effect11.Schema.String)
+  route: import_effect16.Schema.optional(UrlPathnameSchema),
+  parentOutputId: import_effect16.Schema.String,
+  groupId: import_effect16.Schema.Number,
+  pprChain: import_effect16.Schema.optional(import_effect16.Schema.mutable(import_effect16.Schema.Struct({ headers: HttpSingleValueHeadersSchema }))),
+  parentFallbackMode: import_effect16.Schema.optional(JsonValueSchema),
+  fallback: import_effect16.Schema.optional(
+    import_effect16.Schema.mutable(
+      import_effect16.Schema.Struct({
+        filePath: import_effect16.Schema.optional(PortableRelativePathSchema),
+        initialStatus: import_effect16.Schema.optional(import_effect16.Schema.Int.pipe(import_effect16.Schema.between(100, 599))),
+        initialHeaders: import_effect16.Schema.optional(HttpHeadersSchema),
+        initialExpiration: import_effect16.Schema.optional(import_effect16.Schema.Number),
+        initialRevalidate: import_effect16.Schema.optional(import_effect16.Schema.Union(import_effect16.Schema.Number, import_effect16.Schema.Literal(false))),
+        postponedState: import_effect16.Schema.optional(import_effect16.Schema.String)
       })
     )
   ),
-  config: import_effect11.Schema.mutable(
-    import_effect11.Schema.Struct({
-      allowQuery: import_effect11.Schema.optional(StringArraySchema),
-      allowHeader: import_effect11.Schema.optional(StringArraySchema),
-      bypassFor: import_effect11.Schema.optional(import_effect11.Schema.mutable(import_effect11.Schema.Array(JsonValueSchema))),
-      renderingMode: import_effect11.Schema.optional(import_effect11.Schema.String),
-      partialFallback: import_effect11.Schema.optional(import_effect11.Schema.Boolean),
-      bypassToken: import_effect11.Schema.optional(import_effect11.Schema.String)
+  config: import_effect16.Schema.mutable(
+    import_effect16.Schema.Struct({
+      allowQuery: import_effect16.Schema.optional(StringArraySchema),
+      allowHeader: import_effect16.Schema.optional(StringArraySchema),
+      bypassFor: import_effect16.Schema.optional(import_effect16.Schema.mutable(import_effect16.Schema.Array(JsonValueSchema))),
+      renderingMode: import_effect16.Schema.optional(import_effect16.Schema.String),
+      partialFallback: import_effect16.Schema.optional(import_effect16.Schema.Boolean),
+      bypassToken: import_effect16.Schema.optional(import_effect16.Schema.String)
     })
   )
 };
-var GigadriveNextPrerenderClassificationSchema = import_effect11.Schema.Struct({
-  routeType: import_effect11.Schema.Literal("route", "fallback", "shell", "page"),
-  response: import_effect11.Schema.Literal("empty", "initial", "complete"),
-  compute: import_effect11.Schema.Literal("blocking", "resuming", "static"),
-  htmlSize: import_effect11.Schema.optional(import_effect11.Schema.Number)
+var GigadriveNextPrerenderClassificationSchema = import_effect16.Schema.Struct({
+  routeType: import_effect16.Schema.Literal("route", "fallback", "shell", "page"),
+  response: import_effect16.Schema.Literal("empty", "initial", "complete"),
+  compute: import_effect16.Schema.Literal("blocking", "resuming", "static"),
+  htmlSize: import_effect16.Schema.optional(import_effect16.Schema.Number)
 });
-var GigadriveNextPrerenderWithoutClassificationSchema = import_effect11.Schema.Struct({
-  routeType: import_effect11.Schema.optional(import_effect11.Schema.Never),
-  response: import_effect11.Schema.optional(import_effect11.Schema.Never),
-  compute: import_effect11.Schema.optional(import_effect11.Schema.Never),
-  htmlSize: import_effect11.Schema.optional(import_effect11.Schema.Never)
+var GigadriveNextPrerenderWithoutClassificationSchema = import_effect16.Schema.Struct({
+  routeType: import_effect16.Schema.optional(import_effect16.Schema.Never),
+  response: import_effect16.Schema.optional(import_effect16.Schema.Never),
+  compute: import_effect16.Schema.optional(import_effect16.Schema.Never),
+  htmlSize: import_effect16.Schema.optional(import_effect16.Schema.Never)
 });
-var GigadriveNextPrerenderOutputSchema = import_effect11.Schema.Union(
-  import_effect11.Schema.mutable(
-    import_effect11.Schema.Struct({ ...GigadriveNextPrerenderOutputFields, ...GigadriveNextPrerenderClassificationSchema.fields })
+var GigadriveNextPrerenderOutputSchema = import_effect16.Schema.Union(
+  import_effect16.Schema.mutable(
+    import_effect16.Schema.Struct({ ...GigadriveNextPrerenderOutputFields, ...GigadriveNextPrerenderClassificationSchema.fields })
   ),
-  import_effect11.Schema.mutable(
-    import_effect11.Schema.Struct({
+  import_effect16.Schema.mutable(
+    import_effect16.Schema.Struct({
       ...GigadriveNextPrerenderOutputFields,
       ...GigadriveNextPrerenderWithoutClassificationSchema.fields
     })
   )
 );
-var GigadriveNextStaticAssetPrefixSchema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Struct({
+var GigadriveNextStaticAssetPrefixSchema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Struct({
     sourceDir: PortableRelativePathSchema,
     urlPrefix: PortableRelativePathSchema,
-    immutable: import_effect11.Schema.Boolean
+    immutable: import_effect16.Schema.Boolean
   })
 );
-var GigadriveNextRouteConditionSchema = import_effect11.Schema.Union(
-  import_effect11.Schema.mutable(
-    import_effect11.Schema.Struct({
-      type: import_effect11.Schema.Literal("header", "cookie", "query"),
-      key: import_effect11.Schema.String,
-      value: import_effect11.Schema.optional(import_effect11.Schema.String)
+var GigadriveNextRouteConditionSchema = import_effect16.Schema.Union(
+  import_effect16.Schema.mutable(
+    import_effect16.Schema.Struct({
+      type: import_effect16.Schema.Literal("header", "cookie", "query"),
+      key: import_effect16.Schema.String,
+      value: import_effect16.Schema.optional(import_effect16.Schema.String)
     })
   ),
-  import_effect11.Schema.mutable(
-    import_effect11.Schema.Struct({
-      type: import_effect11.Schema.Literal("host"),
-      value: import_effect11.Schema.String
+  import_effect16.Schema.mutable(
+    import_effect16.Schema.Struct({
+      type: import_effect16.Schema.Literal("host"),
+      value: import_effect16.Schema.String
     })
   )
 );
-var GigadriveNextMiddlewareMatcherSchema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Struct({
-    source: import_effect11.Schema.String,
-    sourceRegex: import_effect11.Schema.String,
-    has: import_effect11.Schema.optional(import_effect11.Schema.mutable(import_effect11.Schema.Array(GigadriveNextRouteConditionSchema))),
-    missing: import_effect11.Schema.optional(import_effect11.Schema.mutable(import_effect11.Schema.Array(GigadriveNextRouteConditionSchema)))
+var GigadriveNextMiddlewareMatcherSchema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Struct({
+    source: import_effect16.Schema.String,
+    sourceRegex: import_effect16.Schema.String,
+    has: import_effect16.Schema.optional(import_effect16.Schema.mutable(import_effect16.Schema.Array(GigadriveNextRouteConditionSchema))),
+    missing: import_effect16.Schema.optional(import_effect16.Schema.mutable(import_effect16.Schema.Array(GigadriveNextRouteConditionSchema)))
   })
 );
-var GigadriveNextMiddlewareDescriptorSchema = import_effect11.Schema.Union(
-  import_effect11.Schema.mutable(
-    import_effect11.Schema.Struct({
-      present: import_effect11.Schema.Literal(true),
-      matchers: import_effect11.Schema.mutable(import_effect11.Schema.Array(GigadriveNextMiddlewareMatcherSchema))
+var GigadriveNextMiddlewareDescriptorSchema = import_effect16.Schema.Union(
+  import_effect16.Schema.mutable(
+    import_effect16.Schema.Struct({
+      present: import_effect16.Schema.Literal(true),
+      matchers: import_effect16.Schema.mutable(import_effect16.Schema.Array(GigadriveNextMiddlewareMatcherSchema))
     })
   ),
-  import_effect11.Schema.mutable(
-    import_effect11.Schema.Struct({
-      present: import_effect11.Schema.Literal(false),
-      matchers: import_effect11.Schema.mutable(import_effect11.Schema.Tuple())
+  import_effect16.Schema.mutable(
+    import_effect16.Schema.Struct({
+      present: import_effect16.Schema.Literal(false),
+      matchers: import_effect16.Schema.mutable(import_effect16.Schema.Tuple())
     })
   )
 );
-var GigadriveNextServerDescriptorSchema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Struct({
-    maxDuration: import_effect11.Schema.optional(import_effect11.Schema.Number),
-    preferredRegion: import_effect11.Schema.optional(import_effect11.Schema.Union(import_effect11.Schema.String, StringArraySchema)),
-    env: import_effect11.Schema.optional(StringRecordSchema)
+var GigadriveNextServerDescriptorSchema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Struct({
+    maxDuration: import_effect16.Schema.optional(import_effect16.Schema.Number),
+    preferredRegion: import_effect16.Schema.optional(import_effect16.Schema.Union(import_effect16.Schema.String, StringArraySchema)),
+    env: import_effect16.Schema.optional(StringRecordSchema)
   })
 );
-var PrerenderArraySchema = import_effect11.Schema.mutable(import_effect11.Schema.Array(GigadriveNextPrerenderOutputSchema));
-var StaticAssetArraySchema = import_effect11.Schema.mutable(import_effect11.Schema.Array(GigadriveNextStaticAssetPrefixSchema));
-var JsonValueArraySchema = import_effect11.Schema.mutable(import_effect11.Schema.Array(JsonValueSchema));
-var GigadriveNextPrerenderSeedMethodsSchema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Tuple(import_effect11.Schema.Literal("GET"), import_effect11.Schema.Literal("HEAD"))
+var PrerenderArraySchema = import_effect16.Schema.mutable(import_effect16.Schema.Array(GigadriveNextPrerenderOutputSchema));
+var StaticAssetArraySchema = import_effect16.Schema.mutable(import_effect16.Schema.Array(GigadriveNextStaticAssetPrefixSchema));
+var JsonValueArraySchema = import_effect16.Schema.mutable(import_effect16.Schema.Array(JsonValueSchema));
+var GigadriveNextPrerenderSeedMethodsSchema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Tuple(import_effect16.Schema.Literal("GET"), import_effect16.Schema.Literal("HEAD"))
 );
-var GigadriveNextBuildManifestV1Schema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Struct({
-    version: import_effect11.Schema.Literal(1),
-    output: import_effect11.Schema.Literal("standalone", "export"),
+var GigadriveNextBuildManifestV1Schema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Struct({
+    version: import_effect16.Schema.Literal(1),
+    output: import_effect16.Schema.Literal("standalone", "export"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: import_effect11.Schema.String,
-    buildId: import_effect11.Schema.String
+    nextVersion: import_effect16.Schema.String,
+    buildId: import_effect16.Schema.String
   })
 );
-var GigadriveNextBuildManifestV2ExportSchema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Struct({
-    version: import_effect11.Schema.Literal(2),
-    mode: import_effect11.Schema.Literal("export"),
+var GigadriveNextBuildManifestV2ExportSchema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Struct({
+    version: import_effect16.Schema.Literal(2),
+    mode: import_effect16.Schema.Literal("export"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: import_effect11.Schema.String,
-    buildId: import_effect11.Schema.String
+    nextVersion: import_effect16.Schema.String,
+    buildId: import_effect16.Schema.String
   })
 );
-var GigadriveNextBuildManifestV2StandaloneSchema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Struct({
-    version: import_effect11.Schema.Literal(2),
-    mode: import_effect11.Schema.Literal("standalone-v2"),
+var GigadriveNextBuildManifestV2StandaloneSchema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Struct({
+    version: import_effect16.Schema.Literal(2),
+    mode: import_effect16.Schema.Literal("standalone-v2"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: import_effect11.Schema.String,
-    buildId: import_effect11.Schema.String,
+    nextVersion: import_effect16.Schema.String,
+    buildId: import_effect16.Schema.String,
     server: GigadriveNextServerDescriptorSchema,
-    config: import_effect11.Schema.mutable(
-      import_effect11.Schema.Struct({
-        basePath: import_effect11.Schema.String,
-        trailingSlash: import_effect11.Schema.Boolean,
-        cacheComponents: import_effect11.Schema.Boolean,
-        i18n: import_effect11.Schema.optional(JsonValueSchema),
-        images: import_effect11.Schema.optional(ImagePolicySchema)
+    config: import_effect16.Schema.mutable(
+      import_effect16.Schema.Struct({
+        basePath: import_effect16.Schema.String,
+        trailingSlash: import_effect16.Schema.Boolean,
+        cacheComponents: import_effect16.Schema.Boolean,
+        i18n: import_effect16.Schema.optional(JsonValueSchema),
+        images: import_effect16.Schema.optional(ImagePolicySchema)
       })
     ),
-    routing: import_effect11.Schema.mutable(
-      import_effect11.Schema.Struct({
+    routing: import_effect16.Schema.mutable(
+      import_effect16.Schema.Struct({
         beforeMiddleware: JsonValueArraySchema,
         beforeFiles: JsonValueArraySchema,
         afterFiles: JsonValueArraySchema,
         dynamicRoutes: JsonValueArraySchema,
         onMatch: JsonValueArraySchema,
         fallback: JsonValueArraySchema,
-        shouldNormalizeNextData: import_effect11.Schema.Boolean,
+        shouldNormalizeNextData: import_effect16.Schema.Boolean,
         rsc: JsonValueSchema
       })
     ),
-    outputs: import_effect11.Schema.mutable(
-      import_effect11.Schema.Struct({
+    outputs: import_effect16.Schema.mutable(
+      import_effect16.Schema.Struct({
         prerenders: PrerenderArraySchema,
-        prerenderManifest: import_effect11.Schema.optional(PortableRelativePathSchema),
-        assetManifest: import_effect11.Schema.optional(PortableRelativePathSchema),
-        entryPagePaths: import_effect11.Schema.optional(import_effect11.Schema.mutable(import_effect11.Schema.Array(UrlPathnameSchema))),
+        prerenderManifest: import_effect16.Schema.optional(PortableRelativePathSchema),
+        assetManifest: import_effect16.Schema.optional(PortableRelativePathSchema),
+        entryPagePaths: import_effect16.Schema.optional(import_effect16.Schema.mutable(import_effect16.Schema.Array(UrlPathnameSchema))),
         staticAssets: StaticAssetArraySchema,
-        middleware: import_effect11.Schema.optional(GigadriveNextMiddlewareDescriptorSchema)
+        middleware: import_effect16.Schema.optional(GigadriveNextMiddlewareDescriptorSchema)
       })
     )
   })
 );
-var GigadriveNextBuildManifestSchema = import_effect11.Schema.Union(
+var GigadriveNextBuildManifestSchema = import_effect16.Schema.Union(
   GigadriveNextBuildManifestV1Schema,
   GigadriveNextBuildManifestV2ExportSchema,
   GigadriveNextBuildManifestV2StandaloneSchema
 );
-var GigadriveNextPrerenderManifestV1Schema = import_effect11.Schema.mutable(
-  import_effect11.Schema.Struct({
-    version: import_effect11.Schema.Literal(1),
-    seedMethods: import_effect11.Schema.optional(GigadriveNextPrerenderSeedMethodsSchema),
+var GigadriveNextPrerenderManifestV1Schema = import_effect16.Schema.mutable(
+  import_effect16.Schema.Struct({
+    version: import_effect16.Schema.Literal(1),
+    seedMethods: import_effect16.Schema.optional(GigadriveNextPrerenderSeedMethodsSchema),
     prerenders: PrerenderArraySchema
   })
 );
@@ -1715,22 +2116,22 @@ var parseGigadriveNextPrerenderManifest = (content) => decodeJson(GigadriveNextP
 // src/detection/frameworks/nextjs.ts
 var toPortablePath = (value) => value.replaceAll("\\", "/");
 var STANDALONE_SERVER_MEMORY_MB = 1024;
-var resolveStandaloneServer = import_effect12.Effect.fn("nextjs.resolveStandaloneServer")(function* (projectFolder, distDir, repoRootToProject) {
-  const fs = yield* import_platform8.FileSystem.FileSystem;
-  const pathService = yield* import_platform8.Path.Path;
+var resolveStandaloneServer = import_effect17.Effect.fn("nextjs.resolveStandaloneServer")(function* (projectFolder, distDir, repoRootToProject) {
+  const fs = yield* import_platform11.FileSystem.FileSystem;
+  const pathService = yield* import_platform11.Path.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(import_effect12.Effect.catchAll(() => import_effect12.Effect.succeed(false)));
+  const monorepoServerExists = yield* fs.exists(monorepoServer).pipe(import_effect17.Effect.catchAll(() => import_effect17.Effect.succeed(false)));
   const serverPath = monorepoServerExists ? monorepoServer : rootServer;
-  const serverExists = yield* fs.exists(serverPath).pipe(import_effect12.Effect.catchAll(() => import_effect12.Effect.succeed(false)));
+  const serverExists = yield* fs.exists(serverPath).pipe(import_effect17.Effect.catchAll(() => import_effect17.Effect.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 = import_effect12.Effect.fn("nextjs.buildStandalonePublicAssets")(function* (projectFolder, standaloneRoot, serverDirectory) {
-  const pathService = yield* import_platform8.Path.Path;
+var buildStandalonePublicAssets = import_effect17.Effect.fn("nextjs.buildStandalonePublicAssets")(function* (projectFolder, standaloneRoot, serverDirectory) {
+  const pathService = yield* import_platform11.Path.Path;
   const publicFiles = yield* getDefaultPathMap(pathService.join(projectFolder, "public"));
   const assetPaths = [];
   const assetOverrides = {};
@@ -1746,8 +2147,8 @@ var buildStandalonePublicAssets = import_effect12.Effect.fn("nextjs.buildStandal
   }
   return { assetPaths, assetOverrides, filePathMap };
 });
-var createStaticExportConfig = import_effect12.Effect.fn("nextjs.createStaticExportConfig")(function* (defaults, projectFolder) {
-  const pathService = yield* import_platform8.Path.Path;
+var createStaticExportConfig = import_effect17.Effect.fn("nextjs.createStaticExportConfig")(function* (defaults, projectFolder) {
+  const pathService = yield* import_platform11.Path.Path;
   const outputDirectory = pathService.join(projectFolder, "out");
   const files = yield* getDefaultPathMap(outputDirectory);
   const assetPaths = [];
@@ -1770,8 +2171,8 @@ var createStaticExportConfig = import_effect12.Effect.fn("nextjs.createStaticExp
     package: void 0
   };
 });
-var createStandaloneConfig = import_effect12.Effect.fn("nextjs.createStandaloneConfig")(function* (defaults, projectFolder, manifest) {
-  const pathService = yield* import_platform8.Path.Path;
+var createStandaloneConfig = import_effect17.Effect.fn("nextjs.createStandaloneConfig")(function* (defaults, projectFolder, manifest) {
+  const pathService = yield* import_platform11.Path.Path;
   const resolved = yield* resolveStandaloneServer(projectFolder, manifest.distDir, manifest.repoRootToProject);
   if (!resolved) return defaults;
   const { standaloneRoot, serverDirectory, entrypoint } = resolved;
@@ -1804,7 +2205,7 @@ var createStandaloneConfig = import_effect12.Effect.fn("nextjs.createStandaloneC
     }
   };
 });
-var createStandaloneV2Config = import_effect12.Effect.fn("nextjs.createStandaloneV2Config")(function* (defaults, projectFolder, manifest) {
+var createStandaloneV2Config = import_effect17.Effect.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;
@@ -1912,9 +2313,9 @@ var nextjs = {
     routes: [{ source: "/*", destination: ".next/standalone/server.js" }],
     environmentVariables: { NODE_ENV: "production" }
   }),
-  refineDefaultConfig: (defaults, projectFolder) => import_effect12.Effect.gen(function* () {
-    const fs = yield* import_platform8.FileSystem.FileSystem;
-    const manifestContent = yield* fs.readFileString(`${projectFolder}/.gigadrive/nextjs.json`).pipe(import_effect12.Effect.catchAll(() => import_effect12.Effect.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => import_effect17.Effect.gen(function* () {
+    const fs = yield* import_platform11.FileSystem.FileSystem;
+    const manifestContent = yield* fs.readFileString(`${projectFolder}/.gigadrive/nextjs.json`).pipe(import_effect17.Effect.catchAll(() => import_effect17.Effect.succeed(void 0)));
     const manifest = manifestContent ? parseGigadriveNextBuildManifest(manifestContent) : void 0;
     if (!manifest) return defaults;
     if (manifest.version === 2) {
@@ -1925,8 +2326,8 @@ var nextjs = {
 };
 
 // src/detection/frameworks/nuxt.ts
-var import_platform9 = require("@effect/platform");
-var import_effect13 = require("effect");
+var import_platform12 = require("@effect/platform");
+var import_effect18 = require("effect");
 var isVercelBuildOutputV3 = (content) => {
   try {
     const config = JSON.parse(content);
@@ -1953,9 +2354,9 @@ var nuxt = {
     routes: [{ source: "/*", destination: ".output/server/index.mjs" }],
     environmentVariables: { NODE_ENV: "production", NITRO_PRESET: "node-server" }
   }),
-  refineDefaultConfig: (defaults, projectFolder) => import_effect13.Effect.gen(function* () {
-    const fs = yield* import_platform9.FileSystem.FileSystem;
-    const buildOutputConfig = yield* fs.readFileString(`${projectFolder}/.vercel/output/config.json`).pipe(import_effect13.Effect.catchAll(() => import_effect13.Effect.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => import_effect18.Effect.gen(function* () {
+    const fs = yield* import_platform12.FileSystem.FileSystem;
+    const buildOutputConfig = yield* fs.readFileString(`${projectFolder}/.vercel/output/config.json`).pipe(import_effect18.Effect.catchAll(() => import_effect18.Effect.succeed(void 0)));
     if (!buildOutputConfig || !isVercelBuildOutputV3(buildOutputConfig)) {
       return defaults;
     }
@@ -1970,16 +2371,16 @@ var nuxt = {
 };
 
 // src/detection/frameworks/php.ts
-var import_platform10 = require("@effect/platform");
-var import_effect14 = require("effect");
+var import_platform13 = require("@effect/platform");
+var import_effect19 = require("effect");
 var COMPOSER_FILES = ["composer.json", "composer.lock"];
 var DOCUMENT_ROOTS = ["public", "web", "webroot", "public_html", "htdocs", "."];
-var refinePhpDocumentRoot = (defaults, projectFolder) => import_effect14.Effect.gen(function* () {
-  const fs = yield* import_platform10.FileSystem.FileSystem;
-  const pathService = yield* import_platform10.Path.Path;
+var refinePhpDocumentRoot = (defaults, projectFolder) => import_effect19.Effect.gen(function* () {
+  const fs = yield* import_platform13.FileSystem.FileSystem;
+  const pathService = yield* import_platform13.Path.Path;
   for (const documentRoot of DOCUMENT_ROOTS) {
     const frontController = pathService.join(projectFolder, documentRoot, "index.php");
-    if (yield* fs.exists(frontController).pipe(import_effect14.Effect.catchAll(() => import_effect14.Effect.succeed(false)))) {
+    if (yield* fs.exists(frontController).pipe(import_effect19.Effect.catchAll(() => import_effect19.Effect.succeed(false)))) {
       return phpFrontControllerDefaults({ documentRoot, excludeFiles: COMPOSER_FILES });
     }
   }
@@ -2003,9 +2404,215 @@ var phpSites = DOCUMENT_ROOTS.map((documentRoot) => ({
   detectors: [{ path: frontControllerPath(documentRoot) }],
   priority: 6,
   getDefaultConfig: () => ({ ...getDefaultConfig(), installCommand: "" }),
-  refineDefaultConfig: (defaults, projectFolder) => refinePhpDocumentRoot(defaults, projectFolder).pipe(import_effect14.Effect.map((refined) => ({ ...refined, installCommand: "" })))
+  refineDefaultConfig: (defaults, projectFolder) => refinePhpDocumentRoot(defaults, projectFolder).pipe(import_effect19.Effect.map((refined) => ({ ...refined, installCommand: "" })))
 }));
 
+// src/detection/frameworks/php-runtime.ts
+var import_platform14 = require("@effect/platform");
+var import_effect20 = require("effect");
+
+// src/detection/frameworks/composer-constraint.ts
+var STABILITY_SUFFIX = /-(?:dev|alpha|beta|a|b|rc|patch|pl|p|stable)\.?\d*$/i;
+var parseVersion = (text) => {
+  const parts = text.replace(/^v/i, "").replace(STABILITY_SUFFIX, "").split(".");
+  if (parts.length > 4) {
+    return void 0;
+  }
+  const segments = [];
+  let wildcard = false;
+  for (const part of parts) {
+    if (/^[*x]$/i.test(part)) {
+      wildcard = true;
+    } else if (/^\d+$/.test(part) && !wildcard) {
+      segments.push(Number(part));
+    } else {
+      return void 0;
+    }
+  }
+  return { segments, wildcard };
+};
+var pad = (segments) => [segments[0] ?? 0, segments[1] ?? 0, segments[2] ?? 0, segments[3] ?? 0];
+var bump = (segments, position) => pad(segments.slice(0, position).map((segment, index) => index === position - 1 ? segment + 1 : segment));
+var compare = (a, b) => {
+  for (let index = 0; index < 4; index++) {
+    if (a[index] !== b[index]) {
+      return a[index] - b[index];
+    }
+  }
+  return 0;
+};
+var inRange = (version, lower, upper) => compare(version, lower) >= 0 && compare(version, upper) < 0;
+var allowsAtom = (atom, version) => {
+  const match = /^(\^|~|>=|<=|<>|!=|==|=|>|<)?(.+)$/.exec(atom);
+  const parsed = match ? parseVersion(match[2]) : void 0;
+  if (!match || !parsed) {
+    return void 0;
+  }
+  const operator = match[1];
+  const { segments } = parsed;
+  if (parsed.wildcard) {
+    if (operator !== void 0) {
+      return void 0;
+    }
+    return segments.length === 0 || inRange(version, pad(segments), bump(segments, segments.length));
+  }
+  const target = pad(segments);
+  switch (operator) {
+    case "^": {
+      const position = segments[0] !== 0 || segments.length < 2 ? 1 : segments[1] !== 0 || segments.length < 3 ? 2 : 3;
+      return inRange(version, target, bump(segments, position));
+    }
+    case "~":
+      return inRange(version, target, bump(segments, Math.max(1, segments.length - 1)));
+    case ">=":
+      return compare(version, target) >= 0;
+    case ">":
+      return compare(version, target) > 0;
+    case "<=":
+      return compare(version, target) <= 0;
+    case "<":
+      return compare(version, target) < 0;
+    case "!=":
+    case "<>":
+      return compare(version, target) !== 0;
+    default:
+      return compare(version, target) === 0;
+  }
+};
+var allowsHyphenRange = (from, to, version) => {
+  const lower = parseVersion(from);
+  const upper = parseVersion(to);
+  if (!lower || !upper || lower.wildcard || upper.wildcard) {
+    return void 0;
+  }
+  const withinUpper = upper.segments.length >= 3 ? compare(version, pad(upper.segments)) <= 0 : compare(version, bump(upper.segments, upper.segments.length)) < 0;
+  return compare(version, pad(lower.segments)) >= 0 && withinUpper;
+};
+var allowsAll = (branch, version) => {
+  const tokens = branch.trim().replace(/([<>=!~^]+)\s+/g, "$1").split(/\s*,\s*|\s+/).filter((token) => token !== "");
+  if (tokens.length === 0) {
+    return void 0;
+  }
+  let allowed = true;
+  for (let index = 0; index < tokens.length; index++) {
+    let result;
+    if (tokens[index + 1] === "-") {
+      const to = tokens[index + 2];
+      result = to === void 0 ? void 0 : allowsHyphenRange(tokens[index], to, version);
+      index += 2;
+    } else {
+      result = allowsAtom(tokens[index], version);
+    }
+    if (result === void 0) {
+      return void 0;
+    }
+    allowed &&= result;
+  }
+  return allowed;
+};
+var composerConstraintAllows = (constraint, version) => {
+  const parsed = parseVersion(version);
+  if (!parsed || parsed.wildcard || parsed.segments.length === 0) {
+    return void 0;
+  }
+  const target = pad(parsed.segments);
+  let allowed = false;
+  for (const branch of constraint.replace(/@[a-z]+/gi, "").split(/\|\|?/)) {
+    const result = allowsAll(branch, target);
+    if (result === void 0) {
+      return void 0;
+    }
+    allowed ||= result;
+  }
+  return allowed;
+};
+
+// src/detection/frameworks/php-runtime.ts
+var PHP_RUNTIME_CANDIDATES = [
+  { runtime: "php-84", newestVersion: "8.4.9999" },
+  { runtime: "php-83", newestVersion: "8.3.9999" }
+];
+var phpRuntimeForConstraint = (constraint) => PHP_RUNTIME_CANDIDATES.find(({ newestVersion }) => composerConstraintAllows(constraint, newestVersion) === true)?.runtime;
+var readPhpConstraint = import_effect20.Effect.fn("readPhpConstraint")(
+  function* (projectFolder) {
+    const fs = yield* import_platform14.FileSystem.FileSystem;
+    const pathService = yield* import_platform14.Path.Path;
+    const content = yield* fs.readFileString(pathService.join(projectFolder, "composer.json"));
+    const manifest = yield* import_effect20.Effect.try(() => JSON.parse(content));
+    const requires = manifest && typeof manifest === "object" && "require" in manifest ? manifest.require : void 0;
+    const php = requires && typeof requires === "object" && "php" in requires ? requires.php : void 0;
+    return typeof php === "string" ? import_effect20.Option.some(php) : import_effect20.Option.none();
+  },
+  import_effect20.Effect.catchAll(() => import_effect20.Effect.succeed(import_effect20.Option.none()))
+);
+var refineComposerPhpRuntime = import_effect20.Effect.fn("refineComposerPhpRuntime")(function* (defaults, projectFolder) {
+  const constraint = yield* readPhpConstraint(projectFolder);
+  const runtime = import_effect20.Option.getOrUndefined(import_effect20.Option.flatMapNullable(constraint, phpRuntimeForConstraint));
+  return runtime ? { ...defaults, runtime } : defaults;
+});
+var withComposerPhpRuntime = (framework) => ({
+  ...framework,
+  refineDefaultConfig: (defaults, projectFolder) => import_effect20.Effect.gen(function* () {
+    const refined = framework.refineDefaultConfig ? yield* framework.refineDefaultConfig(defaults, projectFolder) : defaults;
+    return yield* refineComposerPhpRuntime(refined, projectFolder);
+  })
+});
+
+// src/detection/frameworks/rack.ts
+var rack = {
+  slug: "rack",
+  name: "Rack",
+  language: "ruby",
+  detectors: [{ path: "config.ru" }, { path: "Gemfile" }],
+  priority: 10,
+  getDefaultConfig: () => rubyServerDefaults({ environmentVariables: { RACK_ENV: "production" } }),
+  refineDefaultConfig: refineRubyPublicDirectory
+};
+
+// src/detection/frameworks/rails.ts
+var import_effect21 = require("effect");
+var ASSET_PIPELINE_GEMS = ["propshaft", "sprockets", "sprockets-rails"];
+var refineRailsAssets = import_effect21.Effect.fn("refineRailsAssets")(function* (defaults, projectFolder) {
+  const gems = yield* readDependencies(projectFolder, "ruby").pipe(
+    import_effect21.Effect.catchAll(() => import_effect21.Effect.succeed(/* @__PURE__ */ new Set()))
+  );
+  const withPublicDirectory = yield* refineRubyPublicDirectory(defaults, projectFolder);
+  return ASSET_PIPELINE_GEMS.some((gem) => gems.has(gem)) ? {
+    ...withPublicDirectory,
+    commands: [...withPublicDirectory.commands, "SECRET_KEY_BASE_DUMMY=1 bundle exec rails assets:precompile"]
+  } : withPublicDirectory;
+});
+var rails = {
+  slug: "rails",
+  name: "Ruby on Rails",
+  language: "ruby",
+  // `railties` is in every Rails application's Gemfile.lock, including ones
+  // that require individual Rails gems instead of `rails`.
+  detectors: [{ matchPackage: "railties" }, { path: "config/application.rb" }],
+  priority: 80,
+  getDefaultConfig: () => rubyServerDefaults({
+    memory: 512,
+    excludeFiles: ["tmp/", "log/", "storage/", "test/", "spec/", "node_modules/", ".git/"],
+    // tmp/, log/ and storage/ are excluded, so the directories Rails writes
+    // caches, pids, sockets, logs and Active Storage files to are created empty.
+    writablePaths: ["tmp/cache", "tmp/pids", "tmp/sockets", "tmp/storage", "log", "storage"],
+    environmentVariables: {
+      RAILS_ENV: "production",
+      RACK_ENV: "production",
+      // Signs and encrypts cookies and sessions; Rails refuses to boot in production without it.
+      SECRET_KEY_BASE: generatedSecret("hex"),
+      RAILS_LOG_TO_STDOUT: "1",
+      RAILS_SERVE_STATIC_FILES: "1",
+      RAILS_MAX_THREADS: "5"
+    }
+  }),
+  refineDefaultConfig: refineRailsAssets
+};
+var railsPresets = [
+  rails,
+  { ...rails, detectors: [{ matchPackage: "rails" }, { path: "config/application.rb" }] }
+];
+
 // src/detection/frameworks/remix.ts
 var remix = {
   slug: "remix",
@@ -2027,6 +2634,45 @@ var remix = {
   })
 };
 
+// src/detection/frameworks/roda.ts
+var roda = {
+  slug: "roda",
+  name: "Roda",
+  language: "ruby",
+  detectors: [{ matchPackage: "roda" }, { path: "config.ru" }],
+  priority: 60,
+  getDefaultConfig: () => rubyServerDefaults({ environmentVariables: { RACK_ENV: "production" } }),
+  refineDefaultConfig: refineRubyPublicDirectory
+};
+
+// src/detection/frameworks/sinatra.ts
+var import_platform15 = require("@effect/platform");
+var import_effect22 = require("effect");
+var SINATRA_ENTRYPOINTS = ["config.ru", "app.rb", "main.rb", "server.rb", "application.rb"];
+var refineSinatraEntrypoint = import_effect22.Effect.fn("refineSinatraEntrypoint")(function* (defaults, projectFolder) {
+  const fs = yield* import_platform15.FileSystem.FileSystem;
+  const pathService = yield* import_platform15.Path.Path;
+  const entrypoint = yield* import_effect22.Effect.findFirst(
+    SINATRA_ENTRYPOINTS,
+    (file) => fs.exists(pathService.join(projectFolder, file)).pipe(import_effect22.Effect.catchAll(() => import_effect22.Effect.succeed(false)))
+  );
+  const withPublicDirectory = yield* refineRubyPublicDirectory(defaults, projectFolder);
+  return entrypoint._tag === "Some" ? {
+    ...withPublicDirectory,
+    entrypoint: entrypoint.value,
+    routes: [{ source: "/*", destination: entrypoint.value }]
+  } : withPublicDirectory;
+});
+var sinatra = {
+  slug: "sinatra",
+  name: "Sinatra",
+  language: "ruby",
+  detectors: [{ matchPackage: "sinatra" }],
+  priority: 60,
+  getDefaultConfig: () => rubyServerDefaults({ environmentVariables: { APP_ENV: "production", RACK_ENV: "production" } }),
+  refineDefaultConfig: refineSinatraEntrypoint
+};
+
 // src/detection/frameworks/slim.ts
 var slim = {
   slug: "slim",
@@ -2147,17 +2793,33 @@ var FRAMEWORK_DEFINITIONS = [
   mezzio,
   yii,
   slim,
+  ...railsPresets,
+  hanami,
+  ...jekyllPresets,
+  bridgetown,
+  sinatra,
+  roda,
   hono,
   elysia,
   fastify,
   express,
+  rack,
   ...phpComposerProjects,
   ...phpSites,
   vite
-].sort((a, b) => b.priority - a.priority);
+].map((framework) => {
+  switch (framework.language) {
+    case "php":
+      return withComposerPhpRuntime(framework);
+    case "ruby":
+      return withRubyRuntime(framework);
+    case "node":
+      return framework;
+  }
+}).sort((a, b) => b.priority - a.priority);
 
 // src/detection/generate-config.ts
-var import_effect15 = require("effect");
+var import_effect23 = require("effect");
 var getInstallCommand = (pm) => {
   switch (pm) {
     case "bun":
@@ -2168,6 +2830,8 @@ var getInstallCommand = (pm) => {
       return "yarn install";
     case "composer":
       return "composer install";
+    case "bundler":
+      return "bundle install";
     case "npm":
     default:
       return "npm install";
@@ -2178,11 +2842,17 @@ var isPrivatePhpProjectFile = (projectPath) => {
   const segments = projectPath.split("/").filter((segment) => segment !== "" && segment !== ".");
   return segments.some((segment) => segment.startsWith(".")) || segments[0] === "vendor" || segments[0] === "node_modules" || segments.length === 1 && COMPOSER_ROOT_FILES.has(segments[0] ?? "");
 };
-var generateConfig = import_effect15.Effect.fn("generateConfig")(function* (framework, packageManager, projectFolder, refinedDefaults) {
+var BUNDLER_FILES = /* @__PURE__ */ new Set(["Gemfile", "Gemfile.lock", "gems.rb", "gems.locked"]);
+var isPrivateRubyProjectFile = (projectPath) => {
+  const segments = projectPath.split("/").filter((segment) => segment !== "" && segment !== ".");
+  const fileName = segments.at(-1) ?? "";
+  return segments.some((segment) => segment.startsWith(".")) || segments[0] === "vendor" || /\.(rb|ru)$/i.test(fileName) || BUNDLER_FILES.has(fileName);
+};
+var generateConfig = import_effect23.Effect.fn("generateConfig")(function* (framework, packageManager, projectFolder, refinedDefaults) {
   const defaults = refinedDefaults ?? framework.getDefaultConfig(packageManager);
   const installCmd = defaults.installCommand ?? getInstallCommand(packageManager);
   const commands = installCmd ? [installCmd, ...defaults.commands] : [...defaults.commands];
-  yield* import_effect15.Effect.logDebug(`Generating config for ${framework.name}`, {
+  yield* import_effect23.Effect.logDebug(`Generating config for ${framework.name}`, {
     runtime: defaults.runtime,
     entrypoint: defaults.entrypoint,
     commands
@@ -2225,6 +2895,7 @@ var generateConfig = import_effect15.Effect.fn("generateConfig")(function* (fram
       for (const file of yield* collectAssetFiles(projectFolder, assetsDir)) {
         if (framework.language === "php" && /\.(php|phtml|phar)$/i.test(file)) continue;
         if (framework.language === "php" && isPrivatePhpProjectFile(`${assetsDir}/${file}`)) continue;
+        if (framework.language === "ruby" && isPrivateRubyProjectFile(`${assetsDir}/${file}`)) continue;
         paths.push(`${assetsDir}/${file}`);
         if (!servesDirectoryIndexes || file in overrides) continue;
         if (file === "index.html") {
@@ -2247,80 +2918,10 @@ var generateConfig = import_effect15.Effect.fn("generateConfig")(function* (fram
   return config;
 });
 
-// src/detection/read-dependencies.ts
-var import_platform11 = require("@effect/platform");
-var import_effect17 = require("effect");
-
-// src/detection/types.ts
-var import_effect16 = require("effect");
-var ManifestNotFoundError = class extends import_effect16.Schema.TaggedError()("ManifestNotFoundError", {
-  message: import_effect16.Schema.String,
-  filePath: import_effect16.Schema.String
-}) {
-};
-var ManifestReadError = class extends import_effect16.Schema.TaggedError()("ManifestReadError", {
-  message: import_effect16.Schema.String,
-  filePath: import_effect16.Schema.String
-}) {
-};
-var ManifestParseError = class extends import_effect16.Schema.TaggedError()("ManifestParseError", {
-  message: import_effect16.Schema.String,
-  filePath: import_effect16.Schema.String
-}) {
-};
-var FrameworkNotDetectedError = class extends import_effect16.Schema.TaggedError()(
-  "FrameworkNotDetectedError",
-  {
-    message: import_effect16.Schema.String,
-    directory: import_effect16.Schema.String
-  }
-) {
-};
-
-// src/detection/read-dependencies.ts
-var MANIFEST_CONFIG = {
-  node: { file: "package.json", depKeys: ["dependencies", "devDependencies"] },
-  php: { file: "composer.json", depKeys: ["require", "require-dev"] }
-};
-var readManifest = import_effect17.Effect.fn("readManifest")(function* (filePath) {
-  const fs = yield* import_platform11.FileSystem.FileSystem;
-  const exists = yield* fs.exists(filePath).pipe(import_effect17.Effect.catchAll(() => import_effect17.Effect.succeed(false)));
-  if (!exists) {
-    return yield* import_effect17.Effect.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
-  }
-  const content = yield* fs.readFileString(filePath).pipe(import_effect17.Effect.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
-  const parsed = yield* import_effect17.Effect.try({
-    try: () => JSON.parse(content),
-    catch: () => new ManifestParseError({ message: "Failed to parse manifest JSON", filePath })
-  });
-  return parsed;
-});
-var readDependencies = import_effect17.Effect.fn("readDependencies")(function* (projectFolder, language) {
-  const pathService = yield* import_platform11.Path.Path;
-  const config = MANIFEST_CONFIG[language];
-  const filePath = pathService.join(projectFolder, config.file);
-  const manifest = yield* readManifest(filePath).pipe(
-    import_effect17.Effect.catchTag("ManifestNotFoundError", () => import_effect17.Effect.succeed(null))
-  );
-  if (!manifest) {
-    return /* @__PURE__ */ new Set();
-  }
-  const deps = /* @__PURE__ */ new Set();
-  for (const key of config.depKeys) {
-    const section = manifest[key];
-    if (section && typeof section === "object" && !Array.isArray(section)) {
-      for (const name of Object.keys(section)) {
-        deps.add(name);
-      }
-    }
-  }
-  return deps;
-});
-
 // src/detection/detect-framework.ts
-var matchesDetectionItem = import_effect18.Effect.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
-  const fs = yield* import_platform12.FileSystem.FileSystem;
-  const pathService = yield* import_platform12.Path.Path;
+var matchesDetectionItem = import_effect24.Effect.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
+  const fs = yield* import_platform16.FileSystem.FileSystem;
+  const pathService = yield* import_platform16.Path.Path;
   if (item.matchPackage != null) {
     const deps = yield* cachedReadDeps(`${projectFolder}\0${framework.language}`);
     if (!deps.has(item.matchPackage)) {
@@ -2329,12 +2930,12 @@ var matchesDetectionItem = import_effect18.Effect.fn("matchesDetectionItem")(fun
   }
   if (item.path != null) {
     const filePath = pathService.join(projectFolder, item.path);
-    const exists = yield* fs.exists(filePath).pipe(import_effect18.Effect.catchAll(() => import_effect18.Effect.succeed(false)));
+    const exists = yield* fs.exists(filePath).pipe(import_effect24.Effect.catchAll(() => import_effect24.Effect.succeed(false)));
     if (!exists) {
       return false;
     }
     if (item.matchContent != null) {
-      const content = yield* fs.readFileString(filePath).pipe(import_effect18.Effect.catchAll(() => import_effect18.Effect.succeed("")));
+      const content = yield* fs.readFileString(filePath).pipe(import_effect24.Effect.catchAll(() => import_effect24.Effect.succeed("")));
       let regexMatch = false;
       try {
         regexMatch = new RegExp(item.matchContent).test(content);
@@ -2347,7 +2948,7 @@ var matchesDetectionItem = import_effect18.Effect.fn("matchesDetectionItem")(fun
   }
   return true;
 });
-var matchesFramework = import_effect18.Effect.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
+var matchesFramework = import_effect24.Effect.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
   for (const detector of framework.detectors) {
     const matches = yield* matchesDetectionItem(detector, projectFolder, framework, cachedReadDeps);
     if (!matches) {
@@ -2356,9 +2957,19 @@ var matchesFramework = import_effect18.Effect.fn("matchesFramework")(function* (
   }
   return true;
 });
-var detectFramework = import_effect18.Effect.fn("detectFramework")(function* (projectFolder) {
-  yield* import_effect18.Effect.logDebug(`Detecting framework in ${projectFolder}`);
-  const cachedReadDeps = yield* import_effect18.Effect.cachedFunction((key) => {
+var packageManagerForLanguage = (language, detected) => {
+  switch (language) {
+    case "php":
+      return "composer";
+    case "ruby":
+      return "bundler";
+    case "node":
+      return detected === "bundler" ? "npm" : detected;
+  }
+};
+var detectFramework = import_effect24.Effect.fn("detectFramework")(function* (projectFolder) {
+  yield* import_effect24.Effect.logDebug(`Detecting framework in ${projectFolder}`);
+  const cachedReadDeps = yield* import_effect24.Effect.cachedFunction((key) => {
     const sepIndex = key.lastIndexOf("\0");
     const folder = key.slice(0, sepIndex);
     const language = key.slice(sepIndex + 1);
@@ -2367,16 +2978,16 @@ var detectFramework = import_effect18.Effect.fn("detectFramework")(function* (pr
   for (const framework of FRAMEWORK_DEFINITIONS) {
     const matches = yield* matchesFramework(framework, projectFolder, cachedReadDeps);
     if (matches) {
-      yield* import_effect18.Effect.log(`Detected framework: ${framework.name}`, { slug: framework.slug });
+      yield* import_effect24.Effect.log(`Detected framework: ${framework.name}`, { slug: framework.slug });
       const detectedPackageManager = yield* detectPackageManager(projectFolder);
-      const packageManager = framework.language === "php" ? "composer" : detectedPackageManager;
+      const packageManager = packageManagerForLanguage(framework.language, detectedPackageManager);
       const defaults = framework.getDefaultConfig(packageManager);
       const refinedDefaults = framework.refineDefaultConfig ? yield* framework.refineDefaultConfig(defaults, projectFolder) : defaults;
       const config = yield* generateConfig(framework, packageManager, projectFolder, refinedDefaults);
       return { framework, packageManager, config };
     }
   }
-  return yield* import_effect18.Effect.fail(
+  return yield* import_effect24.Effect.fail(
     new FrameworkNotDetectedError({
       message: `No framework detected in project directory`,
       directory: projectFolder
@@ -2385,9 +2996,9 @@ var detectFramework = import_effect18.Effect.fn("detectFramework")(function* (pr
 });
 
 // src/detection/merge-config.ts
-var import_effect19 = require("effect");
-var mergeWithFrameworkDefaults = import_effect19.Effect.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
-  yield* import_effect19.Effect.logDebug("Merging user config with framework defaults");
+var import_effect25 = require("effect");
+var mergeWithFrameworkDefaults = import_effect25.Effect.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
+  yield* import_effect25.Effect.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));
@@ -2428,23 +3039,23 @@ var filterFunctionsFromAssets = (config) => {
 };
 
 // src/parse-config.ts
-var import_effect25 = require("effect");
+var import_effect31 = require("effect");
 
 // src/services/raw-config-reader.ts
-var import_platform13 = require("@effect/platform");
-var import_effect21 = require("effect");
+var import_platform17 = require("@effect/platform");
+var import_effect27 = require("effect");
 var import_yaml2 = require("yaml");
 
 // src/services/config-module-loader.ts
-var import_effect20 = require("effect");
+var import_effect26 = require("effect");
 var import_jiti = require("jiti");
 var MISSING_DEFAULT_EXPORT = /* @__PURE__ */ Symbol("MissingDefaultExport");
 var STRICT_DEFAULT_EXPORT_EXTENSIONS = [".ts", ".mts", ".mjs"];
-var ConfigModuleLoader = class extends import_effect20.Effect.Service()("ConfigModuleLoader", {
-  effect: import_effect20.Effect.gen(function* () {
-    const loadConfigModule = import_effect20.Effect.fn("ConfigModuleLoader.loadConfigModule")(function* (filePath) {
+var ConfigModuleLoader = class extends import_effect26.Effect.Service()("ConfigModuleLoader", {
+  effect: import_effect26.Effect.gen(function* () {
+    const loadConfigModule = import_effect26.Effect.fn("ConfigModuleLoader.loadConfigModule")(function* (filePath) {
       const extension = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
-      const mod = yield* import_effect20.Effect.tryPromise({
+      const mod = yield* import_effect26.Effect.tryPromise({
         try: async () => {
           const jiti = (0, import_jiti.createJiti)(filePath, { fsCache: false, interopDefault: true, moduleCache: false });
           const namespace = await jiti.import(filePath);
@@ -2463,7 +3074,7 @@ var ConfigModuleLoader = class extends import_effect20.Effect.Service()("ConfigM
         })
       });
       if (mod === MISSING_DEFAULT_EXPORT) {
-        return yield* import_effect20.Effect.fail(
+        return yield* import_effect26.Effect.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
@@ -2471,7 +3082,7 @@ var ConfigModuleLoader = class extends import_effect20.Effect.Service()("ConfigM
         );
       }
       if (typeof mod === "function") {
-        return yield* import_effect20.Effect.fail(
+        return yield* import_effect26.Effect.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
@@ -2479,7 +3090,7 @@ var ConfigModuleLoader = class extends import_effect20.Effect.Service()("ConfigM
         );
       }
       if (typeof mod !== "object" || mod === null || Array.isArray(mod)) {
-        return yield* import_effect20.Effect.fail(
+        return yield* import_effect26.Effect.fail(
           new ConfigModuleLoadError({
             message: `Config module at ${filePath} must default-export a config object.`,
             filePath
@@ -2509,36 +3120,36 @@ var ALLOWED_CONFIG_NAMES = [
   "nebula.json"
 ];
 var MODULE_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
-var RawConfigReader = class extends import_effect21.Effect.Service()("RawConfigReader", {
+var RawConfigReader = class extends import_effect27.Effect.Service()("RawConfigReader", {
   dependencies: [ConfigModuleLoader.Default],
-  effect: import_effect21.Effect.gen(function* () {
-    const fs = yield* import_platform13.FileSystem.FileSystem;
-    const pathService = yield* import_platform13.Path.Path;
+  effect: import_effect27.Effect.gen(function* () {
+    const fs = yield* import_platform17.FileSystem.FileSystem;
+    const pathService = yield* import_platform17.Path.Path;
     const moduleLoader = yield* ConfigModuleLoader;
-    const findConfig = import_effect21.Effect.fn("RawConfigReader.findConfig")(function* (projectFolder) {
+    const findConfig = import_effect27.Effect.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(import_effect21.Effect.catchAll(() => import_effect21.Effect.succeed(false)));
+        const exists = yield* fs.exists(filePath).pipe(import_effect27.Effect.catchAll(() => import_effect27.Effect.succeed(false)));
         if (exists) {
           return filePath;
         }
       }
       return null;
     });
-    const readRawConfig = import_effect21.Effect.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
-      const exists = yield* fs.exists(filePath).pipe(import_effect21.Effect.catchAll(() => import_effect21.Effect.succeed(false)));
+    const readRawConfig = import_effect27.Effect.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
+      const exists = yield* fs.exists(filePath).pipe(import_effect27.Effect.catchAll(() => import_effect27.Effect.succeed(false)));
       if (!exists) {
-        return yield* import_effect21.Effect.fail(
+        return yield* import_effect27.Effect.fail(
           new ConfigFileNotFoundError({ message: `Config file not found at ${filePath}`, filePath })
         );
       }
       const fileContents = yield* fs.readFileString(filePath).pipe(
-        import_effect21.Effect.mapError(
+        import_effect27.Effect.mapError(
           () => new ConfigFileParseError({ message: `Failed to read config file at ${filePath}`, filePath })
         )
       );
       if (fileContents.length === 0) {
-        return yield* import_effect21.Effect.fail(
+        return yield* import_effect27.Effect.fail(
           new ConfigFileEmptyError({ message: `Config file is empty at ${filePath}`, filePath })
         );
       }
@@ -2554,7 +3165,7 @@ var RawConfigReader = class extends import_effect21.Effect.Service()("RawConfigR
             parsed = (0, import_yaml2.parse)(fileContents);
           }
         } catch (error) {
-          return yield* import_effect21.Effect.fail(
+          return yield* import_effect27.Effect.fail(
             new ConfigFileParseError({
               message: `Failed to parse config file at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
               filePath,
@@ -2564,21 +3175,21 @@ var RawConfigReader = class extends import_effect21.Effect.Service()("RawConfigR
         }
       }
       if (parsed == null) {
-        return yield* import_effect21.Effect.fail(
+        return yield* import_effect27.Effect.fail(
           new ConfigFileParseError({ message: `Config file could not be parsed at ${filePath}`, filePath })
         );
       }
       if (!options?.disableVersionCheck && typeof parsed.version !== "number") {
-        return yield* import_effect21.Effect.fail(
+        return yield* import_effect27.Effect.fail(
           new ConfigVersionError({ message: `Config file is missing version at ${filePath}`, filePath })
         );
       }
       return parsed;
     });
     const readConfigFile = (configFilePath) => readRawConfig(configFilePath, { disableVersionCheck: true }).pipe(
-      import_effect21.Effect.map((parsed) => parsed),
-      import_effect21.Effect.catchTag("ConfigFileNotFoundError", () => import_effect21.Effect.succeed(null)),
-      import_effect21.Effect.withSpan("RawConfigReader.readConfigFile")
+      import_effect27.Effect.map((parsed) => parsed),
+      import_effect27.Effect.catchTag("ConfigFileNotFoundError", () => import_effect27.Effect.succeed(null)),
+      import_effect27.Effect.withSpan("RawConfigReader.readConfigFile")
     );
     return { findConfig, readRawConfig, readConfigFile };
   })
@@ -2588,17 +3199,17 @@ var RawConfigReader = class extends import_effect21.Effect.Service()("RawConfigR
 // src/services/schema-validator.ts
 var import_ajv = __toESM(require("ajv"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
-var import_effect22 = require("effect");
-var SchemaValidator = class extends import_effect22.Effect.Service()("SchemaValidator", {
-  effect: import_effect22.Effect.gen(function* () {
+var import_effect28 = require("effect");
+var SchemaValidator = class extends import_effect28.Effect.Service()("SchemaValidator", {
+  effect: import_effect28.Effect.gen(function* () {
     const ajv = new import_ajv.default();
     (0, import_ajv_formats.default)(ajv);
-    const validate = import_effect22.Effect.fn("SchemaValidator.validate")(function* (config, schema, filePath) {
+    const validate = import_effect28.Effect.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* import_effect22.Effect.fail(
+        return yield* import_effect28.Effect.fail(
           new ConfigSchemaValidationError({
             message: `Config file at ${filePath} is invalid: ${ajv.errorsText(compiledValidate.errors)}`,
             filePath,
@@ -2654,7 +3265,7 @@ var getFilesForPattern = async (pattern, projectFolder, excludeFiles = []) => {
 };
 
 // src/services/v4-config-parser.ts
-var import_effect23 = require("effect");
+var import_effect29 = require("effect");
 var import_minimatch2 = require("minimatch");
 var import_node_path2 = require("path");
 var import_safe_regex2 = __toESM(require("safe-regex2"));
@@ -2670,7 +3281,7 @@ var toArray = (value) => {
   if (value == null) return void 0;
   return Array.isArray(value) ? value : [value];
 };
-var runtimeStreamsByDefault = (runtime) => runtime == null || runtime.startsWith("node-") || runtime.startsWith("bun-");
+var runtimeStreamsByDefault = (runtime) => runtime == null || runtime.startsWith("node-") || runtime.startsWith("bun-") || runtime.startsWith("ruby-");
 var normalizeImagePolicy = (images) => {
   if (!images) return void 0;
   return {
@@ -2805,7 +3416,7 @@ var mapRoute = (route, entrypoints) => ({
   negativeRequirements: route.missing,
   status: route.statusCode
 });
-var parseEntrypoints = import_effect23.Effect.fn("parseEntrypoints")(function* (config, projectFolder) {
+var parseEntrypoints = import_effect29.Effect.fn("parseEntrypoints")(function* (config, projectFolder) {
   const entrypoints = [];
   const dockerFunctions = [];
   if (config.functions == null) return { entrypoints, dockerFunctions };
@@ -2816,7 +3427,7 @@ var parseEntrypoints = import_effect23.Effect.fn("parseEntrypoints")(function* (
         functionPath: fnPath
       });
     }
-    const matchedFiles = yield* import_effect23.Effect.tryPromise({
+    const matchedFiles = yield* import_effect29.Effect.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)}`,
@@ -2891,13 +3502,13 @@ var parseEntrypoints = import_effect23.Effect.fn("parseEntrypoints")(function* (
   }
   return { entrypoints, dockerFunctions };
 });
-var collectAssets = import_effect23.Effect.fn("collectAssets")(function* (config, projectFolder) {
+var collectAssets = import_effect29.Effect.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 reservedRuntimePorts = (entrypoint) => entrypoint.runtime === CONTAINER_RUNTIME ? [] : entrypoint.runtime.startsWith("php-") ? [8080, 9e3] : [8080];
-var parseContainers = import_effect23.Effect.fn("parseContainers")(function* (config, projectFolder, fileEntrypoints, dockerFunctions) {
+var parseContainers = import_effect29.Effect.fn("parseContainers")(function* (config, projectFolder, fileEntrypoints, dockerFunctions) {
   const warnings = [];
   let containers = {};
   if (config.compose != null) {
@@ -2930,16 +3541,16 @@ var parseContainers = import_effect23.Effect.fn("parseContainers")(function* (co
   }
   return { ...result, warnings };
 });
-var V4ConfigParser = class extends import_effect23.Effect.Service()("V4ConfigParser", {
+var V4ConfigParser = class extends import_effect29.Effect.Service()("V4ConfigParser", {
   accessors: true,
-  effect: import_effect23.Effect.succeed({
+  effect: import_effect29.Effect.succeed({
     /**
      * Parses a ConfigV4 into a NormalizedConfig.
      *
      * @param config - The raw V4 config object
      * @param projectFolder - Absolute path to the project root
      */
-    parse: import_effect23.Effect.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
+    parse: import_effect29.Effect.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];
@@ -2981,7 +3592,7 @@ var V4ConfigParser = class extends import_effect23.Effect.Service()("V4ConfigPar
 };
 
 // src/services/vercel-build-output-parser.ts
-var import_platform14 = require("@effect/platform");
+var import_platform18 = require("@effect/platform");
 
 // ../commons/src/deep-merge.ts
 var deepMerge = (target, ...partials) => {
@@ -3010,7 +3621,7 @@ var deepMerge = (target, ...partials) => {
 };
 
 // src/services/vercel-build-output-parser.ts
-var import_effect24 = require("effect");
+var import_effect30 = require("effect");
 
 // src/build-output-v3/determine-repo-root.ts
 var import_path = __toESM(require("path"));
@@ -3106,11 +3717,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 import_effect24.Effect.Service()("VercelBuildOutputParser", {
-  effect: import_effect24.Effect.gen(function* () {
+var VercelBuildOutputParser = class extends import_effect30.Effect.Service()("VercelBuildOutputParser", {
+  effect: import_effect30.Effect.gen(function* () {
     const rawConfigReader = yield* RawConfigReader;
-    const pathService = yield* import_platform14.Path.Path;
-    const parse = import_effect24.Effect.fn("VercelBuildOutputParser.parse")(function* (parseResult, projectFolder) {
+    const pathService = yield* import_platform18.Path.Path;
+    const parse = import_effect30.Effect.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;
@@ -3122,8 +3733,8 @@ var VercelBuildOutputParser = class extends import_effect24.Effect.Service()("Ve
       merged.regions = [...new Set(merged.regions)];
       return merged;
     });
-    const loadFunctions = import_effect24.Effect.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
-      const functionConfigs = yield* import_effect24.Effect.tryPromise({
+    const loadFunctions = import_effect30.Effect.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
+      const functionConfigs = yield* import_effect30.Effect.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)}`,
@@ -3420,7 +4031,7 @@ var schema_default = {
           },
           streaming: {
             type: "boolean",
-            description: "Enable function response streaming. When omitted, Node and Bun runtimes stream by default."
+            description: "Enable function response streaming. When omitted, Node, Bun and Ruby runtimes stream by default."
           },
           schedule: {
             $ref: "#/$defs/schedule",
@@ -3986,7 +4597,19 @@ var schema_default = {
     },
     runtimes: {
       type: "string",
-      enum: ["php-84", "php-83", "php-81", "node-22", "node-20", "node-18", "node-16", "bun-1"]
+      enum: [
+        "php-84",
+        "php-83",
+        "php-81",
+        "ruby-40",
+        "ruby-34",
+        "ruby-33",
+        "node-22",
+        "node-20",
+        "node-18",
+        "node-16",
+        "bun-1"
+      ]
     },
     matchRequirements: {
       description: "An array of requirements that are needed to match",
@@ -4040,7 +4663,7 @@ var schema_default = {
 };
 
 // src/parse-config.ts
-var parseConfigRaw = import_effect25.Effect.fn("parseConfigRaw")(function* (filePath, projectFolder) {
+var parseConfigRaw = import_effect31.Effect.fn("parseConfigRaw")(function* (filePath, projectFolder) {
   const rawReader = yield* RawConfigReader;
   const validator = yield* SchemaValidator;
   const v4Parser = yield* V4ConfigParser;
@@ -4051,7 +4674,7 @@ var parseConfigRaw = import_effect25.Effect.fn("parseConfigRaw")(function* (file
   };
   const schema = schemaMap[version];
   if (!schema) {
-    return yield* import_effect25.Effect.fail(
+    return yield* import_effect31.Effect.fail(
       new ConfigVersionError({
         message: `Config file at ${filePath} has an unsupported version: ${version}`,
         filePath,
@@ -4062,11 +4685,11 @@ var parseConfigRaw = import_effect25.Effect.fn("parseConfigRaw")(function* (file
   yield* validator.validate(parsed, schema, filePath);
   return yield* v4Parser.parse(parsed, projectFolder);
 });
-var parseConfig = import_effect25.Effect.fn("parseConfig")(function* (filePath, projectFolder) {
+var parseConfig = import_effect31.Effect.fn("parseConfig")(function* (filePath, projectFolder) {
   const parseResult = yield* parseConfigRaw(filePath, projectFolder);
   return yield* postProcessConfig(parseResult, projectFolder);
 });
-var postProcessConfig = import_effect25.Effect.fn("postProcessConfig")(function* (config, projectFolder) {
+var postProcessConfig = import_effect31.Effect.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;
@@ -4114,6 +4737,9 @@ var RUNTIME_DEFINITIONS = [
   "php-84",
   "php-83",
   "php-81",
+  "ruby-40",
+  "ruby-34",
+  "ruby-33",
   "node-22",
   "node-20",
   "node-18",
@@ -4123,14 +4749,14 @@ var RUNTIME_DEFINITIONS = [
 var AVAILABLE_RUNTIMES = [...RUNTIME_DEFINITIONS];
 
 // src/services/index.ts
-var import_effect26 = require("effect");
-var BaseLayers = import_effect26.Layer.mergeAll(
+var import_effect32 = require("effect");
+var BaseLayers = import_effect32.Layer.mergeAll(
   ConfigModuleLoader.Default,
   RawConfigReader.Default,
   SchemaValidator.Default,
   V4ConfigParser.Default
 );
-var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(import_effect26.Layer.provideMerge(BaseLayers));
+var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(import_effect32.Layer.provideMerge(BaseLayers));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALLOWED_CONFIG_NAMES,
@@ -4149,6 +4775,7 @@ var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(import_effect26.Lay
   ContainerConfigError,
   DEFAULT_CONTAINER_MEMORY_MB,
   DEFAULT_FUNCTION_DURATION_SECONDS,
+  DEFAULT_RUBY_RUNTIME,
   DEFAULT_SIDECAR_MEMORY_MB,
   FRAMEWORK_DEFINITIONS,
   FrameworkNotDetectedError,
@@ -4185,6 +4812,7 @@ var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(import_effect26.Lay
   detectContainerProject,
   detectFramework,
   detectPackageManager,
+  detectRubyRuntime,
   dockerFunctionContainerName,
   filterFunctionsFromAssets,
   generateConfig,
@@ -4200,6 +4828,9 @@ var NetworkConfigLive = VercelBuildOutputParser.Default.pipe(import_effect26.Lay
   postProcessConfig,
   readComposeContainers,
   readDependencies,
+  rubyRuntimeForRequirement,
+  rubyRuntimeForVersion,
+  rubyRuntimeFromProjectFiles,
   splitCommandWords
 });
 //# sourceMappingURL=index.js.map