@vercel/ruby 2.4.0-canary.20260211174907.cdd2da6 → 2.5.0

package/dist/index.js

@@ -2371,9 +2371,9 @@ var require_end_of_stream = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js
+// ../../node_modules/.pnpm/pump@3.0.4/node_modules/pump/index.js
 var require_pump = __commonJS({
-  "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/pump@3.0.4/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
     var fs;
@@ -2383,7 +2383,7 @@ var require_pump = __commonJS({
     }
     var noop = function() {
     };
-    var ancient = /^v?\.0/.test(process.version);
+    var ancient = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
     var isFn = function(fn) {
       return typeof fn === "function";
     };
@@ -6940,6 +6940,7 @@ var require_semver2 = __commonJS({
 var src_exports = {};
 __export(src_exports, {
   build: () => build,
+  diagnostics: () => diagnostics,
   shouldServe: () => shouldServe,
   startDevServer: () => startDevServer,
   version: () => version
@@ -6949,7 +6950,7 @@ var import_os2 = require("os");
 var import_path3 = require("path");
 var import_execa2 = __toESM(require_execa());
 var import_fs_extra = __toESM(require_lib());
-var import_build_utils3 = require("@vercel/build-utils");
+var import_build_utils4 = require("@vercel/build-utils");
 
 // src/install-ruby.ts
 var import_execa = __toESM(require_execa());
@@ -7156,12 +7157,16 @@ function isInstalled({ major, minor }) {
   return Boolean(import_which.default.sync((0, import_path.join)(gemHome, "bin/ruby"), { nothrow: true })) && Boolean(import_which.default.sync((0, import_path.join)(gemHome, "bin/gem"), { nothrow: true }));
 }
 
+// src/diagnostics.ts
+var import_build_utils2 = require("@vercel/build-utils");
+var diagnostics = (0, import_build_utils2.createDiagnostics)("ruby");
+
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
 var import_fs = require("fs");
 var import_path2 = require("path");
 var import_which2 = __toESM(require_lib2());
-var import_build_utils2 = require("@vercel/build-utils");
+var import_build_utils3 = require("@vercel/build-utils");
 function silenceNodeWarnings() {
   const original = process.emitWarning.bind(
     process
@@ -7199,12 +7204,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils2.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils3.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils2.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils3.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -7212,7 +7217,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils2.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils3.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -7232,14 +7237,18 @@ function createDevRubyShim(workPath, entrypoint) {
     const vercelRubyDir = (0, import_path2.join)(workPath, ".vercel", "ruby");
     (0, import_fs.mkdirSync)(vercelRubyDir, { recursive: true });
     const shimPath = (0, import_path2.join)(vercelRubyDir, `vc_init_dev.rb`);
+    const utilsPath = (0, import_path2.join)(vercelRubyDir, "vc__utils__ruby.rb");
     const templatePath = (0, import_path2.join)(__dirname, "..", "vc_init_dev.rb");
+    const utilsTemplatePath = (0, import_path2.join)(__dirname, "..", "vc_utils.rb");
     const template = (0, import_fs.readFileSync)(templatePath, "utf8");
+    const utilsTemplate = (0, import_fs.readFileSync)(utilsTemplatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_ENTRYPOINT__/g, entrypoint);
     (0, import_fs.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils2.debug)(`Prepared Ruby dev shim at ${shimPath}`);
+    (0, import_fs.writeFileSync)(utilsPath, utilsTemplate, "utf8");
+    (0, import_build_utils3.debug)(`Prepared Ruby dev shim at ${shimPath}`);
     return shimPath;
   } catch (err) {
-    (0, import_build_utils2.debug)(`Failed to prepare Ruby dev shim: ${err?.message || err}`);
+    (0, import_build_utils3.debug)(`Failed to prepare Ruby dev shim: ${err?.message || err}`);
     return null;
   }
 }
@@ -7260,8 +7269,22 @@ async function run(cmd, args, opts) {
       env: opts.env,
       stdio: ["ignore", "pipe", "pipe"]
     });
-    child.stdout?.on("data", (buf) => process.stdout.write(buf));
-    child.stderr?.on("data", (buf) => process.stderr.write(buf));
+    child.stdout?.on("data", (data) => {
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      if (opts.onStdout) {
+        opts.onStdout(chunk);
+      } else {
+        process.stdout.write(chunk.toString());
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      if (opts.onStderr) {
+        opts.onStderr(chunk);
+      } else {
+        process.stderr.write(chunk.toString());
+      }
+    });
     child.on("close", (code, signal) => resolve({ code, signal }));
   });
 }
@@ -7309,7 +7332,7 @@ var startDevServer = async (opts) => {
       const shimPath = createDevRubyShim(workPath, entrypoint);
       if (!shimPath) {
         rejectChildReady(
-          new import_build_utils2.NowBuildError({
+          new import_build_utils3.NowBuildError({
             code: "RUBY_DEV_SHIM_ERROR",
             message: "Failed to create Ruby dev shim."
           })
@@ -7325,11 +7348,16 @@ var startDevServer = async (opts) => {
       }
       const checkDeps = async () => {
         if (gemfile && bundlerPath) {
-          (0, import_build_utils2.debug)(`Running "bundle check" for ${gemfile}`);
+          (0, import_build_utils3.debug)(`Running "bundle check" for ${gemfile}`);
           const check = await run(
             bundlerPath,
             ["check", "--gemfile", gemfile],
-            { cwd: projectDir, env }
+            {
+              cwd: projectDir,
+              env,
+              onStdout: opts.onStdout,
+              onStderr: opts.onStderr
+            }
           );
           if (check.code !== 0) {
             return false;
@@ -7339,7 +7367,7 @@ var startDevServer = async (opts) => {
       };
       checkDeps().then((ok) => {
         if (!ok) {
-          const err = new import_build_utils2.NowBuildError({
+          const err = new import_build_utils3.NowBuildError({
             code: "RUBY_GEMS_MISSING",
             message: 'Required gems are not installed. Run "vercel build" and try again.'
           });
@@ -7352,25 +7380,25 @@ var startDevServer = async (opts) => {
           cmd = bundlerPath;
           args = ["exec", "ruby", shimPath];
         }
-        (0, import_build_utils2.debug)(`Starting Ruby dev server: ${cmd} ${args.join(" ")}`);
+        (0, import_build_utils3.debug)(`Starting Ruby dev server: ${cmd} ${args.join(" ")}`);
         const child = (0, import_child_process2.spawn)(cmd, args, {
           cwd: workPath,
           env,
-          stdio: ["inherit", "pipe", "pipe"]
+          stdio: ["ignore", "pipe", "pipe"]
         });
         childProcess = child;
         stdoutLogListener = (buf) => {
-          const s = buf.toString();
-          for (const line of s.split(/\r?\n/)) {
-            if (line)
-              process.stdout.write(line.endsWith("\n") ? line : line + "\n");
+          if (opts.onStdout) {
+            opts.onStdout(buf);
+          } else {
+            process.stdout.write(buf.toString());
           }
         };
         stderrLogListener = (buf) => {
-          const s = buf.toString();
-          for (const line of s.split(/\r?\n/)) {
-            if (line)
-              process.stderr.write(line.endsWith("\n") ? line : line + "\n");
+          if (opts.onStderr) {
+            opts.onStderr(buf);
+          } else {
+            process.stderr.write(buf.toString());
           }
         };
         child.stdout?.on("data", stdoutLogListener);
@@ -7448,7 +7476,7 @@ async function matchPaths(configPatterns, workPath) {
   }
   const patternPaths = await Promise.all(
     patterns.map(async (pattern) => {
-      const files = await (0, import_build_utils3.glob)(pattern, workPath);
+      const files = await (0, import_build_utils4.glob)(pattern, workPath);
       return Object.keys(files);
     })
   );
@@ -7477,8 +7505,8 @@ async function prepareGemfile(gemfilePath, major) {
   return { modified };
 }
 async function bundleLock(bundlerPath, gemfilePath, rubyPath) {
-  const bundleAppConfig = await (0, import_build_utils3.getWriteableDirectory)();
-  const bundlerEnv = (0, import_build_utils3.cloneEnv)(process.env, {
+  const bundleAppConfig = await (0, import_build_utils4.getWriteableDirectory)();
+  const bundlerEnv = (0, import_build_utils4.cloneEnv)(process.env, {
     PATH: `${(0, import_path3.dirname)(rubyPath)}:${(0, import_path3.dirname)(bundlerPath)}:${process.env.PATH}`,
     BUNDLE_SILENCE_ROOT_WARNING: "1",
     BUNDLE_APP_CONFIG: bundleAppConfig,
@@ -7493,7 +7521,7 @@ async function bundleLock(bundlerPath, gemfilePath, rubyPath) {
     const darwinPlatform = darwinMajor ? `${darwinArchToken}-darwin-${darwinMajor}` : `${darwinArchToken}-darwin`;
     platforms.push(darwinPlatform);
   }
-  (0, import_build_utils3.debug)(`ruby: ensuring Gemfile.lock has platforms ${platforms.join(", ")}`);
+  (0, import_build_utils4.debug)(`ruby: ensuring Gemfile.lock has platforms ${platforms.join(", ")}`);
   const lockArgs = ["lock"];
   for (const platform of platforms) {
     lockArgs.push("--add-platform", platform);
@@ -7511,8 +7539,8 @@ async function bundleLock(bundlerPath, gemfilePath, rubyPath) {
   }
 }
 async function bundleInstall(bundlePath, bundleDir, gemfilePath, rubyPath) {
-  const bundleAppConfig = await (0, import_build_utils3.getWriteableDirectory)();
-  const bundlerEnv = (0, import_build_utils3.cloneEnv)(process.env, {
+  const bundleAppConfig = await (0, import_build_utils4.getWriteableDirectory)();
+  const bundlerEnv = (0, import_build_utils4.cloneEnv)(process.env, {
     PATH: `${(0, import_path3.dirname)(rubyPath)}:${(0, import_path3.dirname)(bundlePath)}:${process.env.PATH}`,
     BUNDLE_SILENCE_ROOT_WARNING: "1",
     BUNDLE_APP_CONFIG: bundleAppConfig,
@@ -7521,7 +7549,7 @@ async function bundleInstall(bundlePath, bundleDir, gemfilePath, rubyPath) {
     BUNDLE_PATH: bundleDir,
     BUNDLE_FROZEN: "true"
   });
-  (0, import_build_utils3.debug)('running "bundle install"');
+  (0, import_build_utils4.debug)('running "bundle install"');
   const installRes = await (0, import_execa2.default)(
     bundlePath,
     ["install", "--gemfile", gemfilePath],
@@ -7543,12 +7571,13 @@ var build = async ({
   files,
   entrypoint,
   config,
-  meta = {}
+  meta = {},
+  service
 }) => {
-  await (0, import_build_utils3.download)(files, workPath, meta);
+  await (0, import_build_utils4.download)(files, workPath, meta);
   const entrypointFsDirname = (0, import_path3.join)(workPath, (0, import_path3.dirname)(entrypoint));
   const gemfileName = "Gemfile";
-  let gemfilePath = await (0, import_build_utils3.walkParentDirs)({
+  let gemfilePath = await (0, import_build_utils4.walkParentDirs)({
     base: workPath,
     start: entrypointFsDirname,
     filename: gemfileName
@@ -7561,17 +7590,17 @@ var build = async ({
   const { gemHome, bundlerPath, vendorPath, runtime, rubyPath, major } = await installBundler(meta, gemfileContents);
   process.env.GEM_HOME = gemHome;
   try {
-    (0, import_build_utils3.debug)("preparing Gemfile");
+    (0, import_build_utils4.debug)("preparing Gemfile");
     await prepareGemfile(gemfilePath, major);
-    (0, import_build_utils3.debug)('running "bundle lock"');
+    (0, import_build_utils4.debug)('running "bundle lock"');
     await bundleLock(bundlerPath, gemfilePath, rubyPath);
   } catch (err) {
-    (0, import_build_utils3.debug)(
+    (0, import_build_utils4.debug)(
       "failed to normalize Gemfile/lockfile before vendor check",
       err
     );
   }
-  (0, import_build_utils3.debug)(`Checking existing vendor directory at "${vendorPath}"`);
+  (0, import_build_utils4.debug)(`Checking existing vendor directory at "${vendorPath}"`);
   const vendorDir = (0, import_path3.join)(workPath, vendorPath);
   const bundleDir = (0, import_path3.join)(workPath, "vendor", "bundle");
   const relativeVendorDir = (0, import_path3.join)(entrypointFsDirname, vendorPath);
@@ -7579,31 +7608,34 @@ var build = async ({
   const hasRelativeVendorDir = await (0, import_fs_extra.pathExists)(relativeVendorDir);
   if (hasRelativeVendorDir) {
     if (hasRootVendorDir) {
-      (0, import_build_utils3.debug)(
+      (0, import_build_utils4.debug)(
         "found two vendor directories, choosing the vendor directory relative to entrypoint"
       );
     } else {
-      (0, import_build_utils3.debug)("found vendor directory relative to entrypoint");
+      (0, import_build_utils4.debug)("found vendor directory relative to entrypoint");
     }
     await (0, import_fs_extra.move)(relativeVendorDir, vendorDir);
   } else if (hasRootVendorDir) {
-    (0, import_build_utils3.debug)("found vendor directory in project root");
+    (0, import_build_utils4.debug)("found vendor directory in project root");
   }
   await (0, import_fs_extra.ensureDir)(vendorDir);
   await bundleInstall(bundlerPath, bundleDir, gemfilePath, rubyPath);
   try {
     await (0, import_fs_extra.remove)((0, import_path3.join)(vendorDir, "cache"));
-  } catch (e) {
+  } catch (_e) {
   }
   const originalRbPath = (0, import_path3.join)(__dirname, "..", "vc_init.rb");
   const originalHandlerRbContents = await (0, import_fs_extra.readFile)(originalRbPath, "utf8");
-  (0, import_build_utils3.debug)("entrypoint is", entrypoint);
+  const originalUtilsRbPath = (0, import_path3.join)(__dirname, "..", "vc_utils.rb");
+  const originalUtilsRbContents = await (0, import_fs_extra.readFile)(originalUtilsRbPath, "utf8");
+  (0, import_build_utils4.debug)("entrypoint is", entrypoint);
   const userHandlerFilePath = entrypoint.replace(/\.rb$/, "");
   const nowHandlerRbContents = originalHandlerRbContents.replace(
     /__VC_HANDLER_FILENAME/g,
     userHandlerFilePath
   );
   const handlerRbFilename = "vc__handler__ruby";
+  const utilsRbFilename = "vc__utils__ruby.rb";
   const predefinedExcludes = [
     ".git/**",
     ".gitignore",
@@ -7617,10 +7649,13 @@ var build = async ({
     cwd: workPath,
     ignore: predefinedExcludes
   };
-  const outputFiles = await (0, import_build_utils3.glob)("**", globOptions);
-  outputFiles[`${handlerRbFilename}.rb`] = new import_build_utils3.FileBlob({
+  const outputFiles = await (0, import_build_utils4.glob)("**", globOptions);
+  outputFiles[`${handlerRbFilename}.rb`] = new import_build_utils4.FileBlob({
     data: nowHandlerRbContents
   });
+  outputFiles[utilsRbFilename] = new import_build_utils4.FileBlob({
+    data: originalUtilsRbContents
+  });
   if (config && (config.includeFiles || config.excludeFiles)) {
     const includedPaths = await matchPaths(config.includeFiles, workPath);
     const excludedPaths = await matchPaths(
@@ -7631,7 +7666,7 @@ var build = async ({
       if (includedPaths.includes(excludedPaths[i])) {
         continue;
       }
-      if (excludedPaths[i] === `${handlerRbFilename}.rb`) {
+      if (excludedPaths[i] === `${handlerRbFilename}.rb` || excludedPaths[i] === utilsRbFilename) {
         continue;
       }
       if (excludedPaths[i].startsWith(vendorPath)) {
@@ -7640,18 +7675,29 @@ var build = async ({
       delete outputFiles[excludedPaths[i]];
     }
   }
-  const output = new import_build_utils3.Lambda({
+  const output = new import_build_utils4.Lambda({
     files: outputFiles,
     handler: `${handlerRbFilename}.vc__handler`,
     runtime,
     environment: {}
   });
+  try {
+    await (0, import_build_utils2.generateRubyProjectManifest)({
+      workPath,
+      gemfileLockPath: (0, import_path3.join)((0, import_path3.dirname)(gemfilePath), "Gemfile.lock"),
+      framework: config?.framework ?? void 0,
+      serviceType: service ? (0, import_build_utils4.getReportedServiceType)(service) : void 0
+    });
+  } catch (err) {
+    (0, import_build_utils4.debug)(`Failed to write ruby manifest: ${String(err)}`);
+  }
   return { output };
 };
 var shouldServe = () => true;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,
+  diagnostics,
   shouldServe,
   startDevServer,
   version

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@vercel/ruby",
   "author": "Nathan Cahill <nathan@nathancahill.com>",
-  "version": "2.4.0-canary.20260211174907.cdd2da6",
+  "version": "2.5.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/ruby",
   "files": [
     "dist",
     "vc_init.rb",
-    "vc_init_dev.rb"
+    "vc_init_dev.rb",
+    "vc_utils.rb"
   ],
   "repository": {
     "type": "git",
@@ -21,15 +22,17 @@
     "@types/which": "3.0.0",
     "execa": "2.0.4",
     "fs-extra": "^7.0.1",
-    "jest-junit": "16.0.0",
     "semver": "6.3.1",
+    "vitest": "2.0.3",
     "which": "3.0.0",
-    "@vercel/build-utils": "13.4.0-canary.20260211174907.cdd2da6"
+    "@vercel/build-utils": "13.31.0"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",
-    "test": "jest --reporters=default --reporters=jest-junit --env node --verbose --runInBand --bail",
+    "test": "vitest run --config ../../vitest.config.mts",
     "test-e2e": "pnpm test",
-    "type-check": "tsc --noEmit"
+    "type-check": "tsc --noEmit",
+    "vitest-run": "vitest -c ../../vitest.config.mts",
+    "vitest-e2e": "glob --absolute 'test/**/*.test.js' 'test/**/*.test.ts' 'tests/**/*.test.js' 'tests/**/*.test.ts'"
   }
 }

package/vc_init.rb

@@ -3,6 +3,7 @@ require 'webrick'
 require 'net/http'
 require 'base64'
 require 'json'
+require_relative 'vc__utils__ruby'
 
 $entrypoint = '__VC_HANDLER_FILENAME'
 
@@ -10,13 +11,17 @@ ENV['RAILS_ENV'] ||= 'production'
 ENV['RACK_ENV'] ||= 'production'
 ENV['RAILS_LOG_TO_STDOUT'] ||= '1'
 
-def rack_handler(httpMethod, path, body, headers)
+
+$service_route_prefix = resolve_service_route_prefix
+
+def rack_handler(httpMethod, path, body, headers, script_name = '')
   require 'rack'
 
   app, _ = Rack::Builder.parse_file($entrypoint)
   server = Rack::MockRequest.new app
 
   env = headers.transform_keys { |k| k.split('-').join('_').prepend('HTTP_').upcase }
+  env['SCRIPT_NAME'] = script_name unless script_name.empty?
   res = server.request(httpMethod, path, env.merge({ :input => body }))
 
   {
@@ -96,8 +101,13 @@ def vc__handler(event:, context:)
     body = Base64.decode64(body)
   end
 
+  path, script_name = apply_service_route_prefix_to_target(
+    path,
+    $service_route_prefix
+  )
+
   if $entrypoint.end_with? '.ru'
-    return rack_handler(httpMethod, path, body, headers)
+    return rack_handler(httpMethod, path, body, headers, script_name)
   end
 
   return webrick_handler(httpMethod, path, body, headers)

package/vc_init_dev.rb

@@ -10,12 +10,14 @@ require 'rack'
 require 'rack/handler/webrick'
 require 'webrick'
 require 'socket'
+require_relative 'vc__utils__ruby'
 
 $stdout.sync = true
 $stderr.sync = true
 
 USER_ENTRYPOINT = "__VC_DEV_ENTRYPOINT__"
 PUBLIC_DIR = 'public'
+SERVICE_ROUTE_PREFIX = resolve_service_route_prefix
 
 def build_user_app
   if USER_ENTRYPOINT.end_with?('.ru')
@@ -36,17 +38,33 @@ class StaticThenApp
   end
 
   def call(env)
-    req_path = env['PATH_INFO'] || '/'
+    effective_env = env.dup
+    req_path, matched_prefix = strip_service_route_prefix(
+      effective_env['PATH_INFO'] || '/',
+      SERVICE_ROUTE_PREFIX
+    )
+    effective_env['PATH_INFO'] = req_path
+
+    unless matched_prefix.empty?
+      script_name = effective_env['SCRIPT_NAME'] || ''
+      if !script_name.empty? && script_name != '/'
+        script_name = script_name.sub(%r{/+\z}, '')
+      else
+        script_name = ''
+      end
+      effective_env['SCRIPT_NAME'] = "#{script_name}#{matched_prefix}"
+    end
+
     # Normalize path and guard against traversal
     safe = req_path.sub(/^\//, '')
     full = File.expand_path(safe, @base)
 
     if full.start_with?(@base + File::SEPARATOR) && File.file?(full)
       # Delegate to Rack::File which handles HEAD/GET correctly
-      return @file_server.call(env)
+      return @file_server.call(effective_env)
     end
 
-    @app.call(env)
+    @app.call(effective_env)
   end
 end
 

package/vc_utils.rb

@@ -0,0 +1,101 @@
+require 'uri'
+
+# Normalize a configured service prefix into canonical mount-path form.
+#
+# Returns an empty string when unset/blank/root ("/"), otherwise:
+# - always starts with "/"
+# - has no trailing slash
+def normalize_service_route_prefix(raw_prefix)
+  return '' if raw_prefix.nil?
+
+  prefix = raw_prefix.strip
+  return '' if prefix.empty?
+
+  prefix = "/#{prefix}" unless prefix.start_with?('/')
+
+  if prefix != '/'
+    prefix = prefix.sub(%r{/+\z}, '')
+    prefix = '/' if prefix.empty?
+  end
+
+  prefix == '/' ? '' : prefix
+end
+
+# Return whether service-prefix stripping is explicitly enabled.
+#
+# Stripping is gated behind a dedicated env var so manually configured
+# route prefixes can be preserved by default.
+def service_route_prefix_strip_enabled?
+  raw = ENV['VERCEL_SERVICE_ROUTE_PREFIX_STRIP']
+  return false if raw.nil? || raw.empty?
+
+  %w[1 true].include?(raw.downcase)
+end
+
+def resolve_service_route_prefix
+  return '' unless service_route_prefix_strip_enabled?
+
+  normalize_service_route_prefix(ENV['VERCEL_SERVICE_ROUTE_PREFIX'])
+end
+
+# Split an HTTP request-target into [path, query].
+#
+# Supports:
+# - origin-form: "/a/b?x=1"
+# - absolute-form: "https://example.com/a/b?x=1"
+# - asterisk-form: "*"
+def split_request_target(target)
+  return ['/', ''] if target.nil? || target.empty?
+
+  begin
+    parsed = URI.parse(target)
+    if parsed.scheme && parsed.host
+      path = parsed.path.nil? || parsed.path.empty? ? '/' : parsed.path
+      return [path, parsed.query.to_s]
+    end
+  rescue URI::InvalidURIError
+  end
+
+  return ['*', ''] if target == '*'
+
+  path, query = target.split('?', 2)
+  path = '/' if path.nil? || path.empty?
+  path = "/#{path}" unless path.start_with?('/')
+  [path, query.to_s]
+end
+
+# Strip the configured service route prefix from a request path.
+#
+# Returns:
+# - stripped path passed to the user app
+# - matched mount prefix (empty when no prefix matched)
+def strip_service_route_prefix(path, prefix)
+  return [path, ''] if path == '*'
+
+  normalized_path = path.nil? || path.empty? ? '/' : path
+  normalized_path = "/#{normalized_path}" unless normalized_path.start_with?('/')
+
+  normalized_prefix = prefix.to_s
+  return [normalized_path, ''] if normalized_prefix.empty?
+
+  return ['/', normalized_prefix] if normalized_path == normalized_prefix
+
+  if normalized_path.start_with?("#{normalized_prefix}/")
+    stripped = normalized_path[normalized_prefix.length..]
+    return [stripped.nil? || stripped.empty? ? '/' : stripped, normalized_prefix]
+  end
+
+  [normalized_path, '']
+end
+
+# Apply service-prefix stripping to a full request-target.
+#
+# Returns:
+# - updated request-target (path + optional query)
+# - matched mount prefix for Rack SCRIPT_NAME (or "")
+def apply_service_route_prefix_to_target(target, prefix)
+  path, query = split_request_target(target)
+  path, script_name = strip_service_route_prefix(path, prefix)
+  updated = query.empty? ? path : "#{path}?#{query}"
+  [updated, script_name]
+end