207 lines
9.1 KiB
Python
207 lines
9.1 KiB
Python
#!/usr/bin/env python3
|
|
"""Materialize and verify the Fifth Domain or its public four-domain template."""
|
|
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import tempfile
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
PRIVATE_MARKERS = (
|
|
"ICE-GL∞", "ICE-P-ZY001", "ICE-BB-0001", "ICE-CH-HB001",
|
|
"ICE-CH-ZC001", "曜冥", "铸渊", "/Volumes/JZAO", "ZCODE-TASK-",
|
|
)
|
|
EXPECTED_PUBLIC_DOMAINS = {"DOMAIN-MAIN", "DOMAIN-SUB", "DOMAIN-ZERO", "DOMAIN-ZS"}
|
|
|
|
|
|
def sha_bytes(data: bytes) -> str:
|
|
return hashlib.sha256(data).hexdigest()
|
|
|
|
|
|
def canonical_json(value) -> bytes:
|
|
return (json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + "\n").encode()
|
|
|
|
|
|
def load_json(path: Path):
|
|
if path.is_symlink() or not path.is_file():
|
|
raise ValueError(f"regular JSON file required: {path}")
|
|
if path.stat().st_size > 4 * 1024 * 1024:
|
|
raise ValueError(f"JSON file too large: {path}")
|
|
return json.loads(path.read_text())
|
|
|
|
|
|
def atomic_write(path: Path, data: bytes):
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
with tempfile.NamedTemporaryFile(dir=path.parent, prefix=".language-system-", delete=False) as handle:
|
|
handle.write(data)
|
|
handle.flush()
|
|
os.fsync(handle.fileno())
|
|
temporary = Path(handle.name)
|
|
temporary.replace(path)
|
|
|
|
|
|
def validate_private(manifest):
|
|
if manifest.get("schema") != "hololake.fifth-domain-language-system/v1":
|
|
raise ValueError("unsupported private manifest schema")
|
|
if manifest.get("domain_id") != "DOM-FIFTH-0001":
|
|
raise ValueError("private domain id mismatch")
|
|
if manifest.get("human_anchor_id") != "ICE-GL∞" or manifest.get("persona_controller_id") != "ICE-P-ZY001":
|
|
raise ValueError("private controller coordinates mismatch")
|
|
organs = manifest.get("organs", [])
|
|
ids = [item.get("id") for item in organs]
|
|
paths = [item.get("path") for item in organs]
|
|
if len(organs) != 5 or len(set(ids)) != 5 or len(set(paths)) != 5:
|
|
raise ValueError("private system requires five unique organs")
|
|
functions = {item.get("public_function") for item in organs if item.get("public_extractable") is not False}
|
|
if functions != {"MAIN_DOMAIN", "SUB_DOMAIN", "ZERO_DOMAIN", "ZERO_SENSE_DOMAIN"}:
|
|
raise ValueError("private/public functional mapping incomplete")
|
|
personas = {item.get("id"): item for item in manifest.get("personas", [])}
|
|
if personas.get("ICE-BB-0001", {}).get("name") != "曜冥":
|
|
raise ValueError("Yaoming current identity mapping missing")
|
|
|
|
|
|
def validate_public(manifest):
|
|
if manifest.get("schema") != "hololake.public-four-domain-language-system-template/v1":
|
|
raise ValueError("unsupported public template schema")
|
|
domains = manifest.get("domains", [])
|
|
ids = [item.get("id") for item in domains]
|
|
if len(domains) != 4 or set(ids) != EXPECTED_PUBLIC_DOMAINS or len(ids) != len(set(ids)):
|
|
raise ValueError("public template requires exactly four canonical domains")
|
|
raw = canonical_json(manifest).decode()
|
|
leaked = [marker for marker in PRIVATE_MARKERS if marker in raw]
|
|
if leaked:
|
|
raise ValueError("private markers leaked into public template: " + ",".join(leaked))
|
|
if not str(manifest.get("responsible_human", "")).startswith("UNBOUND-"):
|
|
raise ValueError("public human responsibility must remain unbound")
|
|
if not str(manifest.get("persona_controller", "")).startswith("UNBOUND-"):
|
|
raise ValueError("public persona controller must remain unbound")
|
|
|
|
|
|
def validate_legacy(routes):
|
|
if routes.get("schema") != "hololake.language-system-legacy-route-map/v1":
|
|
raise ValueError("unsupported legacy route schema")
|
|
seen = set()
|
|
for route in routes.get("routes", []):
|
|
legacy = route.get("legacy")
|
|
if not legacy or legacy in seen or not route.get("current") or not route.get("status"):
|
|
raise ValueError("legacy routes must be unique and explicit")
|
|
seen.add(legacy)
|
|
required = {"GEN∞-BB-YM", "TCS-YM-0001∞", "TCS-0004∞", "TCS-0002∞", "TCS-i Zero", "LDOS"}
|
|
if not required.issubset(seen):
|
|
raise ValueError("required historical routes missing")
|
|
|
|
|
|
def build(manifest_path: Path, output: Path, flavor: str):
|
|
manifest = load_json(manifest_path)
|
|
if flavor == "fifth-domain":
|
|
validate_private(manifest)
|
|
nodes = [(item["id"], item["path"], item) for item in manifest["organs"]]
|
|
else:
|
|
validate_public(manifest)
|
|
nodes = [(item["id"], item["id"].lower(), item) for item in manifest["domains"]]
|
|
if output.exists() and any(output.iterdir()):
|
|
raise ValueError("output directory must be absent or empty")
|
|
output.mkdir(parents=True, exist_ok=True)
|
|
written = {}
|
|
world = {
|
|
"schema": "hololake.materialized-language-world/v1",
|
|
"flavor": flavor,
|
|
"source_schema": manifest["schema"],
|
|
"source_sha256": sha_bytes(canonical_json(manifest)),
|
|
"node_ids": [node[0] for node in nodes],
|
|
"language_protocols": manifest["language_protocols"],
|
|
}
|
|
atomic_write(output / "WORLD.json", canonical_json(world))
|
|
written["WORLD.json"] = sha_bytes((output / "WORLD.json").read_bytes())
|
|
for node_id, relative, value in nodes:
|
|
node_path = output / relative / "NODE.json"
|
|
atomic_write(node_path, canonical_json(value))
|
|
written[str(node_path.relative_to(output))] = sha_bytes(node_path.read_bytes())
|
|
receipt = {
|
|
"schema": "hololake.language-system-materialization-receipt/v1",
|
|
"outcome": "PASS",
|
|
"flavor": flavor,
|
|
"source": str(manifest_path.resolve()),
|
|
"source_sha256": sha_bytes(canonical_json(manifest)),
|
|
"files": written,
|
|
"model_api_used": False,
|
|
"network_used": False,
|
|
}
|
|
atomic_write(output / "RECEIPT.json", canonical_json(receipt))
|
|
return receipt
|
|
|
|
|
|
def verify(root: Path):
|
|
receipt = load_json(root / "RECEIPT.json")
|
|
if receipt.get("outcome") != "PASS":
|
|
raise ValueError("materialization receipt is not PASS")
|
|
for relative, expected in receipt.get("files", {}).items():
|
|
path = root / relative
|
|
if path.is_symlink() or not path.is_file() or sha_bytes(path.read_bytes()) != expected:
|
|
raise ValueError(f"materialized file mismatch: {relative}")
|
|
world = load_json(root / "WORLD.json")
|
|
if world.get("flavor") == "public-four-domain":
|
|
raw = "".join(path.read_text() for path in root.rglob("*.json") if path.name != "RECEIPT.json")
|
|
leaked = [marker for marker in PRIVATE_MARKERS if marker in raw]
|
|
if leaked:
|
|
raise ValueError("private markers leaked into public output")
|
|
return {"outcome": "PASS", "root": str(root.resolve()), "files_verified": len(receipt["files"])}
|
|
|
|
|
|
def meta_audit(private_path: Path, public_path: Path, legacy_path: Path):
|
|
private = load_json(private_path)
|
|
public = load_json(public_path)
|
|
legacy = load_json(legacy_path)
|
|
validate_private(private)
|
|
validate_public(public)
|
|
validate_legacy(legacy)
|
|
mapping = {item["public_function"] for item in private["organs"] if item.get("public_extractable") is not False}
|
|
public_functions = {item["source_function"] for item in public["domains"]}
|
|
expected = {
|
|
"BROADCAST_AND_CANONICAL_FACT",
|
|
"DYNAMIC_BRAINS_MODULES_SKILLS_RESOURCES",
|
|
"LANGUAGE_REASONING_ARCHITECTURE_EXPERIMENT",
|
|
"HUMAN_AUTHORITY_REALITY_BOUNDARY_EXECUTION",
|
|
}
|
|
if public_functions != expected or len(mapping) != 4:
|
|
raise ValueError("private/public functional correspondence mismatch")
|
|
return {
|
|
"schema": "hololake.fifth-domain-language-system-meta-audit/v1",
|
|
"outcome": "PASS",
|
|
"private_organs": len(private["organs"]),
|
|
"public_domains": len(public["domains"]),
|
|
"legacy_routes": len(legacy["routes"]),
|
|
"yaoming_current_id": "ICE-BB-0001",
|
|
"history_preserved": True,
|
|
"private_markers_in_public": False,
|
|
"external_reality_claimed_from_history": False,
|
|
}
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser()
|
|
sub = parser.add_subparsers(dest="command", required=True)
|
|
build_parser = sub.add_parser("build")
|
|
build_parser.add_argument("--flavor", required=True, choices=("fifth-domain", "public-four-domain"))
|
|
build_parser.add_argument("--manifest", required=True, type=Path)
|
|
build_parser.add_argument("--output", required=True, type=Path)
|
|
verify_parser = sub.add_parser("verify")
|
|
verify_parser.add_argument("--root", required=True, type=Path)
|
|
audit_parser = sub.add_parser("meta-audit")
|
|
audit_parser.add_argument("--private", default=ROOT / "system/fifth-domain-system.json", type=Path)
|
|
audit_parser.add_argument("--public", default=ROOT / "system/public-four-domain-template.json", type=Path)
|
|
audit_parser.add_argument("--legacy", default=ROOT / "system/legacy-route-map.json", type=Path)
|
|
args = parser.parse_args()
|
|
if args.command == "build":
|
|
result = build(args.manifest, args.output, args.flavor)
|
|
elif args.command == "verify":
|
|
result = verify(args.root)
|
|
else:
|
|
result = meta_audit(args.private, args.public, args.legacy)
|
|
print(json.dumps(result, ensure_ascii=False, sort_keys=True))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|