Add strict glyph ASCII renderer proof core

glyph_ascii_v1.py

@@ -0,0 +1,465 @@
+"""Strict, reversible ASCII identifier rendering for pre-certified glyph audio.
+
+This module deliberately contains no runtime generation, audio, asset loading,
+or release-evidence integration.  It defines only the fail-closed
+``glyph_ascii_v1`` grammar and the proof object that a later integration layer
+can bind to a frozen asset manifest.
+
+The accepted language is intentionally narrower than RFC email/URL syntax:
+
+* every input byte must already be lowercase ASCII (there is no case folding);
+* email local parts, DNS labels, and URL path segments contain letters plus a
+  small set of non-consecutive separators;
+* URLs are exactly ``http`` or ``https``, have no authority decorations, and
+  have no query or fragment.
+
+Every accepted byte maps bijectively to one of 32 canonical spoken tokens.
+Tokens in a complete rendering are separated by exactly one ASCII space.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+import hashlib
+import json
+import re
+
+
+GLYPH_ASCII_V1_GRAMMAR_ID = "glyph_ascii_v1"
+GLYPH_ASCII_V1_MAX_IDENTIFIER_BYTES = 512
+GLYPH_ASCII_V1_MAX_ATOMS = 512
+GLYPH_ASCII_V1_MAX_CANONICAL_CHARS = 8_192
+
+_SHA256_RE = re.compile(r"[0-9a-f]{64}\Z", flags=re.ASCII)
+_ALPHA = r"[a-z]+"
+_LABEL = rf"{_ALPHA}(?:-{_ALPHA})*"
+_DOMAIN = rf"{_LABEL}(?:\.{_LABEL})+"
+_LOCAL = rf"{_ALPHA}(?:[._-]{_ALPHA})*"
+_PATH_SEGMENT = rf"{_ALPHA}(?:[-_.]{_ALPHA})*"
+_EMAIL_RE = re.compile(rf"{_LOCAL}@{_DOMAIN}\Z", flags=re.ASCII)
+_URL_RE = re.compile(
+    rf"(?:http|https)://{_DOMAIN}(?:/{_PATH_SEGMENT}(?:/{_PATH_SEGMENT})*)?\Z",
+    flags=re.ASCII,
+)
+
+_ZH_ORDINALS = (
+    "一",
+    "二",
+    "三",
+    "四",
+    "五",
+    "六",
+    "七",
+    "八",
+    "九",
+    "十",
+    "十一",
+    "十二",
+    "十三",
+    "十四",
+    "十五",
+    "十六",
+    "十七",
+    "十八",
+    "十九",
+    "二十",
+    "二十一",
+    "二十二",
+    "二十三",
+    "二十四",
+    "二十五",
+    "二十六",
+)
+
+
+class GlyphAsciiV1Error(ValueError):
+    """Raised when an identifier, manifest binding, or proof is invalid."""
+
+
+@dataclass(frozen=True)
+class GlyphAsciiV1Symbol:
+    """One member of the frozen 32-byte canonical alphabet."""
+
+    raw_byte: int
+    canonical_token: str
+    asset_id: str
+
+
+_LETTER_SYMBOLS = tuple(
+    GlyphAsciiV1Symbol(
+        raw_byte=ord(character),
+        canonical_token=f"字母{ordinal}",
+        asset_id=f"glyph_ascii_v1_letter_{character}",
+    )
+    for character, ordinal in zip("abcdefghijklmnopqrstuvwxyz", _ZH_ORDINALS)
+)
+_PUNCTUATION_SYMBOLS = (
+    GlyphAsciiV1Symbol(ord("@"), "小老鼠", "glyph_ascii_v1_at"),
+    GlyphAsciiV1Symbol(ord("."), "點", "glyph_ascii_v1_dot"),
+    GlyphAsciiV1Symbol(ord("-"), "橫線", "glyph_ascii_v1_hyphen"),
+    GlyphAsciiV1Symbol(ord("_"), "底線", "glyph_ascii_v1_underscore"),
+    GlyphAsciiV1Symbol(ord(":"), "冒號", "glyph_ascii_v1_colon"),
+    GlyphAsciiV1Symbol(ord("/"), "斜線", "glyph_ascii_v1_slash"),
+)
+GLYPH_ASCII_V1_SYMBOLS = _LETTER_SYMBOLS + _PUNCTUATION_SYMBOLS
+
+_SYMBOL_BY_RAW_BYTE = {symbol.raw_byte: symbol for symbol in GLYPH_ASCII_V1_SYMBOLS}
+_SYMBOL_BY_CANONICAL_TOKEN = {
+    symbol.canonical_token: symbol for symbol in GLYPH_ASCII_V1_SYMBOLS
+}
+_EXPECTED_ASSET_IDS = tuple(symbol.asset_id for symbol in GLYPH_ASCII_V1_SYMBOLS)
+
+if (
+    len(GLYPH_ASCII_V1_SYMBOLS) != 32
+    or len(_SYMBOL_BY_RAW_BYTE) != 32
+    or len(_SYMBOL_BY_CANONICAL_TOKEN) != 32
+    or len(set(_EXPECTED_ASSET_IDS)) != 32
+):
+    raise RuntimeError("glyph_ascii_v1 alphabet is not bijective")
+
+
+@dataclass(frozen=True)
+class GlyphAsciiV1AtomProof:
+    """Range- and manifest-bound proof for one exact source byte."""
+
+    ordinal: int
+    absolute_raw_start: int
+    absolute_raw_end: int
+    identifier_raw_start: int
+    identifier_raw_end: int
+    canonical_start: int
+    canonical_end: int
+    raw_byte: int
+    canonical_token: str
+    asset_id: str
+    manifest_entry_sha256: str
+
+
+@dataclass(frozen=True)
+class GlyphAsciiV1Proof:
+    """Complete canonical rendering proof for one accepted identifier."""
+
+    grammar_id: str
+    identifier_kind: str
+    absolute_raw_start: int
+    absolute_raw_end: int
+    canonical_start: int
+    canonical_end: int
+    raw_sha256: str
+    canonical_sha256: str
+    asset_manifest_sha256: str
+    atoms: tuple[GlyphAsciiV1AtomProof, ...]
+
+
+def _require_plain_nonnegative_int(value: object, *, field: str) -> int:
+    if type(value) is not int or value < 0:
+        raise GlyphAsciiV1Error(f"{field} must be a non-negative integer")
+    return value
+
+
+def _require_sha256(value: object, *, field: str) -> str:
+    if type(value) is not str or _SHA256_RE.fullmatch(value) is None:
+        raise GlyphAsciiV1Error(f"{field} must be a lowercase SHA-256 digest")
+    return value
+
+
+def _validated_manifest(
+    asset_entry_sha256_by_asset_id: Mapping[str, str],
+) -> tuple[tuple[str, str], ...]:
+    if not isinstance(asset_entry_sha256_by_asset_id, Mapping):
+        raise GlyphAsciiV1Error("asset manifest entries must be a mapping")
+    if set(asset_entry_sha256_by_asset_id) != set(_EXPECTED_ASSET_IDS):
+        raise GlyphAsciiV1Error(
+            "asset manifest must contain exactly the 32 glyph_ascii_v1 asset ids"
+        )
+    entries: list[tuple[str, str]] = []
+    for asset_id in _EXPECTED_ASSET_IDS:
+        if type(asset_id) is not str:
+            raise GlyphAsciiV1Error("asset id has an invalid type")
+        digest = _require_sha256(
+            asset_entry_sha256_by_asset_id[asset_id],
+            field=f"asset manifest entry {asset_id!r}",
+        )
+        entries.append((asset_id, digest))
+    return tuple(entries)
+
+
+def _asset_manifest_sha256_from_entries(
+    entries: tuple[tuple[str, str], ...],
+) -> str:
+    payload = json.dumps(
+        {
+            "grammar_id": GLYPH_ASCII_V1_GRAMMAR_ID,
+            "entries": [
+                {"asset_id": asset_id, "sha256": digest}
+                for asset_id, digest in entries
+            ],
+        },
+        ensure_ascii=True,
+        separators=(",", ":"),
+        sort_keys=True,
+    ).encode("ascii")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def glyph_ascii_v1_asset_manifest_sha256(
+    asset_entry_sha256_by_asset_id: Mapping[str, str],
+) -> str:
+    """Return the deterministic logical-manifest digest for all 32 assets."""
+
+    return _asset_manifest_sha256_from_entries(
+        _validated_manifest(asset_entry_sha256_by_asset_id)
+    )
+
+
+def _strict_raw_bytes(raw_identifier: str) -> bytes:
+    if type(raw_identifier) is not str:
+        raise GlyphAsciiV1Error("raw identifier must be a string")
+    # This is intentionally lower(), never casefold().  Eligibility requires
+    # the source to arrive in its canonical lowercase form.
+    if raw_identifier != raw_identifier.lower():
+        raise GlyphAsciiV1Error("raw identifier is not native lowercase")
+    try:
+        raw_bytes = raw_identifier.encode("ascii", errors="strict")
+    except UnicodeEncodeError as error:
+        raise GlyphAsciiV1Error("raw identifier is not strict ASCII") from error
+    if not raw_bytes:
+        raise GlyphAsciiV1Error("raw identifier is empty")
+    if len(raw_bytes) > GLYPH_ASCII_V1_MAX_IDENTIFIER_BYTES:
+        raise GlyphAsciiV1Error("raw identifier exceeds the byte cap")
+    if len(raw_bytes) > GLYPH_ASCII_V1_MAX_ATOMS:
+        raise GlyphAsciiV1Error("raw identifier exceeds the atom cap")
+    return raw_bytes
+
+
+def glyph_ascii_v1_identifier_kind(raw_identifier: str) -> str:
+    """Parse the exact v1 byte grammar and return ``email`` or ``url``."""
+
+    raw_bytes = _strict_raw_bytes(raw_identifier)
+    # Match the decoded ASCII only after the byte-level eligibility checks.
+    raw = raw_bytes.decode("ascii")
+    matches = tuple(
+        kind
+        for kind, pattern in (("email", _EMAIL_RE), ("url", _URL_RE))
+        if pattern.fullmatch(raw) is not None
+    )
+    if len(matches) != 1:
+        raise GlyphAsciiV1Error("raw identifier is outside the unambiguous v1 grammar")
+    return matches[0]
+
+
+def render_glyph_ascii_v1(
+    raw_identifier: str,
+    *,
+    asset_entry_sha256_by_asset_id: Mapping[str, str],
+    absolute_raw_start: int = 0,
+    canonical_start: int = 0,
+) -> tuple[str, GlyphAsciiV1Proof]:
+    """Render one identifier and bind every byte to its frozen asset entry."""
+
+    absolute_raw_start = _require_plain_nonnegative_int(
+        absolute_raw_start,
+        field="absolute_raw_start",
+    )
+    canonical_start = _require_plain_nonnegative_int(
+        canonical_start,
+        field="canonical_start",
+    )
+    identifier_kind = glyph_ascii_v1_identifier_kind(raw_identifier)
+    raw_bytes = raw_identifier.encode("ascii")
+    manifest_entries = _validated_manifest(asset_entry_sha256_by_asset_id)
+    entry_sha_by_asset_id = dict(manifest_entries)
+    manifest_sha256 = _asset_manifest_sha256_from_entries(manifest_entries)
+
+    tokens: list[str] = []
+    atoms: list[GlyphAsciiV1AtomProof] = []
+    canonical_cursor = canonical_start
+    for ordinal, raw_byte in enumerate(raw_bytes):
+        symbol = _SYMBOL_BY_RAW_BYTE.get(raw_byte)
+        if symbol is None:
+            # The grammar and alphabet are intentionally independent checks.
+            raise GlyphAsciiV1Error("accepted grammar byte lacks a canonical atom")
+        if ordinal:
+            canonical_cursor += 1  # exactly one ASCII space between atoms
+        token_start = canonical_cursor
+        token_end = token_start + len(symbol.canonical_token)
+        tokens.append(symbol.canonical_token)
+        atoms.append(
+            GlyphAsciiV1AtomProof(
+                ordinal=ordinal,
+                absolute_raw_start=absolute_raw_start + ordinal,
+                absolute_raw_end=absolute_raw_start + ordinal + 1,
+                identifier_raw_start=ordinal,
+                identifier_raw_end=ordinal + 1,
+                canonical_start=token_start,
+                canonical_end=token_end,
+                raw_byte=raw_byte,
+                canonical_token=symbol.canonical_token,
+                asset_id=symbol.asset_id,
+                manifest_entry_sha256=entry_sha_by_asset_id[symbol.asset_id],
+            )
+        )
+        canonical_cursor = token_end
+
+    canonical = " ".join(tokens)
+    if len(canonical) > GLYPH_ASCII_V1_MAX_CANONICAL_CHARS:
+        raise GlyphAsciiV1Error("canonical rendering exceeds the character cap")
+    proof = GlyphAsciiV1Proof(
+        grammar_id=GLYPH_ASCII_V1_GRAMMAR_ID,
+        identifier_kind=identifier_kind,
+        absolute_raw_start=absolute_raw_start,
+        absolute_raw_end=absolute_raw_start + len(raw_bytes),
+        canonical_start=canonical_start,
+        canonical_end=canonical_start + len(canonical),
+        raw_sha256=hashlib.sha256(raw_bytes).hexdigest(),
+        canonical_sha256=hashlib.sha256(canonical.encode("utf-8")).hexdigest(),
+        asset_manifest_sha256=manifest_sha256,
+        atoms=tuple(atoms),
+    )
+    return canonical, proof
+
+
+def inverse_glyph_ascii_v1(
+    proof: GlyphAsciiV1Proof,
+    *,
+    asset_entry_sha256_by_asset_id: Mapping[str, str],
+) -> str:
+    """Validate a proof from first principles and reconstruct its exact bytes."""
+
+    if type(proof) is not GlyphAsciiV1Proof:
+        raise GlyphAsciiV1Error("glyph proof has an invalid type")
+    manifest_entries = _validated_manifest(asset_entry_sha256_by_asset_id)
+    entry_sha_by_asset_id = dict(manifest_entries)
+    manifest_sha256 = _asset_manifest_sha256_from_entries(manifest_entries)
+    if (
+        type(proof.grammar_id) is not str
+        or proof.grammar_id != GLYPH_ASCII_V1_GRAMMAR_ID
+        or type(proof.identifier_kind) is not str
+        or proof.identifier_kind not in {"email", "url"}
+        or _require_plain_nonnegative_int(
+            proof.absolute_raw_start,
+            field="proof.absolute_raw_start",
+        )
+        != proof.absolute_raw_start
+        or _require_plain_nonnegative_int(
+            proof.absolute_raw_end,
+            field="proof.absolute_raw_end",
+        )
+        != proof.absolute_raw_end
+        or _require_plain_nonnegative_int(
+            proof.canonical_start,
+            field="proof.canonical_start",
+        )
+        != proof.canonical_start
+        or _require_plain_nonnegative_int(
+            proof.canonical_end,
+            field="proof.canonical_end",
+        )
+        != proof.canonical_end
+        or proof.absolute_raw_end <= proof.absolute_raw_start
+        or proof.canonical_end <= proof.canonical_start
+        or _require_sha256(proof.raw_sha256, field="proof.raw_sha256")
+        != proof.raw_sha256
+        or _require_sha256(proof.canonical_sha256, field="proof.canonical_sha256")
+        != proof.canonical_sha256
+        or _require_sha256(
+            proof.asset_manifest_sha256,
+            field="proof.asset_manifest_sha256",
+        )
+        != proof.asset_manifest_sha256
+        or proof.asset_manifest_sha256 != manifest_sha256
+        or type(proof.atoms) is not tuple
+        or not proof.atoms
+        or len(proof.atoms) > GLYPH_ASCII_V1_MAX_ATOMS
+    ):
+        raise GlyphAsciiV1Error("glyph proof header is inconsistent")
+
+    raw_bytes = bytearray()
+    canonical_tokens: list[str] = []
+    raw_absolute_cursor = proof.absolute_raw_start
+    raw_identifier_cursor = 0
+    canonical_cursor = proof.canonical_start
+    for ordinal, atom in enumerate(proof.atoms):
+        if type(atom) is not GlyphAsciiV1AtomProof:
+            raise GlyphAsciiV1Error("glyph atom proof has an invalid type")
+        if (
+            type(atom.canonical_token) is not str
+            or type(atom.asset_id) is not str
+        ):
+            raise GlyphAsciiV1Error("glyph atom text field has an invalid type")
+        integer_fields = (
+            atom.ordinal,
+            atom.absolute_raw_start,
+            atom.absolute_raw_end,
+            atom.identifier_raw_start,
+            atom.identifier_raw_end,
+            atom.canonical_start,
+            atom.canonical_end,
+            atom.raw_byte,
+        )
+        if any(type(value) is not int for value in integer_fields):
+            raise GlyphAsciiV1Error("glyph atom integer field has an invalid type")
+        entry_sha256 = _require_sha256(
+            atom.manifest_entry_sha256,
+            field="atom.manifest_entry_sha256",
+        )
+        symbol = _SYMBOL_BY_CANONICAL_TOKEN.get(atom.canonical_token)
+        expected_canonical_start = canonical_cursor + (1 if ordinal else 0)
+        if (
+            atom.ordinal != ordinal
+            or atom.absolute_raw_start != raw_absolute_cursor
+            or atom.absolute_raw_end != raw_absolute_cursor + 1
+            or atom.identifier_raw_start != raw_identifier_cursor
+            or atom.identifier_raw_end != raw_identifier_cursor + 1
+            or atom.canonical_start != expected_canonical_start
+            or atom.canonical_end
+            != expected_canonical_start + len(atom.canonical_token)
+            or symbol is None
+            or symbol.raw_byte != atom.raw_byte
+            or symbol.asset_id != atom.asset_id
+            or entry_sha256 != atom.manifest_entry_sha256
+            or entry_sha_by_asset_id.get(atom.asset_id)
+            != atom.manifest_entry_sha256
+        ):
+            raise GlyphAsciiV1Error("glyph atom proof is inconsistent")
+        raw_bytes.append(atom.raw_byte)
+        canonical_tokens.append(atom.canonical_token)
+        raw_absolute_cursor = atom.absolute_raw_end
+        raw_identifier_cursor = atom.identifier_raw_end
+        canonical_cursor = atom.canonical_end
+
+    canonical = " ".join(canonical_tokens)
+    try:
+        raw = bytes(raw_bytes).decode("ascii", errors="strict")
+    except UnicodeDecodeError as error:
+        raise GlyphAsciiV1Error("glyph proof does not reconstruct ASCII") from error
+    if (
+        raw_absolute_cursor != proof.absolute_raw_end
+        or raw_identifier_cursor != len(raw_bytes)
+        or canonical_cursor != proof.canonical_end
+        or proof.absolute_raw_end
+        != proof.absolute_raw_start + len(raw_bytes)
+        or proof.canonical_end != proof.canonical_start + len(canonical)
+        or hashlib.sha256(bytes(raw_bytes)).hexdigest() != proof.raw_sha256
+        or hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+        != proof.canonical_sha256
+    ):
+        raise GlyphAsciiV1Error("glyph proof does not cover its declared ranges")
+
+    # Re-parse the reconstructed bytes, then rebuild the only valid proof.
+    kind = glyph_ascii_v1_identifier_kind(raw)
+    expected_canonical, expected_proof = render_glyph_ascii_v1(
+        raw,
+        asset_entry_sha256_by_asset_id=entry_sha_by_asset_id,
+        absolute_raw_start=proof.absolute_raw_start,
+        canonical_start=proof.canonical_start,
+    )
+    if (
+        kind != proof.identifier_kind
+        or expected_canonical != canonical
+        or type(expected_proof) is not type(proof)
+        or expected_proof != proof
+    ):
+        raise GlyphAsciiV1Error("glyph proof is not the canonical expected proof")
+    return raw

tests/test_glyph_ascii_v1.py

@@ -0,0 +1,507 @@
+from __future__ import annotations
+
+from dataclasses import asdict, replace
+import hashlib
+import json
+import random
+
+import pytest
+
+from glyph_ascii_v1 import (
+    GLYPH_ASCII_V1_GRAMMAR_ID,
+    GLYPH_ASCII_V1_MAX_IDENTIFIER_BYTES,
+    GLYPH_ASCII_V1_SYMBOLS,
+    GlyphAsciiV1AtomProof,
+    GlyphAsciiV1Error,
+    GlyphAsciiV1Proof,
+    glyph_ascii_v1_asset_manifest_sha256,
+    glyph_ascii_v1_identifier_kind,
+    inverse_glyph_ascii_v1,
+    render_glyph_ascii_v1,
+)
+from production import normalize_spoken_forms, plan_generation_chunks
+
+
+def _asset_manifest() -> dict[str, str]:
+    return {
+        symbol.asset_id: hashlib.sha256(
+            f"test-asset:{symbol.asset_id}".encode("ascii")
+        ).hexdigest()
+        for symbol in GLYPH_ASCII_V1_SYMBOLS
+    }
+
+
+ASSET_MANIFEST = _asset_manifest()
+
+
+def _render(
+    raw: str,
+    *,
+    absolute_raw_start: int = 0,
+    canonical_start: int = 0,
+) -> tuple[str, GlyphAsciiV1Proof]:
+    return render_glyph_ascii_v1(
+        raw,
+        asset_entry_sha256_by_asset_id=ASSET_MANIFEST,
+        absolute_raw_start=absolute_raw_start,
+        canonical_start=canonical_start,
+    )
+
+
+def _inverse(
+    proof: GlyphAsciiV1Proof,
+    *,
+    manifest: dict[str, str] | None = None,
+) -> str:
+    return inverse_glyph_ascii_v1(
+        proof,
+        asset_entry_sha256_by_asset_id=(
+            ASSET_MANIFEST if manifest is None else manifest
+        ),
+    )
+
+
+def test_exact_32_symbol_bijection_and_frozen_tokens():
+    expected_characters = "abcdefghijklmnopqrstuvwxyz@.-_:/"
+    expected_tokens = (
+        "字母一",
+        "字母二",
+        "字母三",
+        "字母四",
+        "字母五",
+        "字母六",
+        "字母七",
+        "字母八",
+        "字母九",
+        "字母十",
+        "字母十一",
+        "字母十二",
+        "字母十三",
+        "字母十四",
+        "字母十五",
+        "字母十六",
+        "字母十七",
+        "字母十八",
+        "字母十九",
+        "字母二十",
+        "字母二十一",
+        "字母二十二",
+        "字母二十三",
+        "字母二十四",
+        "字母二十五",
+        "字母二十六",
+        "小老鼠",
+        "點",
+        "橫線",
+        "底線",
+        "冒號",
+        "斜線",
+    )
+
+    assert len(GLYPH_ASCII_V1_SYMBOLS) == 32
+    assert "".join(chr(symbol.raw_byte) for symbol in GLYPH_ASCII_V1_SYMBOLS) == (
+        expected_characters
+    )
+    assert tuple(symbol.canonical_token for symbol in GLYPH_ASCII_V1_SYMBOLS) == (
+        expected_tokens
+    )
+    assert len({symbol.raw_byte for symbol in GLYPH_ASCII_V1_SYMBOLS}) == 32
+    assert len({symbol.canonical_token for symbol in GLYPH_ASCII_V1_SYMBOLS}) == 32
+    assert len({symbol.asset_id for symbol in GLYPH_ASCII_V1_SYMBOLS}) == 32
+
+
+@pytest.mark.parametrize(
+    ("raw", "kind"),
+    (
+        ("a@b.c", "email"),
+        ("a.b_c-d@e-f.g-h", "email"),
+        ("http://a.b", "url"),
+        ("https://a-b.c-d/e_f.g-h/i", "url"),
+    ),
+)
+def test_strict_examples_roundtrip_with_range_and_manifest_binding(raw, kind):
+    absolute_raw_start = 19
+    canonical_start = 31
+    canonical, proof = _render(
+        raw,
+        absolute_raw_start=absolute_raw_start,
+        canonical_start=canonical_start,
+    )
+    symbols = {symbol.raw_byte: symbol for symbol in GLYPH_ASCII_V1_SYMBOLS}
+
+    assert glyph_ascii_v1_identifier_kind(raw) == kind
+    assert proof.grammar_id == GLYPH_ASCII_V1_GRAMMAR_ID
+    assert proof.identifier_kind == kind
+    assert proof.absolute_raw_start == absolute_raw_start
+    assert proof.absolute_raw_end == absolute_raw_start + len(raw.encode("ascii"))
+    assert proof.canonical_start == canonical_start
+    assert proof.canonical_end == canonical_start + len(canonical)
+    assert proof.raw_sha256 == hashlib.sha256(raw.encode("ascii")).hexdigest()
+    assert proof.canonical_sha256 == hashlib.sha256(
+        canonical.encode("utf-8")
+    ).hexdigest()
+    assert proof.asset_manifest_sha256 == glyph_ascii_v1_asset_manifest_sha256(
+        ASSET_MANIFEST
+    )
+    assert canonical == " ".join(
+        symbols[raw_byte].canonical_token for raw_byte in raw.encode("ascii")
+    )
+    assert "  " not in canonical
+    assert _inverse(proof) == raw
+
+    for ordinal, (raw_byte, atom) in enumerate(zip(raw.encode("ascii"), proof.atoms)):
+        symbol = symbols[raw_byte]
+        assert atom.ordinal == ordinal
+        assert (
+            atom.absolute_raw_start,
+            atom.absolute_raw_end,
+        ) == (
+            absolute_raw_start + ordinal,
+            absolute_raw_start + ordinal + 1,
+        )
+        assert (
+            atom.identifier_raw_start,
+            atom.identifier_raw_end,
+        ) == (ordinal, ordinal + 1)
+        assert canonical[
+            atom.canonical_start - canonical_start :
+            atom.canonical_end - canonical_start
+        ] == atom.canonical_token
+        assert atom.raw_byte == raw_byte
+        assert atom.canonical_token == symbol.canonical_token
+        assert atom.asset_id == symbol.asset_id
+        assert atom.manifest_entry_sha256 == ASSET_MANIFEST[symbol.asset_id]
+
+
+def _alpha(rng: random.Random, *, minimum: int = 1, maximum: int = 8) -> str:
+    return "".join(
+        rng.choice("abcdefghijklmnopqrstuvwxyz")
+        for _ in range(rng.randint(minimum, maximum))
+    )
+
+
+def _joined_alpha(
+    rng: random.Random,
+    separators: str,
+    *,
+    maximum_parts: int = 4,
+) -> str:
+    output = _alpha(rng)
+    for _ in range(rng.randint(0, maximum_parts - 1)):
+        output += rng.choice(separators) + _alpha(rng)
+    return output
+
+
+def _random_email(rng: random.Random) -> str:
+    local = _joined_alpha(rng, "._-")
+    labels = [_joined_alpha(rng, "-", maximum_parts=3) for _ in range(rng.randint(2, 5))]
+    return f"{local}@{'.'.join(labels)}"
+
+
+def _random_url(rng: random.Random) -> str:
+    scheme = rng.choice(("http", "https"))
+    labels = [_joined_alpha(rng, "-", maximum_parts=3) for _ in range(rng.randint(2, 5))]
+    path = ""
+    if rng.choice((False, True)):
+        segments = [
+            _joined_alpha(rng, "-_.", maximum_parts=4)
+            for _ in range(rng.randint(1, 4))
+        ]
+        path = "/" + "/".join(segments)
+    return f"{scheme}://{'.'.join(labels)}{path}"
+
+
+def test_seeded_property_roundtrip_for_random_valid_identifiers():
+    rng = random.Random(0xB10E_5A11)
+    for _ in range(1_000):
+        raw = _random_email(rng) if rng.randrange(2) == 0 else _random_url(rng)
+        raw_offset = rng.randrange(0, 1_000)
+        canonical_offset = rng.randrange(0, 1_000)
+        canonical, proof = _render(
+            raw,
+            absolute_raw_start=raw_offset,
+            canonical_start=canonical_offset,
+        )
+
+        assert _inverse(proof) == raw
+        assert len(proof.atoms) == len(raw.encode("ascii"))
+        assert canonical.split(" ") == [
+            atom.canonical_token for atom in proof.atoms
+        ]
+        assert proof.absolute_raw_end - proof.absolute_raw_start == len(raw)
+
+
+@pytest.mark.parametrize(
+    "raw",
+    (
+        "",
+        "Mead@forest.org",
+        "mead@Forest.org",
+        "MEAD@FOREST.ORG",
+        "HTTP://forest.org",
+        "https://forest.org/Path",
+        "méad@forest.org",
+        "梅@forest.org",
+        "ｍead@forest.org",
+        "xn--caf-dma@example.org",
+        "mead@xn--caf-dma.org",
+        "mead@\u202eforest.org",
+        "mead@forest.org\u2066",
+        "mead@forest.org\x00",
+        "mead@forest.org\n",
+        "mead@forest.org\t",
+        "mead1@forest.org",
+        "mead@forest2.org",
+        "https://forest2.org",
+        "https://forest.org/path2",
+        "https://forest.org/path?query",
+        "https://forest.org/path#fragment",
+        "https://forest.org/pa%74h",
+        "https://forest.org:443/path",
+        "https://user@forest.org/path",
+        "https://user:pass@forest.org/path",
+        "ftp://forest.org/path",
+        "forest.org/path",
+        "mailto:mead@forest.org",
+        ".mead@forest.org",
+        "mead.@forest.org",
+        "mead..voice@forest.org",
+        "mead__voice@forest.org",
+        "mead--voice@forest.org",
+        "mead@.forest.org",
+        "mead@forest.org.",
+        "mead@forest..org",
+        "mead@-forest.org",
+        "mead@forest-.org",
+        "https:///forest.org",
+        "https://forest.org/",
+        "https://forest.org//path",
+        "https://forest.org/.",
+        "https://forest.org/..",
+        "https://forest.org/.path",
+        "https://forest.org/path.",
+        "https://forest.org/path..next",
+        "https://forest.org/-path",
+        "https://forest.org/path-",
+        "https://forest.org/_path",
+        "https://forest.org/path_",
+        "a",
+        "a.b",
+        "@",
+        "://",
+    ),
+)
+def test_unsafe_or_out_of_grammar_inputs_are_rejected(raw):
+    with pytest.raises(GlyphAsciiV1Error):
+        _render(raw)
+
+
+def test_cap_overflow_is_rejected_without_truncation():
+    # 509 letters + "@a.b" is one byte beyond the frozen 512-byte cap.
+    raw = "a" * (GLYPH_ASCII_V1_MAX_IDENTIFIER_BYTES - 3) + "@a.b"
+    assert len(raw.encode("ascii")) == GLYPH_ASCII_V1_MAX_IDENTIFIER_BYTES + 1
+    with pytest.raises(GlyphAsciiV1Error, match="cap"):
+        _render(raw)
+
+
+@pytest.mark.parametrize("value", (b"a@b.c", None, 7, True))
+def test_non_string_raw_input_is_rejected(value):
+    with pytest.raises(GlyphAsciiV1Error):
+        _render(value)  # type: ignore[arg-type]
+
+
+@pytest.mark.parametrize(
+    ("keyword", "value"),
+    (
+        ("absolute_raw_start", -1),
+        ("absolute_raw_start", True),
+        ("absolute_raw_start", 1.5),
+        ("canonical_start", -1),
+        ("canonical_start", False),
+        ("canonical_start", "1"),
+    ),
+)
+def test_invalid_external_offsets_are_rejected(keyword, value):
+    kwargs = {keyword: value}
+    with pytest.raises(GlyphAsciiV1Error):
+        render_glyph_ascii_v1(
+            "a@b.c",
+            asset_entry_sha256_by_asset_id=ASSET_MANIFEST,
+            **kwargs,
+        )
+
+
+def test_manifest_must_bind_exactly_32_valid_entries():
+    missing = dict(ASSET_MANIFEST)
+    missing.pop(next(iter(missing)))
+    extra = dict(ASSET_MANIFEST)
+    extra["glyph_ascii_v1_extra"] = "0" * 64
+    invalid_digest = dict(ASSET_MANIFEST)
+    invalid_digest[next(iter(invalid_digest))] = "A" * 64
+
+    for manifest in (missing, extra, invalid_digest):
+        with pytest.raises(GlyphAsciiV1Error):
+            render_glyph_ascii_v1(
+                "a@b.c",
+                asset_entry_sha256_by_asset_id=manifest,
+            )
+    with pytest.raises(GlyphAsciiV1Error):
+        render_glyph_ascii_v1(
+            "a@b.c",
+            asset_entry_sha256_by_asset_id=[],  # type: ignore[arg-type]
+        )
+
+
+def _proof_with_atoms(
+    proof: GlyphAsciiV1Proof,
+    atoms: tuple[GlyphAsciiV1AtomProof, ...] | list[GlyphAsciiV1AtomProof],
+) -> GlyphAsciiV1Proof:
+    return replace(proof, atoms=atoms)  # type: ignore[arg-type]
+
+
+def test_atom_reorder_omit_duplicate_substitute_and_borrow_are_rejected():
+    _, proof = _render("mead@forest.org", absolute_raw_start=7, canonical_start=11)
+    _, donor = _render("owl@island.net", absolute_raw_start=7, canonical_start=11)
+    atoms = proof.atoms
+
+    tampered = (
+        _proof_with_atoms(proof, (atoms[1], atoms[0], *atoms[2:])),
+        _proof_with_atoms(proof, (*atoms[:3], *atoms[4:])),
+        _proof_with_atoms(proof, (*atoms[:3], atoms[3], *atoms[3:])),
+        _proof_with_atoms(
+            proof,
+            (
+                replace(
+                    atoms[0],
+                    raw_byte=ord("z"),
+                    canonical_token="字母二十六",
+                    asset_id="glyph_ascii_v1_letter_z",
+                    manifest_entry_sha256=ASSET_MANIFEST[
+                        "glyph_ascii_v1_letter_z"
+                    ],
+                ),
+                *atoms[1:],
+            ),
+        ),
+        _proof_with_atoms(proof, (donor.atoms[0], *atoms[1:])),
+    )
+    for forged in tampered:
+        with pytest.raises(GlyphAsciiV1Error):
+            _inverse(forged)
+
+
+@pytest.mark.parametrize(
+    "mutate",
+    (
+        lambda atom: replace(atom, ordinal=atom.ordinal + 1),
+        lambda atom: replace(atom, ordinal=True),
+        lambda atom: replace(atom, absolute_raw_start=atom.absolute_raw_start + 1),
+        lambda atom: replace(atom, absolute_raw_end=atom.absolute_raw_end + 1),
+        lambda atom: replace(
+            atom, identifier_raw_start=atom.identifier_raw_start + 1
+        ),
+        lambda atom: replace(atom, identifier_raw_end=atom.identifier_raw_end + 1),
+        lambda atom: replace(atom, canonical_start=atom.canonical_start + 1),
+        lambda atom: replace(atom, canonical_end=atom.canonical_end + 1),
+        lambda atom: replace(atom, raw_byte=True),
+        lambda atom: replace(atom, raw_byte=ord("z")),
+        lambda atom: replace(atom, canonical_token="字母二十六"),
+        lambda atom: replace(atom, canonical_token=[]),
+        lambda atom: replace(atom, asset_id="glyph_ascii_v1_letter_z"),
+        lambda atom: replace(atom, asset_id=[]),
+        lambda atom: replace(atom, manifest_entry_sha256="0" * 64),
+        lambda atom: replace(atom, manifest_entry_sha256="A" * 64),
+    ),
+)
+def test_atom_gap_overlap_type_hash_and_mapping_tampering_is_rejected(mutate):
+    _, proof = _render("mead@forest.org", absolute_raw_start=7, canonical_start=11)
+    index = 2
+    atoms = list(proof.atoms)
+    atoms[index] = mutate(atoms[index])
+    with pytest.raises(GlyphAsciiV1Error):
+        _inverse(_proof_with_atoms(proof, tuple(atoms)))
+
+
+@pytest.mark.parametrize(
+    "mutate",
+    (
+        lambda proof: replace(proof, grammar_id="glyph_ascii_v2"),
+        lambda proof: replace(proof, identifier_kind="url"),
+        lambda proof: replace(proof, absolute_raw_start=True),
+        lambda proof: replace(proof, absolute_raw_start=proof.absolute_raw_start + 1),
+        lambda proof: replace(proof, absolute_raw_end=proof.absolute_raw_end + 1),
+        lambda proof: replace(proof, canonical_start=False),
+        lambda proof: replace(proof, canonical_start=proof.canonical_start + 1),
+        lambda proof: replace(proof, canonical_end=proof.canonical_end + 1),
+        lambda proof: replace(proof, raw_sha256="0" * 64),
+        lambda proof: replace(proof, canonical_sha256="0" * 64),
+        lambda proof: replace(proof, asset_manifest_sha256="0" * 64),
+        lambda proof: replace(proof, raw_sha256="A" * 64),
+        lambda proof: replace(proof, atoms=()),
+        lambda proof: replace(proof, atoms=list(proof.atoms)),
+    ),
+)
+def test_header_range_hash_type_and_expected_proof_tampering_is_rejected(mutate):
+    _, proof = _render("mead@forest.org", absolute_raw_start=7, canonical_start=11)
+    with pytest.raises(GlyphAsciiV1Error):
+        _inverse(mutate(proof))
+
+
+def test_manifest_substitution_is_rejected_by_entry_and_manifest_hashes():
+    _, proof = _render("mead@forest.org")
+    changed = dict(ASSET_MANIFEST)
+    changed[proof.atoms[0].asset_id] = hashlib.sha256(b"different").hexdigest()
+
+    with pytest.raises(GlyphAsciiV1Error):
+        _inverse(proof, manifest=changed)
+
+
+def test_inverse_rejects_non_proof_and_subclass_types():
+    class ForgedProof(GlyphAsciiV1Proof):
+        pass
+
+    _, proof = _render("mead@forest.org")
+    forged = ForgedProof(**asdict(proof))
+
+    with pytest.raises(GlyphAsciiV1Error):
+        _inverse(forged)
+    with pytest.raises(GlyphAsciiV1Error):
+        inverse_glyph_ascii_v1(  # type: ignore[arg-type]
+            object(),
+            asset_entry_sha256_by_asset_id=ASSET_MANIFEST,
+        )
+
+
+def test_legacy_normalize_and_generation_plan_byte_for_byte_regression():
+    """The isolated core must not alter the frozen legacy frontend or planner."""
+
+    samples = (
+        "今天測試一般句子，保持原有規劃。",
+        "聯絡 mead@forestmail.org。",
+        "請開啟 https://audiocoast.org/tour。",
+    )
+    output = []
+    for raw in samples:
+        normalized = normalize_spoken_forms(raw, locale="zh-TW")
+        output.append(
+            {
+                "raw": raw,
+                "normalized": normalized,
+                "plan": [
+                    asdict(spec)
+                    for spec in plan_generation_chunks(raw, normalized)
+                ],
+            }
+        )
+    serialized = json.dumps(
+        output,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    ).encode("utf-8")
+
+    assert len(serialized) == 3_941
+    assert (
+        hashlib.sha256(serialized).hexdigest()
+        == "cea66a03b4ac1381f1acbc240e73d08f0b992f2a5efd4af1bc855b55d7bb50ee"
+    )