#!/usr/bin/env python3
"""Versioned head/teacher-forcing extension. No model/framework import until load.

The immutable base asset is verified before its inert stdlib module is loaded.
This reports native facts only; host custody, quota publication, independent
capture validation and capability issuance remain separate authorities.
"""
import hashlib
import importlib.util
import importlib.metadata
import json
import math
import os
from pathlib import Path
import struct
import sys
import uuid

VERSION = "omnius.nol.transformers-research.v1"
BASE_SHA = "ea1950abcceda7d76c5fb54c3b10a73d5756cd947149d4b3b6d7be83ae12ebc0"
TF_VERSION = "5.22.1"
TF_FILES = {
    "modeling_qwen3_5.py": "af05d0acfe79fff8aea1c75f93516a6a72bc80f6f901329a73e66a3866fe1e7c",
    "configuration_qwen3_5.py": "332ea31ed31cc81ddb72da28737e9868a55d295f9f1daa3e0ad0d57d56d4e657",
}
CONFIG_SHA = "ddc63e1c717afa86c865bb5e01313d89d72bb53b97ad4a8a03ba8510c0621670"
FULL_LAYERS = (3, 7, 11, 15, 19, 23, 27, 31)
ROOT = Path(__file__).resolve().parent
BASE_PATH = ROOT / "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_frozen_transformers_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("transformers")
    require(distribution.version == TF_VERSION, "Unreviewed Transformers version", "UNSUPPORTED")
    found = {}
    for name, expected in TF_FILES.items():
        path = Path(distribution.locate_file("transformers/models/qwen3_5/" + name))
        actual = base.hash_file(path, 1048576)
        require(actual["sha256"] == expected, "Reviewed Qwen3.5 source changed", "IDENTITY")
        found[name] = actual
    return {"transformersVersion": TF_VERSION, "files": found}


def runtime_info(lock_path=None, hash_runtime=False, max_bytes=34359738368):
    info = ORIGINAL_BUILD(lock_path, hash_runtime, max_bytes)
    info.update(schema="omnius.nol.transformers-research-build.v1", workerVersion=VERSION,
                workerSha256=base.hash_file(Path(__file__).resolve())["sha256"],
                baseWorkerSha256=BASE_SHA, reviewedSource=source_pin())
    return info


# Only this privately imported module's names change; the frozen file is untouched.
base.runtime_info = runtime_info
base.WORKER_VERSION = VERSION


def head_site(value):
    fields(value, ("id", "kind", "layer", "headCount", "width"))
    layer = integer(value["layer"], 0, 31)
    require(value == {"id": "attention:" + str(layer), "kind": "attention_head", "layer": layer,
                      "headCount": 16, "width": 256} and layer in FULL_LAYERS,
            "Only reviewed full-attention output heads are supported; recurrent heads are distinct", "UNSUPPORTED")
    return value


def check_config(config):
    text = config.get("text_config", {})
    expected = {"model_type": "qwen3_5_text", "num_hidden_layers": 32, "hidden_size": 2560,
                "intermediate_size": 9216, "num_attention_heads": 16, "num_key_value_heads": 4,
                "head_dim": 256, "linear_num_key_heads": 16, "linear_num_value_heads": 32,
                "linear_key_head_dim": 128, "linear_value_head_dim": 128, "vocab_size": 248320}
    require(config.get("model_type") == "qwen3_5" and all(text.get(key) == value for key, value in expected.items()),
            "Unreviewed dense Qwen3.5 layout", "UNSUPPORTED")
    require(text.get("layer_types") == ["full_attention" if layer in FULL_LAYERS else "linear_attention" for layer in range(32)],
            "Explicit attention-layer schedule changed", "IDENTITY")


def artifact_bytes(root, ref, maximum):
    fields(ref, ("uri", "sha256", "sizeBytes", "mediaType"))
    require(base.SHA.fullmatch(ref["sha256"]) and ref["uri"] == "omnius-artifact://sha256/" + ref["sha256"], "Invalid artifact identity")
    size = integer(ref["sizeBytes"], 1, maximum)
    path = base.safe_path(root, ref["sha256"][:2] + "/" + ref["sha256"])
    require(base.hash_file(path, maximum) == {"sha256": ref["sha256"], "sizeBytes": size}, "Artifact changed", "IDENTITY")
    with path.open("rb") as stream:
        data = stream.read(size + 1)
    require(len(data) == size and base.digest_bytes(data) == ref["sha256"], "Artifact changed before consumption", "IDENTITY")
    return data


def publish_capture(root, chunks, maximum, suffix):
    """Bounded raw bytes, exclusive private file, complete SHA and fsync."""
    root = Path(root)
    require(root.is_dir() and not root.is_symlink() and root.resolve() == root, "Private capture root changed", "IDENTITY")
    path = root / ("capture-" + str(uuid.uuid4()) + suffix)
    descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o600)
    digest, size = hashlib.sha256(), 0
    try:
        for source in chunks:
            view = memoryview(source).cast("B")
            for offset in range(0, len(view), 1048576):
                block = view[offset:offset + 1048576]
                require(size + len(block) <= maximum, "Capture storage budget exceeded", "CAPACITY")
                consumed = 0
                while consumed < len(block):
                    wrote = os.write(descriptor, block[consumed:])
                    require(wrote > 0, "Capture write made no progress")
                    consumed += wrote
                digest.update(block)
                size += len(block)
        os.fsync(descriptor)
        require(os.fstat(descriptor).st_size == size, "Capture file changed", "IDENTITY")
    finally:
        os.close(descriptor)
    return {"path": str(path), "sha256": digest.hexdigest(), "sizeBytes": size, "mediaType": "application/octet-stream"}


def forward_admission(tokens, rows, sites, parameters, limits, research):
    """Conservative source-bound eager-forward estimate, not a CUDA allocator guarantee.
    Host must reserve resident model + maxWorkingBytes before dispatch and check
    physical peak separately. No unbudgeted warmup or calibration forward occurs.
    """
    tokens = integer(tokens, 1, min(limits["maxInputTokens"], research["maxForwardTokens"]))
    rows = integer(rows, 1, research["maxRows"])
    sites = integer(sites, 0, 8)
    parameters = integer(parameters, 1, 100000000000)
    logits = rows * 248320 * 4
    heads = sites * 2 * tokens * 4096 * 4
    capture = logits + heads
    require(capture <= research["maxCaptureBytes"] and capture <= limits["maxTensorBytes"], "Forward capture bytes exceed admitted storage", "CAPACITY")
    # Overcount all layer intermediates despite inference_mode, plus recurrent
    # chunk states, attention score workspaces, CPU copies and a fixed margin.
    workspace = (tokens * 32 * (9216 * 16 + 2560 * 32) * 4
                 + ((tokens + 63) // 64) * 24 * 32 * 128 * 128 * 4 * 8
                 + 8 * 16 * tokens * tokens * 4 * 8 + capture * 4 + 512 * 1048576)
    operations = 4 * parameters * tokens + 8 * 16 * tokens * tokens * 256 * 4 + 24 * tokens * 32 * 128 * 128 * 32
    require(workspace <= limits["maxWorkingBytes"], "Conservative peak working-memory admission failed", "CAPACITY")
    require(operations <= research["maxForwardMultiplyAdds"], "Conservative native forward compute admission failed", "CAPACITY")
    return {"forwardInputTokens": tokens, "sampledTokens": 0, "captureBytes": capture,
            "parameterCount": parameters,
            "workingBytesBound": workspace, "multiplyAddsBound": operations,
            "estimatePolicy": "qwen35-dense-eager-conservative-v1"}


class Runtime(base.Runtime):
    def __init__(self):
        super().__init__()
        self.research = self.work_root = None
        self.poisoned = self.closed = False
        self.audit_sites = []
        self.head_captures = {}
        self.teacher_forced = False
        self.parameter_count = 0
        self.compute_dtype = None
        self.capture_bytes_reserved = self.forward_work_reserved = 0

    def ready(self):
        require(not self.poisoned and not self.closed, "Worker is closed or poisoned", "RESET")
        super().ready()

    def inspect(self, payload):
        result = super().inspect(payload)
        if "checkpoint" in result:
            checkpoint = result["checkpoint"]
            check_config(checkpoint["config"])
            for layer in FULL_LAYERS:
                checkpoint["tensorSites"].append({"id": "attention:" + str(layer), "kind": "attention_head",
                                                  "layer": layer, "headCount": 16, "width": 256})
            checkpoint["researchMappingOnly"] = True
            checkpoint["recurrentAttentionHeadsSupported"] = False
        return result

    def load(self, payload):
        fields(payload, ("checkpointRoot", "artifactRoot", "model", "binding", "gpuUuid", "dtype", "identity", "dependencyLockPath", "limits", "research"))
        require(not self.closed and not self.poisoned, "Closed worker cannot be reloaded", "RESET")
        require(sys.byteorder == "little", "Only explicit little-endian raw capture hosts are supported", "UNSUPPORTED")
        research = payload["research"]
        fields(research, ("workRoot", "maxCaptureBytes", "maxRows", "maxForwardTokens", "maxForwardMultiplyAdds"))
        integer(research["maxCaptureBytes"], 1, 67108864)
        integer(research["maxRows"], 1, 16)
        integer(research["maxForwardTokens"], 1, 128)
        integer(research["maxForwardMultiplyAdds"], 1, 100000000000000)
        work = Path(research["workRoot"])
        require(work.is_absolute() and work.is_dir() and not work.is_symlink() and work.resolve() == work,
                "Existing exact private research workRoot required")
        state = work.stat()
        require(state.st_uid == os.getuid() and state.st_mode & 0o077 == 0 and not list(work.iterdir()), "Research workRoot must be empty, owned and mode700")
        for root in (Path(payload["checkpointRoot"]).resolve(), Path(payload["artifactRoot"]).resolve()):
            require(not work.is_relative_to(root) and not root.is_relative_to(work), "Research workRoot overlaps frozen inputs")
        require(base.hash_file(base.safe_path(payload["checkpointRoot"], "config.json"))["sha256"] == CONFIG_SHA,
                "Approved complete Qwen3.5 configuration changed", "IDENTITY")
        head_sites = []
        for site in payload["model"]["tensorSites"]:
            if site["kind"] == "attention_head":
                head_sites.append(head_site(site))
            else:
                require(site["kind"] in ("parameter", "mlp_intermediate", "residual"), "Unsupported declared research site", "UNSUPPORTED")
        require(len(head_sites) == 8 and {site["layer"] for site in head_sites} == set(FULL_LAYERS), "Complete exact full-attention map required", "IDENTITY")
        plain = {key: value for key, value in payload.items() if key != "research"}
        result = super().load(plain)
        try:
            check_config(self.model.config.to_dict())
            for site in head_sites:
                layer = self.layers[site["layer"]]
                attention = getattr(layer, "self_attn", None)
                require(type(attention).__name__ == "Qwen3_5Attention" and not hasattr(layer, "linear_attn") and
                        attention.o_proj.in_features == 4096 and attention.o_proj.out_features == 2560 and
                        attention.q_proj.out_features == 8192 and attention.k_proj.out_features == 1024 and
                        attention.v_proj.out_features == 1024 and attention.head_dim == 256,
                        "Loaded head geometry differs from reviewed source", "IDENTITY")
                self.sites[site["id"]] = site
            self.parameter_count = sum(parameter.numel() for parameter in self.parameters.values())
            self.compute_dtype = payload["dtype"]
            self.research, self.work_root = dict(research), work
            result.update(implementation=VERSION, baseWorkerSha256=BASE_SHA,
                          supportedRuntimeOperations=["ATTENTION_HEAD_GAIN"], supportedParameterOperations=[],
                          supportedObservations=["full_vocabulary_teacher_forced_raw_logits"],
                          parameterCount=self.parameter_count,
                          operationRestrictions={"headStage": "post_sigmoid_gate_pre_output_projection", "headOnlyRecipes": True,
                                                 "factorRange": [0, 4], "recurrentHeads": "unsupported", "backward": "unsupported"},
                          siteIds=sorted(self.sites), nativeCapabilityAuthority=False)
            return result
        except BaseException:
            self.poisoned = True
            raise Rejected("IDENTITY", "Research geometry verification failed after load", True)

    def reset(self):
        require(not self.poisoned and not self.closed, "Poisoned or closed worker cannot reset", "RESET")
        try:
            result = super().reset()
            self.audit_sites, self.head_captures, self.teacher_forced = [], {}, False
            return result
        except BaseException:
            self.poisoned = True
            raise Rejected("RESET", "Research reset failed; worker must retire", True)

    def install(self, recipe):
        operations = [] if recipe is None else recipe["operations"]
        if recipe is not None:
            require(recipe.get("schema") == "omnius.nol.recipe.v1" and recipe["modelDigest"] == self.binding["modelDigest"] and
                    recipe["architectureMapDigest"] == self.binding["architectureMapDigest"], "Recipe/model binding mismatch", "IDENTITY")
        require(type(operations) is list and len(operations) <= 64 and len({op["id"] for op in operations}) == len(operations), "Invalid bounded ordered head operation inventory")
        groups, actual = {}, []
        for operation in operations:
            fields(operation, ("id", "operation", "siteId", "tokenScope", "head", "factor"))
            require(operation["operation"] == "ATTENTION_HEAD_GAIN", "Research recipes support only explicit head gains; mixed hooks/parameters are unsupported", "UNSUPPORTED")
            site = self.sites.get(operation["siteId"])
            require(site and site["kind"] == "attention_head", "Head gain requires a verified full-attention site", "UNSUPPORTED")
            head_site(site)
            integer(operation["head"], 0, 15)
            require(0 <= number(operation["factor"]) <= 4, "Head factor is outside reviewed range", "UNSUPPORTED")
            if self.teacher_forced:
                require(operation["tokenScope"]["kind"] != "generated", "Sampled-generated scope is unavailable in teacher-forced observation", "UNSUPPORTED")
            self.positions(operation["tokenScope"])
            groups.setdefault(site["id"], []).append(operation)
            self.edited[operation["id"]] = set()
            actual.append({"operationId": operation["id"], "operation": "ATTENTION_HEAD_GAIN", "siteId": site["id"],
                           "tokenScope": operation["tokenScope"], "implementation": VERSION + ":post-gate-head-gain",
                           "equivalence": "exact"})
        for site_id in sorted(set(groups) | set(self.audit_sites)):
            site = head_site(self.sites[site_id])
            selected = groups.get(site_id, [])
            def pre(module, args, key=site_id, ops=selected):
                value = args[0]
                require(value.ndim == 3 and tuple(value.shape) == (1, self.sequence_length, 4096), "Head hook geometry changed", "IDENTITY")
                require(str(value.dtype).removeprefix("torch.") == self.compute_dtype, "Head activation precision differs from frozen load", "IDENTITY")
                require(bool(self.torch.isfinite(value).all()), "Head input is nonfinite")
                result = value.clone() if ops else value
                before = value.detach().to(device="cpu", dtype=self.torch.float32).contiguous().clone() if key in self.audit_sites else None
                for op in ops:
                    positions = self.positions(op["tokenScope"])
                    self.edited[op["id"]].update(positions)
                    self.charge(len(positions) * 256)
                    if positions and op["factor"] != 1:
                        begin = op["head"] * 256
                        result[:, positions, begin:begin + 256] = result[:, positions, begin:begin + 256] * op["factor"]
                require(bool(self.torch.isfinite(result).all()), "Head gain produced nonfinite values")
                if before is not None:
                    require(key not in self.head_captures, "Head audit executed more than once", "IDENTITY")
                    self.head_captures[key] = (before, result.detach().to(device="cpu", dtype=self.torch.float32).contiguous().clone())
                return (result, *args[1:])
            self.hooks.append(self.layers[site["layer"]].self_attn.o_proj.register_forward_pre_hook(pre))
        return actual

    def generate(self, payload):
        # Generation requires its own pre-forward accounting; do not inherit a
        # base action whose whole-forward admission was not designed here.
        raise Rejected("UNSUPPORTED", "Research v1 is forward-observation-only; generation and backward need separate validation")

    def reserve_forward(self, admission, recipe):
        edit_work = sum(len(self.positions(operation["tokenScope"])) * 256 for operation in ([] if recipe is None else recipe["operations"]))
        require(edit_work <= self.limits["maxMultiplyAdds"], "Head arithmetic exceeds admitted budget before forward", "CAPACITY")
        total_work = admission["multiplyAddsBound"] + edit_work
        require(self.forward_work_reserved + total_work <= self.research["maxForwardMultiplyAdds"], "Cumulative forward compute budget exceeded", "CAPACITY")
        require(self.capture_bytes_reserved + admission["captureBytes"] <= self.research["maxCaptureBytes"], "Cumulative capture storage budget exceeded", "CAPACITY")
        # Reserve conservatively before CUDA computation. Failure, reset,
        # and publication errors cannot refund already dispatched work.
        self.forward_work_reserved += total_work
        self.capture_bytes_reserved += admission["captureBytes"]
        admission.update(headMultiplyAdds=edit_work, cumulativeMultiplyAddsReserved=self.forward_work_reserved,
                         cumulativeCaptureBytesReserved=self.capture_bytes_reserved)

    def profile(self, payload):
        self.ready()
        fields(payload, ("mode", "sourceArtifact", "recipe", "recipeIdentityJson", "captureHeadSiteIds"))
        require(payload["mode"] == "conditional_distributions", "Unknown research profile mode", "UNSUPPORTED")
        require(not self.hooks and not self.backups and self.last_reset is not None and self.cache_key is None, "Explicit clean reset required", "RESET")
        source = base.parse_json(artifact_bytes(self.artifact_root, payload["sourceArtifact"], self.limits["maxTensorBytes"]).decode("utf-8", "strict"))
        fields(source, ("schema", "messages", "inputIds", "positionIds", "vocabulary", "inputTokenCount", "promptTokenCount", "prefixTokenCounts", "tokenizerDigest", "chatTemplateDigest"))
        require(source["schema"] == "omnius.nol.teacher-forced-input.v1" and source["tokenizerDigest"] == self.binding["tokenizerDigest"] and
                source["chatTemplateDigest"] == self.binding["chatTemplateDigest"], "Teacher-forced source identity mismatch", "IDENTITY")
        count = integer(source["inputTokenCount"], 1, self.research["maxForwardTokens"])
        prompt_count = integer(source["promptTokenCount"], 1, count)
        ids_bytes = artifact_bytes(self.artifact_root, source["inputIds"], self.limits["maxTensorBytes"])
        position_bytes = artifact_bytes(self.artifact_root, source["positionIds"], self.limits["maxTensorBytes"])
        require(len(ids_bytes) == len(position_bytes) == count * 4, "Complete u32 input/position bytes required", "IDENTITY")
        ids, positions = list(struct.unpack("<" + "I" * count, ids_bytes)), list(struct.unpack("<" + "I" * count, position_bytes))
        require(all(token < 248320 for token in ids) and positions == list(range(count)), "Invalid vocabulary IDs or noncanonical positions", "UNSUPPORTED")
        prompt = self.tokenize({"messages": source["messages"]})["tokenIds"]
        require(len(prompt) == prompt_count and ids[:prompt_count] == prompt, "Actual rendered prompt differs from frozen teacher-forced IDs", "IDENTITY")
        prefixes = source["prefixTokenCounts"]
        require(type(prefixes) is list and 0 < len(prefixes) <= self.research["maxRows"] and prefixes == sorted(set(prefixes)), "Invalid bounded ordered prediction prefixes")
        for prefix in prefixes:
            integer(prefix, prompt_count, count)
        vocab = base.parse_json(artifact_bytes(self.artifact_root, source["vocabulary"], self.limits["maxTensorBytes"]).decode("utf-8", "strict"))
        fields(vocab, ("schema", "size", "tokenizerDigest", "tokensById"))
        require(vocab["schema"] == "omnius.nol.vocabulary-slots.v1" and vocab["size"] == 248320 and vocab["tokenizerDigest"] == self.binding["tokenizerDigest"] and type(vocab["tokensById"]) is list and len(vocab["tokensById"]) == 248320, "Complete vocabulary slot identity required", "IDENTITY")
        actual_vocab = [[] for _ in range(248320)]
        for token, index in self.tokenizer.get_vocab().items():
            actual_vocab[integer(index, 0, 248319)].append(token)
        for index, tokens in enumerate(actual_vocab):
            require(vocab["tokensById"][index] == sorted(tokens, key=lambda item: item.encode("utf-8")), "Tokenizer/model vocabulary slots changed", "IDENTITY")
        audit = payload["captureHeadSiteIds"]
        require(type(audit) is list and len(audit) <= 8 and len(audit) == len(set(audit)), "Invalid head audit inventory")
        for site_id in audit:
            require(site_id in self.sites, "Unknown head audit site", "IDENTITY")
            head_site(self.sites[site_id])
        admission = forward_admission(count, len(prefixes), len(audit), self.parameter_count, self.limits, self.research)
        recipe = payload["recipe"]
        if recipe is None:
            require(payload["recipeIdentityJson"] is None, "Baseline cannot carry a recipe identity")
        else:
            base.verify_identity(payload["recipeIdentityJson"], {key: value for key, value in recipe.items() if key != "recipeDigest"}, recipe["recipeDigest"])
            require(all(op["siteId"] in audit for op in recipe["operations"]), "Every edited site must have full unchanged-head audit capture")
        before = self.last_reset
        self.prompt_length, self.sequence_length = prompt_count, count
        self.audit_sites, self.teacher_forced = audit, True
        try:
            operations = self.install(recipe)
            self.reserve_forward(admission, recipe)
            self.torch.cuda.synchronize()
            resident = self.torch.cuda.memory_allocated(0)
            self.torch.cuda.reset_peak_memory_stats(0)
            with self.torch.inference_mode():
                inputs = self.torch.tensor([ids], device="cuda:0", dtype=self.torch.long)
                native_positions = self.torch.tensor([positions], device="cuda:0", dtype=self.torch.long)
                selected = self.torch.tensor([prefix - 1 for prefix in prefixes], device="cuda:0", dtype=self.torch.long)
                result = self.model(input_ids=inputs, position_ids=native_positions, attention_mask=self.torch.ones_like(inputs), use_cache=False, logits_to_keep=selected)
                require(result.past_key_values is None and tuple(result.logits.shape) == (1, len(prefixes), 248320), "Full vocabulary or cache geometry changed", "IDENTITY")
                logits = result.logits[0].detach().to(device="cpu", dtype=self.torch.float32).contiguous()
                require(bool(self.torch.isfinite(logits).all()) and set(self.head_captures) == set(audit), "Observation is nonfinite or missed a head hook", "IDENTITY")
                del result, inputs, native_positions, selected
            self.torch.cuda.synchronize()
            peak = max(0, self.torch.cuda.max_memory_allocated(0) - resident)
            require(peak <= admission["workingBytesBound"], "Actual tensor peak exceeded conservative admission", "CAPACITY")
            capture_remaining = admission["captureBytes"]
            tensor_file = publish_capture(self.work_root, [memoryview(logits.numpy()).cast("B")], capture_remaining, ".logits.f32le")
            capture_remaining -= tensor_file["sizeBytes"]
            head_files = []
            for key in sorted(self.head_captures):
                pair = self.head_captures[key]
                files = []
                for value in pair:
                    published = publish_capture(self.work_root, [memoryview(value.numpy()).cast("B")], capture_remaining, ".head.f32le")
                    capture_remaining -= published["sizeBytes"]
                    files.append(published)
                head_files.append({"siteId": key, "shape": [count, 4096], "dtype": "f32", "encoding": "ieee754_le", "before": files[0], "after": files[1]})
            edited = {key: sorted(value) for key, value in self.edited.items()}
            del logits
            after = self.reset()
            return {"schema": "omnius.nol.transformers-research-observation.v1", "sourceArtifact": payload["sourceArtifact"],
                    "inputIds": source["inputIds"], "positionIds": source["positionIds"], "vocabulary": source["vocabulary"],
                    "prefixTokenCounts": prefixes, "promptTokenCount": prompt_count, "inputTokenCount": count,
                    "vocabularySize": 248320, "values": "logits", "stage": "raw_model", "tensorFile": tensor_file,
                    "shape": [len(prefixes), 248320], "dtype": "f32", "encoding": "ieee754_le", "headCaptures": head_files,
                    "computeDtype": self.compute_dtype,
                    "admission": admission, "actualTorchPeakAdditionalBytes": peak, "sampledTokens": 0,
                    "native": {"binding": self.binding, "implementation": VERSION, "baseWorkerSha256": BASE_SHA,
                               "workerSha256": base.hash_file(Path(__file__).resolve())["sha256"],
                               "operations": operations, "editedPositions": edited, "resetBefore": before, "resetAfter": after,
                               "usesCache": False, "recipeDigest": recipe["recipeDigest"] if recipe else None,
                               "nativeCapabilityAuthority": False}}
        except BaseException:
            try:
                self.reset()
            except BaseException:
                self.poisoned = True
                raise Rejected("RESET", "Failed observation cannot reset; worker must retire", True)
            raise

    def close(self):
        require(not self.poisoned, "Poisoned worker must retire; no base action fallback", "RESET")
        try:
            result = super().close()
            self.closed = True
            return result
        except BaseException:
            self.poisoned = True
            raise Rejected("RESET", "Research close failed; worker must retire", True)


def serve():
    sys.stdout = sys.stderr
    require(0 < base.MAX_FRAME <= 67108864 and all(base.OWNER.values()), "Private worker ownership and frame bound required")
    runtime, sequence = Runtime(), 0
    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, "backwardSupported": False, "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 research 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:
            return


if __name__ == "__main__":
    serve()
