@gigadrive/network-config 5.3.1 → 5.5.0

package/dist/index.mjs

@@ -905,8 +905,8 @@ var detectContainerProject = Effect3.fn("detectContainerProject")(function* (pro
 });
 
 // src/detection/detect-framework.ts
-import { FileSystem as FileSystem12, Path as Path10 } from "@effect/platform";
-import { Effect as Effect14 } from "effect";
+import { FileSystem as FileSystem16, Path as Path14 } from "@effect/platform";
+import { Effect as Effect20 } from "effect";
 
 // src/detection/detect-package-manager.ts
 import { FileSystem as FileSystem4, Path as Path4 } from "@effect/platform";
@@ -916,7 +916,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 = Effect4.fn("detectPackageManager")(function* (projectFolder) {
   const fs = yield* FileSystem4.FileSystem;
@@ -955,6 +958,192 @@ var astro = {
   })
 };
 
+// src/detection/frameworks/ruby-runtime.ts
+import { FileSystem as FileSystem5, Path as Path5 } from "@effect/platform";
+import { Effect as Effect5 } from "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 = Effect5.fn("readProjectFile")(
+  function* (projectFolder, file) {
+    const fs = yield* FileSystem5.FileSystem;
+    const pathService = yield* Path5.Path;
+    return yield* fs.readFileString(pathService.join(projectFolder, file));
+  },
+  Effect5.catchAll(() => Effect5.succeed(void 0))
+);
+var detectRubyRuntime = Effect5.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 = Effect5.fn("refineRubyRuntime")(function* (defaults, projectFolder) {
+  const runtime = yield* detectRubyRuntime(projectFolder);
+  return runtime ? { ...defaults, runtime } : defaults;
+});
+var withRubyRuntime = (framework) => ({
+  ...framework,
+  refineDefaultConfig: (defaults, projectFolder) => Effect5.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}}}`;
 
@@ -1029,8 +1218,8 @@ var codeigniter = {
 };
 
 // src/detection/frameworks/resolve-node-entrypoint.ts
-import { FileSystem as FileSystem5, Path as Path5 } from "@effect/platform";
-import { Effect as Effect5 } from "effect";
+import { FileSystem as FileSystem6, Path as Path6 } from "@effect/platform";
+import { Effect as Effect6 } from "effect";
 var SCRIPT_RUNNERS = /* @__PURE__ */ new Set(["node", "bun", "tsx", "ts-node"]);
 var COMMON_ENTRYPOINT_CANDIDATES = [
   "index.js",
@@ -1078,14 +1267,14 @@ var applyEntrypoint = (defaults, entrypoint) => ({
     (route) => route.destination === defaults.entrypoint ? { ...route, destination: entrypoint } : route
   )
 });
-var resolveNodeServerEntrypoint = (defaults, projectFolder) => Effect5.gen(function* () {
-  const fs = yield* FileSystem5.FileSystem;
-  const pathService = yield* Path5.Path;
+var resolveNodeServerEntrypoint = (defaults, projectFolder) => Effect6.gen(function* () {
+  const fs = yield* FileSystem6.FileSystem;
+  const pathService = yield* Path6.Path;
   const isFile = (relativePath) => fs.stat(pathService.join(projectFolder, relativePath)).pipe(
-    Effect5.map((info) => info.type === "File"),
-    Effect5.catchAll(() => Effect5.succeed(false))
+    Effect6.map((info) => info.type === "File"),
+    Effect6.catchAll(() => Effect6.succeed(false))
   );
-  const content = yield* fs.readFileString(pathService.join(projectFolder, "package.json")).pipe(Effect5.catchAll(() => Effect5.succeed(void 0)));
+  const content = yield* fs.readFileString(pathService.join(projectFolder, "package.json")).pipe(Effect6.catchAll(() => Effect6.succeed(void 0)));
   const manifest = content ? parsePackageJson(content) : void 0;
   const startScript = typeof manifest?.scripts?.start === "string" ? manifest.scripts.start : void 0;
   const candidates = [
@@ -1165,6 +1354,189 @@ var fastify = {
   refineDefaultConfig: resolveNodeServerEntrypoint
 };
 
+// src/detection/frameworks/hanami.ts
+import { Effect as Effect10 } from "effect";
+
+// src/detection/read-dependencies.ts
+import { FileSystem as FileSystem7, Path as Path7 } from "@effect/platform";
+import { Effect as Effect8 } from "effect";
+
+// src/detection/types.ts
+import { Schema as Schema4 } from "effect";
+var ManifestNotFoundError = class extends Schema4.TaggedError()("ManifestNotFoundError", {
+  message: Schema4.String,
+  filePath: Schema4.String
+}) {
+};
+var ManifestReadError = class extends Schema4.TaggedError()("ManifestReadError", {
+  message: Schema4.String,
+  filePath: Schema4.String
+}) {
+};
+var ManifestParseError = class extends Schema4.TaggedError()("ManifestParseError", {
+  message: Schema4.String,
+  filePath: Schema4.String
+}) {
+};
+var FrameworkNotDetectedError = class extends Schema4.TaggedError()(
+  "FrameworkNotDetectedError",
+  {
+    message: Schema4.String,
+    directory: Schema4.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 = Effect8.fn("readOptionalText")(function* (filePath) {
+  const fs = yield* FileSystem7.FileSystem;
+  const exists = yield* fs.exists(filePath).pipe(Effect8.catchAll(() => Effect8.succeed(false)));
+  if (!exists) {
+    return void 0;
+  }
+  return yield* fs.readFileString(filePath).pipe(Effect8.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
+});
+var readGemNames = Effect8.fn("readGemNames")(function* (projectFolder) {
+  const pathService = yield* Path7.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 = Effect8.fn("readManifest")(function* (filePath) {
+  const fs = yield* FileSystem7.FileSystem;
+  const exists = yield* fs.exists(filePath).pipe(Effect8.catchAll(() => Effect8.succeed(false)));
+  if (!exists) {
+    return yield* Effect8.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
+  }
+  const content = yield* fs.readFileString(filePath).pipe(Effect8.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
+  const parsed = yield* Effect8.try({
+    try: () => JSON.parse(content),
+    catch: () => new ManifestParseError({ message: "Failed to parse manifest JSON", filePath })
+  });
+  return parsed;
+});
+var readDependencies = Effect8.fn("readDependencies")(function* (projectFolder, language) {
+  if (language === "ruby") {
+    return yield* readGemNames(projectFolder);
+  }
+  const pathService = yield* Path7.Path;
+  const config = MANIFEST_CONFIG[language];
+  const filePath = pathService.join(projectFolder, config.file);
+  const manifest = yield* readManifest(filePath).pipe(
+    Effect8.catchTag("ManifestNotFoundError", () => Effect8.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
+import { FileSystem as FileSystem8, Path as Path8 } from "@effect/platform";
+import { Effect as Effect9 } from "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 = Effect9.fn("refineRubyPublicDirectory")(function* (defaults, projectFolder) {
+  if (!defaults.assetsDir) {
+    return defaults;
+  }
+  const fs = yield* FileSystem8.FileSystem;
+  const pathService = yield* Path8.Path;
+  const exists = yield* fs.exists(pathService.join(projectFolder, defaults.assetsDir)).pipe(Effect9.catchAll(() => Effect9.succeed(false)));
+  if (exists) {
+    return defaults;
+  }
+  const withoutAssets = { ...defaults };
+  delete withoutAssets.assetsDir;
+  delete withoutAssets.populateAssetCache;
+  return withoutAssets;
+});
+
+// src/detection/frameworks/hanami.ts
+var refineHanamiAssets = Effect10.fn("refineHanamiAssets")(function* (defaults, projectFolder) {
+  const gems = yield* readDependencies(projectFolder, "ruby").pipe(
+    Effect10.catchAll(() => Effect10.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",
@@ -1185,6 +1557,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",
@@ -1264,8 +1660,8 @@ var mezzio = {
 };
 
 // src/detection/frameworks/nestjs.ts
-import { FileSystem as FileSystem6 } from "@effect/platform";
-import { Effect as Effect6 } from "effect";
+import { FileSystem as FileSystem9 } from "@effect/platform";
+import { Effect as Effect11 } from "effect";
 var isRecord3 = (value) => typeof value === "object" && value !== null;
 var parseNestCliJson = (content) => {
   try {
@@ -1316,9 +1712,9 @@ var nestjs = {
   detectors: [{ matchPackage: "@nestjs/core" }],
   priority: 90,
   getDefaultConfig: () => createNestConfig("dist"),
-  refineDefaultConfig: (defaults, projectFolder) => Effect6.gen(function* () {
-    const fs = yield* FileSystem6.FileSystem;
-    const content = yield* fs.readFileString(`${projectFolder}/nest-cli.json`).pipe(Effect6.catchAll(() => Effect6.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => Effect11.gen(function* () {
+    const fs = yield* FileSystem9.FileSystem;
+    const content = yield* fs.readFileString(`${projectFolder}/nest-cli.json`).pipe(Effect11.catchAll(() => Effect11.succeed(void 0)));
     if (!content) return defaults;
     const nestConfig = parseNestCliJson(content);
     const outputPath = nestConfig ? getProjectOutputPath(nestConfig) : void 0;
@@ -1327,28 +1723,28 @@ var nestjs = {
 };
 
 // src/detection/frameworks/nextjs.ts
-import { FileSystem as FileSystem8, Path as Path7 } from "@effect/platform";
-import { Effect as Effect8 } from "effect";
+import { FileSystem as FileSystem11, Path as Path10 } from "@effect/platform";
+import { Effect as Effect13 } from "effect";
 
 // src/build-output-v3/get-default-path-map.ts
-import { FileSystem as FileSystem7, Path as Path6 } from "@effect/platform";
-import { Effect as Effect7 } from "effect";
-var getDefaultPathMap = Effect7.fn("getDefaultPathMap")(function* (directory) {
-  const fs = yield* FileSystem7.FileSystem;
-  const pathService = yield* Path6.Path;
+import { FileSystem as FileSystem10, Path as Path9 } from "@effect/platform";
+import { Effect as Effect12 } from "effect";
+var getDefaultPathMap = Effect12.fn("getDefaultPathMap")(function* (directory) {
+  const fs = yield* FileSystem10.FileSystem;
+  const pathService = yield* Path9.Path;
   const result = {};
-  const exists = yield* fs.exists(directory).pipe(Effect7.catchAll(() => Effect7.succeed(false)));
+  const exists = yield* fs.exists(directory).pipe(Effect12.catchAll(() => Effect12.succeed(false)));
   if (!exists) {
     return result;
   }
   const MAX_DEPTH = 100;
-  const processDirectory = (currentPath, basePath = "", depth = 0) => Effect7.gen(function* () {
+  const processDirectory = (currentPath, basePath = "", depth = 0) => Effect12.gen(function* () {
     if (depth > MAX_DEPTH) return;
-    const entries = yield* fs.readDirectory(currentPath).pipe(Effect7.catchAll(() => Effect7.succeed([])));
+    const entries = yield* fs.readDirectory(currentPath).pipe(Effect12.catchAll(() => Effect12.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(Effect7.catchAll(() => Effect7.succeed(null)));
+      const stat = yield* fs.stat(fullPath).pipe(Effect12.catchAll(() => Effect12.succeed(null)));
       if (!stat) continue;
       if (stat.type === "Directory") {
         yield* processDirectory(fullPath, relativePath, depth + 1);
@@ -1365,244 +1761,244 @@ var getDefaultPathMap = Effect7.fn("getDefaultPathMap")(function* (directory) {
 var MAXIMUM_ENTRY_PAGE_PATHS = 50;
 
 // src/nextjs-manifest.ts
-import { Schema as Schema4 } from "effect";
-var StringArraySchema = Schema4.mutable(Schema4.Array(Schema4.String));
-var StringRecordSchema = Schema4.mutable(Schema4.Record({ key: Schema4.String, value: Schema4.String }));
-var JsonValueSchema = Schema4.suspend(
-  () => Schema4.Union(
-    Schema4.Null,
-    Schema4.Boolean,
-    Schema4.Number,
-    Schema4.String,
-    Schema4.mutable(Schema4.Array(JsonValueSchema)),
-    Schema4.mutable(Schema4.Record({ key: Schema4.String, value: JsonValueSchema }))
+import { Schema as Schema5 } from "effect";
+var StringArraySchema = Schema5.mutable(Schema5.Array(Schema5.String));
+var StringRecordSchema = Schema5.mutable(Schema5.Record({ key: Schema5.String, value: Schema5.String }));
+var JsonValueSchema = Schema5.suspend(
+  () => Schema5.Union(
+    Schema5.Null,
+    Schema5.Boolean,
+    Schema5.Number,
+    Schema5.String,
+    Schema5.mutable(Schema5.Array(JsonValueSchema)),
+    Schema5.mutable(Schema5.Record({ key: Schema5.String, value: JsonValueSchema }))
   )
 );
-var ImageLocalPatternSchema = Schema4.mutable(
-  Schema4.Struct({
-    pathname: Schema4.optional(Schema4.String),
-    search: Schema4.optional(Schema4.String)
+var ImageLocalPatternSchema = Schema5.mutable(
+  Schema5.Struct({
+    pathname: Schema5.optional(Schema5.String),
+    search: Schema5.optional(Schema5.String)
   })
 );
-var ImageRemotePatternSchema = Schema4.mutable(
-  Schema4.Struct({
-    protocol: Schema4.optional(Schema4.Literal("http", "https")),
-    hostname: Schema4.String,
-    port: Schema4.optional(Schema4.String),
-    pathname: Schema4.optional(Schema4.String),
-    search: Schema4.optional(Schema4.String)
+var ImageRemotePatternSchema = Schema5.mutable(
+  Schema5.Struct({
+    protocol: Schema5.optional(Schema5.Literal("http", "https")),
+    hostname: Schema5.String,
+    port: Schema5.optional(Schema5.String),
+    pathname: Schema5.optional(Schema5.String),
+    search: Schema5.optional(Schema5.String)
   })
 );
-var ImageVariantSchema = Schema4.mutable(
-  Schema4.Struct({
-    width: Schema4.optional(Schema4.Number),
-    height: Schema4.optional(Schema4.Number),
-    quality: Schema4.optional(Schema4.Number),
-    format: Schema4.optional(Schema4.Literal("image/avif", "image/webp", "image/jpeg", "image/png")),
-    fit: Schema4.optional(Schema4.Literal("contain", "cover", "fill", "inside", "outside"))
+var ImageVariantSchema = Schema5.mutable(
+  Schema5.Struct({
+    width: Schema5.optional(Schema5.Number),
+    height: Schema5.optional(Schema5.Number),
+    quality: Schema5.optional(Schema5.Number),
+    format: Schema5.optional(Schema5.Literal("image/avif", "image/webp", "image/jpeg", "image/png")),
+    fit: Schema5.optional(Schema5.Literal("contain", "cover", "fill", "inside", "outside"))
   })
 );
-var PositiveIntSchema = Schema4.Int.pipe(Schema4.greaterThan(0));
-var ImagePolicySchema = Schema4.mutable(
-  Schema4.Struct({
-    localPatterns: Schema4.mutable(Schema4.Array(ImageLocalPatternSchema)),
-    remotePatterns: Schema4.mutable(Schema4.Array(ImageRemotePatternSchema)),
-    widths: Schema4.mutable(Schema4.Array(PositiveIntSchema)),
-    heights: Schema4.mutable(Schema4.Array(PositiveIntSchema)),
-    qualities: Schema4.mutable(Schema4.Array(Schema4.Number.pipe(Schema4.between(1, 100)))),
-    formats: Schema4.mutable(Schema4.Array(Schema4.Literal("image/avif", "image/webp", "image/jpeg", "image/png"))),
-    minimumCacheTTL: Schema4.Number,
-    dangerouslyAllowSVG: Schema4.Boolean,
-    contentSecurityPolicy: Schema4.String,
-    contentDispositionType: Schema4.Literal("inline", "attachment"),
-    maximumRedirects: Schema4.Number,
-    maximumResponseBody: Schema4.Number,
-    variants: Schema4.mutable(Schema4.Record({ key: Schema4.String, value: ImageVariantSchema }))
+var PositiveIntSchema = Schema5.Int.pipe(Schema5.greaterThan(0));
+var ImagePolicySchema = Schema5.mutable(
+  Schema5.Struct({
+    localPatterns: Schema5.mutable(Schema5.Array(ImageLocalPatternSchema)),
+    remotePatterns: Schema5.mutable(Schema5.Array(ImageRemotePatternSchema)),
+    widths: Schema5.mutable(Schema5.Array(PositiveIntSchema)),
+    heights: Schema5.mutable(Schema5.Array(PositiveIntSchema)),
+    qualities: Schema5.mutable(Schema5.Array(Schema5.Number.pipe(Schema5.between(1, 100)))),
+    formats: Schema5.mutable(Schema5.Array(Schema5.Literal("image/avif", "image/webp", "image/jpeg", "image/png"))),
+    minimumCacheTTL: Schema5.Number,
+    dangerouslyAllowSVG: Schema5.Boolean,
+    contentSecurityPolicy: Schema5.String,
+    contentDispositionType: Schema5.Literal("inline", "attachment"),
+    maximumRedirects: Schema5.Number,
+    maximumResponseBody: Schema5.Number,
+    variants: Schema5.mutable(Schema5.Record({ key: Schema5.String, value: ImageVariantSchema }))
   })
 );
 var GigadriveNextPrerenderOutputFields = {
-  id: Schema4.String,
-  type: Schema4.Literal("PRERENDER"),
+  id: Schema5.String,
+  type: Schema5.Literal("PRERENDER"),
   pathname: UrlPathnameSchema,
-  route: Schema4.optional(UrlPathnameSchema),
-  parentOutputId: Schema4.String,
-  groupId: Schema4.Number,
-  pprChain: Schema4.optional(Schema4.mutable(Schema4.Struct({ headers: HttpSingleValueHeadersSchema }))),
-  parentFallbackMode: Schema4.optional(JsonValueSchema),
-  fallback: Schema4.optional(
-    Schema4.mutable(
-      Schema4.Struct({
-        filePath: Schema4.optional(PortableRelativePathSchema),
-        initialStatus: Schema4.optional(Schema4.Int.pipe(Schema4.between(100, 599))),
-        initialHeaders: Schema4.optional(HttpHeadersSchema),
-        initialExpiration: Schema4.optional(Schema4.Number),
-        initialRevalidate: Schema4.optional(Schema4.Union(Schema4.Number, Schema4.Literal(false))),
-        postponedState: Schema4.optional(Schema4.String)
+  route: Schema5.optional(UrlPathnameSchema),
+  parentOutputId: Schema5.String,
+  groupId: Schema5.Number,
+  pprChain: Schema5.optional(Schema5.mutable(Schema5.Struct({ headers: HttpSingleValueHeadersSchema }))),
+  parentFallbackMode: Schema5.optional(JsonValueSchema),
+  fallback: Schema5.optional(
+    Schema5.mutable(
+      Schema5.Struct({
+        filePath: Schema5.optional(PortableRelativePathSchema),
+        initialStatus: Schema5.optional(Schema5.Int.pipe(Schema5.between(100, 599))),
+        initialHeaders: Schema5.optional(HttpHeadersSchema),
+        initialExpiration: Schema5.optional(Schema5.Number),
+        initialRevalidate: Schema5.optional(Schema5.Union(Schema5.Number, Schema5.Literal(false))),
+        postponedState: Schema5.optional(Schema5.String)
       })
     )
   ),
-  config: Schema4.mutable(
-    Schema4.Struct({
-      allowQuery: Schema4.optional(StringArraySchema),
-      allowHeader: Schema4.optional(StringArraySchema),
-      bypassFor: Schema4.optional(Schema4.mutable(Schema4.Array(JsonValueSchema))),
-      renderingMode: Schema4.optional(Schema4.String),
-      partialFallback: Schema4.optional(Schema4.Boolean),
-      bypassToken: Schema4.optional(Schema4.String)
+  config: Schema5.mutable(
+    Schema5.Struct({
+      allowQuery: Schema5.optional(StringArraySchema),
+      allowHeader: Schema5.optional(StringArraySchema),
+      bypassFor: Schema5.optional(Schema5.mutable(Schema5.Array(JsonValueSchema))),
+      renderingMode: Schema5.optional(Schema5.String),
+      partialFallback: Schema5.optional(Schema5.Boolean),
+      bypassToken: Schema5.optional(Schema5.String)
     })
   )
 };
-var GigadriveNextPrerenderClassificationSchema = Schema4.Struct({
-  routeType: Schema4.Literal("route", "fallback", "shell", "page"),
-  response: Schema4.Literal("empty", "initial", "complete"),
-  compute: Schema4.Literal("blocking", "resuming", "static"),
-  htmlSize: Schema4.optional(Schema4.Number)
+var GigadriveNextPrerenderClassificationSchema = Schema5.Struct({
+  routeType: Schema5.Literal("route", "fallback", "shell", "page"),
+  response: Schema5.Literal("empty", "initial", "complete"),
+  compute: Schema5.Literal("blocking", "resuming", "static"),
+  htmlSize: Schema5.optional(Schema5.Number)
 });
-var GigadriveNextPrerenderWithoutClassificationSchema = Schema4.Struct({
-  routeType: Schema4.optional(Schema4.Never),
-  response: Schema4.optional(Schema4.Never),
-  compute: Schema4.optional(Schema4.Never),
-  htmlSize: Schema4.optional(Schema4.Never)
+var GigadriveNextPrerenderWithoutClassificationSchema = Schema5.Struct({
+  routeType: Schema5.optional(Schema5.Never),
+  response: Schema5.optional(Schema5.Never),
+  compute: Schema5.optional(Schema5.Never),
+  htmlSize: Schema5.optional(Schema5.Never)
 });
-var GigadriveNextPrerenderOutputSchema = Schema4.Union(
-  Schema4.mutable(
-    Schema4.Struct({ ...GigadriveNextPrerenderOutputFields, ...GigadriveNextPrerenderClassificationSchema.fields })
+var GigadriveNextPrerenderOutputSchema = Schema5.Union(
+  Schema5.mutable(
+    Schema5.Struct({ ...GigadriveNextPrerenderOutputFields, ...GigadriveNextPrerenderClassificationSchema.fields })
   ),
-  Schema4.mutable(
-    Schema4.Struct({
+  Schema5.mutable(
+    Schema5.Struct({
       ...GigadriveNextPrerenderOutputFields,
       ...GigadriveNextPrerenderWithoutClassificationSchema.fields
     })
   )
 );
-var GigadriveNextStaticAssetPrefixSchema = Schema4.mutable(
-  Schema4.Struct({
+var GigadriveNextStaticAssetPrefixSchema = Schema5.mutable(
+  Schema5.Struct({
     sourceDir: PortableRelativePathSchema,
     urlPrefix: PortableRelativePathSchema,
-    immutable: Schema4.Boolean
+    immutable: Schema5.Boolean
   })
 );
-var GigadriveNextRouteConditionSchema = Schema4.Union(
-  Schema4.mutable(
-    Schema4.Struct({
-      type: Schema4.Literal("header", "cookie", "query"),
-      key: Schema4.String,
-      value: Schema4.optional(Schema4.String)
+var GigadriveNextRouteConditionSchema = Schema5.Union(
+  Schema5.mutable(
+    Schema5.Struct({
+      type: Schema5.Literal("header", "cookie", "query"),
+      key: Schema5.String,
+      value: Schema5.optional(Schema5.String)
     })
   ),
-  Schema4.mutable(
-    Schema4.Struct({
-      type: Schema4.Literal("host"),
-      value: Schema4.String
+  Schema5.mutable(
+    Schema5.Struct({
+      type: Schema5.Literal("host"),
+      value: Schema5.String
     })
   )
 );
-var GigadriveNextMiddlewareMatcherSchema = Schema4.mutable(
-  Schema4.Struct({
-    source: Schema4.String,
-    sourceRegex: Schema4.String,
-    has: Schema4.optional(Schema4.mutable(Schema4.Array(GigadriveNextRouteConditionSchema))),
-    missing: Schema4.optional(Schema4.mutable(Schema4.Array(GigadriveNextRouteConditionSchema)))
+var GigadriveNextMiddlewareMatcherSchema = Schema5.mutable(
+  Schema5.Struct({
+    source: Schema5.String,
+    sourceRegex: Schema5.String,
+    has: Schema5.optional(Schema5.mutable(Schema5.Array(GigadriveNextRouteConditionSchema))),
+    missing: Schema5.optional(Schema5.mutable(Schema5.Array(GigadriveNextRouteConditionSchema)))
   })
 );
-var GigadriveNextMiddlewareDescriptorSchema = Schema4.Union(
-  Schema4.mutable(
-    Schema4.Struct({
-      present: Schema4.Literal(true),
-      matchers: Schema4.mutable(Schema4.Array(GigadriveNextMiddlewareMatcherSchema))
+var GigadriveNextMiddlewareDescriptorSchema = Schema5.Union(
+  Schema5.mutable(
+    Schema5.Struct({
+      present: Schema5.Literal(true),
+      matchers: Schema5.mutable(Schema5.Array(GigadriveNextMiddlewareMatcherSchema))
     })
   ),
-  Schema4.mutable(
-    Schema4.Struct({
-      present: Schema4.Literal(false),
-      matchers: Schema4.mutable(Schema4.Tuple())
+  Schema5.mutable(
+    Schema5.Struct({
+      present: Schema5.Literal(false),
+      matchers: Schema5.mutable(Schema5.Tuple())
     })
   )
 );
-var GigadriveNextServerDescriptorSchema = Schema4.mutable(
-  Schema4.Struct({
-    maxDuration: Schema4.optional(Schema4.Number),
-    preferredRegion: Schema4.optional(Schema4.Union(Schema4.String, StringArraySchema)),
-    env: Schema4.optional(StringRecordSchema)
+var GigadriveNextServerDescriptorSchema = Schema5.mutable(
+  Schema5.Struct({
+    maxDuration: Schema5.optional(Schema5.Number),
+    preferredRegion: Schema5.optional(Schema5.Union(Schema5.String, StringArraySchema)),
+    env: Schema5.optional(StringRecordSchema)
   })
 );
-var PrerenderArraySchema = Schema4.mutable(Schema4.Array(GigadriveNextPrerenderOutputSchema));
-var StaticAssetArraySchema = Schema4.mutable(Schema4.Array(GigadriveNextStaticAssetPrefixSchema));
-var JsonValueArraySchema = Schema4.mutable(Schema4.Array(JsonValueSchema));
-var GigadriveNextPrerenderSeedMethodsSchema = Schema4.mutable(
-  Schema4.Tuple(Schema4.Literal("GET"), Schema4.Literal("HEAD"))
+var PrerenderArraySchema = Schema5.mutable(Schema5.Array(GigadriveNextPrerenderOutputSchema));
+var StaticAssetArraySchema = Schema5.mutable(Schema5.Array(GigadriveNextStaticAssetPrefixSchema));
+var JsonValueArraySchema = Schema5.mutable(Schema5.Array(JsonValueSchema));
+var GigadriveNextPrerenderSeedMethodsSchema = Schema5.mutable(
+  Schema5.Tuple(Schema5.Literal("GET"), Schema5.Literal("HEAD"))
 );
-var GigadriveNextBuildManifestV1Schema = Schema4.mutable(
-  Schema4.Struct({
-    version: Schema4.Literal(1),
-    output: Schema4.Literal("standalone", "export"),
+var GigadriveNextBuildManifestV1Schema = Schema5.mutable(
+  Schema5.Struct({
+    version: Schema5.Literal(1),
+    output: Schema5.Literal("standalone", "export"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: Schema4.String,
-    buildId: Schema4.String
+    nextVersion: Schema5.String,
+    buildId: Schema5.String
   })
 );
-var GigadriveNextBuildManifestV2ExportSchema = Schema4.mutable(
-  Schema4.Struct({
-    version: Schema4.Literal(2),
-    mode: Schema4.Literal("export"),
+var GigadriveNextBuildManifestV2ExportSchema = Schema5.mutable(
+  Schema5.Struct({
+    version: Schema5.Literal(2),
+    mode: Schema5.Literal("export"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: Schema4.String,
-    buildId: Schema4.String
+    nextVersion: Schema5.String,
+    buildId: Schema5.String
   })
 );
-var GigadriveNextBuildManifestV2StandaloneSchema = Schema4.mutable(
-  Schema4.Struct({
-    version: Schema4.Literal(2),
-    mode: Schema4.Literal("standalone-v2"),
+var GigadriveNextBuildManifestV2StandaloneSchema = Schema5.mutable(
+  Schema5.Struct({
+    version: Schema5.Literal(2),
+    mode: Schema5.Literal("standalone-v2"),
     distDir: PortableRelativePathSchema,
     repoRootToProject: RepositoryRelativePathSchema,
-    nextVersion: Schema4.String,
-    buildId: Schema4.String,
+    nextVersion: Schema5.String,
+    buildId: Schema5.String,
     server: GigadriveNextServerDescriptorSchema,
-    config: Schema4.mutable(
-      Schema4.Struct({
-        basePath: Schema4.String,
-        trailingSlash: Schema4.Boolean,
-        cacheComponents: Schema4.Boolean,
-        i18n: Schema4.optional(JsonValueSchema),
-        images: Schema4.optional(ImagePolicySchema)
+    config: Schema5.mutable(
+      Schema5.Struct({
+        basePath: Schema5.String,
+        trailingSlash: Schema5.Boolean,
+        cacheComponents: Schema5.Boolean,
+        i18n: Schema5.optional(JsonValueSchema),
+        images: Schema5.optional(ImagePolicySchema)
       })
     ),
-    routing: Schema4.mutable(
-      Schema4.Struct({
+    routing: Schema5.mutable(
+      Schema5.Struct({
         beforeMiddleware: JsonValueArraySchema,
         beforeFiles: JsonValueArraySchema,
         afterFiles: JsonValueArraySchema,
         dynamicRoutes: JsonValueArraySchema,
         onMatch: JsonValueArraySchema,
         fallback: JsonValueArraySchema,
-        shouldNormalizeNextData: Schema4.Boolean,
+        shouldNormalizeNextData: Schema5.Boolean,
         rsc: JsonValueSchema
       })
     ),
-    outputs: Schema4.mutable(
-      Schema4.Struct({
+    outputs: Schema5.mutable(
+      Schema5.Struct({
         prerenders: PrerenderArraySchema,
-        prerenderManifest: Schema4.optional(PortableRelativePathSchema),
-        assetManifest: Schema4.optional(PortableRelativePathSchema),
-        entryPagePaths: Schema4.optional(Schema4.mutable(Schema4.Array(UrlPathnameSchema))),
+        prerenderManifest: Schema5.optional(PortableRelativePathSchema),
+        assetManifest: Schema5.optional(PortableRelativePathSchema),
+        entryPagePaths: Schema5.optional(Schema5.mutable(Schema5.Array(UrlPathnameSchema))),
         staticAssets: StaticAssetArraySchema,
-        middleware: Schema4.optional(GigadriveNextMiddlewareDescriptorSchema)
+        middleware: Schema5.optional(GigadriveNextMiddlewareDescriptorSchema)
       })
     )
   })
 );
-var GigadriveNextBuildManifestSchema = Schema4.Union(
+var GigadriveNextBuildManifestSchema = Schema5.Union(
   GigadriveNextBuildManifestV1Schema,
   GigadriveNextBuildManifestV2ExportSchema,
   GigadriveNextBuildManifestV2StandaloneSchema
 );
-var GigadriveNextPrerenderManifestV1Schema = Schema4.mutable(
-  Schema4.Struct({
-    version: Schema4.Literal(1),
-    seedMethods: Schema4.optional(GigadriveNextPrerenderSeedMethodsSchema),
+var GigadriveNextPrerenderManifestV1Schema = Schema5.mutable(
+  Schema5.Struct({
+    version: Schema5.Literal(1),
+    seedMethods: Schema5.optional(GigadriveNextPrerenderSeedMethodsSchema),
     prerenders: PrerenderArraySchema
   })
 );
@@ -1612,22 +2008,22 @@ var parseGigadriveNextPrerenderManifest = (content) => decodeJson(GigadriveNextP
 // src/detection/frameworks/nextjs.ts
 var toPortablePath = (value) => value.replaceAll("\\", "/");
 var STANDALONE_SERVER_MEMORY_MB = 1024;
-var resolveStandaloneServer = Effect8.fn("nextjs.resolveStandaloneServer")(function* (projectFolder, distDir, repoRootToProject) {
-  const fs = yield* FileSystem8.FileSystem;
-  const pathService = yield* Path7.Path;
+var resolveStandaloneServer = Effect13.fn("nextjs.resolveStandaloneServer")(function* (projectFolder, distDir, repoRootToProject) {
+  const fs = yield* FileSystem11.FileSystem;
+  const pathService = yield* Path10.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(Effect8.catchAll(() => Effect8.succeed(false)));
+  const monorepoServerExists = yield* fs.exists(monorepoServer).pipe(Effect13.catchAll(() => Effect13.succeed(false)));
   const serverPath = monorepoServerExists ? monorepoServer : rootServer;
-  const serverExists = yield* fs.exists(serverPath).pipe(Effect8.catchAll(() => Effect8.succeed(false)));
+  const serverExists = yield* fs.exists(serverPath).pipe(Effect13.catchAll(() => Effect13.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 = Effect8.fn("nextjs.buildStandalonePublicAssets")(function* (projectFolder, standaloneRoot, serverDirectory) {
-  const pathService = yield* Path7.Path;
+var buildStandalonePublicAssets = Effect13.fn("nextjs.buildStandalonePublicAssets")(function* (projectFolder, standaloneRoot, serverDirectory) {
+  const pathService = yield* Path10.Path;
   const publicFiles = yield* getDefaultPathMap(pathService.join(projectFolder, "public"));
   const assetPaths = [];
   const assetOverrides = {};
@@ -1643,8 +2039,8 @@ var buildStandalonePublicAssets = Effect8.fn("nextjs.buildStandalonePublicAssets
   }
   return { assetPaths, assetOverrides, filePathMap };
 });
-var createStaticExportConfig = Effect8.fn("nextjs.createStaticExportConfig")(function* (defaults, projectFolder) {
-  const pathService = yield* Path7.Path;
+var createStaticExportConfig = Effect13.fn("nextjs.createStaticExportConfig")(function* (defaults, projectFolder) {
+  const pathService = yield* Path10.Path;
   const outputDirectory = pathService.join(projectFolder, "out");
   const files = yield* getDefaultPathMap(outputDirectory);
   const assetPaths = [];
@@ -1667,8 +2063,8 @@ var createStaticExportConfig = Effect8.fn("nextjs.createStaticExportConfig")(fun
     package: void 0
   };
 });
-var createStandaloneConfig = Effect8.fn("nextjs.createStandaloneConfig")(function* (defaults, projectFolder, manifest) {
-  const pathService = yield* Path7.Path;
+var createStandaloneConfig = Effect13.fn("nextjs.createStandaloneConfig")(function* (defaults, projectFolder, manifest) {
+  const pathService = yield* Path10.Path;
   const resolved = yield* resolveStandaloneServer(projectFolder, manifest.distDir, manifest.repoRootToProject);
   if (!resolved) return defaults;
   const { standaloneRoot, serverDirectory, entrypoint } = resolved;
@@ -1701,7 +2097,7 @@ var createStandaloneConfig = Effect8.fn("nextjs.createStandaloneConfig")(functio
     }
   };
 });
-var createStandaloneV2Config = Effect8.fn("nextjs.createStandaloneV2Config")(function* (defaults, projectFolder, manifest) {
+var createStandaloneV2Config = Effect13.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;
@@ -1809,9 +2205,9 @@ var nextjs = {
     routes: [{ source: "/*", destination: ".next/standalone/server.js" }],
     environmentVariables: { NODE_ENV: "production" }
   }),
-  refineDefaultConfig: (defaults, projectFolder) => Effect8.gen(function* () {
-    const fs = yield* FileSystem8.FileSystem;
-    const manifestContent = yield* fs.readFileString(`${projectFolder}/.gigadrive/nextjs.json`).pipe(Effect8.catchAll(() => Effect8.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => Effect13.gen(function* () {
+    const fs = yield* FileSystem11.FileSystem;
+    const manifestContent = yield* fs.readFileString(`${projectFolder}/.gigadrive/nextjs.json`).pipe(Effect13.catchAll(() => Effect13.succeed(void 0)));
     const manifest = manifestContent ? parseGigadriveNextBuildManifest(manifestContent) : void 0;
     if (!manifest) return defaults;
     if (manifest.version === 2) {
@@ -1822,8 +2218,8 @@ var nextjs = {
 };
 
 // src/detection/frameworks/nuxt.ts
-import { FileSystem as FileSystem9 } from "@effect/platform";
-import { Effect as Effect9 } from "effect";
+import { FileSystem as FileSystem12 } from "@effect/platform";
+import { Effect as Effect14 } from "effect";
 var isVercelBuildOutputV3 = (content) => {
   try {
     const config = JSON.parse(content);
@@ -1850,9 +2246,9 @@ var nuxt = {
     routes: [{ source: "/*", destination: ".output/server/index.mjs" }],
     environmentVariables: { NODE_ENV: "production", NITRO_PRESET: "node-server" }
   }),
-  refineDefaultConfig: (defaults, projectFolder) => Effect9.gen(function* () {
-    const fs = yield* FileSystem9.FileSystem;
-    const buildOutputConfig = yield* fs.readFileString(`${projectFolder}/.vercel/output/config.json`).pipe(Effect9.catchAll(() => Effect9.succeed(void 0)));
+  refineDefaultConfig: (defaults, projectFolder) => Effect14.gen(function* () {
+    const fs = yield* FileSystem12.FileSystem;
+    const buildOutputConfig = yield* fs.readFileString(`${projectFolder}/.vercel/output/config.json`).pipe(Effect14.catchAll(() => Effect14.succeed(void 0)));
     if (!buildOutputConfig || !isVercelBuildOutputV3(buildOutputConfig)) {
       return defaults;
     }
@@ -1867,16 +2263,16 @@ var nuxt = {
 };
 
 // src/detection/frameworks/php.ts
-import { FileSystem as FileSystem10, Path as Path8 } from "@effect/platform";
-import { Effect as Effect10 } from "effect";
+import { FileSystem as FileSystem13, Path as Path11 } from "@effect/platform";
+import { Effect as Effect15 } from "effect";
 var COMPOSER_FILES = ["composer.json", "composer.lock"];
 var DOCUMENT_ROOTS = ["public", "web", "webroot", "public_html", "htdocs", "."];
-var refinePhpDocumentRoot = (defaults, projectFolder) => Effect10.gen(function* () {
-  const fs = yield* FileSystem10.FileSystem;
-  const pathService = yield* Path8.Path;
+var refinePhpDocumentRoot = (defaults, projectFolder) => Effect15.gen(function* () {
+  const fs = yield* FileSystem13.FileSystem;
+  const pathService = yield* Path11.Path;
   for (const documentRoot of DOCUMENT_ROOTS) {
     const frontController = pathService.join(projectFolder, documentRoot, "index.php");
-    if (yield* fs.exists(frontController).pipe(Effect10.catchAll(() => Effect10.succeed(false)))) {
+    if (yield* fs.exists(frontController).pipe(Effect15.catchAll(() => Effect15.succeed(false)))) {
       return phpFrontControllerDefaults({ documentRoot, excludeFiles: COMPOSER_FILES });
     }
   }
@@ -1900,9 +2296,215 @@ var phpSites = DOCUMENT_ROOTS.map((documentRoot) => ({
   detectors: [{ path: frontControllerPath(documentRoot) }],
   priority: 6,
   getDefaultConfig: () => ({ ...getDefaultConfig(), installCommand: "" }),
-  refineDefaultConfig: (defaults, projectFolder) => refinePhpDocumentRoot(defaults, projectFolder).pipe(Effect10.map((refined) => ({ ...refined, installCommand: "" })))
+  refineDefaultConfig: (defaults, projectFolder) => refinePhpDocumentRoot(defaults, projectFolder).pipe(Effect15.map((refined) => ({ ...refined, installCommand: "" })))
 }));
 
+// src/detection/frameworks/php-runtime.ts
+import { FileSystem as FileSystem14, Path as Path12 } from "@effect/platform";
+import { Effect as Effect16, Option as Option3 } from "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 = Effect16.fn("readPhpConstraint")(
+  function* (projectFolder) {
+    const fs = yield* FileSystem14.FileSystem;
+    const pathService = yield* Path12.Path;
+    const content = yield* fs.readFileString(pathService.join(projectFolder, "composer.json"));
+    const manifest = yield* Effect16.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" ? Option3.some(php) : Option3.none();
+  },
+  Effect16.catchAll(() => Effect16.succeed(Option3.none()))
+);
+var refineComposerPhpRuntime = Effect16.fn("refineComposerPhpRuntime")(function* (defaults, projectFolder) {
+  const constraint = yield* readPhpConstraint(projectFolder);
+  const runtime = Option3.getOrUndefined(Option3.flatMapNullable(constraint, phpRuntimeForConstraint));
+  return runtime ? { ...defaults, runtime } : defaults;
+});
+var withComposerPhpRuntime = (framework) => ({
+  ...framework,
+  refineDefaultConfig: (defaults, projectFolder) => Effect16.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
+import { Effect as Effect17 } from "effect";
+var ASSET_PIPELINE_GEMS = ["propshaft", "sprockets", "sprockets-rails"];
+var refineRailsAssets = Effect17.fn("refineRailsAssets")(function* (defaults, projectFolder) {
+  const gems = yield* readDependencies(projectFolder, "ruby").pipe(
+    Effect17.catchAll(() => Effect17.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",
@@ -1924,6 +2526,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
+import { FileSystem as FileSystem15, Path as Path13 } from "@effect/platform";
+import { Effect as Effect18 } from "effect";
+var SINATRA_ENTRYPOINTS = ["config.ru", "app.rb", "main.rb", "server.rb", "application.rb"];
+var refineSinatraEntrypoint = Effect18.fn("refineSinatraEntrypoint")(function* (defaults, projectFolder) {
+  const fs = yield* FileSystem15.FileSystem;
+  const pathService = yield* Path13.Path;
+  const entrypoint = yield* Effect18.findFirst(
+    SINATRA_ENTRYPOINTS,
+    (file) => fs.exists(pathService.join(projectFolder, file)).pipe(Effect18.catchAll(() => Effect18.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",
@@ -2044,17 +2685,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
-import { Effect as Effect11 } from "effect";
+import { Effect as Effect19 } from "effect";
 var getInstallCommand = (pm) => {
   switch (pm) {
     case "bun":
@@ -2065,6 +2722,8 @@ var getInstallCommand = (pm) => {
       return "yarn install";
     case "composer":
       return "composer install";
+    case "bundler":
+      return "bundle install";
     case "npm":
     default:
       return "npm install";
@@ -2075,11 +2734,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 = Effect11.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 = Effect19.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* Effect11.logDebug(`Generating config for ${framework.name}`, {
+  yield* Effect19.logDebug(`Generating config for ${framework.name}`, {
     runtime: defaults.runtime,
     entrypoint: defaults.entrypoint,
     commands
@@ -2122,6 +2787,7 @@ var generateConfig = Effect11.fn("generateConfig")(function* (framework, package
       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") {
@@ -2144,80 +2810,10 @@ var generateConfig = Effect11.fn("generateConfig")(function* (framework, package
   return config;
 });
 
-// src/detection/read-dependencies.ts
-import { FileSystem as FileSystem11, Path as Path9 } from "@effect/platform";
-import { Effect as Effect13 } from "effect";
-
-// src/detection/types.ts
-import { Schema as Schema5 } from "effect";
-var ManifestNotFoundError = class extends Schema5.TaggedError()("ManifestNotFoundError", {
-  message: Schema5.String,
-  filePath: Schema5.String
-}) {
-};
-var ManifestReadError = class extends Schema5.TaggedError()("ManifestReadError", {
-  message: Schema5.String,
-  filePath: Schema5.String
-}) {
-};
-var ManifestParseError = class extends Schema5.TaggedError()("ManifestParseError", {
-  message: Schema5.String,
-  filePath: Schema5.String
-}) {
-};
-var FrameworkNotDetectedError = class extends Schema5.TaggedError()(
-  "FrameworkNotDetectedError",
-  {
-    message: Schema5.String,
-    directory: Schema5.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 = Effect13.fn("readManifest")(function* (filePath) {
-  const fs = yield* FileSystem11.FileSystem;
-  const exists = yield* fs.exists(filePath).pipe(Effect13.catchAll(() => Effect13.succeed(false)));
-  if (!exists) {
-    return yield* Effect13.fail(new ManifestNotFoundError({ message: "Manifest not found", filePath }));
-  }
-  const content = yield* fs.readFileString(filePath).pipe(Effect13.mapError(() => new ManifestReadError({ message: "Failed to read manifest", filePath })));
-  const parsed = yield* Effect13.try({
-    try: () => JSON.parse(content),
-    catch: () => new ManifestParseError({ message: "Failed to parse manifest JSON", filePath })
-  });
-  return parsed;
-});
-var readDependencies = Effect13.fn("readDependencies")(function* (projectFolder, language) {
-  const pathService = yield* Path9.Path;
-  const config = MANIFEST_CONFIG[language];
-  const filePath = pathService.join(projectFolder, config.file);
-  const manifest = yield* readManifest(filePath).pipe(
-    Effect13.catchTag("ManifestNotFoundError", () => Effect13.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 = Effect14.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
-  const fs = yield* FileSystem12.FileSystem;
-  const pathService = yield* Path10.Path;
+var matchesDetectionItem = Effect20.fn("matchesDetectionItem")(function* (item, projectFolder, framework, cachedReadDeps) {
+  const fs = yield* FileSystem16.FileSystem;
+  const pathService = yield* Path14.Path;
   if (item.matchPackage != null) {
     const deps = yield* cachedReadDeps(`${projectFolder}\0${framework.language}`);
     if (!deps.has(item.matchPackage)) {
@@ -2226,12 +2822,12 @@ var matchesDetectionItem = Effect14.fn("matchesDetectionItem")(function* (item,
   }
   if (item.path != null) {
     const filePath = pathService.join(projectFolder, item.path);
-    const exists = yield* fs.exists(filePath).pipe(Effect14.catchAll(() => Effect14.succeed(false)));
+    const exists = yield* fs.exists(filePath).pipe(Effect20.catchAll(() => Effect20.succeed(false)));
     if (!exists) {
       return false;
     }
     if (item.matchContent != null) {
-      const content = yield* fs.readFileString(filePath).pipe(Effect14.catchAll(() => Effect14.succeed("")));
+      const content = yield* fs.readFileString(filePath).pipe(Effect20.catchAll(() => Effect20.succeed("")));
       let regexMatch = false;
       try {
         regexMatch = new RegExp(item.matchContent).test(content);
@@ -2244,7 +2840,7 @@ var matchesDetectionItem = Effect14.fn("matchesDetectionItem")(function* (item,
   }
   return true;
 });
-var matchesFramework = Effect14.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
+var matchesFramework = Effect20.fn("matchesFramework")(function* (framework, projectFolder, cachedReadDeps) {
   for (const detector of framework.detectors) {
     const matches = yield* matchesDetectionItem(detector, projectFolder, framework, cachedReadDeps);
     if (!matches) {
@@ -2253,9 +2849,19 @@ var matchesFramework = Effect14.fn("matchesFramework")(function* (framework, pro
   }
   return true;
 });
-var detectFramework = Effect14.fn("detectFramework")(function* (projectFolder) {
-  yield* Effect14.logDebug(`Detecting framework in ${projectFolder}`);
-  const cachedReadDeps = yield* Effect14.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 = Effect20.fn("detectFramework")(function* (projectFolder) {
+  yield* Effect20.logDebug(`Detecting framework in ${projectFolder}`);
+  const cachedReadDeps = yield* Effect20.cachedFunction((key) => {
     const sepIndex = key.lastIndexOf("\0");
     const folder = key.slice(0, sepIndex);
     const language = key.slice(sepIndex + 1);
@@ -2264,16 +2870,16 @@ var detectFramework = Effect14.fn("detectFramework")(function* (projectFolder) {
   for (const framework of FRAMEWORK_DEFINITIONS) {
     const matches = yield* matchesFramework(framework, projectFolder, cachedReadDeps);
     if (matches) {
-      yield* Effect14.log(`Detected framework: ${framework.name}`, { slug: framework.slug });
+      yield* Effect20.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* Effect14.fail(
+  return yield* Effect20.fail(
     new FrameworkNotDetectedError({
       message: `No framework detected in project directory`,
       directory: projectFolder
@@ -2282,9 +2888,9 @@ var detectFramework = Effect14.fn("detectFramework")(function* (projectFolder) {
 });
 
 // src/detection/merge-config.ts
-import { Effect as Effect15 } from "effect";
-var mergeWithFrameworkDefaults = Effect15.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
-  yield* Effect15.logDebug("Merging user config with framework defaults");
+import { Effect as Effect21 } from "effect";
+var mergeWithFrameworkDefaults = Effect21.fn("mergeWithFrameworkDefaults")(function* (userConfig, frameworkConfig) {
+  yield* Effect21.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));
@@ -2325,23 +2931,23 @@ var filterFunctionsFromAssets = (config) => {
 };
 
 // src/parse-config.ts
-import { Effect as Effect21 } from "effect";
+import { Effect as Effect27 } from "effect";
 
 // src/services/raw-config-reader.ts
-import { FileSystem as FileSystem13, Path as Path11 } from "@effect/platform";
-import { Effect as Effect17 } from "effect";
+import { FileSystem as FileSystem17, Path as Path15 } from "@effect/platform";
+import { Effect as Effect23 } from "effect";
 import { parse as parseYaml2 } from "yaml";
 
 // src/services/config-module-loader.ts
-import { Effect as Effect16 } from "effect";
+import { Effect as Effect22 } from "effect";
 import { createJiti } from "jiti";
 var MISSING_DEFAULT_EXPORT = /* @__PURE__ */ Symbol("MissingDefaultExport");
 var STRICT_DEFAULT_EXPORT_EXTENSIONS = [".ts", ".mts", ".mjs"];
-var ConfigModuleLoader = class extends Effect16.Service()("ConfigModuleLoader", {
-  effect: Effect16.gen(function* () {
-    const loadConfigModule = Effect16.fn("ConfigModuleLoader.loadConfigModule")(function* (filePath) {
+var ConfigModuleLoader = class extends Effect22.Service()("ConfigModuleLoader", {
+  effect: Effect22.gen(function* () {
+    const loadConfigModule = Effect22.fn("ConfigModuleLoader.loadConfigModule")(function* (filePath) {
       const extension = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
-      const mod = yield* Effect16.tryPromise({
+      const mod = yield* Effect22.tryPromise({
         try: async () => {
           const jiti = createJiti(filePath, { fsCache: false, interopDefault: true, moduleCache: false });
           const namespace = await jiti.import(filePath);
@@ -2360,7 +2966,7 @@ var ConfigModuleLoader = class extends Effect16.Service()("ConfigModuleLoader",
         })
       });
       if (mod === MISSING_DEFAULT_EXPORT) {
-        return yield* Effect16.fail(
+        return yield* Effect22.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
@@ -2368,7 +2974,7 @@ var ConfigModuleLoader = class extends Effect16.Service()("ConfigModuleLoader",
         );
       }
       if (typeof mod === "function") {
-        return yield* Effect16.fail(
+        return yield* Effect22.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
@@ -2376,7 +2982,7 @@ var ConfigModuleLoader = class extends Effect16.Service()("ConfigModuleLoader",
         );
       }
       if (typeof mod !== "object" || mod === null || Array.isArray(mod)) {
-        return yield* Effect16.fail(
+        return yield* Effect22.fail(
           new ConfigModuleLoadError({
             message: `Config module at ${filePath} must default-export a config object.`,
             filePath
@@ -2406,36 +3012,36 @@ var ALLOWED_CONFIG_NAMES = [
   "nebula.json"
 ];
 var MODULE_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
-var RawConfigReader = class extends Effect17.Service()("RawConfigReader", {
+var RawConfigReader = class extends Effect23.Service()("RawConfigReader", {
   dependencies: [ConfigModuleLoader.Default],
-  effect: Effect17.gen(function* () {
-    const fs = yield* FileSystem13.FileSystem;
-    const pathService = yield* Path11.Path;
+  effect: Effect23.gen(function* () {
+    const fs = yield* FileSystem17.FileSystem;
+    const pathService = yield* Path15.Path;
     const moduleLoader = yield* ConfigModuleLoader;
-    const findConfig = Effect17.fn("RawConfigReader.findConfig")(function* (projectFolder) {
+    const findConfig = Effect23.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(Effect17.catchAll(() => Effect17.succeed(false)));
+        const exists = yield* fs.exists(filePath).pipe(Effect23.catchAll(() => Effect23.succeed(false)));
         if (exists) {
           return filePath;
         }
       }
       return null;
     });
-    const readRawConfig = Effect17.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
-      const exists = yield* fs.exists(filePath).pipe(Effect17.catchAll(() => Effect17.succeed(false)));
+    const readRawConfig = Effect23.fn("RawConfigReader.readRawConfig")(function* (filePath, options) {
+      const exists = yield* fs.exists(filePath).pipe(Effect23.catchAll(() => Effect23.succeed(false)));
       if (!exists) {
-        return yield* Effect17.fail(
+        return yield* Effect23.fail(
           new ConfigFileNotFoundError({ message: `Config file not found at ${filePath}`, filePath })
         );
       }
       const fileContents = yield* fs.readFileString(filePath).pipe(
-        Effect17.mapError(
+        Effect23.mapError(
           () => new ConfigFileParseError({ message: `Failed to read config file at ${filePath}`, filePath })
         )
       );
       if (fileContents.length === 0) {
-        return yield* Effect17.fail(
+        return yield* Effect23.fail(
           new ConfigFileEmptyError({ message: `Config file is empty at ${filePath}`, filePath })
         );
       }
@@ -2451,7 +3057,7 @@ var RawConfigReader = class extends Effect17.Service()("RawConfigReader", {
             parsed = parseYaml2(fileContents);
           }
         } catch (error) {
-          return yield* Effect17.fail(
+          return yield* Effect23.fail(
             new ConfigFileParseError({
               message: `Failed to parse config file at ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
               filePath,
@@ -2461,21 +3067,21 @@ var RawConfigReader = class extends Effect17.Service()("RawConfigReader", {
         }
       }
       if (parsed == null) {
-        return yield* Effect17.fail(
+        return yield* Effect23.fail(
           new ConfigFileParseError({ message: `Config file could not be parsed at ${filePath}`, filePath })
         );
       }
       if (!options?.disableVersionCheck && typeof parsed.version !== "number") {
-        return yield* Effect17.fail(
+        return yield* Effect23.fail(
           new ConfigVersionError({ message: `Config file is missing version at ${filePath}`, filePath })
         );
       }
       return parsed;
     });
     const readConfigFile = (configFilePath) => readRawConfig(configFilePath, { disableVersionCheck: true }).pipe(
-      Effect17.map((parsed) => parsed),
-      Effect17.catchTag("ConfigFileNotFoundError", () => Effect17.succeed(null)),
-      Effect17.withSpan("RawConfigReader.readConfigFile")
+      Effect23.map((parsed) => parsed),
+      Effect23.catchTag("ConfigFileNotFoundError", () => Effect23.succeed(null)),
+      Effect23.withSpan("RawConfigReader.readConfigFile")
     );
     return { findConfig, readRawConfig, readConfigFile };
   })
@@ -2485,17 +3091,17 @@ var RawConfigReader = class extends Effect17.Service()("RawConfigReader", {
 // src/services/schema-validator.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-import { Effect as Effect18 } from "effect";
-var SchemaValidator = class extends Effect18.Service()("SchemaValidator", {
-  effect: Effect18.gen(function* () {
+import { Effect as Effect24 } from "effect";
+var SchemaValidator = class extends Effect24.Service()("SchemaValidator", {
+  effect: Effect24.gen(function* () {
     const ajv = new Ajv();
     addFormats(ajv);
-    const validate = Effect18.fn("SchemaValidator.validate")(function* (config, schema, filePath) {
+    const validate = Effect24.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* Effect18.fail(
+        return yield* Effect24.fail(
           new ConfigSchemaValidationError({
             message: `Config file at ${filePath} is invalid: ${ajv.errorsText(compiledValidate.errors)}`,
             filePath,
@@ -2551,7 +3157,7 @@ var getFilesForPattern = async (pattern, projectFolder, excludeFiles = []) => {
 };
 
 // src/services/v4-config-parser.ts
-import { Effect as Effect19 } from "effect";
+import { Effect as Effect25 } from "effect";
 import { minimatch as minimatch2 } from "minimatch";
 import { posix as posix2 } from "path";
 import safeRegex from "safe-regex2";
@@ -2567,7 +3173,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 {
@@ -2702,7 +3308,7 @@ var mapRoute = (route, entrypoints) => ({
   negativeRequirements: route.missing,
   status: route.statusCode
 });
-var parseEntrypoints = Effect19.fn("parseEntrypoints")(function* (config, projectFolder) {
+var parseEntrypoints = Effect25.fn("parseEntrypoints")(function* (config, projectFolder) {
   const entrypoints = [];
   const dockerFunctions = [];
   if (config.functions == null) return { entrypoints, dockerFunctions };
@@ -2713,7 +3319,7 @@ var parseEntrypoints = Effect19.fn("parseEntrypoints")(function* (config, projec
         functionPath: fnPath
       });
     }
-    const matchedFiles = yield* Effect19.tryPromise({
+    const matchedFiles = yield* Effect25.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)}`,
@@ -2788,13 +3394,13 @@ var parseEntrypoints = Effect19.fn("parseEntrypoints")(function* (config, projec
   }
   return { entrypoints, dockerFunctions };
 });
-var collectAssets = Effect19.fn("collectAssets")(function* (config, projectFolder) {
+var collectAssets = Effect25.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 = Effect19.fn("parseContainers")(function* (config, projectFolder, fileEntrypoints, dockerFunctions) {
+var parseContainers = Effect25.fn("parseContainers")(function* (config, projectFolder, fileEntrypoints, dockerFunctions) {
   const warnings = [];
   let containers = {};
   if (config.compose != null) {
@@ -2827,16 +3433,16 @@ var parseContainers = Effect19.fn("parseContainers")(function* (config, projectF
   }
   return { ...result, warnings };
 });
-var V4ConfigParser = class extends Effect19.Service()("V4ConfigParser", {
+var V4ConfigParser = class extends Effect25.Service()("V4ConfigParser", {
   accessors: true,
-  effect: Effect19.succeed({
+  effect: Effect25.succeed({
     /**
      * Parses a ConfigV4 into a NormalizedConfig.
      *
      * @param config - The raw V4 config object
      * @param projectFolder - Absolute path to the project root
      */
-    parse: Effect19.fn("V4ConfigParser.parse")(function* (config, projectFolder) {
+    parse: Effect25.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];
@@ -2878,7 +3484,7 @@ var V4ConfigParser = class extends Effect19.Service()("V4ConfigParser", {
 };
 
 // src/services/vercel-build-output-parser.ts
-import { Path as Path12 } from "@effect/platform";
+import { Path as Path16 } from "@effect/platform";
 
 // ../commons/src/deep-merge.ts
 var deepMerge = (target, ...partials) => {
@@ -2907,7 +3513,7 @@ var deepMerge = (target, ...partials) => {
 };
 
 // src/services/vercel-build-output-parser.ts
-import { Effect as Effect20 } from "effect";
+import { Effect as Effect26 } from "effect";
 
 // src/build-output-v3/determine-repo-root.ts
 import path from "path";
@@ -3003,11 +3609,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 Effect20.Service()("VercelBuildOutputParser", {
-  effect: Effect20.gen(function* () {
+var VercelBuildOutputParser = class extends Effect26.Service()("VercelBuildOutputParser", {
+  effect: Effect26.gen(function* () {
     const rawConfigReader = yield* RawConfigReader;
-    const pathService = yield* Path12.Path;
-    const parse = Effect20.fn("VercelBuildOutputParser.parse")(function* (parseResult, projectFolder) {
+    const pathService = yield* Path16.Path;
+    const parse = Effect26.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;
@@ -3019,8 +3625,8 @@ var VercelBuildOutputParser = class extends Effect20.Service()("VercelBuildOutpu
       merged.regions = [...new Set(merged.regions)];
       return merged;
     });
-    const loadFunctions = Effect20.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
-      const functionConfigs = yield* Effect20.tryPromise({
+    const loadFunctions = Effect26.fn("VercelBuildOutputParser.loadFunctions")(function* (config, parseResult, projectFolder) {
+      const functionConfigs = yield* Effect26.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)}`,
@@ -3317,7 +3923,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",
@@ -3883,7 +4489,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",
@@ -3937,7 +4555,7 @@ var schema_default = {
 };
 
 // src/parse-config.ts
-var parseConfigRaw = Effect21.fn("parseConfigRaw")(function* (filePath, projectFolder) {
+var parseConfigRaw = Effect27.fn("parseConfigRaw")(function* (filePath, projectFolder) {
   const rawReader = yield* RawConfigReader;
   const validator = yield* SchemaValidator;
   const v4Parser = yield* V4ConfigParser;
@@ -3948,7 +4566,7 @@ var parseConfigRaw = Effect21.fn("parseConfigRaw")(function* (filePath, projectF
   };
   const schema = schemaMap[version];
   if (!schema) {
-    return yield* Effect21.fail(
+    return yield* Effect27.fail(
       new ConfigVersionError({
         message: `Config file at ${filePath} has an unsupported version: ${version}`,
         filePath,
@@ -3959,11 +4577,11 @@ var parseConfigRaw = Effect21.fn("parseConfigRaw")(function* (filePath, projectF
   yield* validator.validate(parsed, schema, filePath);
   return yield* v4Parser.parse(parsed, projectFolder);
 });
-var parseConfig = Effect21.fn("parseConfig")(function* (filePath, projectFolder) {
+var parseConfig = Effect27.fn("parseConfig")(function* (filePath, projectFolder) {
   const parseResult = yield* parseConfigRaw(filePath, projectFolder);
   return yield* postProcessConfig(parseResult, projectFolder);
 });
-var postProcessConfig = Effect21.fn("postProcessConfig")(function* (config, projectFolder) {
+var postProcessConfig = Effect27.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;
@@ -4011,6 +4629,9 @@ var RUNTIME_DEFINITIONS = [
   "php-84",
   "php-83",
   "php-81",
+  "ruby-40",
+  "ruby-34",
+  "ruby-33",
   "node-22",
   "node-20",
   "node-18",
@@ -4045,6 +4666,7 @@ export {
   ContainerConfigError,
   DEFAULT_CONTAINER_MEMORY_MB,
   DEFAULT_FUNCTION_DURATION_SECONDS,
+  DEFAULT_RUBY_RUNTIME,
   DEFAULT_SIDECAR_MEMORY_MB,
   FRAMEWORK_DEFINITIONS,
   FrameworkNotDetectedError,
@@ -4081,6 +4703,7 @@ export {
   detectContainerProject,
   detectFramework,
   detectPackageManager,
+  detectRubyRuntime,
   dockerFunctionContainerName,
   filterFunctionsFromAssets,
   generateConfig,
@@ -4096,6 +4719,9 @@ export {
   postProcessConfig,
   readComposeContainers,
   readDependencies,
+  rubyRuntimeForRequirement,
+  rubyRuntimeForVersion,
+  rubyRuntimeFromProjectFiles,
   splitCommandWords
 };
 //# sourceMappingURL=index.mjs.map