#!/usr/bin/env python3
"""Pinned, unmerged PEFT extension of the frozen NOL Transformers worker.

Startup and inspect are stdlib-only. CUDA/model work requires the explicit load
command, exact host-owned scope and placement confirmation. Reports are observed
facts, never scientific, promotion, broker or full-base-memory attestations.
"""
import hashlib
import importlib.metadata
import importlib.util
import json
import math
import os
from pathlib import Path
import re
import struct
import sys

sys.dont_write_bytecode = True
VERSION = "omnius.nol.transformers-peft.v2"
BASE_SHA = "ea1950abcceda7d76c5fb54c3b10a73d5756cd947149d4b3b6d7be83ae12ebc0"
PEFT_VERSION = "0.21.2"
PEFT_WHEEL_SHA = "106ab6077ff72c54d21577f9af5970e34bac7582cb14209f7b2b511e322a4eae"
PEFT_FILES = {
    "peft_model.py": "d22a1c50dea7a046ce28e71a79dfc20b1d96a2d238a9b457be6a88b6068e04d5",
    "tuners/lora/layer.py": "9a2688af69fd16cef94fdb08ab0e973b37d7b2a672e64ba2057a01df7e98b7d8",
    "tuners/lora/model.py": "321964321e14ca0d9b4d81c4debcb486bae02193a576755b116ce35252e33555",
    "utils/save_and_load.py": "6afbb53933550a401a19e883ba888f4818eb507f64306f5619a56316b598289b",
}
BASE_PATH = Path(__file__).resolve().parent / "nol-transformers-worker.py"
if BASE_PATH.is_symlink() or hashlib.sha256(BASE_PATH.read_bytes()).hexdigest() != BASE_SHA:
    raise RuntimeError("Frozen Transformers base asset identity changed")
spec = importlib.util.spec_from_file_location("_nol_peft_frozen_base", BASE_PATH)
base = importlib.util.module_from_spec(spec)
spec.loader.exec_module(base)
require, fields, integer, number = base.require, base.fields, base.integer, base.number
Rejected = base.Rejected
ORIGINAL_BUILD = base.runtime_info


def source_pin():
    distribution = importlib.metadata.distribution("peft")
    require(distribution.version == PEFT_VERSION, "Unreviewed PEFT version", "UNSUPPORTED")
    files = {}
    for name, expected in PEFT_FILES.items():
        actual = base.hash_file(Path(distribution.locate_file("peft/" + name)), 4194304)
        require(actual["sha256"] == expected, "Reviewed PEFT source changed", "IDENTITY")
        files[name] = actual
    return {"version": PEFT_VERSION, "reviewedWheelSha256": PEFT_WHEEL_SHA, "files": files}


def runtime_info(lock_path=None, hash_runtime=False, max_bytes=34359738368):
    # ORIGINAL_BUILD hashes the code/native inventory of every installed package,
    # including all PEFT modules, not merely these reviewed loading-path pins.
    info = ORIGINAL_BUILD(lock_path, hash_runtime, max_bytes)
    info.update(schema="omnius.nol.transformers-peft-build.v2", workerVersion=VERSION,
                workerSha256=base.hash_file(Path(__file__).resolve())["sha256"],
                baseWorkerSha256=BASE_SHA, reviewedPeftSource=source_pin())
    return info


base.runtime_info = runtime_info
base.WORKER_VERSION = VERSION


def artifact(ref):
    fields(ref, ("uri", "sha256", "sizeBytes", "mediaType"))
    require(type(ref["sha256"]) is str and base.SHA.fullmatch(ref["sha256"]) and
            ref["uri"] == "omnius-artifact://sha256/" + ref["sha256"], "Invalid full artifact identity")
    integer(ref["sizeBytes"], 1)
    return ref


def read_factors(path, maximum):
    """Exact bounded F32 safetensors parser, with no tensor/framework import."""
    size = path.stat().st_size
    require(8 < size <= maximum, "Adapter safetensors byte limit", "CAPACITY")
    with path.open("rb") as stream:
        data = stream.read(size + 1)
    require(len(data) == size, "Adapter changed during read", "IDENTITY")
    header_size = struct.unpack("<Q", data[:8])[0]
    require(2 <= header_size <= min(4194304, size - 8), "Invalid adapter safetensors header")
    header = base.parse_json(data[8:8 + header_size].decode("utf-8", "strict"))
    require(type(header) is dict and 1 <= len(header) <= 33, "Adapter tensor inventory exceeds bound", "CAPACITY")
    offset, tensors = 0, {}
    for name, value in sorted(header.items(), key=lambda item: item[1].get("data_offsets", [0])[0] if type(item[1]) is dict else -1):
        if name == "__metadata__":
            require(type(value) is dict and all(type(k) is str and type(v) is str for k, v in value.items()), "Invalid safetensors metadata")
            continue
        fields(value, ("dtype", "shape", "data_offsets"))
        require(value["dtype"] == "F32" and type(value["shape"]) is list and len(value["shape"]) == 2,
                "Only matrix F32 LoRA factors are supported", "UNSUPPORTED")
        count = 1
        for dimension in value["shape"]:
            count *= integer(dimension, 1, 1000000)
            require(count * 4 <= maximum, "Adapter tensor byte bound", "CAPACITY")
        bounds = value["data_offsets"]
        require(type(bounds) is list and len(bounds) == 2 and type(bounds[0]) is int and type(bounds[1]) is int and
                bounds[0] == offset and bounds[1] == offset + count * 4 and 8 + header_size + bounds[1] <= size,
                "Overlapping, sparse or out-of-bounds adapter tensor")
        raw = data[8 + header_size + bounds[0]:8 + header_size + bounds[1]]
        require(all(math.isfinite(value[0]) for value in struct.iter_unpack("<f", raw)), "Nonfinite adapter tensor")
        tensors[name] = {"shape": value["shape"], "sha256": base.digest_bytes(raw), "sizeBytes": len(raw)}
        offset = bounds[1]
    require(8 + header_size + offset == size and tensors, "Trailing or missing adapter payload")
    return tensors


def exact_parent_digests(actual, model):
    """Complete declared source closure, never a subset or duplicated lineage."""
    parents = model.get("parents")
    require(type(parents) is list and len(parents) <= 128, "Bounded base ancestry required", "IDENTITY")
    expected = [model["modelDigest"]]
    for parent in parents:
        fields(parent, ("modelDigest",), ("revision",))
        require(type(parent["modelDigest"]) is str and base.SHA.fullmatch(parent["modelDigest"]), "Invalid base ancestor", "IDENTITY")
        expected.append(parent["modelDigest"])
    require(len(expected) == len(set(expected)), "Duplicate/self base ancestry", "IDENTITY")
    return (type(actual) is list and len(actual) == len(expected) and
            all(type(value) is str and base.SHA.fullmatch(value) for value in actual) and
            len(actual) == len(set(actual)) and sorted(actual) == sorted(expected))


def verify_adapter(root, supplied, model, working_limit):
    fields(supplied, ("adapterRoot", "adapterModel", "adapterModelJson", "adapterTensorSitesJson", "moduleBindings", "baseModel", "exportReceipt", "limits"))
    limits = supplied["limits"]
    fields(limits, ("maxAdapterBytes", "maxRank", "maxModules", "maxTargetBytes", "maxAdapterMultiplyAdds"))
    integer(limits["maxAdapterBytes"], 1, 67108864)
    integer(limits["maxRank"], 1, 64)
    integer(limits["maxModules"], 1, 16)
    integer(limits["maxTargetBytes"], 1, 1073741824)
    integer(limits["maxAdapterMultiplyAdds"], 1, 100000000000000)
    require(root.is_absolute() and root.is_dir() and not root.is_symlink() and root.resolve() == root,
            "Exact absolute local adapter root required", "IDENTITY")
    manifest = supplied["adapterModel"]
    require(manifest.get("schema") == "omnius.nol.model.v1" and manifest.get("format") == "lora", "LoRA asset manifest required")
    base.verify_identity(supplied["adapterModelJson"], {k: v for k, v in manifest.items() if k not in ("id", "modelDigest")}, manifest["modelDigest"])
    base.verify_identity(supplied["adapterTensorSitesJson"], manifest["tensorSites"], manifest["architectureMapDigest"])
    require(exact_parent_digests([parent["modelDigest"] for parent in manifest["parents"]], model) and
            all(base.same_json(manifest[key], model[key]) for key in ("architecture", "tokenizerDigest", "chatTemplateDigest", "specialTokens", "contextLength")),
            "Adapter exact base-model parent/semantics mismatch", "IDENTITY")
    paths, total = set(), 0
    require(type(manifest["files"]) is list and 2 <= len(manifest["files"]) <= 4, "Bounded complete adapter file inventory required")
    for part in manifest["files"]:
        fields(part, ("path", "role", "artifact"))
        ref = artifact(part["artifact"])
        require(part["path"] not in paths, "Duplicate adapter file")
        paths.add(part["path"])
        total += ref["sizeBytes"]
        require(total <= limits["maxAdapterBytes"], "Aggregate adapter file byte allowance", "CAPACITY")
        require(base.hash_file(base.safe_path(root, part["path"]), limits["maxAdapterBytes"]) ==
                {"sha256": ref["sha256"], "sizeBytes": ref["sizeBytes"]}, "Adapter file identity mismatch", "IDENTITY")
    actual_paths = set()
    for path in root.rglob("*"):
        require(not path.is_symlink(), "Adapter tree contains a symlink", "IDENTITY")
        if path.is_file():
            actual_paths.add(path.relative_to(root).as_posix())
    require(paths == actual_paths and {"adapter_config.json", "adapter_model.safetensors"} <= paths,
            "Undeclared, missing or nonstandard adapter files", "IDENTITY")
    require(total * 6 + 2097152 <= working_limit, "Adapter pre-parse byte/tensor working admission failed", "CAPACITY")
    config = base.parse_json(base.safe_path(root, "adapter_config.json").read_text("utf-8"))
    base_model = supplied["baseModel"]
    fields(base_model, ("nameOrPath", "revision", "taskType"))
    require(type(base_model["nameOrPath"]) is str and 1 <= len(base_model["nameOrPath"]) <= 400 and
            base_model["nameOrPath"] == base_model["nameOrPath"].strip() and
            type(base_model["revision"]) is str and re.fullmatch("[a-f0-9]{40,64}", base_model["revision"]) and
            base_model["taskType"] == "CAUSAL_LM", "Explicit pinned causal-LM upstream base identity required")
    modules = supplied["moduleBindings"]
    require(type(modules) is list and 1 <= len(modules) <= limits["maxModules"], "Module allowance exceeded", "CAPACITY")
    names, sites = set(), set()
    rank = integer(config.get("r"), 1, limits["maxRank"])
    expected = {"peft_type": "LORA", "task_type": "CAUSAL_LM", "base_model_name_or_path": base_model["nameOrPath"],
                "revision": base_model["revision"], "target_modules": "^(?:" + "|".join(re.escape(value["modulePath"]) for value in sorted(modules, key=lambda item: item["modulePath"])) + ")$",
                "r": rank, "lora_alpha": rank, "lora_dropout": 0, "bias": "none", "fan_in_fan_out": False,
                "inference_mode": True, "init_lora_weights": True, "use_rslora": False, "use_dora": False,
                "rank_pattern": {}, "alpha_pattern": {}}
    require(base.same_json(config, expected), "Only exact standard NOL F32 LoRA config is supported", "UNSUPPORTED")
    tensors = read_factors(base.safe_path(root, "adapter_model.safetensors"), limits["maxAdapterBytes"])
    factor_names, target_bytes, factor_bytes = set(), 0, 0
    geometry = []
    for item in modules:
        fields(item, ("siteId", "modulePath", "moduleType", "layout"))
        require(item["moduleType"] == "torch.nn.Linear" and item["layout"] == "out_in" and
                type(item["modulePath"]) is str and re.fullmatch(r"[A-Za-z_][A-Za-z_0-9]*(?:\.[A-Za-z_0-9]+)*", item["modulePath"]),
                "Only explicitly bound ordinary nn.Linear modules are supported", "UNSUPPORTED")
        require(item["modulePath"] not in names and item["siteId"] not in sites, "Duplicate LoRA module/site")
        names.add(item["modulePath"]); sites.add(item["siteId"])
        site = next((site for site in model["tensorSites"] if site["id"] == item["siteId"]), None)
        require(site is not None and site["kind"] == "parameter" and site["name"] == item["modulePath"] + ".weight" and
                len(site["shape"]) == 2 and site["dtype"] in ("f32", "f16", "bf16"), "Native parameter geometry binding required", "IDENTITY")
        output, input_width = site["shape"]
        for part, shape in (("A", [rank, input_width]), ("B", [output, rank])):
            key = "base_model.model." + item["modulePath"] + ".lora_" + part + ".weight"
            require(key in tensors and tensors[key]["shape"] == shape, "Missing, wrong-shaped or unexpected LoRA factor", "IDENTITY")
            factor_names.add(key); factor_bytes += tensors[key]["sizeBytes"]
        target_bytes += output * input_width * (4 if site["dtype"] == "f32" else 2)
        geometry.append({**item, "parameterName": site["name"], "shape": site["shape"], "dtype": site["dtype"], "rank": rank, "scaling": 1})
    require(set(tensors) == factor_names, "Unexpected LoRA tensor keys", "IDENTITY")
    require(target_bytes <= limits["maxTargetBytes"], "Targeted base hashing byte allowance", "CAPACITY")
    require(total * 2 + factor_bytes * 4 + 2097152 <= working_limit, "Adapter load working byte admission failed", "CAPACITY")
    receipt_ref = artifact(supplied["exportReceipt"])
    receipt_part = next((part for part in manifest["files"] if base.same_json(part["artifact"], receipt_ref)), None)
    require(receipt_part is not None and receipt_ref["mediaType"] == "application/json", "Full export receipt must belong to the adapter manifest", "IDENTITY")
    require(paths == {"adapter_config.json", "adapter_model.safetensors", receipt_part["path"]} and
            receipt_part["path"].endswith(".json"), "Only complete standard adapter assets and their export receipt are supported", "UNSUPPORTED")
    receipt = base.parse_json(base.safe_path(root, receipt_part["path"]).read_text("utf-8"))
    require(receipt.get("schema") == "omnius.nol.lora-export.v1" and receipt.get("parentModelDigest") == model["modelDigest"] and
            exact_parent_digests(receipt.get("parentModelDigests"), model) and
            base.same_json(receipt.get("baseModel"), base_model) and type(receipt.get("recipeDigest")) is str and base.SHA.fullmatch(receipt["recipeDigest"]),
            "Adapter export lineage mismatch", "IDENTITY")
    require(len(manifest["tensorSites"]) == 2 * len(modules) and
            {site["name"] for site in manifest["tensorSites"]} == factor_names and
            all(site["kind"] == "parameter" and site["dtype"] == "f32" and site["shape"] == tensors[site["name"]]["shape"] for site in manifest["tensorSites"]),
            "Adapter manifest factor map mismatch", "IDENTITY")
    return {"manifest": manifest, "config": config, "geometry": geometry, "tensors": tensors, "factorBytes": factor_bytes,
            "targetBytes": target_bytes, "totalBytes": total, "recipeDigest": receipt["recipeDigest"], "exportReceipt": receipt_ref, "limits": limits}


def tensor_sha(tensor, torch):
    require(tensor.is_contiguous(), "Hashing requires an actual contiguous tensor", "IDENTITY")
    raw = tensor.detach().view(torch.uint8).reshape(-1)
    digest = hashlib.sha256()
    # At most one 1MiB CPU chunk plus its bytes copy; never copy a whole 4B model.
    for offset in range(0, raw.numel(), 1048576):
        digest.update(raw[offset:offset + 1048576].cpu().numpy().tobytes())
    return digest.hexdigest()


def storage_identity(parameter):
    return {"object": id(parameter), "data": parameter.data_ptr(), "version": parameter._version,
            "shape": list(parameter.shape), "dtype": str(parameter.dtype), "device": str(parameter.device)}


def attach_peft_model(model, approved, torch, device):
    """Actual PEFT public loading path, also directly testable with CPU Linear.
    Runtime.load itself always uses the frozen approved CUDA/model gate.
    """
    from peft import PeftModel
    from peft.tuners.lora.layer import Linear
    originals = dict(model.named_parameters(remove_duplicate=False))
    identities = {name: storage_identity(parameter) for name, parameter in originals.items()}
    target_hashes = {}
    for item in approved["geometry"]:
        module = model.get_submodule(item["modulePath"])
        require(type(module) is torch.nn.Linear and list(module.weight.shape) == item["shape"] and module.weight.device == torch.device(device),
                "Actual target is not the bound native Linear geometry/device", "IDENTITY")
        require(module.weight.dtype == {"f32": torch.float32, "f16": torch.float16, "bf16": torch.bfloat16}[item["dtype"]],
                "Actual target dtype differs from the parent manifest", "IDENTITY")
        target_hashes[item["parameterName"]] = tensor_sha(module.weight, torch)
    root = approved["root"]
    kwargs = {"adapter_name": "default", "is_trainable": False, "autocast_adapter_dtype": True,
              "low_cpu_mem_usage": False, "local_files_only": True, "ignore_mismatched_sizes": False}
    wrapped = PeftModel.from_pretrained(model, str(root), **kwargs)
    # from_pretrained returns only the model. This second bounded public load
    # returns the actual key diagnostics; no monkeypatch or warning suppression.
    diagnostics = wrapped.load_adapter(str(root), **kwargs)
    require(not diagnostics.missing_keys and not diagnostics.unexpected_keys, "PEFT reported missing or unexpected adapter keys", "IDENTITY")
    loaded_config = wrapped.peft_config["default"]
    actual_config = base.parse_json(json.dumps({key: getattr(loaded_config, key) for key in approved["config"]}))
    require(base.same_json(actual_config, approved["config"]),
            "Actual PEFT configuration differs from the full-hashed source", "IDENTITY")
    wrapped.eval()
    for parameter in wrapped.parameters():
        parameter.requires_grad_(False)
    actual = {name: module for name, module in wrapped.named_modules() if isinstance(module, Linear)}
    expected = {"base_model.model." + item["modulePath"] for item in approved["geometry"]}
    require(set(actual) == expected and set(wrapped.peft_config) == {"default"}, "PEFT inserted undeclared adapter modules", "IDENTITY")
    modules, factors = {}, {}
    for item in approved["geometry"]:
        path = "base_model.model." + item["modulePath"]
        module = actual[path]
        require(type(module) is Linear and not module.merged and not module.merged_adapters and
                module.get_base_layer().weight is originals[item["parameterName"]] and
                set(module.lora_A) == set(module.lora_B) == {"default"} and module.scaling == {"default": 1.0} and
                module.r == {"default": item["rank"]} and not module.use_dora.get("default", False),
                "Unexpected PEFT geometry/scaling/merge state", "IDENTITY")
        modules[item["modulePath"]] = module
        for part in ("A", "B"):
            factor = getattr(module, "lora_" + part)["default"].weight
            key = path + ".lora_" + part + ".weight"
            require(factor.dtype == torch.float32 and factor.device == torch.device(device) and
                    list(factor.shape) == approved["tensors"][key]["shape"] and tensor_sha(factor, torch) == approved["tensors"][key]["sha256"],
                    "Serialized F32 adapter factors changed dtype/bits/device", "IDENTITY")
            factors[key] = factor
    wrapped.base_model.disable_adapter_layers()
    state = {"model": wrapped, "originals": originals, "identities": identities, "targetHashes": target_hashes,
             "modules": modules, "factors": factors, "approved": approved, "device": device}
    verify_state(state, torch, False)
    return state


def verify_state(state, torch, enabled):
    for name, parameter in state["originals"].items():
        require(storage_identity(parameter) == state["identities"][name], "Original base parameter storage/version identity changed", "RESET")
    for name, expected in state["targetHashes"].items():
        require(tensor_sha(state["originals"][name], torch) == expected, "Targeted original base parameter bytes changed", "RESET")
    for module in state["modules"].values():
        require(not module.merged and not module.merged_adapters and module.disable_adapters is (not enabled) and
                module.active_adapters == ["default"],
                "PEFT merged or enabled-state mismatch", "RESET")
    for name, factor in state["factors"].items():
        require(factor.dtype == torch.float32 and factor.device == torch.device(state["device"]) and
                tensor_sha(factor, torch) == state["approved"]["tensors"][name]["sha256"], "PEFT factor mutation/dtype/device mismatch", "RESET")
    return {"schema": "omnius.nol.peft-state.v1", "adapterModelDigest": state["approved"]["manifest"]["modelDigest"],
            "enabled": enabled, "merged": False, "adapterName": "default", "factorDtype": "f32",
            "factorHashes": {name: state["approved"]["tensors"][name]["sha256"] for name in sorted(state["factors"])},
            "targetedBaseWeightHashes": state["targetHashes"], "baseParameterCount": len(state["originals"]),
            "baseParameterIdentityDigest": base.digest_bytes(base.canonical_simple(state["identities"]).encode()),
            "baseProofScope": "all_original_storage_version_identities_and_targeted_full_weight_bytes",
            "fullBaseMemoryBitwiseHashPerformed": False, "retainedCache": False}


class Runtime(base.Runtime):
    def __init__(self):
        super().__init__()
        self.peft_state = None
        self.poisoned = self.closed = False

    def ready(self):
        require(not self.closed and not self.poisoned and self.peft_state is not None, "PEFT worker is closed/poisoned/unloaded", "RESET")
        super().ready()

    def load(self, payload):
        fields(payload, ("checkpointRoot", "artifactRoot", "model", "binding", "gpuUuid", "dtype", "identity", "dependencyLockPath", "limits", "peft"))
        require(not self.closed and not self.poisoned and not self.loaded, "PEFT worker cannot be reloaded", "RESET")
        require(sys.byteorder == "little", "Only explicit little-endian factor hosts are supported", "UNSUPPORTED")
        supplied = payload["peft"]
        root = Path(supplied["adapterRoot"])
        approved = verify_adapter(root, supplied, payload["model"], integer(payload["limits"]["maxWorkingBytes"], 1))
        checkpoint = Path(payload["checkpointRoot"]).resolve(strict=True)
        require(not root.is_relative_to(checkpoint) and not checkpoint.is_relative_to(root), "Adapter/checkpoint roots overlap", "IDENTITY")
        plain = {key: value for key, value in payload.items() if key != "peft"}
        result = super().load(plain)
        try:
            approved["root"] = root
            self.peft_state = attach_peft_model(self.model, approved, self.torch, "cuda:0")
            self.model = self.peft_state["model"]
            # Re-read every immutable source file after PEFT consumption.
            verify_adapter(root, supplied, payload["model"], payload["limits"]["maxWorkingBytes"])
            self.torch.cuda.synchronize()
            result.update(implementation=VERSION, baseWorkerSha256=BASE_SHA,
                          supportedRuntimeOperations=[], supportedParameterOperations=[],
                          supportedAssets=["standard_peft_unmerged_lora"],
                          adapterModelDigest=approved["manifest"]["modelDigest"], sourceRecipeDigest=approved["recipeDigest"],
                          peftState=verify_state(self.peft_state, self.torch, False),
                          operationRestrictions={"nativeRecipes": "unsupported", "tokenScope": "all_computation_positions",
                                                 "parameterMerge": "prohibited", "adapterStorageDtype": "f32",
                                                 "numericalPolicy": "native_peft_f32_low_rank_branch_plus_base_result_cast_to_base_output_dtype"},
                          nativeCapabilityAuthority=False)
            return result
        except BaseException as error:
            base.private_diagnostic(error)
            self.poisoned = True
            raise Rejected("PEFT_LOAD_FAILED", "PEFT load/identity verification failed", True) from error

    def reset(self):
        try:
            if self.peft_state is not None:
                self.peft_state["model"].base_model.disable_adapter_layers()
                state = verify_state(self.peft_state, self.torch, False)
            else:
                state = None
            result = super().reset()
            if state is not None:
                result["peft"] = state
                self.last_reset = result
            return result
        except BaseException as error:
            self.poisoned = True
            raise Rejected("RESET", "PEFT reset could not verify disabled original state", True) from error

    def install(self, recipe):
        require(recipe is None, "Native operation recipes cannot mix with serialized PEFT serving", "UNSUPPORTED")
        return []

    def generate(self, payload):
        self.ready()
        fields(payload, ("messages", "recipe", "recipeIdentityJson", "cacheKeyDigest", "seed", "maxTokens", "decoding", "adapterMode"))
        require(payload["recipe"] is None and payload["recipeIdentityJson"] is None and payload["adapterMode"] in ("disabled", "enabled"),
                "Only explicit disabled/enabled serialized adapter arms are supported", "UNSUPPORTED")
        require(self.last_reset is not None and self.last_reset.get("peft", {}).get("enabled") is False, "Explicit verified disabled reset required", "RESET")
        prompt = self.tokenize({"messages": payload["messages"]})["tokenIds"]
        maximum = integer(payload["maxTokens"], 1, self.limits["maxOutputTokens"])
        positions = sum(len(prompt) + index for index in range(maximum))
        approved = self.peft_state["approved"]
        multiply_adds = sum(positions * item["rank"] * sum(item["shape"]) for item in approved["geometry"])
        working = approved["totalBytes"] * 2 + approved["factorBytes"] * 4 + 2097152 + sum(
            (len(prompt) + maximum) * (item["shape"][1] * 4 + item["rank"] * 8 + item["shape"][0] * 16)
            for item in approved["geometry"])
        require(multiply_adds <= approved["limits"]["maxAdapterMultiplyAdds"] and working <= self.limits["maxWorkingBytes"],
                "Adapter generation arithmetic/working admission failed", "CAPACITY")
        enabled = payload["adapterMode"] == "enabled"
        try:
            verify_state(self.peft_state, self.torch, False)
            if enabled:
                self.model.base_model.enable_adapter_layers()
                for parameter in self.model.parameters(): parameter.requires_grad_(False)
                before = verify_state(self.peft_state, self.torch, True)
                result = super().generate({key: value for key, value in payload.items() if key != "adapterMode"})
            else:
                # Exercise PEFT's documented disabled base path, not a copied
                # model or separately merged checkpoint.
                with self.model.disable_adapter():
                    before = verify_state(self.peft_state, self.torch, False)
                    result = super().generate({key: value for key, value in payload.items() if key != "adapterMode"})
            after = verify_state(self.peft_state, self.torch, False)
            result["native"]["peft"] = {"adapterMode": payload["adapterMode"], "adapterModelDigest": approved["manifest"]["modelDigest"],
                "sourceRecipeDigest": approved["recipeDigest"], "exportReceipt": approved["exportReceipt"],
                "stateAtForward": before, "stateAfter": after, "parameterMergePerformed": False,
                "adapterMultiplyAddsBound": multiply_adds, "adapterWorkingBytesBound": working}
            return result
        except BaseException:
            try: self.reset()
            except BaseException as error:
                self.poisoned = True
                raise Rejected("RESET", "Failed PEFT trial did not settle to disabled state", True) from error
            raise

    def profile(self, payload):
        raise Rejected("UNSUPPORTED", "PEFT observation/backward/native operation recipes are not implemented")

    def close(self):
        if self.closed:
            return {"closed": True, "pid": os.getpid(), "allocationReleaseRequiresHostVerification": True}
        try:
            result = super().close()
            self.peft_state = None
            self.closed = True
            return result
        except BaseException as error:
            self.poisoned = True
            raise Rejected("RESET", "PEFT close failed; process retirement and host settlement required", True) from error


def serve():
    sys.stdout = sys.stderr
    require(0 < base.MAX_FRAME <= 67108864 and all(base.OWNER.values()), "Private ownership and frame bounds required")
    runtime, sequence = Runtime(), 0
    try:
        while True:
            header = base.read_exact(sys.stdin.buffer, 4)
            if header is None: break
            size = struct.unpack(">I", header)[0]
            require(0 < size <= base.MAX_FRAME, "Frame bound exceeded", "CAPACITY")
            raw = base.read_exact(sys.stdin.buffer, size)
            require(raw is not None, "Truncated request")
            request = base.parse_json(raw.decode("utf-8", "strict"))
            fields(request, ("schema", "kind", "sessionId", "jobId", "ownerId", "generation", "id", "action", "payload"))
            require(request["schema"] == base.PROTOCOL and request["kind"] == "request" and
                    all(request[key] == value for key, value in base.OWNER.items()) and request["id"] == sequence + 1,
                    "Owner/generation/sequence mismatch", "IDENTITY")
            sequence += 1
            response = {key: request[key] for key in ("schema", "sessionId", "jobId", "ownerId", "generation", "id", "action")}
            response["kind"] = "response"
            closing = False
            try:
                action, payload = request["action"], request["payload"]
                if action == "hello":
                    fields(payload, ())
                    result = {"protocol": base.PROTOCOL, "workerVersion": VERSION, "workerSha256": base.hash_file(Path(__file__).resolve())["sha256"],
                              "baseWorkerSha256": BASE_SHA, "pid": os.getpid(), "loaded": runtime.loaded,
                              "torchImported": "torch" in sys.modules, "nativeCapabilityAuthority": False}
                elif action in ("inspect", "load", "tokenize", "generate", "profile"):
                    result = getattr(runtime, action)(payload)
                elif action == "confirm_placement": result = runtime.confirm(payload)
                elif action in ("reset", "close"):
                    fields(payload, ()); result = getattr(runtime, action)(); closing = action == "close"
                else: raise Rejected("UNSUPPORTED", "Unknown PEFT worker action")
                response["result"] = result
            except Rejected as error:
                closing = error.fatal or action in ("load", "close") or runtime.poisoned
                response["error"] = {"code": error.code, "message": str(error)[:4096], "fatal": closing}
            except BaseException as error:
                base.private_diagnostic(error); closing = True
                response["error"] = {"code": "RUNTIME_FAILURE", "message": type(error).__name__, "fatal": True}
            encoded = json.dumps(response, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode("utf-8")
            require(len(encoded) <= base.MAX_FRAME, "Response frame bound exceeded", "CAPACITY")
            base.WIRE_OUT.write(struct.pack(">I", len(encoded)) + encoded); base.WIRE_OUT.flush()
            if closing: break
    finally:
        runtime.close()


if __name__ == "__main__":
    try: serve()
    except BaseException as error:
        base.private_diagnostic(error)
        sys.exit(1)
