Research-Stack/4-Infrastructure/infra/embedded_surface/omni_lut/unified_compression_route.py

#!/usr/bin/env python3
"""Unified nanokernel/metaprobe/compression route selector.

This is a bounded Python shim for the revised GCL path:

    payload -> MS3C/S3C codon -> metaprobe/RGFlow -> LUT route -> compressor

It does not authorize execution. It returns the smallest useful route-prior
decision for the GCL nanokernel to admit/refuse.
"""

from __future__ import annotations

import argparse
import base64
import json
import math
import zlib
from dataclasses import asdict, dataclass
from typing import Any

try:
    from .gcl_motif_lut import MOTIFS
    from .matroska_s3c_reduction_gear import make_codon
    from .possibility_space_probe import evaluate
    from .sequence_surface_lut import SURFACES, normalize_sequence, pack_sequence
except ImportError:
    from gcl_motif_lut import MOTIFS
    from matroska_s3c_reduction_gear import make_codon
    from possibility_space_probe import evaluate
    from sequence_surface_lut import SURFACES, normalize_sequence, pack_sequence


@dataclass(frozen=True)
class PayloadProbe:
    raw_bytes: int
    zlib_bytes: int
    zlib_ratio: float
    byte_diversity: float
    entropy: float
    integer_seed: int
    sequence_surface: str | None


@dataclass(frozen=True)
class RouteDecision:
    surface: str
    motif: str
    witness: str
    compressor: str
    rg_lawful: bool
    score: float
    reason: str


def shannon_entropy(data: bytes) -> float:
    if not data:
        return 0.0
    counts: dict[int, int] = {}
    for byte in data:
        counts[byte] = counts.get(byte, 0) + 1
    total = len(data)
    return -sum((count / total) * math.log2(count / total) for count in counts.values())


def detect_sequence_surface(text: str) -> str | None:
    clean = "".join(ch for ch in text.upper() if not ch.isspace())
    if not clean:
        return None
    for name in ("dna", "rna", "mrna", "hachimoji", "xna"):
        surface = SURFACES[name]
        try:
            normalize_sequence(surface, clean)
        except ValueError:
            continue
        return name
    return None


def probe_payload(data: bytes) -> PayloadProbe:
    compressed = zlib.compress(data, level=6)
    unique = len(set(data))
    seed = int.from_bytes(data[:8].ljust(8, b"\0"), "big") if data else 0
    text = data.decode("utf-8", errors="ignore")
    return PayloadProbe(
        raw_bytes=len(data),
        zlib_bytes=len(compressed),
        zlib_ratio=round(len(compressed) / max(1, len(data)), 6),
        byte_diversity=round(unique / 256.0, 6),
        entropy=round(shannon_entropy(data), 6),
        integer_seed=seed,
        sequence_surface=detect_sequence_surface(text),
    )


def motif_candidate(name: str):
    motif = MOTIFS[name]
    try:
        from .possibility_space_probe import SurfaceCandidate
    except ImportError:
        from possibility_space_probe import SurfaceCandidate

    return SurfaceCandidate(
        name=motif.name,
        family="gcl_motif",
        alphabet_size=motif.alphabet_size,
        bits_per_symbol=motif.bits_per_symbol,
        role_flags=motif.role_flags,
        op_flags=motif.op_flags,
        complement_closed=False,
        closure_kind=motif.closure_kind,
        known_surface=True,
    )


def choose_route(data: bytes, workload: str = "auto") -> dict[str, Any]:
    probe = probe_payload(data)
    ms3c = make_codon(probe.integer_seed)

    if workload == "recovery" or probe.raw_bytes <= 4:
        decision = RouteDecision(
            surface="binary_control_lane",
            motif="gcl_recovery",
            witness="informaton_bind",
            compressor="none",
            rg_lawful=True,
            score=0.95,
            reason="tiny recovery/control payload",
        )
    elif probe.sequence_surface:
        surface = SURFACES[probe.sequence_surface]
        text = data.decode("utf-8", errors="ignore")
        packed = pack_sequence(surface, text)
        motif = "gcl_compression" if len(packed) < probe.zlib_bytes else "gcl_admission"
        eval_result = evaluate(motif_candidate(motif), window_symbols=max(1, len(text)), steps=4)
        decision = RouteDecision(
            surface=probe.sequence_surface,
            motif=motif,
            witness="informaton_bind",
            compressor=f"{probe.sequence_surface}_bitpack",
            rg_lawful=eval_result.lawful_under_flow,
            score=eval_result.score,
            reason="sequence surface detected by finite alphabet",
        )
    elif probe.zlib_ratio < 0.8 and workload not in {"ms3c", "topology"}:
        eval_result = evaluate(motif_candidate("gcl_compression"), window_symbols=max(1, probe.raw_bytes), steps=4)
        decision = RouteDecision(
            surface="byte_payload",
            motif="gcl_compression",
            witness="informaton_bind",
            compressor="zlib_test_then_delta_gcl",
            rg_lawful=eval_result.lawful_under_flow,
            score=eval_result.score,
            reason="payload has ordinary compression structure",
        )
    elif ms3c.shear >= 144:
        eval_result = evaluate(motif_candidate("ms3c_reduction_gear"), window_symbols=max(1, probe.raw_bytes), steps=4)
        decision = RouteDecision(
            surface="ms3c_shell_codon",
            motif="ms3c_reduction_gear",
            witness="informaton_genome",
            compressor="ms3c_route_prior_then_delta_gcl",
            rg_lawful=eval_result.lawful_under_flow,
            score=eval_result.score,
            reason="high shell shear route-prior",
        )
    else:
        eval_result = evaluate(motif_candidate("gcl_admission"), window_symbols=max(1, probe.raw_bytes), steps=4)
        decision = RouteDecision(
            surface="byte_payload",
            motif="gcl_admission",
            witness="informaton_bind",
            compressor="delta_gcl",
            rg_lawful=eval_result.lawful_under_flow,
            score=eval_result.score,
            reason="default admission before expansion",
        )

    return {
        "v": "unified-compression-route-0.1",
        "claim_status": "route_selection_not_execution_authority",
        "workload": workload,
        "probe": asdict(probe),
        "ms3c_codon": asdict(ms3c),
        "decision": asdict(decision),
        "nanokernel_tuple": {
            "surface": decision.surface,
            "motif": decision.motif,
            "witness": decision.witness,
            "compressor": decision.compressor,
        },
        "gcl_required_gate": [
            "OBSERVE",
            "BIND",
            "ROUTE",
            "SIGMA_CHECK",
            "POLICY_CHECK",
            "DAG_CHECK",
            "VERIFY",
            "RECEIPT",
        ],
    }


def parse_payload(args: argparse.Namespace) -> bytes:
    if args.b64:
        return base64.b64decode(args.b64)
    if args.file:
        return args.file.read()
    return args.payload.encode("utf-8")


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("payload", nargs="?", default="")
    parser.add_argument("--file", type=argparse.FileType("rb"))
    parser.add_argument("--b64")
    parser.add_argument("--workload", default="auto")
    args = parser.parse_args()
    data = parse_payload(args)
    print(json.dumps(choose_route(data, args.workload), indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())