diff --git a/vite-pr-22269/solution/gold.patch b/vite-pr-22269/solution/gold.patch
new file mode 100644
index 0000000000000000000000000000000000000000..0ed3e3795f4d934752a831630ceb909fce4cbad0
--- /dev/null
+++ b/vite-pr-22269/solution/gold.patch
@@ -0,0 +1,90 @@
+diff --git a/packages/vite/src/node/server/environments/fullBundleEnvironment.ts b/packages/vite/src/node/server/environments/fullBundleEnvironment.ts
+index 3f96a6428..4d5d86b0f 100644
+--- a/packages/vite/src/node/server/environments/fullBundleEnvironment.ts
++++ b/packages/vite/src/node/server/environments/fullBundleEnvironment.ts
+@@ -339,7 +339,16 @@ export class FullBundleDevEnvironment extends DevEnvironment {
+       code: typeof hmrOutput.code === 'string' ? '[code]' : hmrOutput.code,
+     })
+ 
+-    this.memoryFiles.set(hmrOutput.filename, { source: hmrOutput.code })
++    this.memoryFiles.set(hmrOutput.filename, {
++      // ensure that the generated hmr patch contains ESM syntax
++      // this is to avoid attacks like GHSA-4v9v-hfq4-rm2v
++      // https://github.com/webpack/webpack-dev-server/security/advisories/GHSA-4v9v-hfq4-rm2v
++      // https://green.sapphi.red/blog/local-server-security-best-practices#_2-using-xssi-and-modifying-the-prototype
++      // https://green.sapphi.red/blog/local-server-security-best-practices#properly-check-the-request-origin
++      // we can also use `Cross-Origin Resource Policy` header instead of this
++      // but we cannot use `Sec-Fetch-*` headers as they are only sent to potentially-trustworthy origins
++      source: hmrOutput.code + '\n; export {}',
++    })
+     if (hmrOutput.sourcemapFilename && hmrOutput.sourcemap) {
+       this.memoryFiles.set(hmrOutput.sourcemapFilename, {
+         source: hmrOutput.sourcemap,
+diff --git a/packages/vite/src/node/server/index.ts b/packages/vite/src/node/server/index.ts
+index 1b2501b28..dc0b272bf 100644
+--- a/packages/vite/src/node/server/index.ts
++++ b/packages/vite/src/node/server/index.ts
+@@ -107,7 +107,6 @@ import type { DevEnvironment } from './environment'
+ import { hostValidationMiddleware } from './middlewares/hostCheck'
+ import { rejectInvalidRequestMiddleware } from './middlewares/rejectInvalidRequest'
+ import { memoryFilesMiddleware } from './middlewares/memoryFiles'
+-import { rejectNoCorsRequestMiddleware } from './middlewares/rejectNoCorsRequest'
+ 
+ const usedConfigs = new WeakSet<ResolvedConfig>()
+ 
+@@ -929,7 +928,6 @@ export async function _createServer(
+   }
+ 
+   middlewares.use(rejectInvalidRequestMiddleware())
+-  middlewares.use(rejectNoCorsRequestMiddleware())
+ 
+   // cors
+   const { cors } = serverConfig
+diff --git a/packages/vite/src/node/server/middlewares/rejectNoCorsRequest.ts b/packages/vite/src/node/server/middlewares/rejectNoCorsRequest.ts
+deleted file mode 100644
+index a45de1748..000000000
+--- a/packages/vite/src/node/server/middlewares/rejectNoCorsRequest.ts
++++ /dev/null
+@@ -1,42 +0,0 @@
+-import type { Connect } from '#dep-types/connect'
+-
+-/**
+- * A middleware that rejects no-cors mode requests that are not same-origin.
+- *
+- * We should avoid untrusted sites to load the script to avoid attacks like GHSA-4v9v-hfq4-rm2v.
+- * This is because:
+- * - the path of HMR patch files / entry point files can be predictable
+- * - the HMR patch files may not include ESM syntax
+- *   (if they include ESM syntax, loading as a classic script would fail)
+- * - the HMR runtime in the browser has the list of all loaded modules
+- *
+- * https://github.com/webpack/webpack-dev-server/security/advisories/GHSA-4v9v-hfq4-rm2v
+- * https://green.sapphi.red/blog/local-server-security-best-practices#_2-using-xssi-and-modifying-the-prototype
+- * https://green.sapphi.red/blog/local-server-security-best-practices#properly-check-the-request-origin
+- */
+-export function rejectNoCorsRequestMiddleware(): Connect.NextHandleFunction {
+-  // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
+-  return function viteRejectNoCorsRequestMiddleware(req, res, next) {
+-    // While we can set Cross-Origin-Resource-Policy header instead of rejecting requests,
+-    // we choose to reject the request to be safer in case the request handler has any side-effects.
+-    if (
+-      req.headers['sec-fetch-mode'] === 'no-cors' &&
+-      req.headers['sec-fetch-site'] !== 'same-origin' &&
+-      // we only need to block classic script requests
+-      req.headers['sec-fetch-dest'] === 'script'
+-    ) {
+-      // Send a JavaScript code instead of 403 so that the error is shown in the devtools
+-      // If we send 403, the browser will avoid loading the body of the response
+-      // and just show "Failed to load" error without the detailed message.
+-      res.setHeader('Content-Type', 'text/javascript')
+-      res.end(
+-        `throw new Error(${JSON.stringify(
+-          '[Vite] Cross-origin requests for classic scripts must be made with CORS mode enabled.' +
+-            ' Make sure to set the "crossorigin" attribute on your <script> tag.',
+-        )});`,
+-      )
+-      return
+-    }
+-    return next()
+-  }
+-}
diff --git a/vite-pr-22269/solution/solve.sh b/vite-pr-22269/solution/solve.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b23b1455c5a01d637a3985c89514ac2b453ecec2
--- /dev/null
+++ b/vite-pr-22269/solution/solve.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch
diff --git a/vite-pr-22269/task.toml b/vite-pr-22269/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a6ffb68ec23419c4d8517a05f401619d33097a0b
--- /dev/null
+++ b/vite-pr-22269/task.toml
@@ -0,0 +1,49 @@
+schema_version = "1.4"
+artifacts = ["/opt/selfbench/agent.patch"]
+
+[task]
+name = "selfbench/vite-pr-22269"
+version = "1.0.0"
+description = "Reproduce vite-pr-22269 from its authentic engineer request."
+keywords = ["software-engineering", "private-swe", "selfbench", "medium"]
+
+[metadata]
+selfbench_task_id = "vite-pr-22269"
+difficulty = "medium"
+repo = "vitejs/vite"
+base_commit = "3ec9cdaac7936ca32d0956c4cb1eb6e172945996"
+workdir = "."
+source_pr = 22269
+compiler_revision = 23
+
+[agent]
+timeout_sec = 2400.0
+user = "agent"
+network_mode = "allowlist"
+allowed_hosts = ["chatgpt.com", "*.chatgpt.com", "openai.com", "*.openai.com"]
+
+[verifier]
+timeout_sec = 1800.0
+user = "root"
+environment_mode = "separate"
+network_mode = "public"
+
+[[verifier.collect]]
+service = "main"
+user = "root"
+timeout_sec = 300.0
+command = "git --git-dir=/opt/selfbench/base.git --work-tree=/app add -A && git --git-dir=/opt/selfbench/base.git --work-tree=/app diff --cached --binary HEAD > /opt/selfbench/agent.patch"
+
+[environment]
+network_mode = "public"
+build_timeout_sec = 1500.0
+cpus = 4
+memory_mb = 8192
+storage_mb = 20480
+
+[verifier.environment]
+network_mode = "public"
+build_timeout_sec = 1500.0
+cpus = 4
+memory_mb = 8192
+storage_mb = 20480
diff --git a/vite-pr-22269/tests/Dockerfile b/vite-pr-22269/tests/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..aa0e958e38ce778008a0f2302451f3fee20fecd7
--- /dev/null
+++ b/vite-pr-22269/tests/Dockerfile
@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.33.0 --activate && pnpm install --frozen-lockfile && pnpm exec playwright install --with-deps chromium && pnpm run build' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app
diff --git a/vite-pr-22269/tests/repo.tar.gz b/vite-pr-22269/tests/repo.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..d860c147dff62e24f1829afda0f396bb382e8943
--- /dev/null
+++ b/vite-pr-22269/tests/repo.tar.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7293f9f3f608aa6bbc7daa076b9a778e9a1d8e309f4f222e8a155cf6f57e6196
+size 12186692
diff --git a/vite-pr-22269/tests/test.patch b/vite-pr-22269/tests/test.patch
new file mode 100644
index 0000000000000000000000000000000000000000..a80359a4d0feef1446f8e62cf6a3922892e9db69
--- /dev/null
+++ b/vite-pr-22269/tests/test.patch
@@ -0,0 +1,53 @@
+diff --git a/playground/fs-serve/__tests__/commonTests.ts b/playground/fs-serve/__tests__/commonTests.ts
+index 06c58fae6..a5b3fb958 100644
+--- a/playground/fs-serve/__tests__/commonTests.ts
++++ b/playground/fs-serve/__tests__/commonTests.ts
+@@ -601,7 +601,7 @@ describe.runIf(!isServe)('preview HTML', () => {
+ })
+ 
+ test.runIf(isServe)(
+-  'load script with no-cors mode from a different origin',
++  'serve regular scripts independently of cross-origin fetch metadata',
+   async () => {
+     const viteTestUrlUrl = new URL(viteTestUrl)
+ 
+@@ -629,9 +629,7 @@ test.runIf(isServe)(
+     })
+     expect(res.statusCode).toBe(200)
+     const body = Buffer.concat(await ArrayFromAsync(res)).toString()
+-    expect(body).toContain(
+-      'Cross-origin requests for classic scripts must be made with CORS mode enabled.',
+-    )
++    expect(body).toContain('// code.js')
+   },
+ )
+ 
+diff --git a/playground/hmr-full-bundle-mode/__tests__/hmr-full-bundle-mode.spec.ts b/playground/hmr-full-bundle-mode/__tests__/hmr-full-bundle-mode.spec.ts
+index 0c78cb863..99dbdc527 100644
+--- a/playground/hmr-full-bundle-mode/__tests__/hmr-full-bundle-mode.spec.ts
++++ b/playground/hmr-full-bundle-mode/__tests__/hmr-full-bundle-mode.spec.ts
+@@ -95,14 +95,20 @@ if (isBuild) {
+   // BUNDLED -> GENERATING_HMR_PATCH -> BUNDLED
+   test('generate hmr patch', async () => {
+     await expect.poll(() => page.textContent('.hmr')).toBe('hello')
++    const hmrPatchFileRes = page.waitForResponse(/\/hmr_patch_\d\.js$/)
+     editFile('hmr.js', (code) =>
+       code.replace("const foo = 'hello'", "const foo = 'hello1'"),
+     )
+-    await expect.poll(() => page.textContent('.hmr')).toBe('hello1')
++    try {
++      await expect.poll(() => page.textContent('.hmr')).toBe('hello1')
+ 
+-    editFile('hmr.js', (code) =>
+-      code.replace("const foo = 'hello1'", "const foo = 'hello'"),
+-    )
++      const hmrPatch = await (await hmrPatchFileRes).text()
++      expect(() => Function(hmrPatch)).toThrow(SyntaxError)
++    } finally {
++      editFile('hmr.js', (code) =>
++        code.replace("const foo = 'hello1'", "const foo = 'hello'"),
++      )
++    }
+     await expect.poll(() => page.textContent('.hmr')).toContain('hello')
+     await expect.poll(() => page.textContent('.asset')).toMatch(assetUrl)
+   })
diff --git a/vite-pr-22269/tests/test.sh b/vite-pr-22269/tests/test.sh
new file mode 100644
index 0000000000000000000000000000000000000000..90615b11ebd6423efe2f87628bbee4afb7f67464
--- /dev/null
+++ b/vite-pr-22269/tests/test.sh
@@ -0,0 +1,100 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='playground/fs-serve/__tests__/commonTests.ts' --exclude='playground/fs-serve/__tests__/commonTests.ts/*' --exclude='playground/hmr-full-bundle-mode/__tests__/hmr-full-bundle-mode.spec.ts' --exclude='playground/hmr-full-bundle-mode/__tests__/hmr-full-bundle-mode.spec.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  for protected_path in 'playground/fs-serve/__tests__/commonTests.ts' 'playground/hmr-full-bundle-mode/__tests__/hmr-full-bundle-mode.spec.ts'; do
+    git -C /app restore --source=HEAD --staged --worktree -- "$protected_path" 2>/dev/null || true
+    git -C /app clean -fd -- "$protected_path" >/dev/null 2>&1 || true
+  done
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/playground/fs-serve/__tests__/commonTests.ts' '/app/playground/hmr-full-bundle-mode/__tests__/hmr-full-bundle-mode.spec.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'pnpm --filter vite run build-bundle && CI=1 pnpm run test-serve '"'"'playground/hmr-full-bundle-mode/__tests__/hmr-full-bundle-mode.spec.ts'"'"' '"'"'playground/fs-serve/__tests__/fs-serve.spec.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm --filter vite run build-bundle && CI=1 pnpm run test-serve '"'"'playground/hmr-full-bundle-mode/__tests__/hmr-full-bundle-mode.spec.ts'"'"' '"'"'playground/fs-serve/__tests__/fs-serve.spec.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'pnpm --filter vite run build-bundle && CI=1 pnpm run test-serve '"'"'playground/assets-sanitize/__tests__/assets-sanitize.spec.ts'"'"''; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0
diff --git a/vite-server-port-zero/.selfbench-manifest.json b/vite-server-port-zero/.selfbench-manifest.json
new file mode 100644
index 0000000000000000000000000000000000000000..35b66d48928a90dd8d60b23734c5c72fac79f447
--- /dev/null
+++ b/vite-server-port-zero/.selfbench-manifest.json
@@ -0,0 +1,10 @@
+{
+  "generator": "selfbench",
+  "harborSchemaVersion": "1.4",
+  "compilerRevision": 23,
+  "taskId": "vite-server-port-zero",
+  "difficulty": "medium",
+  "definitionSha256": "f755005680ad7bfc2b439b24eba0b80c9f140b4afd69929d263d1cef1d8dd4d1",
+  "testPatchSha256": "957593f423db7a3a8cee81c45f55fcde423ffa34a2424f4294f18b73046f84dc",
+  "goldPatchSha256": "cb6329926fa06bf883fbe5108f4240e4c39efafeadbfa709e06b53bc51350b0d"
+}
diff --git a/vite-server-port-zero/environment/Dockerfile b/vite-server-port-zero/environment/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..e1f4338f224aaa319f2818a4c9cc24611713c2a2
--- /dev/null
+++ b/vite-server-port-zero/environment/Dockerfile
@@ -0,0 +1,44 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.34.5 --activate && PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 pnpm install --frozen-lockfile && pnpm run build' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app
diff --git a/vite-server-port-zero/environment/repo.tar.gz b/vite-server-port-zero/environment/repo.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..3eca933f0c337639eb493baf60996a2c3ef5170b
--- /dev/null
+++ b/vite-server-port-zero/environment/repo.tar.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c855310633b921fccc94a22085529a152071c2f0e25fdcf6c23e62defd19107f
+size 12917035
diff --git a/vite-server-port-zero/instruction.md b/vite-server-port-zero/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5fa7cf763ba52dfc7a3d707eede327e3415b7c27
--- /dev/null
+++ b/vite-server-port-zero/instruction.md
@@ -0,0 +1 @@
+Fix the dev server so `server.port = 0` retains Node's standard meaning. Starting a server with a numeric zero must ask the OS for an available ephemeral port instead of treating the value as missing and substituting Vite's default port. This must work through the public `createServer`/`listen` flow even when `strictPort` is enabled and the normal default port is occupied. After listening, consumers must be able to read the actual assigned non-zero port from the server's existing public HTTP server interface. Keep behavior for omitted ports and explicit non-zero ports unchanged, including current fallback and strict-port semantics.
diff --git a/vite-server-port-zero/solution/gold.patch b/vite-server-port-zero/solution/gold.patch
new file mode 100644
index 0000000000000000000000000000000000000000..8a03201467148ffa9180d92c9a96d6b188d2e118
--- /dev/null
+++ b/vite-server-port-zero/solution/gold.patch
@@ -0,0 +1,104 @@
+diff --git a/packages/vite/src/node/http.ts b/packages/vite/src/node/http.ts
+index cc83504d3..50bb5ee88 100644
+--- a/packages/vite/src/node/http.ts
++++ b/packages/vite/src/node/http.ts
+@@ -164,6 +164,31 @@ async function readFileIfExists(value?: string | Buffer | any[]) {
+   return value
+ }
+ 
++// Let the OS select an ephemeral port on the first wildcard interface, then
++// verify that same concrete port is available on every remaining interface.
++async function getAvailableEphemeralPort(
++  specifiedHost: string | undefined,
++): Promise<number | null> {
++  for (let attempt = 0; attempt < 3; attempt++) {
++    // Passing 0 asks the OS for a new candidate on every attempt.
++    // We assume that the OS will return a different candidate on every attempt,
++    // which does not always hold true, but it should be fine for most cases.
++    let port = 0
++    let available = true
++    for (const host of [...wildcardHosts, specifiedHost]) {
++      // Gracefully handle errors (e.g., IPv6 disabled on the system)
++      const availablePort = await tryListen(port, host).catch(() => port)
++      if (availablePort == null) {
++        available = false
++        break
++      }
++      port = availablePort
++    }
++    if (available) return port
++  }
++  return null
++}
++
+ // Check if a port is available on wildcard addresses (0.0.0.0, ::)
+ async function isPortAvailable(port: number): Promise<boolean> {
+   for (const host of wildcardHosts) {
+@@ -174,14 +199,20 @@ async function isPortAvailable(port: number): Promise<boolean> {
+   return true
+ }
+ 
+-function tryListen(port: number, host: string): Promise<boolean> {
++function tryListen(
++  port: number,
++  host: string | undefined,
++): Promise<number | null> {
+   return new Promise((resolve) => {
+     const server = net.createServer()
+     server.once('error', (e: NodeJS.ErrnoException) => {
+-      server.close(() => resolve(e.code !== 'EADDRINUSE'))
++      server.close(() => resolve(e.code === 'EADDRINUSE' ? null : port))
+     })
+     server.once('listening', () => {
+-      server.close(() => resolve(true))
++      const address = server.address()
++      server.close(() =>
++        resolve(typeof address === 'object' && address ? address.port : port),
++      )
+     })
+     server.listen(port, host)
+   })
+@@ -226,6 +257,23 @@ export async function httpServerStart(
+ ): Promise<number> {
+   const { port: startPort, strictPort, host, logger } = serverOptions
+ 
++  if (startPort === 0) {
++    const port = await getAvailableEphemeralPort(host)
++    if (port == null) {
++      throw new Error('No available ephemeral port found')
++    }
++
++    const result = await tryBindServer(httpServer, port, host)
++    if (result.success) {
++      return port
++    }
++    if (result.error.code !== 'EADDRINUSE') {
++      throw result.error
++    }
++    // this can happen if the port was listened by other process between getAvailableEphemeralPort and tryBindServer
++    throw new Error(`Port ${port} is already in use`)
++  }
++
+   for (let port = startPort; port <= MAX_PORT; port++) {
+     // Pre-check port availability on wildcard addresses (0.0.0.0, ::)
+     // so that we avoid conflicts with other servers listening on all interfaces
+diff --git a/packages/vite/src/node/server/index.ts b/packages/vite/src/node/server/index.ts
+index 84a8d567a..2dd71aa85 100644
+--- a/packages/vite/src/node/server/index.ts
++++ b/packages/vite/src/node/server/index.ts
+@@ -1110,11 +1110,11 @@ async function startServer(
+   const configPort = inlinePort ?? options.port
+   // When using non strict port for the dev server, the running port can be different from the config one.
+   // When restarting, the original port may be available but to avoid a switch of URL for the running
+-  // browser tabs, we enforce the previously used port, expect if the config port changed.
++  // browser tabs, we enforce the previously used port, except if the config port changed.
+   const port =
+-    (!configPort || configPort === server._configServerPort
+-      ? server._currentServerPort
+-      : configPort) ?? DEFAULT_DEV_PORT
++    configPort === server._configServerPort
++      ? (server._currentServerPort ?? configPort)
++      : configPort
+   server._configServerPort = configPort
+ 
+   const serverPort = await httpServerStart(httpServer, {
diff --git a/vite-server-port-zero/solution/solve.sh b/vite-server-port-zero/solution/solve.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b23b1455c5a01d637a3985c89514ac2b453ecec2
--- /dev/null
+++ b/vite-server-port-zero/solution/solve.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch
diff --git a/vite-server-port-zero/task.toml b/vite-server-port-zero/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..626559dd82caa040f9ab7a6f7aeb1e307bca6385
--- /dev/null
+++ b/vite-server-port-zero/task.toml
@@ -0,0 +1,49 @@
+schema_version = "1.4"
+artifacts = ["/opt/selfbench/agent.patch"]
+
+[task]
+name = "selfbench/vite-server-port-zero"
+version = "1.0.0"
+description = "Reproduce vite-server-port-zero from its authentic engineer request."
+keywords = ["software-engineering", "private-swe", "selfbench", "medium"]
+
+[metadata]
+selfbench_task_id = "vite-server-port-zero"
+difficulty = "medium"
+repo = "vitejs/vite"
+base_commit = "16944824fd5fae014101737ec0029ab6a58e774b"
+workdir = "."
+source_pr = 23158
+compiler_revision = 23
+
+[agent]
+timeout_sec = 2400.0
+user = "agent"
+network_mode = "allowlist"
+allowed_hosts = ["chatgpt.com", "*.chatgpt.com", "openai.com", "*.openai.com"]
+
+[verifier]
+timeout_sec = 1800.0
+user = "root"
+environment_mode = "separate"
+network_mode = "public"
+
+[[verifier.collect]]
+service = "main"
+user = "root"
+timeout_sec = 300.0
+command = "git --git-dir=/opt/selfbench/base.git --work-tree=/app add -A && git --git-dir=/opt/selfbench/base.git --work-tree=/app diff --cached --binary HEAD > /opt/selfbench/agent.patch"
+
+[environment]
+network_mode = "public"
+build_timeout_sec = 1500.0
+cpus = 4
+memory_mb = 8192
+storage_mb = 20480
+
+[verifier.environment]
+network_mode = "public"
+build_timeout_sec = 1500.0
+cpus = 4
+memory_mb = 8192
+storage_mb = 20480
diff --git a/vite-server-port-zero/tests/Dockerfile b/vite-server-port-zero/tests/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..edea8bf0d97462454c791c99cd78a02ae2779c2d
--- /dev/null
+++ b/vite-server-port-zero/tests/Dockerfile
@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.34.5 --activate && PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 pnpm install --frozen-lockfile && pnpm run build' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app
diff --git a/vite-server-port-zero/tests/repo.tar.gz b/vite-server-port-zero/tests/repo.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..3eca933f0c337639eb493baf60996a2c3ef5170b
--- /dev/null
+++ b/vite-server-port-zero/tests/repo.tar.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c855310633b921fccc94a22085529a152071c2f0e25fdcf6c23e62defd19107f
+size 12917035
diff --git a/vite-server-port-zero/tests/test.patch b/vite-server-port-zero/tests/test.patch
new file mode 100644
index 0000000000000000000000000000000000000000..ba4a2d70d8f4992726081217cad7fb9897687739
--- /dev/null
+++ b/vite-server-port-zero/tests/test.patch
@@ -0,0 +1,30 @@
+diff --git a/packages/vite/src/node/__tests__/http.spec.ts b/packages/vite/src/node/__tests__/http.spec.ts
+index 94ab9b6e8..fa1b646e5 100644
+--- a/packages/vite/src/node/__tests__/http.spec.ts
++++ b/packages/vite/src/node/__tests__/http.spec.ts
+@@ -48,6 +48,25 @@ describe('port detection', () => {
+   }
+ 
+   describe('port fallback', () => {
++    test('uses an OS-assigned port when configured with port 0', async () => {
++      await using _defaultPortServer = await createSimpleServer(
++        5173,
++        'localhost',
++      )
++
++      viteServer = await createServer({
++        root: import.meta.dirname,
++        optimizeDeps,
++        logLevel: 'silent',
++        server: { port: 0, strictPort: true, ws: false },
++      })
++      await viteServer.listen()
++
++      const address = viteServer.httpServer!.address() as net.AddressInfo
++      expect(address.port).toBeGreaterThan(0)
++      expect(address.port).not.toBe(5173)
++    })
++
+     test('detects port conflict', async () => {
+       await using _blockingServer = await createSimpleServer(
+         BASE_PORT,
diff --git a/vite-server-port-zero/tests/test.sh b/vite-server-port-zero/tests/test.sh
new file mode 100644
index 0000000000000000000000000000000000000000..f1f115e93c0d71bcc9575da0c77cd1abe5419095
--- /dev/null
+++ b/vite-server-port-zero/tests/test.sh
@@ -0,0 +1,100 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='packages/vite/src/node/__tests__/http.spec.ts' --exclude='packages/vite/src/node/__tests__/http.spec.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  for protected_path in 'packages/vite/src/node/__tests__/http.spec.ts'; do
+    git -C /app restore --source=HEAD --staged --worktree -- "$protected_path" 2>/dev/null || true
+    git -C /app clean -fd -- "$protected_path" >/dev/null 2>&1 || true
+  done
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/packages/vite/src/node/__tests__/http.spec.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'pnpm run test-unit '"'"'packages/vite/src/node/__tests__/http.spec.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm run test-unit '"'"'packages/vite/src/node/__tests__/http.spec.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'pnpm run test-unit '"'"'packages/vite/src/node/__tests__/constants.spec.ts'"'"''; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0
diff --git a/vite-ssr-switch-case-scope/.selfbench-manifest.json b/vite-ssr-switch-case-scope/.selfbench-manifest.json
new file mode 100644
index 0000000000000000000000000000000000000000..e968e45b9d94e9071d0a7fb73572f727f238d141
--- /dev/null
+++ b/vite-ssr-switch-case-scope/.selfbench-manifest.json
@@ -0,0 +1,10 @@
+{
+  "generator": "selfbench",
+  "harborSchemaVersion": "1.4",
+  "compilerRevision": 23,
+  "taskId": "vite-ssr-switch-case-scope",
+  "difficulty": "easy",
+  "definitionSha256": "1dc1ec1e4e9867a17dd44a2612da5f896aa483d65f66164326ae02654a287b31",
+  "testPatchSha256": "732a386380eec3d419ae04138735e75e90c91f6ad0bb29e652c95b3a80e83f21",
+  "goldPatchSha256": "ade5242b0f79481a7f4e40a6b7392e90ac0ed41b1811864b6e3a391f435c9ca7"
+}
diff --git a/vite-ssr-switch-case-scope/environment/Dockerfile b/vite-ssr-switch-case-scope/environment/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..e1f4338f224aaa319f2818a4c9cc24611713c2a2
--- /dev/null
+++ b/vite-ssr-switch-case-scope/environment/Dockerfile
@@ -0,0 +1,44 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.34.5 --activate && PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 pnpm install --frozen-lockfile && pnpm run build' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app
diff --git a/vite-ssr-switch-case-scope/environment/repo.tar.gz b/vite-ssr-switch-case-scope/environment/repo.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..f0ddf3e1523bd7086908787f41110beb380ef4ef
--- /dev/null
+++ b/vite-ssr-switch-case-scope/environment/repo.tar.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:868cc9ca3631190662a4a6746c19e3e754426a60a267d3cf5e3301959adb7b30
+size 12876284
diff --git a/vite-ssr-switch-case-scope/instruction.md b/vite-ssr-switch-case-scope/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..6dc21da3cfc0fa34be832cc810b4fe05f2ed4b14
--- /dev/null
+++ b/vite-ssr-switch-case-scope/instruction.md
@@ -0,0 +1,3 @@
+Fix SSR import rewriting around JavaScript `switch` statements. When a case declares a binding directly in its body with the same name as an import, that declaration must obey module lexical scoping rather than making the import appear shadowed across the enclosing function.
+
+Imported references before the switch, in the switch discriminant, from closures defined outside the switch, and after the switch must continue to resolve to the import. References within the switch that resolve to a case declaration must remain local, and all cases must share JavaScript's standard switch lexical environment, including temporal-dead-zone behavior. Cover lexical variable declarations as well as function and class declarations written directly in a case without additional braces, while preserving existing SSR transformation behavior.
diff --git a/vite-ssr-switch-case-scope/solution/gold.patch b/vite-ssr-switch-case-scope/solution/gold.patch
new file mode 100644
index 0000000000000000000000000000000000000000..edd17383c4700ddfe91ba8ab2a4a6637e0e9ef05
--- /dev/null
+++ b/vite-ssr-switch-case-scope/solution/gold.patch
@@ -0,0 +1,59 @@
+diff --git a/packages/vite/src/node/ssr/ssrTransform.ts b/packages/vite/src/node/ssr/ssrTransform.ts
+index 8ebaa63e8..65a5c67da 100644
+--- a/packages/vite/src/node/ssr/ssrTransform.ts
++++ b/packages/vite/src/node/ssr/ssrTransform.ts
+@@ -537,12 +537,8 @@ function walk(
+         onStatements(node.consequent)
+       }
+ 
+-      // track parent stack, skip for "else-if"/"else" branches as acorn nests
+-      // the ast within "if" nodes instead of flattening them
+-      if (
+-        parent &&
+-        !(parent.type === 'IfStatement' && node === parent.alternate)
+-      ) {
++      // track parent stack
++      if (parent && !isSkippedParent(node, parent)) {
+         parentStack.unshift(parent)
+       }
+ 
+@@ -638,10 +634,7 @@ function walk(
+ 
+     leave(node: ESTree.Node, parent: ESTree.Node | null) {
+       // untrack parent stack from above
+-      if (
+-        parent &&
+-        !(parent.type === 'IfStatement' && node === parent.alternate)
+-      ) {
++      if (parent && !isSkippedParent(node, parent)) {
+         parentStack.shift()
+       }
+ 
+@@ -779,11 +772,26 @@ type FunctionNodes = ESTree.Node & {
+     | `${string}Function${'Expression' | 'Declaration'}`
+     | `${string}Method`
+ }
++/**
++ * Children that must not see `parent` as an enclosing scope:
++ * - "else-if"/"else" branches, as acorn nests the ast within "if" nodes
++ *   instead of flattening them.
++ * - a `switch` discriminant, which is evaluated outside the case block:
++ *   in `switch (x) { case 1: let x }`, `x` is the outer binding.
++ */
++function isSkippedParent(node: ESTree.Node, parent: ESTree.Node) {
++  return (
++    (parent.type === 'IfStatement' && node === parent.alternate) ||
++    (parent.type === 'SwitchStatement' && node === parent.discriminant)
++  )
++}
++
+ function isFunction(node: ESTree.Node): node is FunctionNodes {
+   return functionNodeTypeRE.test(node.type)
+ }
+ 
+-const blockNodeTypeRE = /^BlockStatement$|^For(?:In|Of)?Statement$/
++const blockNodeTypeRE =
++  /^BlockStatement$|^SwitchStatement$|^For(?:In|Of)?Statement$/
+ function isBlock(node: ESTree.Node) {
+   return blockNodeTypeRE.test(node.type)
+ }
diff --git a/vite-ssr-switch-case-scope/solution/solve.sh b/vite-ssr-switch-case-scope/solution/solve.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b23b1455c5a01d637a3985c89514ac2b453ecec2
--- /dev/null
+++ b/vite-ssr-switch-case-scope/solution/solve.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch
diff --git a/vite-ssr-switch-case-scope/task.toml b/vite-ssr-switch-case-scope/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f4a02cab299be174f6f6a2c277998e4dd3ce8d4d
--- /dev/null
+++ b/vite-ssr-switch-case-scope/task.toml
@@ -0,0 +1,49 @@
+schema_version = "1.4"
+artifacts = ["/opt/selfbench/agent.patch"]
+
+[task]
+name = "selfbench/vite-ssr-switch-case-scope"
+version = "1.0.0"
+description = "Reproduce vite-ssr-switch-case-scope from its authentic engineer request."
+keywords = ["software-engineering", "private-swe", "selfbench", "easy"]
+
+[metadata]
+selfbench_task_id = "vite-ssr-switch-case-scope"
+difficulty = "easy"
+repo = "vitejs/vite"
+base_commit = "4bfe8bb0344a21d25134d8db06f3a8ae4a8ad69d"
+workdir = "."
+source_pr = 22893
+compiler_revision = 23
+
+[agent]
+timeout_sec = 2400.0
+user = "agent"
+network_mode = "allowlist"
+allowed_hosts = ["chatgpt.com", "*.chatgpt.com", "openai.com", "*.openai.com"]
+
+[verifier]
+timeout_sec = 1800.0
+user = "root"
+environment_mode = "separate"
+network_mode = "public"
+
+[[verifier.collect]]
+service = "main"
+user = "root"
+timeout_sec = 300.0
+command = "git --git-dir=/opt/selfbench/base.git --work-tree=/app add -A && git --git-dir=/opt/selfbench/base.git --work-tree=/app diff --cached --binary HEAD > /opt/selfbench/agent.patch"
+
+[environment]
+network_mode = "public"
+build_timeout_sec = 1500.0
+cpus = 4
+memory_mb = 8192
+storage_mb = 20480
+
+[verifier.environment]
+network_mode = "public"
+build_timeout_sec = 1500.0
+cpus = 4
+memory_mb = 8192
+storage_mb = 20480
diff --git a/vite-ssr-switch-case-scope/tests/Dockerfile b/vite-ssr-switch-case-scope/tests/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..edea8bf0d97462454c791c99cd78a02ae2779c2d
--- /dev/null
+++ b/vite-ssr-switch-case-scope/tests/Dockerfile
@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.34.5 --activate && PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 pnpm install --frozen-lockfile && pnpm run build' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app
diff --git a/vite-ssr-switch-case-scope/tests/repo.tar.gz b/vite-ssr-switch-case-scope/tests/repo.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..f0ddf3e1523bd7086908787f41110beb380ef4ef
--- /dev/null
+++ b/vite-ssr-switch-case-scope/tests/repo.tar.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:868cc9ca3631190662a4a6746c19e3e754426a60a267d3cf5e3301959adb7b30
+size 12876284
diff --git a/vite-ssr-switch-case-scope/tests/test.patch b/vite-ssr-switch-case-scope/tests/test.patch
new file mode 100644
index 0000000000000000000000000000000000000000..43413875f66762b829470d595ab68686dc82cca7
--- /dev/null
+++ b/vite-ssr-switch-case-scope/tests/test.patch
@@ -0,0 +1,128 @@
+diff --git a/packages/vite/src/node/ssr/__tests__/switchCaseScope.spec.ts b/packages/vite/src/node/ssr/__tests__/switchCaseScope.spec.ts
+new file mode 100644
+index 000000000..cef9e69d2
+--- /dev/null
++++ b/packages/vite/src/node/ssr/__tests__/switchCaseScope.spec.ts
+@@ -0,0 +1,122 @@
++import { expect, test } from 'vitest'
++import { moduleRunnerTransform } from '../..'
++
++async function evaluateSsrModule(
++  source: string,
++  modules: Record<string, Record<string, unknown>>,
++) {
++  const transformed = await moduleRunnerTransform(
++    source,
++    null,
++    'entry.js',
++    source,
++  )
++  expect(transformed).not.toBeNull()
++
++  const exported = new Map<string, () => unknown>()
++  const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor
++  const execute = new AsyncFunction(
++    '__vite_ssr_import__',
++    '__vite_ssr_exportName__',
++    `"use strict";\n${transformed!.code}`,
++  )
++
++  await execute(
++    async (id: string) => modules[id],
++    (name: string, getter: () => unknown) => exported.set(name, getter),
++  )
++
++  return Object.fromEntries(
++    Array.from(exported, ([name, getter]) => [name, getter()]),
++  )
++}
++
++test('switch case bindings preserve imported references outside the switch scope', async () => {
++  const importCalls: unknown[] = []
++  const exports = await evaluateSsrModule(
++    `import { createObjectProperty as o } from './ast'
++export function buildProps(node) {
++  const marker = () => o('ref_for')
++  const values = []
++  switch (o(node.type)) {
++    case 1:
++      let o = node.value
++      values.push(o)
++      break
++  }
++  return [marker(), ...values, o('after')]
++}`,
++    {
++      './ast': {
++        createObjectProperty(value: unknown) {
++          importCalls.push(value)
++          return typeof value === 'number' ? value : `import:${value}`
++        },
++      },
++    },
++  )
++
++  const buildProps = exports.buildProps as (node: {
++    type: number
++    value: string
++  }) => unknown
++  expect(buildProps({ type: 1, value: 'case-local' })).toEqual([
++    'import:ref_for',
++    'case-local',
++    'import:after',
++  ])
++  expect(importCalls).toEqual([1, 'ref_for', 'after'])
++})
++
++test('all cases use the switch lexical environment', async () => {
++  const exports = await evaluateSsrModule(
++    `import { value } from './dependency'
++export function readCase(selected) {
++  switch (selected) {
++    case 0:
++      return value
++    case 1:
++      let value = 'case-local'
++      return value
++  }
++}`,
++    { './dependency': { value: 'imported' } },
++  )
++
++  const readCase = exports.readCase as (selected: number) => string
++  expect(readCase(1)).toBe('case-local')
++  expect(() => readCase(0)).toThrow(ReferenceError)
++})
++
++test('case function and class declarations do not shadow imports after the switch', async () => {
++  class ImportedClass {
++    kind = 'imported class'
++  }
++
++  const exports = await evaluateSsrModule(
++    `import { f, C } from './dependency'
++export function run(selected) {
++  let locals
++  switch (selected) {
++    case 1:
++      function f() { return 'local function' }
++      class C { kind = 'local class' }
++      locals = [f(), new C().kind]
++      break
++  }
++  return { locals, imports: [f(), new C().kind] }
++}`,
++    {
++      './dependency': {
++        f: () => 'imported function',
++        C: ImportedClass,
++      },
++    },
++  )
++
++  const run = exports.run as (selected: number) => unknown
++  expect(run(1)).toEqual({
++    locals: ['local function', 'local class'],
++    imports: ['imported function', 'imported class'],
++  })
++})
diff --git a/vite-ssr-switch-case-scope/tests/test.sh b/vite-ssr-switch-case-scope/tests/test.sh
new file mode 100644
index 0000000000000000000000000000000000000000..cdaabafa3fd7b060a5a47734997a61da7ad33452
--- /dev/null
+++ b/vite-ssr-switch-case-scope/tests/test.sh
@@ -0,0 +1,100 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='packages/vite/src/node/ssr/__tests__/switchCaseScope.spec.ts' --exclude='packages/vite/src/node/ssr/__tests__/switchCaseScope.spec.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  for protected_path in 'packages/vite/src/node/ssr/__tests__/switchCaseScope.spec.ts'; do
+    git -C /app restore --source=HEAD --staged --worktree -- "$protected_path" 2>/dev/null || true
+    git -C /app clean -fd -- "$protected_path" >/dev/null 2>&1 || true
+  done
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/packages/vite/src/node/ssr/__tests__/switchCaseScope.spec.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'pnpm test-unit '"'"'packages/vite/src/node/ssr/__tests__/switchCaseScope.spec.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm test-unit '"'"'packages/vite/src/node/ssr/__tests__/switchCaseScope.spec.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'true'; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0
diff --git a/vite-top-level-virtual-input/.selfbench-manifest.json b/vite-top-level-virtual-input/.selfbench-manifest.json
new file mode 100644
index 0000000000000000000000000000000000000000..c33914ce87761e6d065f3246b20fdf4c1803f92f
--- /dev/null
+++ b/vite-top-level-virtual-input/.selfbench-manifest.json
@@ -0,0 +1,10 @@
+{
+  "generator": "selfbench",
+  "harborSchemaVersion": "1.4",
+  "compilerRevision": 23,
+  "taskId": "vite-top-level-virtual-input",
+  "difficulty": "hard",
+  "definitionSha256": "2f859f0c0376eb18e4ac8825c2951fd8d992e204e3af1a045d1b9c829a601e5e",
+  "testPatchSha256": "fecc8f3ae1585ef5b4515654b09dcc949e6d9e2330aab1728445d04daeaeb1e3",
+  "goldPatchSha256": "1806d439ece22a69997ca4950955ec9ebe0417375791f53aef008e576ee5b8f6"
+}
diff --git a/vite-top-level-virtual-input/environment/Dockerfile b/vite-top-level-virtual-input/environment/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..e1f4338f224aaa319f2818a4c9cc24611713c2a2
--- /dev/null
+++ b/vite-top-level-virtual-input/environment/Dockerfile
@@ -0,0 +1,44 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.34.5 --activate && PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 pnpm install --frozen-lockfile && pnpm run build' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app
diff --git a/vite-top-level-virtual-input/environment/repo.tar.gz b/vite-top-level-virtual-input/environment/repo.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..8d893fdce37f4c2924b7298f15e1c95bb55b90b6
--- /dev/null
+++ b/vite-top-level-virtual-input/environment/repo.tar.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b8a4a24054e8b3f2de83d043d73952a9fb92260a7522009ba3e3775f65777e9
+size 12904260
diff --git a/vite-top-level-virtual-input/instruction.md b/vite-top-level-virtual-input/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..2308d971c152c32f2722cf899ddbc6a3b489d348
--- /dev/null
+++ b/vite-top-level-virtual-input/instruction.md
@@ -0,0 +1 @@
+Support virtual modules in Vite's top-level `input` option. When a configured plugin can resolve and load the specified input ID, Vite must use that module as the entry instead of treating the ID as a path under the project root. Preserve existing behavior for ordinary file-based inputs and the default entry.
diff --git a/vite-top-level-virtual-input/solution/gold.patch b/vite-top-level-virtual-input/solution/gold.patch
new file mode 100644
index 0000000000000000000000000000000000000000..ef79d5a8a5176387dd328f85e2624559036a8244
--- /dev/null
+++ b/vite-top-level-virtual-input/solution/gold.patch
@@ -0,0 +1,271 @@
+diff --git a/packages/vite/src/node/build.ts b/packages/vite/src/node/build.ts
+index 80d27ce34..15c402285 100644
+--- a/packages/vite/src/node/build.ts
++++ b/packages/vite/src/node/build.ts
+@@ -621,9 +621,7 @@ export function resolveRolldownOptions(
+     : typeof options.ssr === 'string'
+       ? resolve(options.ssr)
+       : options.rolldownOptions.input ||
+-        (topLevelInput != null
+-          ? topLevelInput // top-level `input` is already resolved in resolveConfig
+-          : resolve('index.html'))
++        (topLevelInput ?? resolve('index.html'))
+ 
+   if (ssr && typeof input === 'string' && input.endsWith('.html')) {
+     throw new Error(
+diff --git a/packages/vite/src/node/config.ts b/packages/vite/src/node/config.ts
+index 79371b377..f3defc59d 100644
+--- a/packages/vite/src/node/config.ts
++++ b/packages/vite/src/node/config.ts
+@@ -923,27 +923,21 @@ const configDefaults = Object.freeze({
+   appType: 'spa',
+ } satisfies UserConfig)
+ 
+-function resolveInput(
++function normalizeInput(
+   input: InputOption | undefined,
+-  root: string,
+ ): InputOption | undefined {
+   if (input === undefined) {
+     return undefined
+   }
+   if (typeof input === 'string') {
+-    const unescapedInput = unescapeGlobCharacters(input)
+-    return normalizePath(path.resolve(root, unescapedInput))
++    return unescapeGlobCharacters(input)
+   }
+   if (Array.isArray(input)) {
+-    return input.map((inp) => {
+-      const unescapedInput = unescapeGlobCharacters(inp)
+-      return normalizePath(path.resolve(root, unescapedInput))
+-    })
++    return input.map(unescapeGlobCharacters)
+   }
+   const resolved: Record<string, string> = {}
+   for (const key in input) {
+-    const unescapedInput = unescapeGlobCharacters(input[key])
+-    resolved[key] = normalizePath(path.resolve(root, unescapedInput))
++    resolved[key] = unescapeGlobCharacters(input[key])
+   }
+   return resolved
+ }
+@@ -996,7 +990,6 @@ function resolveEnvironmentOptions(
+   options: EnvironmentOptions,
+   alias: Alias[],
+   preserveSymlinks: boolean,
+-  root: string,
+   forceOptimizeDeps: boolean | undefined,
+   logger: Logger,
+   environmentName: string,
+@@ -1044,7 +1037,7 @@ function resolveEnvironmentOptions(
+     isSsrTargetWebworkerEnvironment,
+   )
+   return {
+-    input: resolveInput(options.input, root),
++    input: normalizeInput(options.input),
+     define: options.define,
+     resolve,
+     keepProcessEnv:
+@@ -1727,7 +1720,6 @@ export async function resolveConfig(
+       config.environments[environmentName],
+       resolvedDefaultResolve.alias,
+       resolvedDefaultResolve.preserveSymlinks,
+-      resolvedRoot,
+       inlineConfig.forceOptimizeDeps,
+       logger,
+       environmentName,
+@@ -1865,13 +1857,8 @@ export async function resolveConfig(
+         )
+       : ''
+ 
+-  const input = resolveInput(config.input, resolvedRoot)
+-  const server = await resolveServerOptions(
+-    resolvedRoot,
+-    config.server,
+-    input,
+-    logger,
+-  )
++  const input = normalizeInput(config.input)
++  const server = await resolveServerOptions(resolvedRoot, config.server, logger)
+ 
+   const builder = resolveBuilderOptions(config.builder)
+ 
+diff --git a/packages/vite/src/node/optimizer/scan.ts b/packages/vite/src/node/optimizer/scan.ts
+index 1f2844b80..812db8498 100644
+--- a/packages/vite/src/node/optimizer/scan.ts
++++ b/packages/vite/src/node/optimizer/scan.ts
+@@ -214,19 +214,13 @@ async function computeEntries(environment: ScanEnvironment) {
+   let entries: string[] = []
+ 
+   const explicitEntryPatterns = environment.config.optimizeDeps.entries
+-  const buildInput =
++  const input =
+     environment.config.input ?? environment.config.build.rolldownOptions.input
+ 
+   if (explicitEntryPatterns) {
+     entries = await globEntries(explicitEntryPatterns, environment)
+-  } else if (buildInput) {
++  } else if (input) {
+     const resolvePath = async (p: string) => {
+-      if (environment.config.input) {
+-        // input is already resolved in resolveConfig
+-        return p
+-      }
+-      // `build.rollupOptions.input` is resolved from the root (not `process.cwd()`)
+-      // by the build, so resolve it from the root here too by not passing an importer.
+       const id = (
+         await environment.pluginContainer.resolveId(p, undefined, {
+           isEntry: true,
+@@ -240,12 +234,12 @@ async function computeEntries(environment: ScanEnvironment) {
+       }
+       return id
+     }
+-    if (typeof buildInput === 'string') {
+-      entries = [await resolvePath(buildInput)]
+-    } else if (Array.isArray(buildInput)) {
+-      entries = await Promise.all(buildInput.map(resolvePath))
+-    } else if (isObject(buildInput)) {
+-      entries = await Promise.all(Object.values(buildInput).map(resolvePath))
++    if (typeof input === 'string') {
++      entries = [await resolvePath(input)]
++    } else if (Array.isArray(input)) {
++      entries = await Promise.all(input.map(resolvePath))
++    } else if (isObject(input)) {
++      entries = await Promise.all(Object.values(input).map(resolvePath))
+     } else {
+       throw new Error('invalid rolldownOptions.input value.')
+     }
+diff --git a/packages/vite/src/node/server/environment.ts b/packages/vite/src/node/server/environment.ts
+index d74657109..a08b4e11a 100644
+--- a/packages/vite/src/node/server/environment.ts
++++ b/packages/vite/src/node/server/environment.ts
+@@ -1,3 +1,4 @@
++import path from 'node:path'
+ import colors from 'picocolors'
+ import type { FetchFunctionOptions, FetchResult } from 'vite/module-runner'
+ import type { FSWatcher } from '#dep-types/chokidar'
+@@ -16,7 +17,7 @@ import {
+   createExplicitDepsOptimizer,
+ } from '../optimizer/optimizer'
+ import { ERR_OUTDATED_OPTIMIZED_DEP } from '../../shared/constants'
+-import { promiseWithResolvers } from '../../shared/utils'
++import { cleanUrl, promiseWithResolvers } from '../../shared/utils'
+ import type { ViteDevServer } from '../server'
+ import { EnvironmentModuleGraph } from './moduleGraph'
+ import type { EnvironmentModuleNode } from './moduleGraph'
+@@ -220,6 +221,47 @@ export class DevEnvironment extends BaseEnvironment {
+     )
+   }
+ 
++  /** @internal */
++  async _registerInputsAsSafeModules(): Promise<void> {
++    const input = this.config.input
++    const entries =
++      input == null
++        ? ['index.html']
++        : typeof input === 'string'
++          ? [input]
++          : Array.isArray(input)
++            ? input
++            : Object.values(input)
++
++    const resolveEntries = async () => {
++      const resolvedEntries = await Promise.all(
++        entries.map((entry) =>
++          this.pluginContainer.resolveId(entry, undefined, {
++            isEntry: true,
++            // Avoid a deadlock when the dependency scanner triggers the first
++            // buildStart. Normal resolution waits for the scan to finish,
++            // while the scan is waiting for buildStart to finish.
++            scan: true,
++          }),
++        ),
++      )
++      for (const resolved of resolvedEntries) {
++        if (resolved && !resolved.external) {
++          const resolvedId = cleanUrl(resolved.id)
++          if (path.isAbsolute(resolvedId)) {
++            this.getTopLevelConfig().safeModulePaths.add(resolvedId)
++          }
++        }
++      }
++    }
++
++    if (input == null) {
++      await resolveEntries().catch(() => {})
++    } else {
++      await resolveEntries()
++    }
++  }
++
+   /**
+    * When the dev server is restarted, the methods are called in the following order:
+    * - new instance `init`
+diff --git a/packages/vite/src/node/server/index.ts b/packages/vite/src/node/server/index.ts
+index fa2c551af..84a8d567a 100644
+--- a/packages/vite/src/node/server/index.ts
++++ b/packages/vite/src/node/server/index.ts
+@@ -14,7 +14,7 @@ import chokidar from 'chokidar'
+ import launchEditorMiddleware from 'launch-editor-middleware'
+ import { determineAgent } from '@vercel/detect-agent'
+ import { disableCache } from '@voidzero-dev/vite-task-client'
+-import type { InputOption, SourceMap } from 'rolldown'
++import type { SourceMap } from 'rolldown'
+ import type { ModuleRunner } from 'vite/module-runner'
+ import type { FSWatcher, WatchOptions } from '#dep-types/chokidar'
+ import type { Connect } from '#dep-types/connect'
+@@ -1214,7 +1214,6 @@ const RESERVED_ALLOWED_HOSTS_CHARACTERS_RE = /[\\"']/
+ export async function resolveServerOptions(
+   root: string,
+   raw: ServerOptions | undefined,
+-  input: InputOption | undefined,
+   logger: Logger,
+ ): Promise<ResolvedServerOptions> {
+   const _server = mergeWithDefaults(
+@@ -1244,7 +1243,6 @@ export async function resolveServerOptions(
+   }
+ 
+   let allowDirs = server.fs.allow
+-  allowDirs.push(...getInputPaths(root, input))
+ 
+   const cwd = searchForPackageRoot(root)
+   if (process.versions.pnp) {
+@@ -1345,12 +1343,6 @@ export async function resolveServerOptions(
+   return server
+ }
+ 
+-function getInputPaths(root: string, input: ResolvedConfig['input']): string[] {
+-  if (input == null) return [path.resolve(root, 'index.html')]
+-  if (typeof input === 'string') return [input]
+-  return Array.isArray(input) ? input : Object.values(input)
+-}
+-
+ async function restartServer(server: ViteDevServer) {
+   global.__vite_start_time = performance.now()
+ 
+diff --git a/packages/vite/src/node/server/pluginContainer.ts b/packages/vite/src/node/server/pluginContainer.ts
+index e14d5c613..081b57d44 100644
+--- a/packages/vite/src/node/server/pluginContainer.ts
++++ b/packages/vite/src/node/server/pluginContainer.ts
+@@ -334,7 +334,7 @@ class EnvironmentPluginContainer<Env extends Environment = Environment> {
+     }
+     this._started = true
+     const config = this.environment.getTopLevelConfig()
+-    this._buildStartPromise = this.handleHookPromise(
++    const hookPromise = this.handleHookPromise(
+       this.hookParallel(
+         'buildStart',
+         (plugin) => this._getPluginContext(plugin),
+@@ -345,6 +345,12 @@ class EnvironmentPluginContainer<Env extends Environment = Environment> {
+           plugin.perEnvironmentStartEndDuringDev,
+       ),
+     ) as Promise<void>
++    this._buildStartPromise = (async () => {
++      await hookPromise
++      if (this.environment.mode === 'dev') {
++        await this.environment._registerInputsAsSafeModules()
++      }
++    })()
+     await this._buildStartPromise
+     this._buildStartPromise = undefined
+   }
diff --git a/vite-top-level-virtual-input/solution/solve.sh b/vite-top-level-virtual-input/solution/solve.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b23b1455c5a01d637a3985c89514ac2b453ecec2
--- /dev/null
+++ b/vite-top-level-virtual-input/solution/solve.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch
diff --git a/vite-top-level-virtual-input/task.toml b/vite-top-level-virtual-input/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a0141b41d413c9c47525d29afb2c45a9243d2681
--- /dev/null
+++ b/vite-top-level-virtual-input/task.toml
@@ -0,0 +1,49 @@
+schema_version = "1.4"
+artifacts = ["/opt/selfbench/agent.patch"]
+
+[task]
+name = "selfbench/vite-top-level-virtual-input"
+version = "1.0.0"
+description = "Reproduce vite-top-level-virtual-input from its authentic engineer request."
+keywords = ["software-engineering", "private-swe", "selfbench", "hard"]
+
+[metadata]
+selfbench_task_id = "vite-top-level-virtual-input"
+difficulty = "hard"
+repo = "vitejs/vite"
+base_commit = "fa005d19af5d847931c6dbefc63841c137383e6c"
+workdir = "."
+source_pr = 23101
+compiler_revision = 23
+
+[agent]
+timeout_sec = 2400.0
+user = "agent"
+network_mode = "allowlist"
+allowed_hosts = ["chatgpt.com", "*.chatgpt.com", "openai.com", "*.openai.com"]
+
+[verifier]
+timeout_sec = 1800.0
+user = "root"
+environment_mode = "separate"
+network_mode = "public"
+
+[[verifier.collect]]
+service = "main"
+user = "root"
+timeout_sec = 300.0
+command = "git --git-dir=/opt/selfbench/base.git --work-tree=/app add -A && git --git-dir=/opt/selfbench/base.git --work-tree=/app diff --cached --binary HEAD > /opt/selfbench/agent.patch"
+
+[environment]
+network_mode = "public"
+build_timeout_sec = 1500.0
+cpus = 4
+memory_mb = 8192
+storage_mb = 20480
+
+[verifier.environment]
+network_mode = "public"
+build_timeout_sec = 1500.0
+cpus = 4
+memory_mb = 8192
+storage_mb = 20480
diff --git a/vite-top-level-virtual-input/tests/Dockerfile b/vite-top-level-virtual-input/tests/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..edea8bf0d97462454c791c99cd78a02ae2779c2d
--- /dev/null
+++ b/vite-top-level-virtual-input/tests/Dockerfile
@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && corepack prepare pnpm@10.34.5 --activate && PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 pnpm install --frozen-lockfile && pnpm run build' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app
diff --git a/vite-top-level-virtual-input/tests/repo.tar.gz b/vite-top-level-virtual-input/tests/repo.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..8d893fdce37f4c2924b7298f15e1c95bb55b90b6
--- /dev/null
+++ b/vite-top-level-virtual-input/tests/repo.tar.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b8a4a24054e8b3f2de83d043d73952a9fb92260a7522009ba3e3775f65777e9
+size 12904260
diff --git a/vite-top-level-virtual-input/tests/test.patch b/vite-top-level-virtual-input/tests/test.patch
new file mode 100644
index 0000000000000000000000000000000000000000..4ca15cf206312999b7b420c46e83d64bc1c7fe86
--- /dev/null
+++ b/vite-top-level-virtual-input/tests/test.patch
@@ -0,0 +1,41 @@
+diff --git a/packages/vite/src/node/__tests__/build.spec.ts b/packages/vite/src/node/__tests__/build.spec.ts
+index e956370b4..16e885348 100644
+--- a/packages/vite/src/node/__tests__/build.spec.ts
++++ b/packages/vite/src/node/__tests__/build.spec.ts
+@@ -112,6 +112,36 @@ describe('build', () => {
+     expect(chunk?.code).toContain('from-top-level-input')
+   })
+ 
++  test('top-level input can be a virtual module for build', async () => {
++    const input = 'virtual:entry'
++    const resolvedInput = `\0${input}`
++    const result = (await build({
++      root: resolve(dirname, 'packages/build-project'),
++      logLevel: 'silent',
++      input,
++      build: {
++        write: false,
++      },
++      plugins: [
++        {
++          name: 'virtual-entry',
++          resolveId(id) {
++            if (id === input) {
++              return resolvedInput
++            }
++          },
++          load(id) {
++            if (id === resolvedInput) {
++              return `console.log('from-virtual-top-level-input')`
++            }
++          },
++        },
++      ],
++    })) as RolldownOutput
++    const chunk = result.output.find((o) => o.type === 'chunk')
++    expect(chunk?.code).toContain('from-virtual-top-level-input')
++  })
++
+   test('file hash should change when pure css chunk changes', async () => {
+     const buildProject = async (cssColor: string) => {
+       return (await build({
diff --git a/vite-top-level-virtual-input/tests/test.sh b/vite-top-level-virtual-input/tests/test.sh
new file mode 100644
index 0000000000000000000000000000000000000000..a678a6952ed4ba533880b3d5fc2bcd9eca08d63c
--- /dev/null
+++ b/vite-top-level-virtual-input/tests/test.sh
@@ -0,0 +1,100 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='packages/vite/src/node/__tests__/build.spec.ts' --exclude='packages/vite/src/node/__tests__/build.spec.ts/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  for protected_path in 'packages/vite/src/node/__tests__/build.spec.ts'; do
+    git -C /app restore --source=HEAD --staged --worktree -- "$protected_path" 2>/dev/null || true
+    git -C /app clean -fd -- "$protected_path" >/dev/null 2>&1 || true
+  done
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/packages/vite/src/node/__tests__/build.spec.ts'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'pnpm run test-unit '"'"'packages/vite/src/node/__tests__/build.spec.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm run test-unit '"'"'packages/vite/src/node/__tests__/build.spec.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'pnpm run test-unit '"'"'packages/vite/src/node/__tests__/logger.spec.ts'"'"' '"'"'packages/vite/src/node/__tests__/constants.spec.ts'"'"''; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0
diff --git a/vite-wasm-global-string-builtins/.selfbench-manifest.json b/vite-wasm-global-string-builtins/.selfbench-manifest.json
new file mode 100644
index 0000000000000000000000000000000000000000..87f96b6b667cc5170915b4145d7637a56bcde622
--- /dev/null
+++ b/vite-wasm-global-string-builtins/.selfbench-manifest.json
@@ -0,0 +1,10 @@
+{
+  "generator": "selfbench",
+  "harborSchemaVersion": "1.4",
+  "compilerRevision": 23,
+  "taskId": "vite-wasm-global-string-builtins",
+  "difficulty": "easy",
+  "definitionSha256": "93a683cbd3457845ec9099d155b83e307dae985fa2243c947c91c726d08d9d01",
+  "testPatchSha256": "c82d090c5528e366925ef44945b3ec5b925d2520522a2ebc0dbdf2469d3027aa",
+  "goldPatchSha256": "a51bc68b215be7c753d9a0c91d1932aa7a155b11d9771b7e8e58614b719af9b3"
+}
diff --git a/vite-wasm-global-string-builtins/environment/Dockerfile b/vite-wasm-global-string-builtins/environment/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..2e7c509e9e2f21ee89b07a5af8b09bd1a948569d
--- /dev/null
+++ b/vite-wasm-global-string-builtins/environment/Dockerfile
@@ -0,0 +1,44 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+RUN useradd --create-home --shell /bin/bash agent
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && pnpm install --frozen-lockfile && pnpm exec playwright install --with-deps chromium && pnpm run build' \
+    && chmod -R a+rwX /opt/uv-cache
+RUN git -C /app reset --hard -q HEAD \
+    && git -C /app clean -fdq \
+    && mkdir -p /opt/selfbench \
+    && cp -a /app/.git /opt/selfbench/base.git \
+    && chown -R agent:agent /app /home/agent /opt/uv-cache \
+    && chown -R root:root /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/agent/.cache/uv \
+    && chown -R agent:agent /home/agent/.cache
+ENV UV_CACHE_DIR=/home/agent/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+USER agent
+WORKDIR /app
diff --git a/vite-wasm-global-string-builtins/environment/repo.tar.gz b/vite-wasm-global-string-builtins/environment/repo.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..6c2506a804ffc5b934ede319ecb39d365db44ffd
--- /dev/null
+++ b/vite-wasm-global-string-builtins/environment/repo.tar.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c86ffe35eda3dd43cb9d4db9f36b182e80f919caf9cb5f50027fe0d8eacbf51
+size 12882301
diff --git a/vite-wasm-global-string-builtins/instruction.md b/vite-wasm-global-string-builtins/instruction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5c44f256ce398a030f968b119013ff354eba0cf5
--- /dev/null
+++ b/vite-wasm-global-string-builtins/instruction.md
@@ -0,0 +1,3 @@
+Enhance Vite's WebAssembly ESM integration. Direct `.wasm` imports must expose exported `WebAssembly.Global` values to JavaScript as their normal JS values (for example, an i32 global is imported as a number), rather than as `WebAssembly.Global` objects. At the same time, wasm-to-wasm imports must continue receiving the actual live global cell: a module may import another wasm module's global, and mutations from the exporting module must be visible to the consumer.
+
+Enable the WebAssembly JS String Builtins and Imported String Constants proposals for the compilation and instantiation paths used by Vite's wasm support, consistent with the specification and Node.js behavior. Engine-provided builtin and string-constant imports must not be treated as ordinary JavaScript module imports. Preserve existing direct `.wasm` imports and `?init` behavior.
diff --git a/vite-wasm-global-string-builtins/solution/gold.patch b/vite-wasm-global-string-builtins/solution/gold.patch
new file mode 100644
index 0000000000000000000000000000000000000000..160350f297ac8303c53d8aaa4a3ef13a7470f7ac
--- /dev/null
+++ b/vite-wasm-global-string-builtins/solution/gold.patch
@@ -0,0 +1,307 @@
+diff --git a/packages/vite/src/node/plugins/wasm.ts b/packages/vite/src/node/plugins/wasm.ts
+index 77fe1301f..ae28b242a 100644
+--- a/packages/vite/src/node/plugins/wasm.ts
++++ b/packages/vite/src/node/plugins/wasm.ts
+@@ -12,8 +12,31 @@ const wasmHelperId = '\0vite/wasm-helper.js'
+ const wasmInitRE = /(?<![?#].*)\.wasm\?init/
+ const wasmDirectRE = /(?<![?#].*)\.wasm$/
+ 
++// Lower "instance" layer of a directly imported `.wasm` module that exports a
++// WebAssembly.Global. It owns the WebAssembly.Instance and exposes exports
++// verbatim (globals stay WebAssembly.Global objects), so that wasm-to-wasm
++// global imports receive the actual Global. The user-facing `.wasm` module is a
++// thin wrapper around this layer that unwraps globals for JS consumers.
++const wasmInstanceSuffix = '?vite-wasm-instance'
++const wasmInstanceRE = /[?&]vite-wasm-instance(?:&|$)/
++
+ const wasmInitUrlRE: RegExp = /__VITE_WASM_INIT__([\w$]+)__/g
+ 
++// Enabled per spec
++const wasmCompileOptions = {
++  builtins: ['js-string'],
++  importedStringConstants: 'wasm:js/string-constants',
++}
++
++// Modules satisfied by the engine when the above proposals are enabled. They
++// must never surface as JS imports in the generated glue. The host Node running
++// `parseWasm` may not support these proposals yet (older versions), in which
++// case `WebAssembly.Module.imports` still reports them, so we filter explicitly.
++const wasmReservedModules = new Set<string>([
++  ...wasmCompileOptions.builtins.map((name) => `wasm:${name}`),
++  wasmCompileOptions.importedStringConstants,
++])
++
+ const wasmHelper = async (opts = {}, url: string) => {
+   let result
+   if (url.startsWith('data:')) {
+@@ -32,7 +55,7 @@ const wasmHelper = async (opts = {}, url: string) => {
+         'Failed to decode base64-encoded data URL, Buffer and atob are not supported',
+       )
+     }
+-    result = await WebAssembly.instantiate(bytes, opts)
++    result = await WebAssembly.instantiate(bytes, opts, wasmCompileOptions)
+   } else {
+     result = await instantiateFromUrl(url, opts)
+   }
+@@ -53,10 +76,10 @@ const instantiateFromUrl = async (url: string, opts?: WebAssembly.Imports) => {
+     'instantiateStreaming' in WebAssembly &&
+     contentType.startsWith('application/wasm')
+   ) {
+-    return WebAssembly.instantiateStreaming(response, opts)
++    return WebAssembly.instantiateStreaming(response, opts, wasmCompileOptions)
+   } else {
+     const buffer = await response.arrayBuffer()
+-    return WebAssembly.instantiate(buffer, opts)
++    return WebAssembly.instantiate(buffer, opts, wasmCompileOptions)
+   }
+ }
+ 
+@@ -69,7 +92,7 @@ const instantiateFromFile = async (
+   const { readFile } = await import('node:fs/promises')
+   const fileUrl = new URL(fileUrlString, /** #__KEEP__ */ import.meta.url)
+   const buffer = await readFile(fileUrl)
+-  return WebAssembly.instantiate(buffer, opts)
++  return WebAssembly.instantiate(buffer, opts, wasmCompileOptions)
+ }
+ 
+ const instantiateFromFileCode = instantiateFromFile.toString()
+@@ -87,19 +110,43 @@ export const wasmHelperPlugin = (): Plugin => {
+       },
+ 
+       load: {
+-        filter: { id: [exactRegex(wasmHelperId), wasmInitRE, wasmDirectRE] },
++        filter: {
++          id: [
++            exactRegex(wasmHelperId),
++            wasmInitRE,
++            wasmDirectRE,
++            wasmInstanceRE,
++          ],
++        },
+         async handler(id) {
+           const ssr = this.environment.config.consumer === 'server'
+ 
+           if (id === wasmHelperId) {
+             return `
++const wasmCompileOptions = ${JSON.stringify(wasmCompileOptions)}
+ const instantiateFromUrl = ${ssr ? instantiateFromFileCode : instantiateFromUrlCode}
+ export default ${wasmHelperCode}
+ `
+           }
+ 
+           const isInit = wasmInitRE.test(id)
+-          const cleanedId = id.split('?')[0]
++          const isInstance = wasmInstanceRE.test(id)
++          const cleanedId = isInstance ? cleanUrl(id) : id.split('?')[0]
++
++          // Direct .wasm import (WASM ESM Integration)
++          let wasmInfo: WasmInfo | undefined
++          if (!isInit) {
++            wasmInfo = await parseWasm(cleanedId)
++            // The user-facing module of a wasm that exports a global is a thin
++            // wrapper that re-exports the instance layer, unwrapping globals for JS.
++            if (!isInstance && wasmInfo.hasGlobalExport) {
++              return generateWrapperGlue(
++                wasmInfo,
++                cleanedId + wasmInstanceSuffix,
++              )
++            }
++          }
++
+           let url = await fileToUrl(this, cleanedId, ssr)
+           assetUrlRE.lastIndex = 0
+           if (ssr && assetUrlRE.test(url)) {
+@@ -113,9 +160,7 @@ export default ${wasmHelperCode}
+   `
+           }
+ 
+-          // Direct .wasm import (WASM ESM Integration)
+-          const wasmInfo = await parseWasm(cleanedId)
+-          const glueCode = generateGlueCode(wasmInfo, {
++          const glueCode = generateInstanceGlue(wasmInfo!, {
+             initWasm: '__vite__initWasm',
+             wasmUrl: '__vite__wasmUrl',
+           })
+@@ -179,33 +224,41 @@ ${glueCode}
+   })
+ }
+ 
++interface WasmName {
++  name: string
++  isGlobal: boolean
++}
++
+ interface WasmInfo {
+   imports: {
+     from: string
+-    names: string[]
++    names: WasmName[]
+   }[]
+-  exports: string[]
++  exports: WasmName[]
++  hasGlobalExport: boolean
+ }
+ 
+ async function parseWasm(wasmFilePath: string): Promise<WasmInfo> {
+   try {
+     const wasmBinary = await fsp.readFile(wasmFilePath)
+-    const wasmModule = await WebAssembly.compile(wasmBinary)
+-    const importMap: Record<string, string[]> = Object.create(null)
++    const wasmModule = await WebAssembly.compile(wasmBinary, wasmCompileOptions)
++    const importMap = new Map<string, WasmName[]>()
+     for (const item of WebAssembly.Module.imports(wasmModule)) {
+-      importMap[item.module] ??= []
+-      importMap[item.module].push(item.name)
++      if (wasmReservedModules.has(item.module)) continue
++      let names = importMap.get(item.module)
++      if (!names) importMap.set(item.module, (names = []))
++      names.push({ name: item.name, isGlobal: item.kind === 'global' })
+     }
+-    const imports = Object.entries(importMap).map(([from, names]) => ({
+-      from,
+-      names,
+-    }))
++    const imports = [...importMap].map(([from, names]) => ({ from, names }))
+ 
+-    const exports = WebAssembly.Module.exports(wasmModule).map(
+-      (item) => item.name,
+-    )
++    let hasGlobalExport = false
++    const exports = WebAssembly.Module.exports(wasmModule).map((item) => {
++      const isGlobal = item.kind === 'global'
++      if (isGlobal) hasGlobalExport = true
++      return { name: item.name, isGlobal }
++    })
+ 
+-    return { imports, exports }
++    return { imports, exports, hasGlobalExport }
+   } catch (e) {
+     throw new Error(
+       `Failed to parse WASM file "${wasmFilePath}": ${(e as Error).message}`,
+@@ -214,25 +267,43 @@ async function parseWasm(wasmFilePath: string): Promise<WasmInfo> {
+   }
+ }
+ 
+-function generateGlueCode(
++// Instantiates the wasm module and re-exports its exports verbatim. Globals stay
++// WebAssembly.Global objects so wasm-to-wasm global imports get the live cell.
++function generateInstanceGlue(
+   wasmInfo: WasmInfo,
+   names: { initWasm: string; wasmUrl: string },
+ ): string {
+-  const importStatements = wasmInfo.imports.map(({ from }, i) => {
+-    return `import * as __vite__wasmImport_${i} from ${JSON.stringify(from)};`
+-  })
+-
++  const importStatements: string[] = []
+   const importObject: SimpleObject = wasmInfo.imports.map(
+     ({ from, names: importNames }, i) => {
+-      return {
+-        key: JSON.stringify(from),
+-        value: importNames.map((name) => {
+-          return {
++      const value: SimpleObject = []
++      const globals = importNames.filter((n) => n.isGlobal)
++      const others = importNames.filter((n) => !n.isGlobal)
++      if (others.length > 0) {
++        const ns = `__vite__wasmImport_${i}`
++        importStatements.push(`import * as ${ns} from ${JSON.stringify(from)};`)
++        for (const { name } of others) {
++          value.push({
+             key: JSON.stringify(name),
+-            value: `__vite__wasmImport_${i}[${JSON.stringify(name)}]`,
+-          }
+-        }),
++            value: `${ns}[${JSON.stringify(name)}]`,
++          })
++        }
++      }
++      if (globals.length > 0) {
++        // Wasm global imports need the WebAssembly.Global object, so import them
++        // from the exporter's instance layer instead of its JS-unwrapped value.
++        const ns = `__vite__wasmImportInstance_${i}`
++        importStatements.push(
++          `import * as ${ns} from ${JSON.stringify(from + wasmInstanceSuffix)};`,
++        )
++        for (const { name } of globals) {
++          value.push({
++            key: JSON.stringify(name),
++            value: `${ns}[${JSON.stringify(name)}]`,
++          })
++        }
+       }
++      return { key: JSON.stringify(from), value }
+     },
+   )
+ 
+@@ -244,7 +315,7 @@ function generateGlueCode(
+ 
+   const exportStatements: string[] = []
+   const nameMap = new Map<string, string>()
+-  for (const [index, name] of wasmInfo.exports.entries()) {
++  for (const [index, { name }] of wasmInfo.exports.entries()) {
+     if (isValidJsDeclareName(name)) {
+       exportStatements.push(`  ${name},`)
+     } else {
+@@ -258,7 +329,7 @@ function generateGlueCode(
+     exportStatements.unshift(`const {`)
+     exportStatements.push(`} = __vite__wasmModule;`)
+     exportStatements.push(`export {`)
+-    for (const name of wasmInfo.exports) {
++    for (const { name } of wasmInfo.exports) {
+       const localName = nameMap.get(name)
+       if (localName) {
+         exportStatements.push(`  ${localName} as ${JSON.stringify(name)},`)
+@@ -275,6 +346,52 @@ function generateGlueCode(
+   return [...importStatements, initCode, ...exportStatements].join('\n')
+ }
+ 
++// User-facing module of a wasm that exports a global. Re-exports the instance
++// layer and overrides each global with its unwrapped JS value.
++function generateWrapperGlue(wasmInfo: WasmInfo, instanceId: string): string {
++  const instanceIdLiteral = JSON.stringify(instanceId)
++  const lines = [`export * from ${instanceIdLiteral};`]
++
++  // `export *` skips `default`, so re-export it explicitly when present.
++  if (wasmInfo.exports.some((e) => e.name === 'default')) {
++    lines.push(`export { default } from ${instanceIdLiteral};`)
++  }
++
++  const imports: string[] = []
++  const bindings: string[] = []
++  const unwraps: string[] = []
++  const reExports: string[] = []
++  for (const [index, { name, isGlobal }] of wasmInfo.exports.entries()) {
++    if (!isGlobal || name === 'default') continue
++    const alias = `__vite__wasmGlobal_${index}`
++    imports.push(`${codegenModuleExportName(name)} as ${alias}`)
++    // Use the export name as the binding directly; only non-identifier names
++    // need a separate aliased local.
++    const binding = isValidJsDeclareName(name)
++      ? name
++      : `__vite__wasmGlobalValue_${index}`
++    bindings.push(binding)
++    // v128 globals throw in GetGlobalValue and have no JS value, so stay undefined.
++    unwraps.push(`try { ${binding} = ${alias}.value; } catch {}`)
++    reExports.push(
++      binding === name ? name : `${binding} as ${JSON.stringify(name)}`,
++    )
++  }
++
++  if (bindings.length > 0) {
++    lines.push(`import { ${imports.join(', ')} } from ${instanceIdLiteral};`)
++    lines.push(`let ${bindings.join(', ')};`)
++    lines.push(...unwraps)
++    lines.push(`export { ${reExports.join(', ')} };`)
++  }
++
++  return lines.join('\n')
++}
++
++function codegenModuleExportName(name: string): string {
++  return isValidJsDeclareName(name) ? name : JSON.stringify(name)
++}
++
+ type SimpleObject = SimpleObjectKeyValue[]
+ 
+ interface SimpleObjectKeyValue {
diff --git a/vite-wasm-global-string-builtins/solution/solve.sh b/vite-wasm-global-string-builtins/solution/solve.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b23b1455c5a01d637a3985c89514ac2b453ecec2
--- /dev/null
+++ b/vite-wasm-global-string-builtins/solution/solve.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+git -C /app apply --binary --whitespace=nowarn /solution/gold.patch
diff --git a/vite-wasm-global-string-builtins/task.toml b/vite-wasm-global-string-builtins/task.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1aefe7803431195e5afa275e56378bc32780eccd
--- /dev/null
+++ b/vite-wasm-global-string-builtins/task.toml
@@ -0,0 +1,49 @@
+schema_version = "1.4"
+artifacts = ["/opt/selfbench/agent.patch"]
+
+[task]
+name = "selfbench/vite-wasm-global-string-builtins"
+version = "1.0.0"
+description = "Reproduce vite-wasm-global-string-builtins from its authentic engineer request."
+keywords = ["software-engineering", "private-swe", "selfbench", "easy"]
+
+[metadata]
+selfbench_task_id = "vite-wasm-global-string-builtins"
+difficulty = "easy"
+repo = "vitejs/vite"
+base_commit = "6319827116c5be2a19c1b91c84ba3d38ad26a41c"
+workdir = "."
+source_pr = 22674
+compiler_revision = 23
+
+[agent]
+timeout_sec = 2400.0
+user = "agent"
+network_mode = "allowlist"
+allowed_hosts = ["chatgpt.com", "*.chatgpt.com", "openai.com", "*.openai.com"]
+
+[verifier]
+timeout_sec = 1800.0
+user = "root"
+environment_mode = "separate"
+network_mode = "public"
+
+[[verifier.collect]]
+service = "main"
+user = "root"
+timeout_sec = 300.0
+command = "git --git-dir=/opt/selfbench/base.git --work-tree=/app add -A && git --git-dir=/opt/selfbench/base.git --work-tree=/app diff --cached --binary HEAD > /opt/selfbench/agent.patch"
+
+[environment]
+network_mode = "public"
+build_timeout_sec = 1500.0
+cpus = 4
+memory_mb = 8192
+storage_mb = 20480
+
+[verifier.environment]
+network_mode = "public"
+build_timeout_sec = 1500.0
+cpus = 4
+memory_mb = 8192
+storage_mb = 20480
diff --git a/vite-wasm-global-string-builtins/tests/Dockerfile b/vite-wasm-global-string-builtins/tests/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..c1cb987a607522be6eb835bd90c2c394cfafd9a4
--- /dev/null
+++ b/vite-wasm-global-string-builtins/tests/Dockerfile
@@ -0,0 +1,42 @@
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive \
+    UV_LINK_MODE=copy \
+    UV_CACHE_DIR=/opt/uv-cache \
+    UV_PYTHON_INSTALL_DIR=/usr/local/share/uv/python \
+    UV_PYTHON_BIN_DIR=/usr/local/bin \
+    RUSTUP_HOME=/usr/local/rustup \
+    CARGO_HOME=/usr/local/cargo \
+    COREPACK_HOME=/opt/corepack \
+    PATH=/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash build-essential ca-certificates curl git jq passwd pkg-config procps unzip xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
+RUN mkdir -p "$PLAYWRIGHT_BROWSERS_PATH" && chmod 755 "$PLAYWRIGHT_BROWSERS_PATH" \
+    && arch="$(dpkg --print-architecture)" && case "$arch" in arm64) node_arch=arm64 ;; amd64) node_arch=x64 ;; *) exit 1 ;; esac \
+    && curl -fsSL "https://nodejs.org/dist/v22.14.0/node-v22.14.0-linux-${node_arch}.tar.xz" | tar -C /usr/local --strip-components=1 -xJ \
+    && mkdir -p /opt/corepack && chmod 755 /opt/corepack \
+    && corepack enable
+COPY repo.tar.gz /tmp/repo.tar.gz
+RUN mkdir -p /app && tar -xzf /tmp/repo.tar.gz -C /app && rm /tmp/repo.tar.gz \
+    && git -C /app init -q \
+    && git -C /app config user.email selfbench@local \
+    && git -C /app config user.name selfbench \
+    && git -C /app add -A \
+    && git -C /app commit -qm base
+RUN mkdir -p /opt/uv-cache && chmod 777 /opt/uv-cache \
+    && cd '/app/.' \
+    && bash -lc 'corepack enable && pnpm install --frozen-lockfile && pnpm exec playwright install --with-deps chromium && pnpm run build' \
+    && chmod -R a+rwX /opt/uv-cache
+
+RUN useradd --create-home --shell /bin/bash verifier \
+    && chown -R verifier:verifier /app /opt/uv-cache \
+    && mkdir -p /opt/selfbench \
+    && chmod 700 /opt/selfbench \
+    && mkdir -p /home/verifier/.cache/uv \
+    && chown -R verifier:verifier /home/verifier/.cache
+ENV UV_CACHE_DIR=/home/verifier/.cache/uv \
+    UV_NO_BUILD_ISOLATION=1
+COPY test.patch test.sh /tests/
+RUN chmod 700 /tests && chmod 600 /tests/test.patch && chmod +x /tests/test.sh
+WORKDIR /app
diff --git a/vite-wasm-global-string-builtins/tests/repo.tar.gz b/vite-wasm-global-string-builtins/tests/repo.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..6c2506a804ffc5b934ede319ecb39d365db44ffd
--- /dev/null
+++ b/vite-wasm-global-string-builtins/tests/repo.tar.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c86ffe35eda3dd43cb9d4db9f36b182e80f919caf9cb5f50027fe0d8eacbf51
+size 12882301
diff --git a/vite-wasm-global-string-builtins/tests/test.patch b/vite-wasm-global-string-builtins/tests/test.patch
new file mode 100644
index 0000000000000000000000000000000000000000..4626afc311d1c8db3775967f0d8825cc11e762c2
--- /dev/null
+++ b/vite-wasm-global-string-builtins/tests/test.patch
@@ -0,0 +1,134 @@
+diff --git a/playground/wasm/__tests__/wasm.spec.ts b/playground/wasm/__tests__/wasm.spec.ts
+index 86cb015b8..a43a75b1b 100644
+--- a/playground/wasm/__tests__/wasm.spec.ts
++++ b/playground/wasm/__tests__/wasm.spec.ts
+@@ -41,3 +41,27 @@ test('direct wasm import with wasm imports', async () => {
+     .poll(() => page.textContent('.direct-wasm-with-imports .result'))
+     .toMatch('42')
+ })
++
++test('direct wasm import unwraps exported WebAssembly.Global', async () => {
++  await expect
++    .poll(() => page.textContent('.direct-wasm-global .result'))
++    .toMatch('42 number')
++})
++
++test('wasm importing a global from another wasm', async () => {
++  await expect
++    .poll(() => page.textContent('.direct-wasm-global-import .result'))
++    .toMatch('43')
++})
++
++test('wasm reading a mutable global mutated by another wasm', async () => {
++  await expect
++    .poll(() => page.textContent('.direct-wasm-mutable-global-import .result'))
++    .toMatch('9')
++})
++
++test('wasm using js-string builtins and imported string constants', async () => {
++  await expect
++    .poll(() => page.textContent('.direct-wasm-string-builtins .result'))
++    .toMatch('5')
++})
+diff --git a/playground/wasm/global-consumer.wasm b/playground/wasm/global-consumer.wasm
+new file mode 100644
+index 0000000000000000000000000000000000000000..7d925265a5794f06c45f7fe32b7124701c54d3ab
+GIT binary patch
+literal 131
+zcmZQbEY4+QU|?WmWlUgTtY@-h;?>hn&&f|p%+V_c%CRNp6_=+LG1oJoiu2``mLw+S
+zq&nx9=9Pft8JU@x7#P@<m;};OOB}(P0&+@={qs^87`Tg46H}ln85p_vnAjPV85|k2
+KxLFvK8My)aBO%KG
+
+literal 0
+HcmV?d00001
+
+diff --git a/playground/wasm/global.wasm b/playground/wasm/global.wasm
+new file mode 100644
+index 0000000000000000000000000000000000000000..769dfda95bca8f547101dca8d6062f7dfd72cae0
+GIT binary patch
+literal 108
+zcmXZUF$#k~5CzcxXM;-|NRtZ)v9ie-7BAw8HsWefmy~mLEo@)$5cfm?ETt1OS_e2M
+zV4-3NjT(bj|9up3+5h9_@JjiJ{XDj7UXBas;xGW(=k&Yn+TP+(q2i=Zd>A;@)Dw|E
+B71RI#
+
+literal 0
+HcmV?d00001
+
+diff --git a/playground/wasm/index.html b/playground/wasm/index.html
+index f2d3c226c..378e9fe9e 100644
+--- a/playground/wasm/index.html
++++ b/playground/wasm/index.html
+@@ -38,6 +38,31 @@
+   <span class="result"></span>
+ </div>
+ 
++<div class="direct-wasm-global">
++  <h3>Direct wasm import of a global, result should be 42 (number)</h3>
++  <span class="result"></span>
++</div>
++
++<div class="direct-wasm-global-import">
++  <h3>wasm importing a global from another wasm, result should be 43</h3>
++  <span class="result"></span>
++</div>
++
++<div class="direct-wasm-mutable-global-import">
++  <h3>
++    wasm reading a mutable global mutated by another wasm, result should be 9
++  </h3>
++  <span class="result"></span>
++</div>
++
++<div class="direct-wasm-string-builtins">
++  <h3>
++    wasm using js-string builtins and imported string constants, result should
++    be 5
++  </h3>
++  <span class="result"></span>
++</div>
++
+ <script type="module">
+   import light from './light.wasm?init'
+   import heavy from './heavy.wasm?init'
+@@ -45,6 +70,10 @@
+   import { add } from './add.wasm'
+   import { exported_func } from './light-with-imports.wasm'
+   import { getResult } from './imports.js'
++  import { answer } from './global.wasm'
++  import { getAnswerPlusOne, readCounter } from './global-consumer.wasm'
++  import { bumpCounter } from './global.wasm'
++  import { helloLength } from './string-constants.wasm'
+ 
+   const w = new myWorker()
+   w.addEventListener('message', (ev) => {
+@@ -56,6 +85,19 @@
+   exported_func()
+   text('.direct-wasm-with-imports .result', getResult())
+ 
++  text('.direct-wasm-global .result', `${answer} ${typeof answer}`)
++  text('.direct-wasm-global-import .result', getAnswerPlusOne())
++
++  // The mutable global is a single live cell shared between the two wasm
++  // modules: mutating it from one is observed by the other (7 + 2 = 9).
++  bumpCounter()
++  bumpCounter()
++  text('.direct-wasm-mutable-global-import .result', readCounter())
++
++  // 'hello'.length, where 'hello' is an engine-provided imported string constant
++  // and `length` is a js-string builtin.
++  text('.direct-wasm-string-builtins .result', helloLength())
++
+   async function testWasm(init, resultElement) {
+     const { exported_func } = await init({
+       imports: {
+diff --git a/playground/wasm/string-constants.wasm b/playground/wasm/string-constants.wasm
+new file mode 100644
+index 0000000000000000000000000000000000000000..fa6d4db73d01f6c12ffd5d3453be25ed2944ee31
+GIT binary patch
+literal 112
+zcmXZT%L+h17>42R8#zQ_X>ToiZox&6<j|NY|CFU$CoJEmUJSAm0AtnD^6J4$wJJRy
+wZ#JpK9jloGJ(<}pK=FJ1c{N%iZZJ;#WzyPu7M>!*jLF;Gw=s?wphS-32B-ubApigX
+
+literal 0
+HcmV?d00001
+
diff --git a/vite-wasm-global-string-builtins/tests/test.sh b/vite-wasm-global-string-builtins/tests/test.sh
new file mode 100644
index 0000000000000000000000000000000000000000..09886d11301e007cd356fa11424d698528b81406
--- /dev/null
+++ b/vite-wasm-global-string-builtins/tests/test.sh
@@ -0,0 +1,100 @@
+#!/bin/bash
+set -uo pipefail
+mkdir -p /logs/verifier
+patch_applied=1
+fail_to_pass=0
+pass_to_pass=0
+deterministic=0
+setup_completed=0
+fail_to_pass_exit_code=-1
+fail_to_pass_repeat_exit_code=-1
+pass_to_pass_exit_code=-1
+verifier_cache=""
+
+kill_verifier_processes() { pkill -KILL -u "$(id -u verifier)" 2>/dev/null || true; }
+# Some toolchains fetch dependencies at test runtime (e.g. Next.js e2e installs),
+# so a single registry connection reset must not be misread as a dead test. Retry
+# only infrastructure-style failures with backoff; real assertion failures fail fast.
+run_verifier_command() {
+  local logfile
+  logfile="$(mktemp /tmp/selfbench-verifier-command-XXXXXX.log)"
+  local attempt=1
+  local status=1
+  while [ "$attempt" -le 3 ]; do
+    : > "$logfile"
+    runuser -u verifier -- env PATH="/usr/local/go/bin:/usr/local/cargo/bin:/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin" UV_CACHE_DIR="$verifier_cache" UV_NO_BUILD_ISOLATION=1 bash -lc "$1" >"$logfile" 2>&1
+    status=$?
+    if [ "$status" -eq 0 ]; then
+      break
+    fi
+    if [ "$attempt" -lt 3 ] && grep -qE 'ECONNRESET|ETIMEDOUT|ESOCKETTIMEDOUT|ENOTFOUND|EAI_AGAIN|META_FETCH_FAIL|FetchError|EPIPE|EPERM|registry\.npmjs' "$logfile"; then
+      sleep "$((10 * attempt))"
+      attempt=$((attempt + 1))
+      continue
+    fi
+    break
+  done
+  cat "$logfile"
+  rm -f "$logfile"
+  kill_verifier_processes
+  return "$status"
+}
+protect_held_out_path() {
+  local path="$1"
+  chown -R root:root -- "$path"
+  chmod -R a-w,go+rX -- "$path"
+}
+
+if [ ! -f /opt/selfbench/agent.patch ]; then
+  patch_applied=0
+elif [ -s /opt/selfbench/agent.patch ]; then
+  git -C /app apply --binary --whitespace=nowarn --exclude='playground/wasm/__tests__/wasm.spec.ts' --exclude='playground/wasm/__tests__/wasm.spec.ts/*' --exclude='playground/wasm/global-consumer.wasm' --exclude='playground/wasm/global-consumer.wasm/*' --exclude='playground/wasm/global.wasm' --exclude='playground/wasm/global.wasm/*' --exclude='playground/wasm/index.html' --exclude='playground/wasm/index.html/*' --exclude='playground/wasm/string-constants.wasm' --exclude='playground/wasm/string-constants.wasm/*' /opt/selfbench/agent.patch || patch_applied=0
+fi
+
+if [ "$patch_applied" -eq 1 ]; then setup_completed=1; fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  kill_verifier_processes
+  for protected_path in 'playground/wasm/__tests__/wasm.spec.ts' 'playground/wasm/global-consumer.wasm' 'playground/wasm/global.wasm' 'playground/wasm/index.html' 'playground/wasm/string-constants.wasm'; do
+    git -C /app restore --source=HEAD --staged --worktree -- "$protected_path" 2>/dev/null || true
+    git -C /app clean -fd -- "$protected_path" >/dev/null 2>&1 || true
+  done
+  git -C /app apply --binary --whitespace=nowarn /tests/test.patch || patch_applied=0
+  if [ "$patch_applied" -eq 1 ]; then
+    for protected_path in '/app/playground/wasm/__tests__/wasm.spec.ts' '/app/playground/wasm/global-consumer.wasm' '/app/playground/wasm/global.wasm' '/app/playground/wasm/index.html' '/app/playground/wasm/string-constants.wasm'; do protect_held_out_path "$protected_path"; done
+  fi
+  rm -f /tests/test.patch
+fi
+
+if [ "$patch_applied" -eq 1 ] && [ "$setup_completed" -eq 1 ]; then
+  cd '/app/.'
+  verifier_cache="$(mktemp -d /tmp/selfbench-verifier-uv-XXXXXX)"
+  cp -a /opt/uv-cache/. "$verifier_cache"/
+  chown -R verifier:verifier "$verifier_cache"
+  if run_verifier_command 'pnpm run build && pnpm run test-serve '"'"'playground/wasm/__tests__/wasm.spec.ts'"'"''; then
+    fail_to_pass_exit_code=0
+    fail_to_pass=1
+    if run_verifier_command 'pnpm run build && pnpm run test-serve '"'"'playground/wasm/__tests__/wasm.spec.ts'"'"''; then
+      fail_to_pass_repeat_exit_code=0
+      deterministic=1
+    else
+      fail_to_pass_repeat_exit_code=$?
+    fi
+  else
+    fail_to_pass_exit_code=$?
+  fi
+  if run_verifier_command 'true'; then
+    pass_to_pass_exit_code=0
+    pass_to_pass=1
+  else
+    pass_to_pass_exit_code=$?
+  fi
+  rm -rf "$verifier_cache"
+fi
+
+reward=0
+if [ "$patch_applied" -eq 1 ] && [ "$fail_to_pass" -eq 1 ] && [ "$pass_to_pass" -eq 1 ] && [ "$deterministic" -eq 1 ]; then reward=1; fi
+cat > /logs/verifier/reward.json <<EOF
+{"reward": $reward, "patch_applied": $patch_applied, "fail_to_pass": $fail_to_pass, "pass_to_pass": $pass_to_pass, "deterministic": $deterministic, "setup_completed": $setup_completed, "fail_to_pass_exit_code": $fail_to_pass_exit_code, "fail_to_pass_repeat_exit_code": $fail_to_pass_repeat_exit_code, "pass_to_pass_exit_code": $pass_to_pass_exit_code}
+EOF
+exit 0