#!/usr/bin/env python3
"""Inert ownership/admission companion for a proposed eager vLLM startup worker.

Only the lazy native-worker factory imports NNsight. CPU fixture classes may be
passed directly; that seam is not a native compatibility or placement proof.
Routine calls are not physical CUDA-kernel counts. Unknown work is rejected.
"""
import contextlib
import hashlib
import importlib.metadata
import importlib.util
import json
import math
import os
from pathlib import Path
import re
import select
import stat
import struct
import sysconfig
import time

VERSION = "omnius.nol.vllm-startup.v2"
PRIVATE = "omnius.nol.vllm-private.v1"
SHA = re.compile(r"^[a-f0-9]{64}$")
GPU = re.compile(r"^GPU-[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$", re.I)
ROUTINES = ("block_table_warmup", "kv_zeroer_warmup", "qwen_causal_conv1d", "qwen_post_conv_1", "qwen_post_conv_2", "qwen_post_conv_16", "qwen_gating_delta", "sampler_warmup")
# This is a source-owned designation boundary, never a request/environment flag.
# Root must install an exact reviewed runtime after the user's designation.
NATIVE_RUNTIME_DESIGNATION = {"modelDigest":"ec51c81fe0bd6a94ac364936367a5d2b307ef7482af38232d6e09f47ac989f8a","inventoryDigest":"7e7c60008b3fa872ce219d6847aa56c7972884314918c48d7b0db63fb3e1947d","dependencyLockPath":"/home/roko/Documents/Projects/Adjacent/omnius/omnius/.aiwg/research/sources/vllm-0.27.1/requirements.lock","dependencyLockSha256":"6c074e3ac3817c43e024133c386aa8ca90154151165ac84ed61667ddb7599fe9","maxRuntimeBytes":34359738368,"maxRuntimeFiles":200000}
RUNTIME_SHA = "92998612f884bd49a7823608ae6897c73192344e534176086a0dbd6ec2c2ba89"
EXECUTABLE = re.compile(r"(?:\.py|\.pyc|\.pyd|\.dll|\.dylib|\.ptx|\.cubin|\.pth|\.so(?:\.[0-9]+)*)$", re.I)
SOURCE_PINS = {
    "vllm/platforms/cuda.py": "ea6cade0bc560dcafea09bef8d30249b949e322ed8696ff02c6d20fa250640d2",
    "vllm/utils/mem_utils.py": "c56776468121f217e205df157289bc90a2ea3719d3ce3d63c597efe3cfd66919",
    "vllm/outputs.py": "44e2ea5d8a34403a99a867b42806e8102b3d9e7b1a0f735af26e6650cc482342",
    "vllm/v1/engine/output_processor.py": "7cd99f14e0c0dc5f8cd69100d12489abfddee21d5fb3d6594a713beeefe3cdb0",
    "vllm/v1/metrics/stats.py": "7682d3086bf5395f163f423677485432ee2c035aada2f370c0f82b291e53ca47",
    "vllm/v1/metrics/loggers.py": "d5a91626cf79118f98ae6438c842cb30fc44ca14463c7e2af5871e3da8e51bcf",
    "vllm/v1/worker/worker_base.py": "7da44338c2645ebf03d23394e452b31a8e3da1011fd1b42fcfcccfe99551b3fe",
    "vllm/model_executor/layers/linear.py": "d0662fddc4785419002320a4d9eb5183c9268051ebcf31f1c8276e8529633308",
    "vllm/model_executor/layers/activation.py": "24fa82b26c7be0ff4b9953ee26247eb6bbb7a23bbdc631651ea3978ecc3f79ea",
    "vllm/model_executor/models/qwen3_next.py": "e195dc4d5522a8cce5399cb35d9d96d6e5a0c07bf9460ef6912c840dcb7a6dc9",
    "vllm/model_executor/models/qwen2_moe.py": "a35f10db36c4bdb2a4a6314474512589f73a04d12e69206a633e345b3755d4db",
    "vllm/sampling_params.py": "cc040f9b21e373be3fa5f47c0f3a50e77229dede20cae6a8019f2b7f5ce365cf",
    "vllm/v1/core/sched/scheduler.py": "c67bda2886b52865ddafabaae7d797c359e930752f374421a33e537d94a5f45a",
    "vllm/tokenizers/detokenizer_utils.py": "e17ef23dae7bbb1db5875024c249567b988d8611b560d095c3f786d1e697fe11",
    "vllm/v1/engine/detokenizer.py": "213d71cf6eefcea061b28b656cf8a08af60c9f3513403e724b16876995f3de93",
    "vllm/v1/engine/llm_engine.py": "46caab7b8a09d74321ef7a64683e8019b2187810725c80a15298cf9f51f1df03",
    "vllm/entrypoints/llm.py": "3bb98c9bff8d018902f4352bb5f81f1b4d13276ba1c3f18a9ec11d9a5aa5a57a",
    "nnsight/modeling/vllm/engines/engine.py": "1c8d3bd653c4dca8474339988d9f8fbbf1dd9139d09a12372b2f8fa04b110f34",
    "nnsight/modeling/vllm/workers/GPUWorker.py": "30f29bfb96c7b68a33ed3a6e8d92f40ce1fd9fdcf50d089d3d204acd3ac3dbea",
    "nnsight/modeling/vllm/model_runners/GPUModelRunner.py": "4c1baef9af53eca2d3d6f16a287113c6f7be33125c49a6417cd54f2a3bc0a8ff",
    "nnsight/modeling/vllm/vllm.py": "5d3f77dd7afff4fb6ac31f5fe867f2fcafe2b7abfb1a4d7578b92ce4fbe76b32",
    "vllm/v1/worker/gpu_worker.py": "50134ca3a147f5470e556437cbd40a13ea05b098efbac6553d5ea2f3e5f7ff57",
    "vllm/v1/worker/gpu_model_runner.py": "993f2c926012241bcb8cc7f568c8e82968e4d81ca125641c831ecf501aac02ac",
    "vllm/v1/engine/core.py": "6fdd067f54e5d42c57ff413e292685f5bdf6f343498d85c9262567f1eb746916",
    "vllm/v1/executor/uniproc_executor.py": "4625c8e59aef1482600b02204701d348d7f716427581d3cf23b06bff9b056abe",
    "vllm/model_executor/warmup/kernel_warmup.py": "452ae5db905110df8eb7aac90a93ac80863d166f8ea7d52b8cec02c477477aed",
    "vllm/model_executor/warmup/qwen_triton_warmup.py": "2b08d94662e7b04ce61c0f7a818e0cd1768fe7602a89df04ec6148f62fe3acdb",
    "vllm/model_executor/models/qwen3_5.py": "29a9e4c1d4ac5158b1981a526020ea6ddfe3d0fa0ac70c91c018f273ffc4ec96",
}


class Rejected(RuntimeError):
    def __init__(self, message, code="INVALID", fatal=True):
        super().__init__(message)
        self.code, self.fatal = code, fatal


def require(value, message, code="INVALID"):
    if not value:
        raise Rejected(message, code)


def fields(value, required, optional=()):
    require(type(value) is dict and set(required) <= set(value) and set(value) <= set(required) | set(optional), "Unknown or missing fields")


def integer(value, low, high):
    require(type(value) is int and low <= value <= high, "Integer allowance exceeded", "CAPACITY")
    return value


def canonical(value):
    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False)


def digest(value):
    return hashlib.sha256(canonical(value).encode()).hexdigest()


def finite_json(value):
    if type(value) is dict:
        for child in value.values(): finite_json(child)
    elif type(value) is list:
        for child in value: finite_json(child)
    elif type(value) is float:
        require(math.isfinite(value), "Nonfinite JSON")


def no_duplicates(pairs):
    value = {}
    for key, child in pairs:
        require(key not in value, "Duplicate JSON key")
        value[key] = child
    return value


def parse_json(raw):
    value = json.loads(raw, object_pairs_hook=no_duplicates, parse_constant=lambda _: (_ for _ in ()).throw(Rejected("Nonfinite JSON")))
    finite_json(value)
    return value


def plan(value):
    fields(value, ("schema", "binding", "gpuUuid", "reservedMiB", "requestPolicyDigest", "engine", "limits", "source"))
    require(value["schema"] == VERSION and type(value["gpuUuid"]) is str and GPU.fullmatch(value["gpuUuid"]), "Exact startup version/GPU required")
    integer(value["reservedMiB"], 1024, 131072)
    binding = value["binding"]
    fields(binding, ("schema", "id", "backend", "modelDigest", "architectureMapDigest", "runtimeBuildDigest", "dependencyLockDigest", "tokenizerDigest", "chatTemplateDigest", "contextLimit"))
    require(binding["schema"] == "omnius.nol.runtime.v1" and binding["backend"] == "vllm" and type(binding["id"]) is str and re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.:-]{0,159}", binding["id"]), "Exact vLLM binding required")
    for key in ("modelDigest", "architectureMapDigest", "runtimeBuildDigest", "dependencyLockDigest", "tokenizerDigest", "chatTemplateDigest"):
        require(type(binding[key]) is str and SHA.fullmatch(binding[key]), "Full runtime/model identity required", "IDENTITY")
    integer(binding["contextLimit"], 1, 1048576)
    require(type(value["requestPolicyDigest"]) is str and SHA.fullmatch(value["requestPolicyDigest"]), "Exact request policy digest required", "IDENTITY")
    source = value["source"]
    fields(source, ("workerSha256", "companionSha256", "runtimeSha256"))
    for item in source.values(): require(type(item) is str and SHA.fullmatch(item), "Full worker source identities required", "IDENTITY")
    engine = value["engine"]
    fields(engine, ("dtype", "maxModelLen", "maxNumBatchedTokens", "maxNumSeqs", "kvCacheBytes", "seed", "tensorParallelSize", "pipelineParallelSize", "dataParallelSize", "executor", "enforceEager", "chunkedPrefill", "prefixCaching", "asyncScheduling", "taps", "speculative", "lora", "logStats"))
    require(engine["logStats"] is True, "Native RequestStateStats must be enabled", "UNSUPPORTED")
    require(engine["dtype"] == "bfloat16" and engine["executor"] == "uni" and engine["enforceEager"] is True and
            all(type(engine[key]) is int and engine[key] == 1 for key in ("maxNumSeqs", "tensorParallelSize", "pipelineParallelSize", "dataParallelSize")) and
            all(engine[key] is False for key in ("chunkedPrefill", "prefixCaching", "asyncScheduling", "speculative", "lora")) and engine["taps"] == [],
            "Only bounded sync eager single-rank legacy startup is supported", "UNSUPPORTED")
    integer(engine["maxModelLen"], 1, min(256, binding["contextLimit"]))
    integer(engine["maxNumBatchedTokens"], engine["maxModelLen"], 256)
    integer(engine["kvCacheBytes"], 1048576, min(1073741824, value["reservedMiB"] * 1048576))
    integer(engine["seed"], 0, 4294967295)
    limits = value["limits"]
    fields(limits, ("maxProfileCalls", "maxDummyForwards", "maxForwardPositions", "maxRoutineCalls", "maxRoutinePositions", "maxSamplerDrawRows", "maxCaptureBytes", "maxCaptures", "maxGeneratedTokens", "maxLoadBytes", "maxGateMs"))
    integer(limits["maxProfileCalls"], 1, 2)
    integer(limits["maxDummyForwards"], 1, 4)
    integer(limits["maxForwardPositions"], engine["maxNumBatchedTokens"], 1024)
    integer(limits["maxRoutineCalls"], 1, 64)
    integer(limits["maxRoutinePositions"], 1, 4096)
    integer(limits["maxSamplerDrawRows"], 0, 16)
    require(all(limits[key] == 0 and type(limits[key]) is int for key in ("maxCaptureBytes", "maxCaptures", "maxGeneratedTokens")), "Capture/generation remain unsupported", "UNSUPPORTED")
    integer(limits["maxLoadBytes"], 1, 68719476736)
    integer(limits["maxGateMs"], 1, 900000)
    return parse_json(canonical(value))


def source_inventory():
    versions = {name: importlib.metadata.version(name) for name in ("vllm", "nnsight", "torch", "transformers")}
    require(versions == {"vllm": "0.27.1", "nnsight": "0.8.2", "torch": "2.13.0", "transformers": "5.22.1"} or
            versions == {"vllm": "0.27.1", "nnsight": "0.8.2", "torch": "2.13.0+cu130", "transformers": "5.22.1"}, "Unreviewed runtime versions", "UNSUPPORTED")
    observed = {}
    for name, expected in SOURCE_PINS.items():
        package = name.split("/", 1)[0]
        path = Path(importlib.metadata.distribution(package).locate_file(name))
        require(not path.is_symlink() and path.is_file() and path.stat().st_size <= 4194304, "Unbounded/symlink source pin", "IDENTITY")
        actual = hashlib.sha256(path.read_bytes()).hexdigest()
        require(actual == expected, "Reviewed runtime source changed", "IDENTITY")
        observed[name] = actual
    return {"versions": versions, "sourcePins": observed}


def file_identity(path, remaining):
    """Bounded full bytes, including executable pyc; never import the file."""
    path = Path(path)
    flags = os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK
    fd = os.open(path, flags)
    try:
        before = os.fstat(fd)
        require(stat.S_ISREG(before.st_mode) and 0 <= before.st_size <= remaining, "Runtime inventory file allowance exceeded", "CAPACITY")
        value, count = hashlib.sha256(), 0
        while True:
            block = os.read(fd, min(1048576, remaining - count + 1))
            if not block: break
            count += len(block)
            require(count <= remaining, "Runtime inventory byte allowance exceeded", "CAPACITY")
            value.update(block)
        after = os.fstat(fd)
        require((before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns, before.st_ctime_ns, before.st_mode) ==
                (after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns, after.st_ctime_ns, after.st_mode) and count == before.st_size,
                "Runtime file changed during inventory", "IDENTITY")
        return {"sha256": value.hexdigest(), "sizeBytes": count}
    finally: os.close(fd)


def runtime_inventory(lock_path, expected_lock_sha256, max_bytes, max_files):
    """Full installed executable inventory, not a claim to trace CUDA kernels.

    Python -B does NOT disable reading pyc. Include unlisted cache files under
    every installed code root, wheel metadata, interpreter and relevant env.
    This function is stdlib-only and never imports a framework or creates a model.
    """
    integer(max_bytes, 1, 68719476736); integer(max_files, 1, 400000)
    require(type(lock_path) is str and Path(lock_path).is_absolute() and SHA.fullmatch(expected_lock_sha256 or ""), "Pinned absolute dependency lock required", "IDENTITY")
    spent, seen, stamps, roots = 0, {}, {}, set()

    def stamp(path):
        s = os.stat(path, follow_symlinks=False)
        require(stat.S_ISREG(s.st_mode), "Runtime inventory type changed", "IDENTITY")
        return (s.st_dev, s.st_ino, s.st_size, s.st_mtime_ns, s.st_ctime_ns, s.st_mode)

    def pinned(path):
        nonlocal spent
        path = Path(path)
        require(not path.is_symlink(), "Runtime code symlink is unsupported", "IDENTITY")
        name = str(path.absolute())
        if name in seen: return seen[name]
        require(len(seen) < max_files, "Runtime inventory file allowance exceeded", "CAPACITY")
        before = stamp(path)
        info = file_identity(path, max_bytes - spent)
        require(stamp(path) == before, "Runtime inventory file changed", "IDENTITY")
        spent += info["sizeBytes"]; seen[name], stamps[name] = info, before
        return info

    lock = pinned(lock_path)
    require(lock["sha256"] == expected_lock_sha256, "Dependency lock changed", "IDENTITY")
    executable = pinned(Path(os.path.realpath(os.sys.executable)))
    packages = []
    distributions = sorted(importlib.metadata.distributions(), key=lambda d: str(d.metadata.get("Name", "")).lower())
    require(len(distributions) <= 4096, "Runtime distribution allowance exceeded", "CAPACITY")
    names = set()
    for distribution in distributions:
        name = distribution.metadata.get("Name", "")
        require(type(name) is str and name and name.lower() not in names, "Duplicate/unnamed runtime distribution", "IDENTITY")
        names.add(name.lower()); entries = []
        files = sorted(distribution.files or [], key=str)
        require(files and len(files) <= max_files, "Missing/unbounded wheel inventory", "IDENTITY")
        for relative in files:
            text = str(relative)
            if not (EXECUTABLE.search(text) or text.endswith(("/METADATA", "/WHEEL", "/RECORD", "/entry_points.txt"))): continue
            path = Path(distribution.locate_file(relative))
            entries.append({"path": text, **pinned(path)})
            # Include cache files missing from wheel RECORD. A top-level module
            # contributes its parent; a package contributes its exact code root.
            if text.endswith(".py") and not text.startswith("../"):
                first = Path(text).parts[0]
                root = Path(distribution.locate_file(first))
                roots.add(root if root.is_dir() else root.parent)
        packages.append({"name": name, "version": distribution.version, "files": len(entries), "digest": digest(entries)})
    caches, discovered, walked_roots = [], [], []
    for root in sorted(roots, key=lambda p: (len(p.parts), str(p))):
        if any(root == prior or prior in root.parents for prior in walked_roots): continue
        walked_roots.append(root)
        require(root.is_dir() and not root.is_symlink(), "Runtime code root changed", "IDENTITY")
        # Never follow directory symlinks. Hash all executable cache payloads,
        # including optimized/unrecorded pyc; merely setting -B is insufficient.
        for directory, directories, files in os.walk(root, followlinks=False):
            require(len(directories) + len(files) <= max_files, "Runtime directory allowance exceeded", "CAPACITY")
            for name in directories:
                require(not Path(directory, name).is_symlink(), "Runtime code directory symlink", "IDENTITY")
            for name in sorted(files):
                if EXECUTABLE.search(name):
                    path = Path(directory, name)
                    missing = str(path.absolute()) not in seen
                    entry = {"path": str(path.absolute()), **pinned(path)}
                    if name.endswith(".pyc"): caches.append(entry)
                    if missing: discovered.append(entry)
                    require(len(caches) <= max_files, "Runtime bytecode allowance exceeded", "CAPACITY")
    # Explicit names avoid accidentally disclosing unrelated credentials whose
    # names happen to share a framework prefix. Unknown vLLM execution knobs
    # require review instead of silently changing the frozen engine.
    env_keys = ("PATH", "HOME", "TMPDIR", "LANG", "LC_ALL", "HIP_VISIBLE_DEVICES", "ROCR_VISIBLE_DEVICES", "CUDA_VISIBLE_DEVICES", "CUDA_MODULE_LOADING", "NVIDIA_VISIBLE_DEVICES", "PYTHONPATH", "PYTHONHOME", "PYTHONNOUSERSITE", "PYTHONPYCACHEPREFIX", "PYTHONDONTWRITEBYTECODE", "PYTORCH_CUDA_ALLOC_CONF", "PYTORCH_ALLOC_CONF", "TORCHINDUCTOR_CACHE_DIR", "TRITON_CACHE_DIR", "HF_HUB_OFFLINE", "TRANSFORMERS_OFFLINE", "VLLM_USE_V1", "VLLM_USE_V2_MODEL_RUNNER", "VLLM_ENABLE_V1_MULTIPROCESSING", "VLLM_WORKER_MULTIPROC_METHOD", "VLLM_USE_DEEP_GEMM", "VLLM_USE_FLASHINFER_SAMPLER", "VLLM_DEEP_GEMM_WARMUP", "VLLM_FLASHINFER_AUTOTUNE_SKIP_OPS", "VLLM_TARGET_DEVICE", "VLLM_LOGGING_LEVEL", "VLLM_ATTENTION_BACKEND", "VLLM_PLUGINS", "VLLM_ALLOW_INSECURE_SERIALIZATION")
    require(not any(key.startswith("VLLM_") and key not in env_keys for key in os.environ), "Unreviewed vLLM environment option", "IDENTITY")
    relevant = {key: os.environ[key] for key in env_keys if key in os.environ}
    stdlib = []
    cache_paths = {entry["path"] for entry in caches}
    stdlib_roots = set(Path(p) for key, p in sysconfig.get_paths().items() if key in ("stdlib", "platstdlib"))
    for root in sorted(stdlib_roots, key=str):
        require(root.is_dir() and not root.is_symlink(), "Unreviewed Python stdlib root", "IDENTITY")
        for directory, directories, files in os.walk(root, followlinks=False):
            # Different installations' site-packages are not the active venv.
            # Active installed packages are covered by wheel roots above.
            directories[:] = [name for name in directories if name not in ("site-packages", "dist-packages")]
            require(len(directories) + len(files) <= max_files, "Python stdlib directory allowance exceeded", "CAPACITY")
            for name in directories: require(not Path(directory, name).is_symlink(), "Python stdlib symlink", "IDENTITY")
            for name in sorted(files):
                if EXECUTABLE.search(name):
                    path = Path(directory, name)
                    entry = {"path": str(path.absolute()), **pinned(path)}
                    stdlib.append(entry)
                    if name.endswith(".pyc") and entry["path"] not in cache_paths:
                        caches.append(entry); cache_paths.add(entry["path"])
    library = None
    if sysconfig.get_config_var("Py_ENABLE_SHARED"):
        path = Path(sysconfig.get_config_var("LIBDIR"), sysconfig.get_config_var("LDLIBRARY")).resolve(strict=True)
        library = {"path": str(path), **pinned(path)}
    archives = []
    for item in os.sys.path:
        if item and str(item).endswith((".zip", ".egg")) and Path(item).exists():
            archives.append({"path": str(Path(item).absolute()), **pinned(item)})
    # No generic environment or credentials are emitted; only executable/runtime
    # flags are frozen. CUDA_VISIBLE_DEVICES must still be scoped by the lease.
    require(len(canonical(relevant).encode()) <= 65536, "Runtime environment allowance exceeded", "CAPACITY")
    body = {"schema": "omnius.nol.vllm-runtime-inventory.v1", "pythonVersion": os.sys.version.split()[0],
            "pythonExecutable": executable, "pythonCacheTag": os.sys.implementation.cache_tag,
            "pythonRuntimeLibrary": library, "pythonStdlib": {"files": len(stdlib), "digest": digest(stdlib)},
            "pythonImportArchives": archives, "pythonImportPathDigest": digest(os.sys.path),
            "bytecodeMagic": importlib.util.MAGIC_NUMBER.hex(), "optimization": os.sys.flags.optimize, "isolated": bool(os.sys.flags.isolated), "userSiteDisabled": bool(os.sys.flags.no_user_site), "bytecodeWritesDisabled": bool(os.sys.flags.dont_write_bytecode) and os.sys.dont_write_bytecode,
            "dependencyLock": lock, "packages": packages, "bytecode": {"files": len(caches), "digest": digest(sorted(caches, key=lambda x: x["path"]))},
            "unrecordedExecutable": {"files": len(discovered), "digest": digest(sorted(discovered, key=lambda x: x["path"]))},
            "environment": relevant, "files": len(seen), "bytes": spent,
            "scope": "installed_wheel_code_metadata_stdlib_executable_bytecode_interpreter_and_lock_not_driver_or_future_JIT_artifacts",
            "nativeConformance": "unverified", "capabilityAuthority": "none"}
    for path, expected in stamps.items():
        require(stamp(path) == expected, "Runtime changed during complete inventory", "IDENTITY")
    return {**body, "inventoryDigest": digest(body)}


class Admission:
    def __init__(self, startup):
        self.plan = plan(startup)
        self.phase, self.epoch = "created", 0
        self.counts = {"profileCalls": 0, "dummyForwards": 0, "forwardPositions": 0, "observedModelForwards": 0,
                       "routineCalls": 0, "routinePositions": 0, "samplerDrawRows": 0, "captures": 0,
                       "captureBytes": 0, "generatedTokens": 0, "unknownAttempts": 0}
        self.routines, self.active = [], None
        self.grant_used = False
        self.model_load_wall_seconds = None

    def deny(self, message, code="ADMISSION"):
        self.counts["unknownAttempts"] += 1
        self.phase = "poisoned"
        raise Rejected(message, code)

    def begin_load(self):
        if self.phase != "created": self.deny("Load cannot be replayed")
        self.phase = "loading"

    def resident(self):
        if self.phase != "loading": self.deny("Resident event out of order")
        self.phase = "awaiting_placement"

    def confirm(self):
        if self.phase != "awaiting_placement" or self.grant_used: self.deny("Placement grant out of order or replayed")
        self.grant_used, self.phase = True, "initializing"

    def charge(self, counter, amount, limit):
        if self.phase != "initializing": self.deny("Startup computation precedes actual host placement")
        integer(amount, 0, 1048576)
        if self.counts[counter] + amount > self.plan["limits"][limit]: self.deny("Startup work allowance exhausted: counter=" + counter + " current=" + str(self.counts[counter]) + " request=" + str(amount) + " limit=" + str(self.plan["limits"][limit]), "CAPACITY")
        self.counts[counter] += amount

    @contextlib.contextmanager
    def profile(self):
        self.charge("profileCalls", 1, "maxProfileCalls")
        yield

    @contextlib.contextmanager
    def forward(self, positions):
        if self.active is not None: self.deny("Nested/unclassified model forward")
        self.charge("dummyForwards", 1, "maxDummyForwards")
        self.charge("forwardPositions", integer(positions, 1, self.plan["engine"]["maxNumBatchedTokens"]), "maxForwardPositions")
        self.active = {"kind": "forward", "observed": 0}
        try:
            yield
            if self.active["observed"] != 1: self.deny("Admitted forward was not independently observed exactly once")
        finally:
            self.active = None

    def model_forward(self):
        if self.phase == "request" and getattr(self, "request_bridge", None) is not None:
            return self.request_bridge.observed_root()
        if self.phase != "initializing" or self.active is None or self.active["kind"] != "forward": self.deny("Unclassified real model forward")
        self.active["observed"] += 1
        if self.active["observed"] > 1: self.deny("Multiple real forwards under one admission")
        self.counts["observedModelForwards"] += 1

    @contextlib.contextmanager
    def routine(self, name, positions=0):
        if name not in ROUTINES or self.active is not None: self.deny("Unknown or nested native warmup routine")
        self.charge("routineCalls", 1, "maxRoutineCalls")
        self.charge("routinePositions", positions, "maxRoutinePositions")
        self.routines.append({"name": name, "positions": positions})
        self.active = {"kind": "routine", "name": name}
        try: yield
        finally: self.active = None

    def sampler_draw(self, rows):
        if self.phase == "request" and getattr(self, "request_bridge", None) is not None:
            return self.request_bridge.observed_sampler(rows)
        if self.active is None or self.active.get("name") != "sampler_warmup": self.deny("Unclassified synthetic sampler draw")
        self.charge("samplerDrawRows", rows, "maxSamplerDrawRows")

    def finish(self):
        if self.phase != "initializing" or self.active is not None or self.counts["unknownAttempts"] or self.counts["profileCalls"] < 1 or self.counts["dummyForwards"] < 1 or self.counts["observedModelForwards"] != self.counts["dummyForwards"]: self.deny("Startup cannot finish with unknown/active/unobserved work")
        if getattr(self, "requires_native_startup", False) and not getattr(self, "native_startup_completed", False): self.deny("Actual upstream startup did not complete")
        self.phase = "ready"
        return self.receipt()

    def stop(self):
        self.phase = "stopping"

    def receipt(self):
        return {"schema": "omnius.nol.vllm-startup-observation.v1", "phase": self.phase, "counts": dict(self.counts),
                "routines": list(self.routines), "routineUnit": "logical_native_routine_invocations_not_physical_CUDA_kernel_count",
                "nativeConformance": "unverified", "capabilityAuthority": "none",
                "performance": {"schema": "omnius.nol.vllm-startup-performance.v1", "modelLoadWallSeconds": self.model_load_wall_seconds,
                    "modelLoadDefinition": "monotonic_super_load_model_weights_and_nnsight_envoy_setup_excluding_manual_gates_and_later_warmup",
                    "sharedOncePerWorker": True, "nativeRequestStatsEnabled": True, "memory": None,
                    "memoryUnavailableReason": "no_independent_memory_observer_in_startup_wire"}}


def process_start():
    raw = Path("/proc/self/stat").read_text()
    value = raw[raw.rfind(")") + 2:].split()[19]
    require(value.isdigit() and int(value) > 0, "Process identity unavailable", "IDENTITY")
    return value


def write_frame(fd, value, maximum=65536):
    raw = canonical(value).encode()
    require(0 < len(raw) <= maximum, "Private frame capacity exceeded", "CAPACITY")
    payload = struct.pack(">I", len(raw)) + raw
    while payload:
        count = os.write(fd, payload)
        require(count > 0, "Private channel closed", "CUSTODY")
        payload = payload[count:]


def read_frame(fd, maximum, deadline):
    def exact(size):
        parts = []
        while size:
            remaining = deadline - time.monotonic()
            require(remaining > 0, "Private placement channel timed out; process custody retained", "CUSTODY")
            require(select.select([fd], [], [], remaining)[0], "Private placement channel timed out", "CUSTODY")
            raw = os.read(fd, size)
            require(raw, "Private placement channel closed", "CUSTODY")
            parts.append(raw); size -= len(raw)
        return b"".join(parts)
    size = struct.unpack(">I", exact(4))[0]
    require(0 < size <= maximum, "Private channel frame exceeds allowance", "CAPACITY")
    return parse_json(exact(size).decode("utf8"))


class PrivatePlacement:
    def __init__(self, identity, startup, event_fd=3, grant_fd=4):
        fields(identity, ("sessionId", "jobId", "ownerId", "generation", "loadNonce"))
        require(all(type(identity[key]) is str and 1 <= len(identity[key]) <= 1024 and not any(ord(char) < 32 for char in identity[key]) for key in ("sessionId", "jobId", "ownerId", "loadNonce")), "Bounded private ownership required", "IDENTITY")
        integer(identity["generation"], 1, 9007199254740991)
        require(type(event_fd) is int and type(grant_fd) is int and event_fd > 2 and grant_fd > 2 and event_fd != grant_fd, "Separate inherited private descriptors required", "CUSTODY")
        self.identity, self.startup = dict(identity), plan(startup)
        self.event_fd, self.grant_fd, self.used = event_fd, grant_fd, set()
        for fd in (event_fd, grant_fd):
            mode = os.fstat(fd).st_mode
            require(stat.S_ISFIFO(mode) or stat.S_ISSOCK(mode), "Private inherited pipes required", "CUSTODY")

    def await_grant(self, kind, placement=None):
        require(kind in ("authorize_load", "confirm_placement") and kind not in self.used, "Private authority replay", "CUSTODY")
        self.used.add(kind)
        event = {"schema": PRIVATE, "kind": kind, **self.identity, "pid": os.getpid(), "startIdentity": process_start(),
                 "gpuUuid": self.startup["gpuUuid"], "planDigest": digest(self.startup)}
        if placement is not None: event["resident"] = placement
        write_frame(self.event_fd, event)
        grant = read_frame(self.grant_fd, 65536, time.monotonic() + self.startup["limits"]["maxGateMs"] / 1000)
        require(grant == {**event, "grant": "proceed"}, "Private grant identity/scope/source/replay mismatch", "CUSTODY")
        return event


class NativeSourceGuards:
    """Guards pinned upstream calls in a dedicated one-rank worker process.

    The dependency port admits explicit CPU fixture modules, never a native
    compatibility receipt. No imports or model constructors occur here.
    Accounting is logical model/routine calls; allocations, CUDA initialization
    and internal physical kernel launches are NOT exhaustively traced.
    """
    NOOPS = ("deepseek_v4_mhc_warmup", "flashinfer_sparse_mla_decode_autotune_warmup", "deepseek_v4_sparse_mla_attention_warmup", "minimax_m3_msa_warmup")
    DENIED = ("kimi_k3_triton_warmup", "fa4_cutedsl_warmup", "sparse_mla_triton_warmup", "_warmup_ll_bf16_router_gemm", "cutedsl_warmup", "deep_gemm_warmup", "flashinfer_autotune")

    def __init__(self, controller, torch_module, modules):
        self.controller, self.torch, self.modules = controller, torch_module, dict(modules)
        self.handles, self.patches, self.runner = [], [], None
        self.allocator_peak_observed, self.allocator_reset_calls, self.allocator_available = 0, 0, False
        self.warming, self.started, self.completed, self.armed = False, False, False, False
        self.profile_hook, self.prior_profiler = self._python_forward, None
        self.controller.requires_native_startup = True

    def _patch(self, obj, name, wrapper):
        owner = (obj.__module__ + "." + obj.__qualname__) if isinstance(obj, type) else getattr(obj, "__name__", type(obj).__module__ + "." + type(obj).__qualname__)
        qualified = str(owner)[:384] + "." + str(name)[:128]
        require(hasattr(obj, name), "Pinned native call is missing: " + qualified, "IDENTITY")
        original = getattr(obj, name)
        require(callable(original), "Pinned native call is not callable: " + qualified, "IDENTITY")
        self.patches.append((obj, name, original)); setattr(obj, name, wrapper(original))

    def _module_call(self, module, args):
        c = self.controller
        if c.phase not in ("initializing", "request") or c.active is None: c.deny("Module forward before placement or outside admitted work")

    def _python_forward(self, frame, event, arg):
        # Also catch direct Python .forward() calls that bypass nn.Module's
        # __call__ prehooks during loading. This is deliberately not described
        # as a trace of native C++/CUDA kernels or arbitrary foreign threads.
        if event == "call" and frame.f_code.co_name in ("forward", "forward_native") and frame.f_locals.get("self") is not self.controller:
            if self.controller.phase not in ("initializing", "request") or self.controller.active is None:
                self.controller.deny("Direct forward before placement or outside admitted startup")

    def begin(self, worker):
        require(not self.started, "Native guard cannot be replayed", "CUSTODY")
        self.validate_configuration(worker)
        require(self.controller.phase == "loading", "Guard must precede device initialization", "CUSTODY")
        if not self.armed: self.arm()
        require(os.sys.getprofile() is self.profile_hook, "Startup forward guard changed", "CUSTODY")
        self.started = True

    def arm(self):
        # The real factory arms before an engine constructor can run plugins,
        # worker constructors or weight loading. CPU fixtures may arm in begin.
        require(not self.armed and self.controller.phase == "loading", "Forward guard arming replay", "CUSTODY")
        self.install_allocator_observer()
        self.prior_profiler = os.sys.getprofile()
        require(self.prior_profiler is None, "Foreign Python profiler is unsupported", "UNSUPPORTED")
        os.sys.setprofile(self.profile_hook)
        self.handles.append(self.torch.nn.modules.module.register_module_forward_pre_hook(self._module_call))
        self.install_sampler_guard()
        self.armed = True

    def install_allocator_observer(self):
        cuda = getattr(self.torch, "cuda", None)
        self.allocator_available = cuda is not None and all(callable(getattr(cuda, key, None)) for key in ("current_device", "memory_allocated", "memory_reserved", "max_memory_allocated", "get_allocator_backend"))
        if not self.allocator_available: return
        def reset_wrapper(original):
            def invoke(*args, **kwargs):
                # Preserve upstream's exact resets; add none. The load profiler
                # resets its counter at entry/exit, so retain the earlier peak.
                self.memory_snapshot()
                self.allocator_reset_calls += 1
                require(self.allocator_reset_calls <= 1024, "Allocator reset observation allowance", "CAPACITY")
                return original(*args, **kwargs)
            return invoke
        for api in (cuda, getattr(self.torch, "accelerator", None)):
            if api is not None and callable(getattr(api, "reset_peak_memory_stats", None)):
                self._patch(api, "reset_peak_memory_stats", reset_wrapper)

    def memory_snapshot(self):
        if not self.allocator_available: return None
        cuda = self.torch.cuda
        require(cuda.current_device() == 0, "Allocator snapshot escaped scoped CUDA device", "IDENTITY")
        if cuda.get_allocator_backend() != "native": return None
        allocated, reserved, current_peak = (getattr(cuda, name)(0) for name in ("memory_allocated", "memory_reserved", "max_memory_allocated"))
        for value in (allocated, reserved, current_peak): integer(value, 0, 128 * 1073741824)
        require(reserved >= allocated and current_peak >= allocated, "Allocator observation ordering differs", "IDENTITY")
        self.allocator_peak_observed = max(self.allocator_peak_observed, current_peak)
        return {"schema": "omnius.nol.vllm-cuda-allocator.v1", "logicalDevice": 0, "gpuUuid": self.controller.plan["gpuUuid"], "allocatorBackend": "native",
                "allocatedBytes": allocated, "reservedBytes": reserved, "currentEpochPeakAllocatedBytes": current_peak,
                "observedWorkerPeakAllocatedBytes": self.allocator_peak_observed, "observedPublicPeakResetCalls": self.allocator_reset_calls,
                "scope": "process_torch_cuda_allocator_observed_cumulative_peak_including_load_warmup_and_prior_requests",
                "peakDefinition": "maximum_before_source_reviewed_public_peak_resets_and_current_snapshot_not_driver_or_per_trial_kernel_peak"}

    def validate_configuration(self, worker):
        v, p = worker.vllm_config, self.controller.plan
        parallel, scheduler, cache, model, compilation = v.parallel_config, v.scheduler_config, v.cache_config, v.model_config, v.compilation_config
        require(os.environ.get("VLLM_USE_FLASHINFER_SAMPLER") == "0", "Source-owned native PyTorch GPU sampler changed", "IDENTITY")
        require(str(v.device_config.device) in ("cuda", "cuda:0"), "Only the sole scoped CUDA device is admitted; no CPU fallback", "UNSUPPORTED")
        require(all(getattr(parallel, key) == 1 for key in ("tensor_parallel_size", "pipeline_parallel_size", "data_parallel_size")) and parallel.distributed_executor_backend == "uni", "Only the scoped in-process rank is supported", "UNSUPPORTED")
        require(not getattr(parallel, "enable_eplb", False) and not getattr(parallel, "enable_elastic_ep", False) and not getattr(worker, "use_v2_model_runner", False), "Unreviewed elastic/V2 path", "UNSUPPORTED")
        require(getattr(parallel, "worker_extension_cls", None) in (None, "") and os.environ.get("VLLM_ENABLE_V1_MULTIPROCESSING") == "0" and os.environ.get("VLLM_USE_V2_MODEL_RUNNER") == "0" and os.environ.get("VLLM_PLUGINS") == "", "Unreviewed subprocess/plugin/extension path", "UNSUPPORTED")
        require(str(model.dtype) == "torch.bfloat16" and model.enforce_eager is True and model.quantization is None and model.max_model_len == p["engine"]["maxModelLen"], "Native model precision/context differs", "IDENTITY")
        require(getattr(model.hf_config, "model_type", None) == "qwen3_5" and getattr(model.hf_text_config, "num_hidden_layers", None) == 32 and getattr(model.hf_text_config, "hidden_size", None) == 2560 and not getattr(model.hf_text_config, "num_experts", None), "Only pinned dense Qwen3.5 text geometry is supported", "UNSUPPORTED")
        require(model.multimodal_config is not None and model.multimodal_config.language_model_only is True, "Multimodal profiling needs separate admission", "UNSUPPORTED")
        require(str(getattr(compilation.mode, "name", compilation.mode)) == "NONE" and str(getattr(compilation.cudagraph_mode, "name", compilation.cudagraph_mode)) == "NONE", "Compilation/CUDA graphs are not admitted", "UNSUPPORTED")
        require(scheduler.max_num_seqs == 1 and scheduler.max_num_batched_tokens == p["engine"]["maxNumBatchedTokens"] and not scheduler.enable_chunked_prefill and not getattr(scheduler, "async_scheduling", False), "Unreviewed scheduler geometry", "UNSUPPORTED")
        require(cache.kv_cache_memory_bytes == p["engine"]["kvCacheBytes"] and cache.enable_prefix_caching is False and v.speculative_config is None and v.lora_config is None and v.weight_transfer_config is None, "Unreviewed cache/adapter/weight-transfer path", "UNSUPPORTED")
        require(v.kernel_config.enable_jit_warmup is False and v.kernel_config.enable_cutedsl_warmup is False and v.kernel_config.enable_flashinfer_autotune is False and os.environ.get("VLLM_USE_DEEP_GEMM") == "0", "Unknown JIT/autotune path is not admitted", "UNSUPPORTED")

    def bind(self, runner):
        require(self.started and self.runner is None and self.controller.phase == "loading", "Native observer bind out of order", "CUSTODY")
        require(os.sys.getprofile() is self.profile_hook, "Pre-placement forward guard changed during load", "CUSTODY")
        require(hasattr(runner, "nnsight_model") and hasattr(runner, "nnsight_requests") and hasattr(runner, "nnsight_persistent_objects"), "NNsight load state was not preserved", "IDENTITY")
        topk = getattr(getattr(runner, "sampler", None), "topk_topp_sampler", None)
        expected = self.modules["topk_sampler_type"]
        forward = getattr(topk, "forward", None)
        require(type(topk) is expected and getattr(forward, "__self__", None) is topk and
                getattr(forward, "__func__", None) is expected.forward_native,
                "Actual CUDA top-k/top-p sampler differs from pinned native PyTorch implementation", "IDENTITY")
        self.runner = runner
        self.handles.append(runner.get_model().register_forward_pre_hook(lambda module, args: self.controller.model_forward()))

    def _routine(self, name, positions, original, *args, **kwargs):
        c = self.controller
        # These operators also occur inside an already admitted real forward.
        if c.active is not None and c.active.get("kind") in ("forward", "request"): return original(*args, **kwargs)
        if not self.warming: c.deny("Native routine outside upstream warmup")
        with c.routine(name, positions): return original(*args, **kwargs)

    def install_warmup_calls(self, worker):
        import importlib
        kernel, qwen, post = (self.modules[key] for key in ("kernel", "qwen", "post_conv"))
        self._patch(kernel, "warm_v1_block_table_kernels", lambda original: lambda *a, **k: self._routine("block_table_warmup", 0, original, *a, **k))
        zeroer = getattr(self.runner, "_kv_block_zeroer", None)
        if zeroer is not None:
            self._patch(zeroer, "warmup", lambda original: lambda *a, **k: self._routine("kv_zeroer_warmup", 0, original, *a, **k))
        self._patch(qwen, "_warm_causal_conv1d_fwd_kernel", lambda original: lambda *a, **k: self._routine("qwen_causal_conv1d", 1, original, *a, **k))
        self._patch(qwen, "_warm_fused_sigmoid_gating_delta_rule_update_kernel", lambda original: lambda *a, **k: self._routine("qwen_gating_delta", 1, original, *a, **k))

        def post_wrapper(original):
            def invoke(*args, **kwargs):
                positions = int((args[0] if args else kwargs["conv_output"]).shape[0])
                if positions not in (1, 2, 16) and self.controller.active is None: self.controller.deny("Unreviewed Qwen post-convolution geometry")
                return self._routine("qwen_post_conv_" + str(positions), positions, original, *args, **kwargs)
            return invoke
        self._patch(post, "fused_post_conv_prep", post_wrapper)

        for name in self.NOOPS:
            def wrap_noop(original, name=name):
                def invoke(*args, **kwargs):
                    require(self.warming and worker.vllm_config.model_config.hf_config.model_type == "qwen3_5", "Unreviewed foreign model dispatcher", "UNSUPPORTED")
                    # Pinned upstream Qwen predicates return without kernels.
                    # Execute those predicates instead of skipping dispatcher work.
                    return original(*args, **kwargs)
                return invoke
            # The pinned dispatcher imports MiniMax locally inside its function;
            # patch the real owning module so that import gets this wrapper.
            owner = importlib.import_module("vllm.model_executor.warmup.minimax_m3_msa_warmup") if name == "minimax_m3_msa_warmup" else kernel
            self._patch(owner, name, wrap_noop)
        for name in self.DENIED:
            self._patch(kernel, name, lambda original, name=name: lambda *a, **k: self.controller.deny("Unexpected native warmup branch: " + name))

    def install_sampler_guard(self):
        # Profile_run samples before compile_or_warm_up_model. Install this
        # guard before loading, not only in the later kernel dispatcher.
        def sample_wrapper(original):
            def invoke(instance, *args, **kwargs):
                logits = args[0] if args else kwargs["logits"]
                self.controller.sampler_draw(int(logits.shape[0]))
                return original(instance, *args, **kwargs)
            return invoke
        self._patch(self.modules["sampler_type"], "forward", sample_wrapper)

    @contextlib.contextmanager
    def warmup(self, worker):
        require(self.started and self.runner is worker.model_runner and self.controller.phase == "initializing" and not self.warming and not self.completed, "Warmup before placement or replayed", "CUSTODY")
        self.validate_configuration(worker)
        names = [group.backend.get_name() for groups in self.runner.attn_groups for group in groups]
        require(names and all(name in ("FLASH_ATTN", "GDN_ATTN") for name in names), "Unreviewed attention/warmup dispatcher backend", "UNSUPPORTED")
        require(tuple(self.torch.cuda.get_device_capability()) == (8, 0), "This startup protocol is scoped to A100", "UNSUPPORTED")
        self.install_warmup_calls(worker); self.warming = True
        try:
            yield
            self.completed = self.controller.native_startup_completed = True
        finally: self.warming = False

    def close(self):
        if os.sys.getprofile() is self.profile_hook: os.sys.setprofile(self.prior_profiler)
        for handle in reversed(self.handles): handle.remove()
        self.handles.clear()
        for obj, name, original in reversed(self.patches): setattr(obj, name, original)
        self.patches.clear()


def owned_worker_class(base_worker, runner_type, controller, placement, native_guards=None):
    """Same-instance runner subclass preserves the NNsight replacement/envoys.
    Explicit fake classes exercise order only. They cannot mint native receipts.
    """
    class OwnedRunner(runner_type):
        def profile_run(self):
            with controller.profile(): return super().profile_run()

        def _dummy_run(self, num_tokens, *args, **kwargs):
            require(not kwargs.get("is_graph_capturing"), "CUDA graph capture unsupported", "UNSUPPORTED")
            with controller.forward(num_tokens): return super()._dummy_run(num_tokens, *args, **kwargs)

        def _dummy_sampler_run(self, hidden_states):
            rows = int(hidden_states.shape[0])
            with controller.routine("sampler_warmup", rows): return super()._dummy_sampler_run(hidden_states)

        def execute_model(self, scheduler_output, intermediate_tensors=None):
            bridge = getattr(controller, "request_bridge", None)
            if bridge is None: controller.deny("Generation bridge is not installed", "UNSUPPORTED")
            require(intermediate_tensors is None, "Pipeline tensors unsupported", "UNSUPPORTED")
            bridge.before_execute(scheduler_output)
            with bridge.scope("execute"):
                return super().execute_model(scheduler_output, intermediate_tensors)

        def _model_forward(self, *args, **kwargs):
            bridge = getattr(controller, "request_bridge", None)
            if controller.phase == "initializing": return super()._model_forward(*args, **kwargs)
            require(bridge is not None and not args, "Fixed model-forward bridge required", "CUSTODY")
            with bridge.model_forward(kwargs): return super()._model_forward(**kwargs)

        def sample_tokens(self, *args, **kwargs):
            bridge = getattr(controller, "request_bridge", None)
            require(bridge is not None, "Fixed sampler bridge required", "CUSTODY")
            with bridge.scope("sample"): return super().sample_tokens(*args, **kwargs)

        def _sample(self, *args, **kwargs):
            bridge = getattr(controller, "request_bridge", None)
            require(bridge is not None, "Fixed actual-sample witness required", "CUSTODY")
            with bridge.sampling():
                result = super()._sample(*args, **kwargs)
                bridge.sampled(result)
                return result
        def capture_model(self, *args, **kwargs): controller.deny("CUDA capture is unsupported", "UNSUPPORTED")

    class OwnedWorker(base_worker):
        def init_device(self):
            if native_guards is not None: native_guards.begin(self)
            super().init_device()
            require(type(self.model_runner) is runner_type, "NNsight legacy runner replacement missing", "UNSUPPORTED")
            self.model_runner.__class__ = OwnedRunner

        def load_model(self, *args, **kwargs):
            # Inherits NNsight's existing runner.load_model: one actual load,
            # then its envoy/tokenizer/request state; no replacement constructor.
            started = time.monotonic()
            result = super().load_model(*args, **kwargs)
            elapsed = time.monotonic() - started
            require(math.isfinite(elapsed) and 0 <= elapsed <= 7200, "Model load observation is invalid", "IDENTITY")
            controller.model_load_wall_seconds = elapsed
            if native_guards is not None: native_guards.bind(self.model_runner)
            controller.resident()
            placement.await_grant("confirm_placement")
            controller.confirm()
            return result

        def compile_or_warm_up_model(self):
            # No silent no-op or skipped warmup. This foundation intentionally
            # refuses the still-unvalidated dispatcher before calling it.
            if native_guards is None:
                controller.deny("Native warmup coverage requires separate model-specific conformance", "UNSUPPORTED")
            with native_guards.warmup(self):
                return super().compile_or_warm_up_model()

    return OwnedWorker


def runtime_module():
    # Leaf module is exact-source pinned, stdlib-only and never imports frameworks.
    import sys
    path = Path(__file__).resolve().with_name("nol-vllm-runtime.py")
    require(not path.is_symlink() and path.is_file() and path.stat().st_size <= 1048576 and hashlib.sha256(path.read_bytes()).hexdigest() == RUNTIME_SHA, "Pinned request runtime changed", "IDENTITY")
    name = "_nol_vllm_runtime"
    if name in sys.modules:
        require(getattr(sys.modules[name], "__file__", None) == str(path), "Runtime module collision", "IDENTITY")
        return sys.modules[name]
    spec = importlib.util.spec_from_file_location(name, path)
    module = importlib.util.module_from_spec(spec)
    sys.modules[name] = module
    spec.loader.exec_module(module)
    return module


def native_worker_class(controller, placement):
    # Deliberately hard-unavailable until root installs the exact user-designated
    # runtime. Neither request JSON, a passed flag nor an environment override can
    # install that source-owned designation.
    if NATIVE_RUNTIME_DESIGNATION is None:
        raise Rejected("Native startup activation awaits model-specific conformance; no framework import attempted", "UNSUPPORTED")
    designated = NATIVE_RUNTIME_DESIGNATION
    fields(designated, ("modelDigest", "inventoryDigest", "dependencyLockPath", "dependencyLockSha256", "maxRuntimeBytes", "maxRuntimeFiles"))
    require(isinstance(placement, PrivatePlacement) and "authorize_load" in placement.used and placement.startup == controller.plan, "Actual private load authority required before imports", "CUSTODY")
    require(os.environ.get("VLLM_ENABLE_V1_MULTIPROCESSING") == "0" and os.environ.get("VLLM_USE_V2_MODEL_RUNNER") == "0" and os.environ.get("VLLM_PLUGINS") == "", "Explicit in-process plugin-free runtime required before imports", "UNSUPPORTED")
    require(os.environ.get("VLLM_ALLOW_INSECURE_SERIALIZATION") in (None, "0"), "Insecure generic serialization unsupported", "UNSUPPORTED")
    require(os.environ.get("VLLM_USE_FLASHINFER_SAMPLER") == "0", "Source-owned native PyTorch GPU sampler required before imports", "UNSUPPORTED")
    require(controller.plan["binding"]["modelDigest"] == designated["modelDigest"] and controller.plan["binding"]["runtimeBuildDigest"] == designated["inventoryDigest"] and controller.plan["binding"]["dependencyLockDigest"] == designated["dependencyLockSha256"], "Designated native model/runtime differs", "IDENTITY")
    actual = runtime_inventory(designated["dependencyLockPath"], designated["dependencyLockSha256"], designated["maxRuntimeBytes"], designated["maxRuntimeFiles"])
    require(actual["inventoryDigest"] == designated["inventoryDigest"], "Complete native runtime inventory changed", "IDENTITY")
    require(actual["isolated"] and actual["userSiteDisabled"] and actual["bytecodeWritesDisabled"], "Isolated designated interpreter required before imports", "UNSUPPORTED")
    source_inventory()
    return _materialize_native_worker(controller, placement)


def _materialize_native_worker(controller, placement):
    """Real upstream types; called only behind the source-owned designation.
    Importing these types never constructs an LLM/model here. The initialized
    NNsight runner is subclassed in place by owned_worker_class.
    """
    import importlib
    torch_module = importlib.import_module("torch")
    base = importlib.import_module("nnsight.modeling.vllm.workers.GPUWorker").NNsightGPUWorker
    runner = importlib.import_module("nnsight.modeling.vllm.model_runners.GPUModelRunner").NNsightGPUModelRunner
    modules = {
        "kernel": importlib.import_module("vllm.model_executor.warmup.kernel_warmup"),
        "qwen": importlib.import_module("vllm.model_executor.warmup.qwen_triton_warmup"),
        "post_conv": importlib.import_module("vllm.third_party.flash_linear_attention.ops.fused_gdn_prefill_post_conv"),
        "sampler_type": importlib.import_module("vllm.v1.sample.sampler").Sampler,
        "topk_sampler_type": importlib.import_module("vllm.v1.sample.ops.topk_topp_sampler").TopKTopPSampler,
    }
    guards = NativeSourceGuards(controller, torch_module, modules)
    guards.arm()
    result = owned_worker_class(base, runner, controller, placement, guards)
    result._nol_source_guards = guards
    return _publish_native_worker_class(result)


def _publish_native_worker_class(worker_type):
    """vLLM 0.27.1 accepts a qualified string, not a class object. Uni uses
    this same interpreter/module, preserving the exact private guard closure.
    The symbol is installed once; MP/remote reconstruction is unsupported.
    """
    name = "NolOwnedNNsightGPUWorker"
    require(name not in globals() and isinstance(worker_type, type), "Owned worker class registration replay", "CUSTODY")
    worker_type.__module__, worker_type.__qualname__ = __name__, name
    globals()[name] = worker_type
    return worker_type
