Add pinned speculative metadata runtime wheels

.gitattributes

@@ -58,3 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+vllm-0.24.0+mayhem.specmeta1-cp38-abi3-manylinux_2_28_aarch64.whl filter=lfs diff=lfs merge=lfs -text
+vllm-0.24.0+mayhem.specmeta1-cp38-abi3-manylinux_2_28_x86_64.whl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,17 @@
+---
+license: apache-2.0
+---
+# OpenMayhem Runtime Wheels
+
+vLLM 0.24.0 downstream runtime with the speculative FlashInfer host-metadata
+lifetime fix. The original upstream native binaries, dependencies, licenses,
+and platform metadata are preserved. This is not an official vLLM release.
+
+Each wheel has a SHA-256 provenance record. The source patch, regression test,
+and offline reproducible packager are included. Source base:
+https://github.com/vllm-project/vllm/commit/ee0da84ab9e04ac7610e28580af62c365e898389
+
+The change extends the existing ModelRunnerV2 host-buffer lifetime guard to
+speculative decoding. Non-speculative V1 decoding retains its existing behavior.
+It does not introduce global GPU synchronization or change native kernels.
+Consumers must use an immutable repository revision and verify the wheel hash.

package-vllm-speculative-runtime.py

@@ -0,0 +1,485 @@
+#!/usr/bin/env python3
+"""Offline, pinned vLLM wheel rewrite; never import/build/install wheel code.
+
+ZIP_STORED, sorted members, fixed timestamps and canonical permissions make
+outputs reproducible without depending on a particular zlib version. Native
+members are streamed, not buffered. The adjacent JSON is deterministic too.
+
+--source-checkout needs only vllm/v1/attention/backends/flashinfer.py plus either:
+  * .git with HEAD at FIX_COMMIT, its pinned parent, the backend's tree objects,
+    and a clean backend index entry (other worktree files may be absent); or
+  * vllm-specmeta-source.json containing exactly base_commit, fix_commit and
+    backend_sha256, with the pinned values below. No Git state is needed for
+    this export form. The manifest is an identity declaration, not a signature;
+    the backend bytes are always independently checked against the built-in SHA.
+No tests, _version.py, setup.py, dependencies or build artifacts are needed in
+the source tree. _version.py is read only from the pinned upstream wheel.
+"""
+
+import argparse
+import ast
+import base64
+import csv
+from email import policy
+from email.parser import BytesParser
+import hashlib
+import io
+import json
+import os
+from pathlib import Path
+import stat
+import subprocess
+import tempfile
+import zipfile
+
+
+BASE_COMMIT = "ee0da84ab9e04ac7610e28580af62c365e898389"
+FIX_COMMIT = "9a9cbb67ac23d78cf7384650b561ce7b122f770b"
+OLD_BACKEND_SHA = "ce9071eade3d1a9c7dc9dd9f187212599e1c20058ffda901d6950b9dcde19913"
+NEW_BACKEND_SHA = "01678024fc88e5f031b866fd6affbb0d82917c271938d8c5878fa0e68c023ab5"
+UPSTREAM_HASHES = {
+    "vllm-0.24.0-cp38-abi3-manylinux_2_28_aarch64.whl":
+        "700db71c3cf14697d42583521f38b12fac38db1e7a8ad062e8e4d63a5dadebd5",
+    "vllm-0.24.0-cp38-abi3-manylinux_2_28_x86_64.whl":
+        "2d2831aeba311292250df0132dbc4d8e9f42c654536eaec48e6fe58acb1822cf",
+}
+UPSTREAM_WHEEL_TAGS = {
+    "vllm-0.24.0-cp38-abi3-manylinux_2_28_aarch64.whl":
+        ["cp38-abi3-linux_aarch64"],
+    "vllm-0.24.0-cp38-abi3-manylinux_2_28_x86_64.whl":
+        ["cp38-abi3-linux_x86_64"],
+}
+VERSION = "0.24.0+mayhem.specmeta1"
+BACKEND = "vllm/v1/attention/backends/flashinfer.py"
+VERSION_FILE = "vllm/_version.py"
+DIST = "vllm-0.24.0.dist-info"
+NEW_DIST = "vllm-" + VERSION + ".dist-info"
+RECORD = DIST + "/RECORD"
+CHUNK = 1024 * 1024
+MAX_ARCHIVE = 16 * 1024**3
+MAX_MEMBER = 8 * 1024**3
+MAX_TOTAL = 32 * 1024**3
+MAX_SMALL = 16 * 1024**2
+MAX_CENTRAL = 32 * 1024**2
+MAX_ENTRIES = 50000
+
+
+class InvalidWheel(ValueError):
+    pass
+
+
+def require(condition, message):
+    if not condition:
+        raise InvalidWheel(message)
+
+
+def sha256(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def digest_stream(stream, sink=None, limit=MAX_ARCHIVE):
+    digest, size = hashlib.sha256(), 0
+    while True:
+        chunk = stream.read(CHUNK)
+        if not chunk:
+            break
+        size += len(chunk)
+        require(size <= limit, "stream exceeds size bound")
+        digest.update(chunk)
+        if sink is not None:
+            sink.write(chunk)
+    return digest.hexdigest(), size
+
+
+def safe_path(name):
+    require(isinstance(name, str) and 0 < len(name) <= 4096,
+            "invalid member path length")
+    require(not any(ord(c) < 32 or ord(c) == 127 or c in "\\:" for c in name),
+            "unsafe member path: " + repr(name))
+    parts = name.rstrip("/").split("/")
+    require(all(p and p not in (".", "..") and not p.endswith((".", " "))
+                for p in parts), "unsafe member path: " + repr(name))
+    require(not name.endswith("//"), "unsafe directory path")
+
+
+def git(checkout, *args):
+    # These are read-only plumbing commands, never diff/filter/build commands.
+    env = dict(os.environ, GIT_NO_REPLACE_OBJECTS="1", GIT_OPTIONAL_LOCKS="0")
+    for key in list(env):
+        if key.startswith("GIT_") and key not in (
+                "GIT_NO_REPLACE_OBJECTS", "GIT_OPTIONAL_LOCKS"):
+            del env[key]
+    result = subprocess.run(
+        ["git", "-c", "core.fsmonitor=false", "-c", "core.hooksPath=/dev/null",
+         "-C", str(checkout), *args], env=env, check=True,
+        stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=60)
+    require(len(result.stdout) <= MAX_CENTRAL, "source listing too large")
+    return result.stdout
+
+
+def fixed_source(checkout):
+    checkout = Path(checkout).resolve(strict=True)
+    path = checkout / BACKEND
+    require(all(not parent.is_symlink() for parent in
+                (path, *path.parents) if parent != checkout), "source symlink rejected")
+    require(stat.S_ISREG(path.stat().st_mode), "backend must be a regular file")
+    with path.open("rb") as stream:
+        backend = stream.read(MAX_SMALL + 1)
+    require(len(backend) <= MAX_SMALL and sha256(backend) == NEW_BACKEND_SHA,
+            "fixed backend SHA256 mismatch")
+    if os.path.lexists(checkout / ".git"):
+        require(git(checkout, "rev-parse", "HEAD").strip().decode() == FIX_COMMIT,
+                "source HEAD is not the pinned fix commit")
+        require(git(checkout, "rev-parse", "HEAD^").strip().decode() == BASE_COMMIT,
+                "source parent is not the pinned base commit")
+        blob = hashlib.sha1(b"blob " + str(len(backend)).encode() + b"\0" + backend).hexdigest().encode()
+        tree = git(checkout, "ls-tree", "--full-tree", "-z", "HEAD", "--", BACKEND)
+        # Git owns the tracked mode; transported source bytes need not be executable.
+        require(tree in {mode + b" blob " + blob + b"\t" + BACKEND.encode() + b"\0"
+                         for mode in (b"100644", b"100755")},
+                "backend does not match pinned source tree")
+        mode = tree.split(b" ", 1)[0]
+        require(git(checkout, "ls-files", "--stage", "-z", "--", BACKEND) ==
+                mode + b" " + blob + b" 0\t" + BACKEND.encode() + b"\0",
+                "source backend index is not clean")
+    else:
+        manifest = checkout / "vllm-specmeta-source.json"
+        require(not manifest.is_symlink() and stat.S_ISREG(manifest.stat().st_mode),
+                "source manifest must be regular")
+        with manifest.open("rb") as stream:
+            data = stream.read(MAX_SMALL + 1)
+        require(len(data) <= MAX_SMALL, "source manifest too large")
+        require(json.loads(data) == {"base_commit": BASE_COMMIT,
+                                   "fix_commit": FIX_COMMIT,
+                                   "backend_sha256": NEW_BACKEND_SHA},
+                "exported source identity mismatch")
+    return backend
+
+
+def check_zip_bounds(stream):
+    require(os.fstat(stream.fileno()).st_size <= MAX_ARCHIVE, "archive too large")
+    # zipfile's bounded EOCD/ZIP64 parser avoids loading a huge central directory.
+    end = zipfile._EndRecData(stream)
+    require(end is not None, "missing ZIP end record")
+    require(end[zipfile._ECD_SIZE] <= MAX_CENTRAL, "central directory too large")
+    require(end[zipfile._ECD_ENTRIES_TOTAL] <= MAX_ENTRIES, "too many ZIP entries")
+    require(end[zipfile._ECD_DISK_NUMBER] == 0 and
+            end[zipfile._ECD_DISK_START] == 0 and
+            end[zipfile._ECD_ENTRIES_THIS_DISK] == end[zipfile._ECD_ENTRIES_TOTAL],
+            "multidisk ZIP unsupported")
+    stream.seek(0)
+
+
+def inventory(wheel):
+    infos, aliases, total = {}, set(), 0
+    require(len(wheel.infolist()) <= MAX_ENTRIES, "too many ZIP entries")
+    for info in wheel.infolist():
+        name = info.filename
+        require(info.orig_filename == name, "truncated ZIP path")
+        safe_path(name)
+        alias = name.rstrip("/").casefold()
+        require(alias not in aliases, "duplicate ZIP path: " + name)
+        aliases.add(alias)
+        mode = stat.S_IFMT(info.external_attr >> 16)
+        require(mode in (0, stat.S_IFDIR if info.is_dir() else stat.S_IFREG),
+                "symlink or special ZIP member: " + name)
+        require(not info.flag_bits & 1 and info.compress_type in
+                (zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED),
+                "encrypted or unsupported ZIP member")
+        require(0 <= info.file_size <= MAX_MEMBER and
+                0 <= info.compress_size <= MAX_ARCHIVE, "ZIP member too large")
+        require(not info.is_dir() or info.file_size == 0, "nonempty ZIP directory")
+        total += info.file_size
+        require(total <= MAX_TOTAL, "expanded ZIP too large")
+        for part in name.rstrip("/").split("/"):
+            require(not part.endswith(".dist-info") or part == DIST,
+                    "unknown dist-info directory")
+        require(name not in (DIST + "/RECORD.jws", DIST + "/RECORD.p7s"),
+                "signed RECORD cannot be rewritten")
+        infos[name] = info
+    files = {n.rstrip("/").casefold() for n, i in infos.items() if not i.is_dir()}
+    for name in infos:
+        parts = name.rstrip("/").casefold().split("/")
+        require(all("/".join(parts[:i]) not in files for i in range(1, len(parts))),
+                "ZIP file/directory collision")
+    require({BACKEND, VERSION_FILE, RECORD, DIST + "/METADATA", DIST + "/WHEEL"}
+            <= infos.keys(), "required wheel member missing")
+    return infos
+
+
+def small(wheel, name):
+    require(wheel.getinfo(name).file_size <= MAX_SMALL, "metadata member too large")
+    with wheel.open(name) as stream:
+        data = stream.read(MAX_SMALL + 1)
+    require(len(data) <= MAX_SMALL, "metadata exceeds size bound")
+    return data
+
+
+def read_record(data, infos):
+    rows = {}
+    for row in csv.reader(io.StringIO(data.decode("utf-8"), newline=""), strict=True):
+        require(len(row) == 3, "invalid RECORD row")
+        name, digest, size = row
+        safe_path(name)
+        require(name not in rows and name in infos and not infos[name].is_dir(),
+                "duplicate or unknown RECORD path")
+        if name == RECORD:
+            require(digest == size == "", "RECORD must not hash itself")
+        else:
+            require(digest.startswith("sha256=") and len(digest) == 50,
+                    "RECORD requires SHA256")
+            encoded = digest[7:]
+            raw = base64.b64decode(encoded + "=", altchars=b"-_", validate=True)
+            require(base64.urlsafe_b64encode(raw).decode().rstrip("=") == encoded,
+                    "noncanonical RECORD hash")
+            require(size == str(infos[name].file_size), "RECORD size mismatch")
+        rows[name] = (digest, size)
+    require(rows.keys() == {n for n, i in infos.items() if not i.is_dir()},
+            "RECORD does not cover every file")
+    return rows
+
+
+def record_hash(hex_digest):
+    return "sha256=" + base64.urlsafe_b64encode(bytes.fromhex(hex_digest)).decode().rstrip("=")
+
+
+def verify_record(name, digest, size, rows):
+    if name != RECORD:
+        require(rows[name] == (record_hash(digest), str(size)),
+                "RECORD hash/size mismatch: " + name)
+
+
+def rewrite_version(data):
+    tree = ast.parse(data)
+    fields = {
+        ("__version__", "version"): ("0.24.0", VERSION),
+        ("__version_tuple__", "version_tuple"):
+            ((0, 24, 0), (0, 24, 0, "mayhem.specmeta1")),
+        ("__commit_id__", "commit_id"): ("gee0da84ab", "g" + FIX_COMMIT[:9]),
+    }
+    names = {name for pair in fields for name in pair}
+    lines = data.splitlines(keepends=True)
+    offsets = [0]
+    for line in lines:
+        offsets.append(offsets[-1] + len(line))
+    edits, seen = [], set()
+    for node in tree.body:
+        if isinstance(node, ast.Assign):
+            require(all(isinstance(t, ast.Name) for t in node.targets),
+                    "unknown version assignment")
+            keys = tuple(t.id for t in node.targets)
+            if keys == ("__all__",):
+                require(set(ast.literal_eval(node.value)) == names,
+                        "unknown version exports")
+                continue
+            require(keys in fields and keys not in seen, "unknown version fields")
+            old, new = fields[keys]
+            require(ast.literal_eval(node.value) == old, "unknown original version")
+            seen.add(keys)
+            value = node.value
+            start = offsets[value.lineno - 1] + value.col_offset
+            end = offsets[value.end_lineno - 1] + value.end_col_offset
+            edits.append((start, end, repr(new).encode("ascii")))
+        elif isinstance(node, ast.AnnAssign):
+            require(isinstance(node.target, ast.Name) and node.target.id in names
+                    and node.value is None, "unknown version annotation")
+        elif isinstance(node, ast.ImportFrom):
+            require(node.level == 0 and node.module in ("__future__", "typing")
+                    and all(n.asname is None and n.name in
+                            ("annotations", "Tuple", "Union") for n in node.names),
+                    "unknown version import")
+        else:
+            require(isinstance(node, ast.Expr) and isinstance(node.value, ast.Constant)
+                    and isinstance(node.value.value, str), "unknown version schema")
+    require(seen == fields.keys(), "missing version fields")
+    for start, end, replacement in sorted(edits, reverse=True):
+        data = data[:start] + replacement + data[end:]
+    return data
+
+
+def headers(data):
+    message = BytesParser(policy=policy.compat32).parsebytes(data)
+    require(not message.defects, "malformed wheel metadata")
+    return message
+
+
+def rewrite_metadata(data):
+    message = headers(data)
+    require(message.get_all("Name") == ["vllm"] and
+            message.get_all("Version") == ["0.24.0"], "unknown original METADATA")
+    # Parse structurally, but splice only this header to preserve dependencies,
+    # license fields and the description byte-for-byte (email reserializes them).
+    lines = data.splitlines(keepends=True)
+    for i, line in enumerate(lines):
+        if line in (b"\n", b"\r\n"):
+            break
+        if line.lower().startswith(b"version:"):
+            ending = b"\r\n" if line.endswith(b"\r\n") else b"\n"
+            require(line.rstrip(b"\r\n").split(b":", 1)[1].strip() == b"0.24.0"
+                    and (i + 1 == len(lines) or not lines[i + 1].startswith((b" ", b"\t"))),
+                    "unknown Version header encoding")
+            lines[i] = line.split(b":", 1)[0] + b": " + VERSION.encode() + ending
+            return b"".join(lines)
+    raise InvalidWheel("missing Version header")
+
+
+def renamed(name):
+    return NEW_DIST + name[len(DIST):] if name == DIST + "/" or name.startswith(DIST + "/") else name
+
+
+def write_wheel(source, target, infos, rows, replacements):
+    records, changes = [], []
+    with zipfile.ZipFile(target, "w", compression=zipfile.ZIP_STORED,
+                         allowZip64=True) as output:
+        for name in sorted(infos, key=renamed):
+            if name == RECORD:
+                continue
+            original = infos[name]
+            new_name = renamed(name)
+            info = zipfile.ZipInfo(new_name, date_time=(1980, 1, 1, 0, 0, 0))
+            info.create_system = 3
+            mode = 0o755 if original.is_dir() or original.external_attr >> 16 & 0o111 else 0o644
+            info.external_attr = ((stat.S_IFDIR if original.is_dir() else stat.S_IFREG) | mode) << 16
+            if original.is_dir():
+                info.external_attr |= 0x10
+            info.file_size = len(replacements[name]) if name in replacements else original.file_size
+            with output.open(info, "w", force_zip64=info.file_size >= 2**31) as sink:
+                if name in replacements:
+                    data = replacements[name]
+                    sink.write(data)
+                    digest, size = sha256(data), len(data)
+                    old_digest = sha256(small(source, name))
+                else:
+                    with source.open(original) as stream:
+                        digest, size = digest_stream(stream, sink, original.file_size)
+                    old_digest = digest
+                    if not original.is_dir():
+                        verify_record(name, digest, size, rows)
+            if not original.is_dir():
+                records.append((new_name, record_hash(digest), str(size)))
+            if name != new_name or name in replacements:
+                changes.append({"original": name, "output": new_name,
+                                "original_sha256": old_digest, "sha256": digest})
+        record_text = io.StringIO(newline="")
+        writer = csv.writer(record_text, lineterminator="\n")
+        writer.writerows(sorted(records + [(renamed(RECORD), "", "")]))
+        record_data = record_text.getvalue().encode("utf-8")
+        info = zipfile.ZipInfo(renamed(RECORD), (1980, 1, 1, 0, 0, 0))
+        info.create_system = 3
+        info.external_attr = (stat.S_IFREG | 0o644) << 16
+        output.writestr(info, record_data)
+        changes.append({"original": RECORD, "output": renamed(RECORD),
+                        "original_sha256": sha256(small(source, RECORD)),
+                        "sha256": sha256(record_data)})
+    return sorted(changes, key=lambda row: row["output"])
+
+
+def _package(wheel_path, output_dir, backend, expected_input_sha):
+    """Internal fixture seam; the public entry point always selects pinned hashes."""
+    wheel_path, output_dir = Path(wheel_path), Path(output_dir)
+    require(wheel_path.name in UPSTREAM_HASHES, "unapproved upstream wheel filename")
+    require(sha256(backend) == NEW_BACKEND_SHA, "fixed backend SHA256 mismatch")
+    output_name = wheel_path.name.replace("vllm-0.24.0-", "vllm-" + VERSION + "-", 1)
+    destinations = [output_dir / output_name, output_dir / (output_name + ".provenance.json")]
+    owned, success = {}, False
+
+    def remember(path):
+        info = path.lstat()
+        owned[path] = (info.st_dev, info.st_ino)
+
+    try:
+        with wheel_path.open("rb") as stream:
+            require(stat.S_ISREG(os.fstat(stream.fileno()).st_mode), "wheel must be regular")
+            check_zip_bounds(stream)
+            input_sha, input_size = digest_stream(stream)
+            require(input_sha == expected_input_sha, "upstream wheel SHA256 mismatch")
+            stream.seek(0)
+            with zipfile.ZipFile(stream) as source:
+                infos = inventory(source)
+                rows = read_record(small(source, RECORD), infos)
+                originals = {n: small(source, n) for n in
+                             (BACKEND, VERSION_FILE, DIST + "/METADATA", DIST + "/WHEEL")}
+                for name, data in originals.items():
+                    verify_record(name, sha256(data), len(data), rows)
+                require(sha256(originals[BACKEND]) == OLD_BACKEND_SHA,
+                        "unknown original backend SHA256")
+                wheel_headers = headers(originals[DIST + "/WHEEL"])
+                # Pinned upstream metadata may differ from the published filename.
+                require(wheel_headers.get_all("Tag") == UPSTREAM_WHEEL_TAGS[wheel_path.name] and
+                        wheel_headers.get_all("Wheel-Version") == ["1.0"] and
+                        wheel_headers.get_all("Root-Is-Purelib") == ["false"],
+                        "unknown original WHEEL metadata")
+                replacements = {BACKEND: backend,
+                                VERSION_FILE: rewrite_version(originals[VERSION_FILE]),
+                                DIST + "/METADATA": rewrite_metadata(originals[DIST + "/METADATA"])}
+                output_dir.mkdir(parents=True, exist_ok=True)
+                require(not any(os.path.lexists(p) for p in destinations), "output already exists")
+                with tempfile.NamedTemporaryFile(prefix=".vllm-", suffix=".tmp",
+                                                 dir=output_dir, delete=False) as target:
+                    temporary = Path(target.name)
+                    remember(temporary)
+                    changes = write_wheel(source, target, infos, rows, replacements)
+                    target.flush()
+                    os.fsync(target.fileno())
+                # Detect an input changed during streaming, including ZIP headers.
+                stream.seek(0)
+                require(digest_stream(stream) == (input_sha, input_size),
+                        "upstream wheel changed during packaging")
+        with temporary.open("rb") as stream:
+            output_sha, output_size = digest_stream(stream, limit=MAX_TOTAL + MAX_CENTRAL)
+        provenance = {
+            "schema_version": 1, "upstream_version": "0.24.0", "version": VERSION,
+            "base_commit": BASE_COMMIT, "fix_commit": FIX_COMMIT,
+            "backend": {"path": BACKEND, "original_sha256": OLD_BACKEND_SHA,
+                        "sha256": NEW_BACKEND_SHA},
+            "upstream_wheel": {"filename": wheel_path.name, "sha256": input_sha, "size": input_size},
+            "output_wheel": {"filename": output_name, "sha256": output_sha, "size": output_size},
+            "changed_members": changes,
+        }
+        with tempfile.NamedTemporaryFile(prefix=".vllm-", suffix=".tmp",
+                                         dir=output_dir, delete=False) as target:
+            sidecar = Path(target.name)
+            remember(sidecar)
+            target.write((json.dumps(provenance, sort_keys=True, indent=2) + "\n").encode())
+            target.flush()
+            os.fsync(target.fileno())
+        for temporary_path, destination in zip((temporary, sidecar), destinations):
+            os.link(temporary_path, destination)  # Atomic publication, never overwrite.
+            owned[destination] = owned[temporary_path]
+        success = True
+        return tuple(destinations)
+    finally:
+        for path, identity in owned.items():
+            if success and path in destinations:
+                continue
+            try:
+                info = path.lstat()
+                if (info.st_dev, info.st_ino) == identity:
+                    path.unlink()
+            except FileNotFoundError:
+                pass
+
+
+def package(upstream_wheel, source_checkout, output_dir):
+    name = Path(upstream_wheel).name
+    require(name in UPSTREAM_HASHES, "unapproved upstream wheel filename")
+    return _package(upstream_wheel, output_dir, fixed_source(source_checkout),
+                    UPSTREAM_HASHES[name])
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--upstream-wheel", required=True, type=Path)
+    parser.add_argument("--source-checkout", required=True, type=Path)
+    parser.add_argument("--output-dir", required=True, type=Path)
+    args = parser.parse_args()
+    try:
+        for path in package(args.upstream_wheel, args.source_checkout, args.output_dir):
+            print(path)
+    except (ValueError, OSError, SyntaxError, csv.Error, zipfile.BadZipFile,
+            RuntimeError, subprocess.SubprocessError) as error:
+        parser.exit(1, "packaging failed: " + str(error) + "\n")
+
+
+if __name__ == "__main__":
+    main()

test_package_vllm_speculative_runtime.py

@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+"""Run offline: python3 -B scripts/test_package_vllm_speculative_runtime.py."""
+
+import ast
+import csv
+import importlib.util
+import io
+import json
+from pathlib import Path
+import stat
+import tempfile
+import unittest
+from unittest import mock
+import warnings
+import zipfile
+
+
+SPEC = importlib.util.spec_from_file_location(
+    "packager", Path(__file__).with_name("package-vllm-speculative-runtime.py"))
+p = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(p)
+
+OLD = b"# synthetic original backend\n"
+NEW = b"# synthetic fixed backend\n"
+VERSION_SOURCE = b'''# file generated by vcs-versioning\nfrom __future__ import annotations
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple", "__commit_id__", "commit_id"]
+__version__: str
+version: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+__commit_id__: str | None
+commit_id: str | None
+__version__ = version = '0.24.0'
+__version_tuple__ = version_tuple = (0, 24, 0)
+__commit_id__ = commit_id = 'gee0da84ab'
+'''
+
+
+class PackagerTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name)
+        self.wheel = self.root / next(iter(p.UPSTREAM_HASHES))
+        self.output = self.root / "output"
+        self.patches = mock.patch.multiple(
+            p, OLD_BACKEND_SHA=p.sha256(OLD), NEW_BACKEND_SHA=p.sha256(NEW))
+        self.patches.start()
+        self.addCleanup(self.patches.stop)
+
+    def fixture(self, changes=None, extra=(), record_edit=None):
+        tag = p.UPSTREAM_WHEEL_TAGS[self.wheel.name][0]
+        members = {
+            p.BACKEND: OLD,
+            p.VERSION_FILE: VERSION_SOURCE,
+            p.DIST + "/METADATA": (
+                b"Metadata-Version: 2.4\r\nName: vllm\r\nVersion: 0.24.0\r\n"
+                b"Requires-Dist: torch==2.11.0\r\nRequires-Dist: example;\r\n"
+                b" python_version >= '3.8'\r\nLicense-Expression: Apache-2.0\r\n"
+                b"\r\nDescription\r\nVersion: not a header\r\n"),
+            p.DIST + "/WHEEL": ("Wheel-Version: 1.0\nGenerator: fixture\n"
+                                  "Root-Is-Purelib: false\nTag: " + tag + "\n").encode(),
+            p.DIST + "/licenses/LICENSE": b"untouched license\n",
+            "vllm/_C.abi3.so": bytes(range(256)) * 10000,
+            "vllm/unchanged.py": b"raise RuntimeError('must never execute')\n",
+            p.DIST + "/": b"",
+        }
+        members.update(changes or {})
+        entries = list(members.items()) + list(extra)
+        rows = [(n, p.record_hash(p.sha256(d)), str(len(d)))
+                for n, d in entries if not n.endswith("/")]
+        rows.append((p.RECORD, "", ""))
+        if record_edit:
+            record_edit(rows)
+        record = io.StringIO(newline="")
+        csv.writer(record, lineterminator="\n").writerows(rows)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", UserWarning)
+            with zipfile.ZipFile(self.wheel, "w", zipfile.ZIP_DEFLATED) as wheel:
+                for name, data in entries:
+                    wheel.writestr(name, data)
+                wheel.writestr(p.RECORD, record.getvalue().encode())
+        return members
+
+    def run_package(self, output=None):
+        return p._package(self.wheel, output or self.output, NEW,
+                          p.sha256(self.wheel.read_bytes()))
+
+    def assert_rejected(self, pattern=None):
+        with self.assertRaisesRegex((p.InvalidWheel, zipfile.BadZipFile, ValueError), pattern or "."):
+            self.run_package()
+        if self.output.exists():
+            self.assertEqual(list(self.output.iterdir()), [])
+
+    def test_deterministic_rewrite_and_complete_record(self):
+        for name in p.UPSTREAM_HASHES:
+            with self.subTest(name=name):
+                self.wheel = self.root / name
+                members = self.fixture()
+                first, provenance_path = self.run_package(self.root / (name + "-a"))
+                second, second_provenance = self.run_package(self.root / (name + "-b"))
+                self.assertEqual(first.read_bytes(), second.read_bytes())
+                self.assertEqual(provenance_path.read_bytes(), second_provenance.read_bytes())
+                provenance = json.loads(provenance_path.read_bytes())
+                self.assertEqual(provenance["output_wheel"]["sha256"], p.sha256(first.read_bytes()))
+                self.assertEqual(provenance["base_commit"], p.BASE_COMMIT)
+                self.assertEqual(provenance["fix_commit"], p.FIX_COMMIT)
+                with zipfile.ZipFile(first) as result:
+                    expected_names = {p.renamed(n) for n in members} | {p.renamed(p.RECORD)}
+                    self.assertEqual(set(result.namelist()), expected_names)
+                    for member, data in members.items():
+                        if member not in (p.BACKEND, p.VERSION_FILE, p.DIST + "/METADATA"):
+                            self.assertEqual(result.read(p.renamed(member)), data)
+                    self.assertEqual(result.read(p.BACKEND), NEW)
+                    version = ast.parse(result.read(p.VERSION_FILE))
+                    values = {node.targets[0].id: ast.literal_eval(node.value)
+                              for node in version.body if isinstance(node, ast.Assign)}
+                    self.assertEqual(values["__version__"], p.VERSION)
+                    self.assertEqual(values["__version_tuple__"], (0, 24, 0, "mayhem.specmeta1"))
+                    self.assertEqual(values["__commit_id__"], "g" + p.FIX_COMMIT[:9])
+                    self.assertEqual(result.read(p.NEW_DIST + "/METADATA"),
+                                     members[p.DIST + "/METADATA"].replace(
+                                         b"Version: 0.24.0\r\n", b"Version: " + p.VERSION.encode() + b"\r\n"))
+                    record = list(csv.reader(io.StringIO(result.read(p.renamed(p.RECORD)).decode())))
+                    self.assertEqual({r[0] for r in record},
+                                     {n for n in expected_names if not n.endswith("/")})
+                    for member, digest, size in record:
+                        data = result.read(member)
+                        if member == p.renamed(p.RECORD):
+                            self.assertEqual((digest, size), ("", ""))
+                        else:
+                            self.assertEqual((digest, size), (p.record_hash(p.sha256(data)), str(len(data))))
+                    self.assertTrue(all(i.date_time == (1980, 1, 1, 0, 0, 0)
+                                        and i.compress_type == zipfile.ZIP_STORED
+                                        for i in result.infolist()))
+                changed = {row["original"] for row in provenance["changed_members"]}
+                self.assertEqual(changed, {p.BACKEND, p.VERSION_FILE, p.RECORD} |
+                                 {n for n in members if n.startswith(p.DIST + "/")})
+
+    def test_production_hash_gate_has_no_fixture_override(self):
+        self.fixture()
+        with mock.patch.object(p, "fixed_source", return_value=NEW):
+            with self.assertRaisesRegex(p.InvalidWheel, "upstream wheel SHA256"):
+                p.package(self.wheel, self.root, self.output)
+        self.assertFalse(self.output.exists())
+        self.assertEqual(len(p.UPSTREAM_HASHES), 2)
+
+    def test_pinned_internal_linux_tags_are_preserved(self):
+        for arch, other in (("aarch64", "x86_64"), ("x86_64", "aarch64")):
+            with self.subTest(architecture=arch):
+                self.wheel = self.root / ("vllm-0.24.0-cp38-abi3-manylinux_2_28_" + arch + ".whl")
+                self.output = self.root / arch
+                tag = ("cp38-abi3-linux_" + arch).encode()
+                metadata = (b"Wheel-Version: 1.0\nGenerator: setuptools (80.10.2)\n"
+                            b"Root-Is-Purelib: false\nTag: " + tag + b"\n")
+                self.fixture({p.DIST + "/WHEEL": metadata})
+                output, _ = self.run_package()
+                with zipfile.ZipFile(output) as wheel:
+                    self.assertEqual(wheel.read(p.NEW_DIST + "/WHEEL"), metadata)
+                self.output = self.root / (arch + "-rejected")
+                for wrong in ("cp38-abi3-manylinux_2_28_" + arch, "cp38-abi3-linux_" + other):
+                    self.fixture({p.DIST + "/WHEEL": metadata.replace(tag, wrong.encode())})
+                    self.assert_rejected("unknown original WHEEL metadata")
+
+    def test_unknown_filename(self):
+        self.fixture()
+        self.wheel = self.wheel.rename(self.root / "vllm-0.24.0-py3-none-any.whl")
+        self.assert_rejected("filename")
+
+    def test_malicious_and_duplicate_paths(self):
+        for name in ("../escape", "/absolute", "a/../../b", "a\\b", "C:/bad", "a//b",
+                     "a/./b", "a/space /b", "a\x00bad", "a\nb", p.BACKEND,
+                     p.BACKEND.upper(), "vllm/_C.abi3.so/child", "other.dist-info/METADATA"):
+            with self.subTest(name=name):
+                self.fixture(extra=[(name, b"bad")])
+                self.assert_rejected()
+
+    def test_symlink_and_special_file(self):
+        for mode in (stat.S_IFLNK, stat.S_IFIFO, stat.S_IFCHR):
+            self.fixture()
+            with zipfile.ZipFile(self.wheel, "a") as wheel:
+                info = zipfile.ZipInfo("link")
+                info.create_system = 3
+                info.external_attr = (mode | 0o777) << 16
+                wheel.writestr(info, b"../outside")
+            self.assert_rejected("symlink or special")
+
+    def test_record_hash_size_coverage_and_duplicates(self):
+        edits = [
+            lambda rows: rows.__setitem__(0, (rows[0][0], p.record_hash("00" * 32), rows[0][2])),
+            lambda rows: rows.__setitem__(0, (rows[0][0], rows[0][1], "999")),
+            lambda rows: rows.pop(0),
+            lambda rows: rows.append(rows[0]),
+            lambda rows: rows.append(("ghost", "", "")),
+            lambda rows: rows.__setitem__(-1, (p.RECORD, "sha256=bad", "0")),
+            lambda rows: rows.__setitem__(0, (rows[0][0], "", rows[0][2])),
+        ]
+        for edit in edits:
+            self.fixture(record_edit=edit)
+            self.assert_rejected()
+
+    def test_streamed_binary_hash_failure_cleans_owned_temps(self):
+        def corrupt(rows):
+            for i, row in enumerate(rows):
+                if row[0].endswith(".so"):
+                    rows[i] = (row[0], p.record_hash("00" * 32), row[2])
+        self.fixture(record_edit=corrupt)
+        self.assert_rejected("RECORD hash/size mismatch")
+
+    def test_unknown_backend_version_and_metadata(self):
+        for changes in (
+            {p.BACKEND: b"unrecognized"},
+            {p.VERSION_FILE: VERSION_SOURCE.replace(b"gee0da84ab", b"gunknown0")},
+            {p.VERSION_FILE: VERSION_SOURCE.replace(b"(0, 24, 0)", b"(0, 23, 0)")},
+            {p.VERSION_FILE: VERSION_SOURCE + b"raise RuntimeError('never run')\n"},
+            {p.VERSION_FILE: VERSION_SOURCE + b"version = '0.24.0'\n"},
+            {p.DIST + "/METADATA": b"Name: vllm\nVersion: 0.25.0\n\n"},
+            {p.DIST + "/METADATA": b"Name: vllm\nVersion: 0.24.0\nVersion: 0.24.0\n\n"},
+            {p.DIST + "/WHEEL": b"Wheel-Version: 1.0\nTag: py3-none-any\n"},
+            {p.DIST + "/RECORD.jws": b"signature"},
+        ):
+            self.fixture(changes)
+            self.assert_rejected()
+
+    def test_size_bounds(self):
+        self.fixture()
+        for field in ("MAX_ARCHIVE", "MAX_CENTRAL", "MAX_ENTRIES", "MAX_MEMBER", "MAX_TOTAL", "MAX_SMALL"):
+            with self.subTest(field=field), mock.patch.object(p, field, 1):
+                self.assert_rejected()
+
+    def test_no_overwrite_and_cleanup_publication_race(self):
+        self.fixture()
+        wheel, sidecar = self.run_package()
+        saved = (wheel.read_bytes(), sidecar.read_bytes())
+        with self.assertRaisesRegex(p.InvalidWheel, "output already exists"):
+            self.run_package()
+        self.assertEqual((wheel.read_bytes(), sidecar.read_bytes()), saved)
+        wheel.unlink()
+        sidecar.unlink()
+        real_link = p.os.link
+
+        def race(source, destination):
+            if str(destination).endswith(".json"):
+                Path(destination).write_bytes(b"other owner")
+            real_link(source, destination)
+
+        with mock.patch.object(p.os, "link", side_effect=race):
+            with self.assertRaises(FileExistsError):
+                self.run_package()
+        self.assertFalse(wheel.exists())
+        self.assertEqual(sidecar.read_bytes(), b"other owner")
+        self.assertEqual(list(self.output.iterdir()), [sidecar])
+
+    def test_large_members_are_streamed(self):
+        self.fixture()
+        original_read = zipfile.ZipExtFile.read
+
+        def bounded_read(stream, size=-1):
+            if stream.name.endswith(".so"):
+                self.assertGreater(size, 0)
+                self.assertLessEqual(size, p.CHUNK)
+            return original_read(stream, size)
+
+        with mock.patch.object(zipfile.ZipExtFile, "read", bounded_read):
+            self.run_package()
+
+    def test_minimal_export_source_and_pinned_identity(self):
+        source = self.root / "source"
+        backend = source / p.BACKEND
+        backend.parent.mkdir(parents=True)
+        backend.write_bytes(NEW)
+        manifest = source / "vllm-specmeta-source.json"
+        identity = {"base_commit": p.BASE_COMMIT, "fix_commit": p.FIX_COMMIT,
+                    "backend_sha256": p.NEW_BACKEND_SHA}
+        manifest.write_text(json.dumps(identity))
+        with mock.patch.object(p, "git", side_effect=AssertionError("no git for export")):
+            self.assertEqual(p.fixed_source(source), NEW)
+        for key in identity:
+            manifest.write_text(json.dumps({**identity, key: "wrong"}))
+            with self.assertRaisesRegex(p.InvalidWheel, "identity mismatch"):
+                p.fixed_source(source)
+        manifest.write_text(json.dumps(identity))
+        backend.write_bytes(OLD)
+        with self.assertRaisesRegex(p.InvalidWheel, "backend SHA256"):
+            p.fixed_source(source)
+
+    def test_sparse_git_source_identity_and_index(self):
+        source = self.root / "source"
+        backend = source / p.BACKEND
+        backend.parent.mkdir(parents=True)
+        backend.write_bytes(NEW)
+        (source / ".git").mkdir()
+        blob = p.hashlib.sha1(b"blob " + str(len(NEW)).encode() + b"\0" + NEW).hexdigest().encode()
+        replies = [p.FIX_COMMIT.encode(), p.BASE_COMMIT.encode(),
+                   b"100644 blob " + blob + b"\t" + p.BACKEND.encode() + b"\0",
+                   b"100644 " + blob + b" 0\t" + p.BACKEND.encode() + b"\0"]
+        for mode in (b"100644", b"100755"):
+            for local_mode in (0o644, 0o755):
+                backend.chmod(local_mode)
+                matching = [row.replace(b"100644", mode) for row in replies]
+                with self.subTest(git_mode=mode, local_mode=local_mode):
+                    with mock.patch.object(p, "git", side_effect=matching):
+                        self.assertEqual(p.fixed_source(source), NEW)
+        mismatched_index = replies.copy()
+        mismatched_index[-1] = mismatched_index[-1].replace(b"100644", b"100755")
+        with mock.patch.object(p, "git", side_effect=mismatched_index):
+            with self.assertRaisesRegex(p.InvalidWheel, "index is not clean"):
+                p.fixed_source(source)
+        for i in range(len(replies)):
+            changed = replies.copy()
+            changed[i] = b"wrong"
+            with mock.patch.object(p, "git", side_effect=changed):
+                with self.assertRaises(p.InvalidWheel):
+                    p.fixed_source(source)
+
+
+if __name__ == "__main__":
+    unittest.main()

vllm-0.24.0+mayhem.specmeta1-cp38-abi3-manylinux_2_28_aarch64.whl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:edd083a50cc8469ec5ebf347dbe73236d8cd988b63ed63ca49f4e7a7b7480e39
+size 614981674

vllm-0.24.0+mayhem.specmeta1-cp38-abi3-manylinux_2_28_aarch64.whl.provenance.json

@@ -0,0 +1,72 @@
+{
+  "backend": {
+    "original_sha256": "ce9071eade3d1a9c7dc9dd9f187212599e1c20058ffda901d6950b9dcde19913",
+    "path": "vllm/v1/attention/backends/flashinfer.py",
+    "sha256": "01678024fc88e5f031b866fd6affbb0d82917c271938d8c5878fa0e68c023ab5"
+  },
+  "base_commit": "ee0da84ab9e04ac7610e28580af62c365e898389",
+  "changed_members": [
+    {
+      "original": "vllm-0.24.0.dist-info/METADATA",
+      "original_sha256": "142e542d132be54f21f696c35ef841b90f92427d3bf1dbdc9a08d16e343daacd",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/METADATA",
+      "sha256": "927c5856499e96b08e92164e802a1059af52a35d2326a621a83e6123600f91ec"
+    },
+    {
+      "original": "vllm-0.24.0.dist-info/RECORD",
+      "original_sha256": "cd774ecdf7dab4820deb22c2001da67eb3928af88a78e6952ca4dc7b01b39faf",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/RECORD",
+      "sha256": "615ab38a86f63077d5abf9c7b604c8f30949635556d5cba9a106e1cff11d80bc"
+    },
+    {
+      "original": "vllm-0.24.0.dist-info/WHEEL",
+      "original_sha256": "3ccf5124a5e39af4379a4a0bf5c8922613862738afe138af2497b555c331d397",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/WHEEL",
+      "sha256": "3ccf5124a5e39af4379a4a0bf5c8922613862738afe138af2497b555c331d397"
+    },
+    {
+      "original": "vllm-0.24.0.dist-info/entry_points.txt",
+      "original_sha256": "37761e1ffd913d6e1859b7450911af4e6275a92ccbb319657c28e951fe5ee140",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/entry_points.txt",
+      "sha256": "37761e1ffd913d6e1859b7450911af4e6275a92ccbb319657c28e951fe5ee140"
+    },
+    {
+      "original": "vllm-0.24.0.dist-info/licenses/LICENSE",
+      "original_sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/licenses/LICENSE",
+      "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    },
+    {
+      "original": "vllm-0.24.0.dist-info/top_level.txt",
+      "original_sha256": "7c081bf0fb78cd0a0a4d40376672842207238742fdeff7701236034cbe4c104a",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/top_level.txt",
+      "sha256": "7c081bf0fb78cd0a0a4d40376672842207238742fdeff7701236034cbe4c104a"
+    },
+    {
+      "original": "vllm/_version.py",
+      "original_sha256": "763ed234b0648da39d230104ca1afb879dd874d64a4fb6363a43a73649592804",
+      "output": "vllm/_version.py",
+      "sha256": "be5e443590a7da3d2f8b1c50f0c4d29a357fd0d8f95dc682abf21b3948b445ca"
+    },
+    {
+      "original": "vllm/v1/attention/backends/flashinfer.py",
+      "original_sha256": "ce9071eade3d1a9c7dc9dd9f187212599e1c20058ffda901d6950b9dcde19913",
+      "output": "vllm/v1/attention/backends/flashinfer.py",
+      "sha256": "01678024fc88e5f031b866fd6affbb0d82917c271938d8c5878fa0e68c023ab5"
+    }
+  ],
+  "fix_commit": "9a9cbb67ac23d78cf7384650b561ce7b122f770b",
+  "output_wheel": {
+    "filename": "vllm-0.24.0+mayhem.specmeta1-cp38-abi3-manylinux_2_28_aarch64.whl",
+    "sha256": "edd083a50cc8469ec5ebf347dbe73236d8cd988b63ed63ca49f4e7a7b7480e39",
+    "size": 614981674
+  },
+  "schema_version": 1,
+  "upstream_version": "0.24.0",
+  "upstream_wheel": {
+    "filename": "vllm-0.24.0-cp38-abi3-manylinux_2_28_aarch64.whl",
+    "sha256": "700db71c3cf14697d42583521f38b12fac38db1e7a8ad062e8e4d63a5dadebd5",
+    "size": 271361241
+  },
+  "version": "0.24.0+mayhem.specmeta1"
+}

vllm-0.24.0+mayhem.specmeta1-cp38-abi3-manylinux_2_28_x86_64.whl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15b03d4d57e971627349dfc72275f2806457334d934cc1e29dfbd4d616d5a058
+size 638028744

vllm-0.24.0+mayhem.specmeta1-cp38-abi3-manylinux_2_28_x86_64.whl.provenance.json

@@ -0,0 +1,72 @@
+{
+  "backend": {
+    "original_sha256": "ce9071eade3d1a9c7dc9dd9f187212599e1c20058ffda901d6950b9dcde19913",
+    "path": "vllm/v1/attention/backends/flashinfer.py",
+    "sha256": "01678024fc88e5f031b866fd6affbb0d82917c271938d8c5878fa0e68c023ab5"
+  },
+  "base_commit": "ee0da84ab9e04ac7610e28580af62c365e898389",
+  "changed_members": [
+    {
+      "original": "vllm-0.24.0.dist-info/METADATA",
+      "original_sha256": "142e542d132be54f21f696c35ef841b90f92427d3bf1dbdc9a08d16e343daacd",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/METADATA",
+      "sha256": "927c5856499e96b08e92164e802a1059af52a35d2326a621a83e6123600f91ec"
+    },
+    {
+      "original": "vllm-0.24.0.dist-info/RECORD",
+      "original_sha256": "faedfff053a871980816cea1bc6b20aea1108b8fb2e951047c196a6548e9e6c5",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/RECORD",
+      "sha256": "24b119b527f4bf89dcf16199aef88f90222e6718a64adae6bf80940b33a204fd"
+    },
+    {
+      "original": "vllm-0.24.0.dist-info/WHEEL",
+      "original_sha256": "3195b844c385a39b126f4c647a4bee9c534d9bc9d95a3025edc887ed33933941",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/WHEEL",
+      "sha256": "3195b844c385a39b126f4c647a4bee9c534d9bc9d95a3025edc887ed33933941"
+    },
+    {
+      "original": "vllm-0.24.0.dist-info/entry_points.txt",
+      "original_sha256": "37761e1ffd913d6e1859b7450911af4e6275a92ccbb319657c28e951fe5ee140",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/entry_points.txt",
+      "sha256": "37761e1ffd913d6e1859b7450911af4e6275a92ccbb319657c28e951fe5ee140"
+    },
+    {
+      "original": "vllm-0.24.0.dist-info/licenses/LICENSE",
+      "original_sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/licenses/LICENSE",
+      "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"
+    },
+    {
+      "original": "vllm-0.24.0.dist-info/top_level.txt",
+      "original_sha256": "7c081bf0fb78cd0a0a4d40376672842207238742fdeff7701236034cbe4c104a",
+      "output": "vllm-0.24.0+mayhem.specmeta1.dist-info/top_level.txt",
+      "sha256": "7c081bf0fb78cd0a0a4d40376672842207238742fdeff7701236034cbe4c104a"
+    },
+    {
+      "original": "vllm/_version.py",
+      "original_sha256": "763ed234b0648da39d230104ca1afb879dd874d64a4fb6363a43a73649592804",
+      "output": "vllm/_version.py",
+      "sha256": "be5e443590a7da3d2f8b1c50f0c4d29a357fd0d8f95dc682abf21b3948b445ca"
+    },
+    {
+      "original": "vllm/v1/attention/backends/flashinfer.py",
+      "original_sha256": "ce9071eade3d1a9c7dc9dd9f187212599e1c20058ffda901d6950b9dcde19913",
+      "output": "vllm/v1/attention/backends/flashinfer.py",
+      "sha256": "01678024fc88e5f031b866fd6affbb0d82917c271938d8c5878fa0e68c023ab5"
+    }
+  ],
+  "fix_commit": "9a9cbb67ac23d78cf7384650b561ce7b122f770b",
+  "output_wheel": {
+    "filename": "vllm-0.24.0+mayhem.specmeta1-cp38-abi3-manylinux_2_28_x86_64.whl",
+    "sha256": "15b03d4d57e971627349dfc72275f2806457334d934cc1e29dfbd4d616d5a058",
+    "size": 638028744
+  },
+  "schema_version": 1,
+  "upstream_version": "0.24.0",
+  "upstream_wheel": {
+    "filename": "vllm-0.24.0-cp38-abi3-manylinux_2_28_x86_64.whl",
+    "sha256": "2d2831aeba311292250df0132dbc4d8e9f42c654536eaec48e6fe58acb1822cf",
+    "size": 279209310
+  },
+  "version": "0.24.0+mayhem.specmeta1"
+}

vllm-specmeta-v1.patch

@@ -0,0 +1,149 @@
+diff --git a/tests/v1/attention/test_flashinfer_metadata_builder.py b/tests/v1/attention/test_flashinfer_metadata_builder.py
+new file mode 100644
+index 0000000..5e85c81
+--- /dev/null
++++ b/tests/v1/attention/test_flashinfer_metadata_builder.py
+@@ -0,0 +1,120 @@
++# SPDX-License-Identifier: Apache-2.0
++# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
++"""Regression tests for FlashInfer's persistent host metadata buffers."""
++
++import unittest
++from itertools import product
++from unittest.mock import MagicMock, patch
++
++import torch
++
++from vllm.config import (
++    AttentionConfig,
++    CUDAGraphMode,
++    ModelConfig,
++    SpeculativeConfig,
++    VllmConfig,
++    set_current_vllm_config,
++)
++from vllm.platforms import current_platform
++from vllm.v1.attention.backends.utils import PerLayerParameters
++from vllm.v1.kv_cache_interface import FullAttentionSpec
++
++
++def check_persistent_host_buffer_pinning(
++    cuda_device: torch.device,
++    use_v2_model_runner: bool,
++    has_speculation: bool,
++    pin_memory: bool,
++):
++    from vllm.v1.attention.backends import flashinfer
++
++    # Mock configuration only: no model config resolution or weight downloads.
++    config = MagicMock(spec=VllmConfig)
++    config.model_config = MagicMock(spec=ModelConfig)
++    config.model_config.dtype = torch.float16
++    config.model_config.max_model_len = 32
++    config.model_config.get_num_attention_heads.return_value = 4
++    config.cache_config = MagicMock()
++    config.scheduler_config = MagicMock(max_num_seqs=2)
++    config.compilation_config = MagicMock(cudagraph_mode=CUDAGraphMode.NONE)
++    config.parallel_config = MagicMock(
++        decode_context_parallel_size=1,
++        dcp_kv_cache_interleave_size=1,
++    )
++    config.attention_config = AttentionConfig(use_trtllm_attention=False)
++    config.use_v2_model_runner = use_v2_model_runner
++    config.speculative_config = (
++        MagicMock(
++            spec=SpeculativeConfig,
++            num_speculative_tokens=1,
++            parallel_drafting=False,
++        )
++        if has_speculation
++        else None
++    )
++    kv_cache_spec = FullAttentionSpec(
++        block_size=16,
++        num_kv_heads=2,
++        head_size=64,
++        dtype=torch.float16,
++    )
++    per_layer_parameters = {
++        "layer.0": PerLayerParameters(
++            window_left=-1, logits_soft_cap=0.0, sm_scale=64**-0.5
++        )
++    }
++
++    # Exercise the real constructor and allocators; only layer registration
++    # and the platform pinning flag are patched. GPU buffers total 36 bytes.
++    with (
++        set_current_vllm_config(config),
++        patch.object(flashinfer, "PIN_MEMORY", pin_memory),
++        patch.object(
++            flashinfer, "get_per_layer_parameters", return_value=per_layer_parameters
++        ),
++    ):
++        builder = flashinfer.FlashInferMetadataBuilder(
++            kv_cache_spec, ["layer.0"], config, cuda_device
++        )
++
++    # V2 and speculative proposals can reuse host metadata while an earlier
++    # asynchronous H2D copy is in flight. Legacy non-spec decoding stays pinned.
++    expected_pinned = pin_memory and not use_v2_model_runner and not has_speculation
++    assert builder.pin_memory is expected_pinned
++    for name in ("paged_kv_indptr", "paged_kv_indices", "paged_kv_last_page_len"):
++        buffer = getattr(builder, name)
++        assert buffer.gpu.device == cuda_device, name
++        assert buffer.cpu.device.type == "cpu", name
++        assert buffer.cpu.is_pinned() is expected_pinned, name
++    assert builder.paged_kv_indptr_cpu_buffer.device.type == "cpu"
++    assert builder.paged_kv_indptr_cpu_buffer.is_pinned() is expected_pinned
++
++
++class TestFlashInferMetadataBuilder(unittest.TestCase):
++    @classmethod
++    def setUpClass(cls):
++        if not current_platform.is_cuda() or not torch.cuda.is_available():
++            raise unittest.SkipTest("Requires CUDA for real pinned host allocations")
++        try:
++            import flashinfer  # noqa: F401
++        except ImportError as exc:
++            raise unittest.SkipTest("Requires FlashInfer") from exc
++
++    def test_persistent_host_buffer_pinning(self):
++        device = torch.device("cuda:0")
++        for use_v2_model_runner, has_speculation, pin_memory in product(
++            (False, True), repeat=3
++        ):
++            with self.subTest(
++                use_v2_model_runner=use_v2_model_runner,
++                has_speculation=has_speculation,
++                pin_memory=pin_memory,
++            ):
++                check_persistent_host_buffer_pinning(
++                    device, use_v2_model_runner, has_speculation, pin_memory
++                )
++
++
++if __name__ == "__main__":
++    unittest.main()
+diff --git a/vllm/v1/attention/backends/flashinfer.py b/vllm/v1/attention/backends/flashinfer.py
+index 8031900..f11a1bd 100755
+--- a/vllm/v1/attention/backends/flashinfer.py
++++ b/vllm/v1/attention/backends/flashinfer.py
+@@ -718,10 +718,14 @@ class FlashInferMetadataBuilder(AttentionMetadataBuilder[FlashInferMetadata]):
+                 "earlier GPUs."
+             )
+         # Preparing persistent buffers
+-        # Since we do not have explicit synchronization in ModelRunnerV2, we do not pin
+-        # reused CPU buffers to avoid a race condition between step N async copies to
+-        # GPU and step N+1 buffer updates.
+-        self.pin_memory = not vllm_config.use_v2_model_runner and PIN_MEMORY
++        # ModelRunnerV2 and speculative proposals can reuse host metadata before
++        # an earlier asynchronous H2D copy completes. Pageable staging prevents
++        # the next proposal's metadata from overwriting that copy's source.
++        self.pin_memory = (
++            PIN_MEMORY
++            and not vllm_config.use_v2_model_runner
++            and speculative_config is None
++        )
+         self.paged_kv_indptr = self._make_buffer(max_num_reqs + 1)
+         self.paged_kv_indptr_cpu_buffer = torch.zeros_like(
+             self.paged_kv_indptr.cpu, pin_memory=self.pin_memory