Publish TIFXYZ UUID producer audit

uuid-producer-audit/README.md

@@ -0,0 +1,55 @@
+# TIFXYZ UUID producer audit
+
+TIFXYZ Doctor found that most registered normalized roots reuse the literal
+UUID `output_tifxyz`. This audit distinguishes three questions:
+
+1. **Corpus fact:** how many current registered artifacts reuse each UUID?
+2. **Producer fingerprint:** which public Villa writer has defaults matching
+   the emitted metadata?
+3. **Safe remediation:** can the writer accept an explicit identity without
+   changing its backward-compatible directory-name default?
+
+The corpus result alone does not prove which private production command was
+run. The source fingerprint is reported as an inference and kept separate from
+the directly observed metadata.
+
+## Frozen result (2026-08-02)
+
+- 450 registered TIFXYZ roots were fetched from the current public registry.
+- They contain 174 distinct metadata UUID values.
+- 277/450 roots use the literal UUID `output_tifxyz`.
+- The reuse is systematic in normalized artifacts: 262/262 normalized roots
+  use `output_tifxyz`, versus 15/188 original roots.
+- All 262 normalized roots also use scale `[0.05, 0.05]` and the same five-key
+  metadata shape (`bbox`, `format`, `scale`, `type`, `uuid`).
+- Among 140 segments with both variants, all 140 normalized roots use
+  `output_tifxyz`; 127 of their original counterparts have a source-specific
+  identity.
+
+Every downloaded `meta.json` is represented in `uuid-audit-2026-08-02.json`
+with its public URL and SHA-256. These are collection-identity observations,
+not a claim that geometry or text content is duplicated.
+
+## Producer inference and remediation
+
+The normalized fingerprint is consistent with public
+`vc_obj2tifxyz_legacy` defaults: step size 20 produces scale 0.05, while the
+writer derives `uuid` from the output-directory basename. A production job
+that always writes to a staging directory named `output_tifxyz` would therefore
+create exactly this metadata. The public corpus does not expose its private
+command line, so this remains an inference.
+
+The isolated Villa patch in `../villa` adds `--uuid=<id>` to both current and
+legacy OBJ-to-TIFXYZ converters. An explicit value wins; omitting the option
+retains the historical output-directory behavior. The shared resolver has four
+standalone C++ regression tests covering override, compatibility, fallback,
+and empty-input rejection; all four pass under `clang++ -std=c++20 -Werror`.
+
+A read-only GitHub issue/PR search on 2026-08-02 found no existing Villa item
+matching `uuid`, `tifxyz`, or `output_tifxyz` together.
+
+```bash
+python audit_uuid_metadata.py \
+  --manifest ../boundary-corpus-study/manifest-2026-08-02.json \
+  --output uuid-audit-2026-08-02.json
+```

uuid-producer-audit/audit_uuid_metadata.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Fetch current registered TIFXYZ metadata and quantify UUID reuse."""
+
+from __future__ import annotations
+
+import argparse
+import concurrent.futures
+import hashlib
+import json
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+import requests
+
+
+HTTPS_ROOT = "https://vesuvius-challenge-open-data.s3.amazonaws.com/"
+
+
+def fetch(root: dict) -> dict:
+    url = HTTPS_ROOT + root["prefix"] + "meta.json"
+    response = requests.get(url, timeout=60)
+    response.raise_for_status()
+    metadata = response.json()
+    return {
+        "sample": root["sample"],
+        "segment": root["segment"],
+        "artifact": root["artifact"],
+        "prefix": root["prefix"],
+        "url": url,
+        "sha256": hashlib.sha256(response.content).hexdigest(),
+        "metadata": metadata,
+    }
+
+
+def run(manifest_path: Path, output: Path, workers: int) -> None:
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as pool:
+        records = list(pool.map(fetch, manifest["roots"]))
+    uuid_counts = Counter(str(item["metadata"].get("uuid")) for item in records)
+    by_artifact = defaultdict(Counter)
+    scales = defaultdict(Counter)
+    keysets = defaultdict(Counter)
+    for item in records:
+        artifact = item["artifact"]
+        metadata = item["metadata"]
+        by_artifact[artifact][str(metadata.get("uuid"))] += 1
+        scales[artifact][json.dumps(metadata.get("scale"), separators=(",", ":"))] += 1
+        keysets[artifact][",".join(sorted(metadata))] += 1
+
+    pairs = defaultdict(dict)
+    for item in records:
+        pairs[(item["sample"], item["segment"])][item["artifact"]] = item
+    paired = [value for value in pairs.values() if set(value) == {"tifxyz_original", "tifxyz_normalized"}]
+    normalized_literal_pairs = 0
+    source_specific_original_pairs = 0
+    for pair in paired:
+        normalized_uuid = str(pair["tifxyz_normalized"]["metadata"].get("uuid"))
+        original_uuid = str(pair["tifxyz_original"]["metadata"].get("uuid"))
+        normalized_literal_pairs += normalized_uuid == "output_tifxyz"
+        source_specific_original_pairs += original_uuid not in {"None", "output_tifxyz"}
+
+    result = {
+        "schema_version": "1.0",
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "manifest_sha256": hashlib.sha256(manifest_path.read_bytes()).hexdigest(),
+        "observations": {
+            "registered_roots": len(records),
+            "distinct_uuid_values": len(uuid_counts),
+            "uuid_counts_top20": uuid_counts.most_common(20),
+            "uuid_counts_by_artifact": {
+                key: value.most_common() for key, value in sorted(by_artifact.items())
+            },
+            "scale_counts_by_artifact": {
+                key: value.most_common() for key, value in sorted(scales.items())
+            },
+            "metadata_keysets_by_artifact": {
+                key: value.most_common() for key, value in sorted(keysets.items())
+            },
+            "paired_original_normalized_segments": len(paired),
+            "pairs_with_normalized_uuid_output_tifxyz": normalized_literal_pairs,
+            "pairs_with_source_specific_original_uuid": source_specific_original_pairs,
+        },
+        "source_inference": {
+            "claim": (
+                "The normalized metadata fingerprint is consistent with Villa's "
+                "vc_obj2tifxyz_legacy defaults: scale 1/20 = 0.05 and UUID copied "
+                "from the temporary output-directory basename. This does not prove "
+                "that a private workflow invoked that executable."
+            ),
+            "public_source_locations": {
+                "legacy_default_step_and_scale": "volume-cartographer/apps/src/vc_obj2tifxyz_legacy.cpp",
+                "legacy_uuid_from_output_basename": "volume-cartographer/apps/src/vc_obj2tifxyz_legacy.cpp",
+                "shared_metadata_writer": "volume-cartographer/core/src/QuadSurface.cpp",
+            },
+        },
+        "records": records,
+    }
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(result["observations"], indent=2))
+    print(f"wrote {output}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--workers", type=int, default=24)
+    args = parser.parse_args()
+    run(args.manifest, args.output, args.workers)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())