문단과 매체의 순서를 비교하는 합성 원고 검토기

"""Independent synthetic ordered-plan review. No upload, browser or server proof."""
import hashlib
import json
import re
from copy import deepcopy


def fail(code):
    raise ValueError(code)


def shape(value, fields, code):
    if not isinstance(value, dict) or set(value) != set(fields):
        fail(code)


def name(value):
    if not isinstance(value, str) or not value.strip() or len(value) > 240 or any(c in value for c in "/\\\r\n\x00"):
        fail("FILENAME")


def digest(value):
    if not isinstance(value, str) or not re.fullmatch(r"[a-f0-9]{64}", value):
        fail("DIGEST")


def identity(value):
    if not isinstance(value, str) or not re.fullmatch(r"[A-Za-z0-9_-]{1,80}", value):
        fail("IDENTITY")


def validate(raw):
    shape(raw, {"version", "blocks"}, "PLAN_SHAPE")
    if type(raw["version"]) is not int or raw["version"] != 1:
        fail("VERSION")
    blocks = raw["blocks"]
    if not isinstance(blocks, list) or not 3 <= len(blocks) <= 50:
        fail("BLOCK_COUNT")
    text_size = 0
    for index, block in enumerate(blocks):
        if not isinstance(block, dict):
            fail("BLOCK_SHAPE")
        kind = block.get("kind")
        if kind == "text":
            shape(block, {"kind", "text"}, "TEXT_SHAPE")
            text = block["text"]
            if not isinstance(text, str) or not text.strip() or "\r" in text or len(text) > 20000:
                fail("TEXT")
            if index and blocks[index-1].get("kind") == "text":
                fail("ADJACENT_TEXT")
            text_size += len(text) + 2
        elif kind in {"image", "video"}:
            shape(block, {"kind", "fileName", "sha256"} | ({"title"} if kind == "video" else set()), "MEDIA_SHAPE")
            name(block["fileName"]); digest(block["sha256"])
            if kind == "video" and (not isinstance(block["title"], str) or not block["title"].strip() or len(block["title"]) > 100):
                fail("VIDEO_TITLE")
        else:
            fail("KIND")
    if blocks[0]["kind"] != "text" or blocks[-1]["kind"] != "text" or not any(b["kind"] != "text" for b in blocks):
        fail("RICH_LAYOUT")
    if text_size > 20000:
        fail("TEXT_LIMIT")
    return deepcopy(raw)


def plan_digest(plan):
    value = validate(plan)
    canonical = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()


def compile_plan(raw, selected):
    plan = validate(raw)
    if not isinstance(selected, list) or not 1 <= len(selected) <= 20:
        fail("SELECTED_COUNT")
    handles = set()
    for file in selected:
        shape(file, {"handle", "name", "sha256"}, "SELECTED_SHAPE")
        identity(file["handle"]); name(file["name"]); digest(file["sha256"])
        if file["handle"] in handles:
            fail("DUPLICATE_HANDLE")
        handles.add(file["handle"])
    bindings = []
    for index, block in enumerate(plan["blocks"]):
        if block["kind"] == "text":
            continue
        matches = [f for f in selected if f["name"] == block["fileName"] and f["sha256"] == block["sha256"]]
        if len(matches) != 1:
            fail("FILE_NOT_UNIQUE")
        bindings.append({"index": index, "handle": matches[0]["handle"]})
    return {"plan": plan, "digest": plan_digest(plan), "bindings": bindings}


def review(compiled, observed, *, expected_digest):
    # Recompute identity. Bindings are inert diagnostic output, not service receipts.
    shape(compiled, {"plan", "digest", "bindings"}, "COMPILED_SHAPE")
    actual_digest = plan_digest(compiled["plan"])
    digest(expected_digest)
    if compiled["digest"] != actual_digest or expected_digest != actual_digest:
        fail("PLAN_CHANGED")
    if not isinstance(observed, list) or len(observed) > 50:
        fail("OBSERVATION")
    ids = set()
    for block in observed:
        if not isinstance(block, dict):
            fail("OBSERVED_SHAPE")
        if block.get("kind") == "text":
            shape(block, {"kind", "text"}, "OBSERVED_SHAPE")
            if not isinstance(block["text"], str):
                fail("OBSERVED_TEXT")
        elif block.get("kind") in {"image", "video"}:
            shape(block, {"kind", "fileName", "sha256", "id", "ready"}, "OBSERVED_SHAPE")
            name(block["fileName"]); digest(block["sha256"]); identity(block["id"])
            if type(block["ready"]) is not bool:
                fail("OBSERVED_READY")
            if block["id"] in ids:
                fail("DUPLICATE_COMPONENT")
            ids.add(block["id"])
        else:
            fail("OBSERVED_KIND")
    differences = []
    expected = compiled["plan"]["blocks"]
    if len(expected) != len(observed):
        differences.append({"code": "COUNT", "expected": len(expected), "actual": len(observed)})
    for index, (wanted, found) in enumerate(zip(expected, observed)):
        codes = []
        if wanted["kind"] != found["kind"]:
            codes.append("KIND")
        elif wanted["kind"] == "text":
            if wanted["text"] != found["text"]:
                codes.append("TEXT")
        else:
            if wanted["fileName"] != found["fileName"]:
                codes.append("FILENAME")
            if wanted["sha256"] != found["sha256"]:
                codes.append("MEDIA_BYTES")
            if not found["ready"]:
                codes.append("NOT_READY")
        differences.extend({"index": index, "code": code} for code in codes)
    return {"matches": not differences, "differences": differences,
            "evidence": "caller-declared synthetic layout only", "publication_verified": False}