#!/usr/bin/env python3 """ regenerate_surfaces.py — bring every derived surface into agreement with data/registry.json. ═══════════════════════════════════════════════════════════════════════════════ THE PROBLEM THIS SCRIPT SOLVES ═══════════════════════════════════════════════════════════════════════════════ data/registry.json is the canonical source of truth for all deposits. But Alexanarch serves the archive through MANY derived surfaces, and if any of them goes stale relative to registry.json the archive is internally inconsistent — a deposit can exist in the registry but be invisible to anyone browsing the site. The derived surfaces are: 1. s/browse/index.html — static browse page (every deposit, no JS) 2. data/browse-index.json — compact JSON of all deposits (used by tools) 3. data/chunks/registry/*.json — 1MB-targeted chunks for streaming 4. data/chunks/registry/_index.json — chunk catalog metadata 5. sitemap.xml — XML sitemap for crawlers 6. SHA256SUMS.txt — content-addressable checksums The mint-axn.yml workflow handles registry + record pages + deposits/*.md, but does NOT touch ANY of the six derived surfaces above. The result is that any deposit minted through the auto-flow leaves the archive in an inconsistent state until someone runs this script. THE FIX: run this script after EVERY change to data/registry.json. ═══════════════════════════════════════════════════════════════════════════════ USAGE ═══════════════════════════════════════════════════════════════════════════════ python3 scripts/regenerate_surfaces.py # regenerate all surfaces python3 scripts/regenerate_surfaces.py --dry-run # show what would change python3 scripts/regenerate_surfaces.py --only browse # only browse page python3 scripts/regenerate_surfaces.py --only browse,chunks # subset Available surfaces: browse, browse-index, chunks, sitemap, sha256sums After running this script the archive is internally consistent. The script is idempotent — running it twice produces the same result. ═══════════════════════════════════════════════════════════════════════════════ """ import argparse import hashlib import json import os import sys from datetime import datetime, timezone from pathlib import Path # Import canonical navbar renderer sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) from scripts.render_navbar import render_navbar REPO_ROOT = Path(__file__).resolve().parent.parent REGISTRY_PATH = REPO_ROOT / "data" / "registry.json" # Pre-overwrite receipt mechanism (workplan item 8.13). # Each regenerator write logs an auto-receipt to data/pre-overwrite-receipts.log # so the audit trail captures EVERY surface-overwrite event, regardless of # whether the write came from an instance or from the regenerator. The # receipt log is the structural complement to the discipline of running # scripts/pre_overwrite.py before any ad-hoc edit. sys.path.insert(0, str(Path(__file__).resolve().parent)) try: from overwrite_guard import issue_auto_receipt _OVERWRITE_GUARD_AVAILABLE = True except ImportError: _OVERWRITE_GUARD_AVAILABLE = False ALL_SURFACES = ["state", "browse", "browse-index", "chunks", "sitemap", "sha256sums", "wiki", "graph", "homepage-noscript", "api-index"] def _receipt(path, reason: str = "regenerate_surfaces write"): """Issue an auto-receipt for a regenerator write. No-op if guard module isn't importable (defensive — the script should still work even if the guard module is missing or temporarily broken).""" if not _OVERWRITE_GUARD_AVAILABLE: return try: issue_auto_receipt(path, actor="regenerate_surfaces", reason=reason, instance_id=os.environ.get("ALEXANARCH_INSTANCE_ID", "regenerator")) except Exception as e: # Don't let receipt failure block a regenerator run; log and continue. print(f"[regenerate_surfaces] warning: receipt failed for {path}: {e}", file=sys.stderr) # ────────────────────────────────────────────────────────────────────────────── # Helpers # ────────────────────────────────────────────────────────────────────────────── def load_registry(): with open(REGISTRY_PATH) as f: return json.load(f) def esc_html(s): if s is None: return "" return (str(s) .replace("&", "&") .replace("<", "<") .replace(">", ">") .replace('"', """)) def esc_xml(s): if s is None: return "" return (str(s) .replace("&", "&") .replace("<", "<") .replace(">", ">") .replace("'", "'") .replace('"', """)) # ────────────────────────────────────────────────────────────────────────────── # Surface 1: s/browse/index.html # ────────────────────────────────────────────────────────────────────────────── BROWSE_HEADER = """ Browse — Alexanarch ({total} deposits)

Complete Deposit Registry

{total} deposits · sorted by deposit number, oldest first · for newest see home page
""" BROWSE_CARD = """
#{n} {title}{version_chip}
{axn}{status_badge}
 """ BROWSE_FOOTER = """
Alexanarch
∮ = 1
""" def regenerate_browse(reg, dry_run=False): """Rebuild s/browse/index.html — the canonical static browse surface. Sort order: ascending by deposit_number (#1 first). This matches the existing convention. Most-recent deposits appear at the bottom of the page; use the home page Recent Deposits section to see newest-first. """ deposits = reg["deposits"] total = len(deposits) sorted_deps = sorted( deposits, key=lambda d: d.get("deposit_number") or d.get("issue_number") or 0, ) jsonld = json.dumps({ "@context": "https://schema.org", "@type": "DataCatalog", "@id": "https://alexanarch.org/s/browse/", "name": "Alexanarch — Complete Deposit Registry", "description": f"Self-governing library for machine-mediated scholarship. {total} deposits with content-derived AXN identifiers.", "url": "https://alexanarch.org/s/browse/", "creator": { "@type": "Person", "name": "Lee Sharks", "identifier": "https://orcid.org/0009-0000-1599-0703", }, "license": "https://creativecommons.org/licenses/by/4.0/", "dateModified": datetime.now(timezone.utc).strftime("%Y-%m-%d"), "numberOfItems": total, }) parts = [BROWSE_HEADER.format(total=total, jsonld=jsonld).replace('__NAVBAR_TOKEN__', render_navbar()[len('')])] for d in sorted_deps: n = d.get("deposit_number") or d.get("issue_number") or 0 if n == 0: continue # Version / status chips version = d.get("version", "") status = d.get("status", "ACTIVE") superseded_by_n = d.get("superseded_by_deposit_number") in_real_series = bool(d.get("version_series_id")) version_chip = '' if version and (version != 'v1.0' or in_real_series): version_chip = f' {esc_html(version)}' status_badge = '' card_opacity = '' if status == 'SUPERSEDED' and superseded_by_n: status_badge = f' · superseded by #{superseded_by_n}' card_opacity = ';opacity:.65' elif status == 'DRAFT_PENDING': status_badge = ' · draft pending' card_opacity = ';opacity:.65' parts.append(BROWSE_CARD.format( n=n, title=esc_html(d.get("title", "(untitled)")), date=esc_html(d.get("date", "")), axn=esc_html(d.get("axn", "")), version_chip=version_chip, status_badge=status_badge, card_opacity=card_opacity, )) parts.append(BROWSE_FOOTER) out = "".join(parts) target = REPO_ROOT / "s" / "browse" / "index.html" if dry_run: print(f" [DRY] would write {target} ({len(out):,} bytes, {total} deposits)") return target.parent.mkdir(parents=True, exist_ok=True) _receipt(target) with open(target, "w", encoding="utf-8") as f: f.write(out) print(f" ✓ s/browse/index.html ({len(out):,} bytes, {total} deposits)") # ────────────────────────────────────────────────────────────────────────────── # Surface 2: data/browse-index.json # ────────────────────────────────────────────────────────────────────────────── def regenerate_browse_index(reg, dry_run=False): """Rebuild data/browse-index.json — compact deposit list for tools.""" deposits = reg["deposits"] out = { "total": len(deposits), "deposits": [], } for d in sorted(deposits, key=lambda x: x.get("deposit_number") or x.get("issue_number") or 0): n = d.get("deposit_number") or d.get("issue_number") or 0 if n == 0: continue # Compact schema preserves existing format: n/a/t/c/d/f/s/y desc = d.get("description", "") or "" snippet = desc[:200] if len(desc) > 200: snippet += "..." out["deposits"].append({ "n": n, "a": d.get("axn", ""), "t": d.get("title", ""), "c": d.get("creator", ""), "d": d.get("date", ""), "f": d.get("download_md") or d.get("full_text_path") or f"/data/texts/AXN-{d.get('hex','')}-text.md", "s": snippet, "y": d.get("content_type", ""), }) target = REPO_ROOT / "data" / "browse-index.json" payload = json.dumps(out, ensure_ascii=False, indent=2) if dry_run: print(f" [DRY] would write {target} ({len(payload):,} bytes)") return _receipt(target) with open(target, "w", encoding="utf-8") as f: f.write(payload) print(f" ✓ data/browse-index.json ({len(payload):,} bytes, {len(out['deposits'])} deposits)") # ────────────────────────────────────────────────────────────────────────────── # Surface 3 + 4: data/chunks/registry/*.json + _index.json # ────────────────────────────────────────────────────────────────────────────── def regenerate_chunks(reg, dry_run=False, chunk_target_bytes=1_000_000): """ Rebuild data/chunks/registry/chunk-NNN-deposits-X-to-Y.json + _index.json. The chunking strategy: walk deposits in deposit_number order; greedily fill each chunk until adding the next deposit would exceed chunk_target_bytes; then close the chunk and start a new one. Existing chunk file names use the actual first/last deposit numbers they contain. """ deposits = sorted( reg["deposits"], key=lambda d: d.get("deposit_number") or d.get("issue_number") or 0, ) deposits = [d for d in deposits if (d.get("deposit_number") or d.get("issue_number"))] chunks_dir = REPO_ROOT / "data" / "chunks" / "registry" chunks_dir.mkdir(parents=True, exist_ok=True) chunks = [] current = [] chunk_num = 1 def serialize_chunk(deps_in_chunk, num): """Return (chunk_obj, serialized_bytes) for a candidate chunk.""" first = deps_in_chunk[0].get("deposit_number") or deps_in_chunk[0].get("issue_number") last = deps_in_chunk[-1].get("deposit_number") or deps_in_chunk[-1].get("issue_number") obj = { "chunk_number": num, "first_deposit": first, "last_deposit": last, "count": len(deps_in_chunk), "deposits": deps_in_chunk, } payload = json.dumps(obj, ensure_ascii=False, indent=2) return obj, payload def flush(deps_in_chunk, num): obj, payload = serialize_chunk(deps_in_chunk, num) first, last = obj["first_deposit"], obj["last_deposit"] path = chunks_dir / f"chunk-{num:03d}-deposits-{first}-to-{last}.json" payload_bytes = payload.encode("utf-8") chunk_sha = hashlib.sha256(payload_bytes).hexdigest() if dry_run: print(f" [DRY] would write {path.name} (#{first}-#{last}, {len(payload):,} bytes, sha256 {chunk_sha[:16]}…)") else: _receipt(path) with open(path, "w", encoding="utf-8") as f: f.write(payload) return { "chunk_number": num, "path": str(path.relative_to(REPO_ROOT)), "first_deposit": first, "last_deposit": last, "count": len(deps_in_chunk), "size_bytes": len(payload_bytes), "sha256": chunk_sha, } # Remove existing chunk files (recreate fresh from current registry) if not dry_run: for f in chunks_dir.glob("chunk-*.json"): f.unlink() for d in deposits: # Measure exact size of chunk if we added this deposit _, candidate_payload = serialize_chunk(current + [d], chunk_num) if current and len(candidate_payload.encode("utf-8")) > chunk_target_bytes: chunks.append(flush(current, chunk_num)) chunk_num += 1 current = [] current.append(d) if current: chunks.append(flush(current, chunk_num)) index_obj = { "@context": "https://schema.org", "@type": "DataCatalog", "name": "Alexanarch Registry — Chunked", "chunk_target_bytes": chunk_target_bytes, "total_chunks": len(chunks), "total_deposits": len(deposits), "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ"), "chunks": chunks, } index_path = chunks_dir / "_index.json" payload = json.dumps(index_obj, indent=4) if dry_run: print(f" [DRY] would write {index_path} ({len(chunks)} chunks, {len(deposits)} deposits)") else: _receipt(index_path) with open(index_path, "w", encoding="utf-8") as f: f.write(payload) print(f" ✓ data/chunks/registry/ ({len(chunks)} chunks, {len(deposits)} deposits)") # ────────────────────────────────────────────────────────────────────────────── # Surface 5: sitemap.xml # ────────────────────────────────────────────────────────────────────────────── # Static (non-deposit) URLs the sitemap must always include STATIC_URLS = [ # Core ("https://alexanarch.org/", 1.0), ("https://alexanarch.org/deposit/", 0.8), ("https://alexanarch.org/guide/", 0.8), ("https://alexanarch.org/manifest/", 0.8), ("https://alexanarch.org/principles/", 0.8), ("https://alexanarch.org/identifiers/", 0.8), # Discovery surfaces (the 7 the audit flagged as missing) ("https://alexanarch.org/observatory/", 0.9), ("https://alexanarch.org/lexical/", 0.8), ("https://alexanarch.org/citations/", 0.8), ("https://alexanarch.org/captures/", 0.8), ("https://alexanarch.org/addresses/", 0.7), ("https://alexanarch.org/resolve/", 0.7), ("https://alexanarch.org/datasets/", 0.7), # Generated surfaces ("https://alexanarch.org/s/browse/", 0.7), ("https://alexanarch.org/s/wiki/", 0.6), ("https://alexanarch.org/s/graph/", 0.6), # Canonical data ("https://alexanarch.org/data/registry.json", 0.5), ("https://alexanarch.org/data/state.json", 0.6), ("https://alexanarch.org/data/navigation.json", 0.4), ("https://alexanarch.org/data/doi-resolution-index.json", 0.5), ("https://alexanarch.org/data/batch-axn-assignment.json", 0.4), ("https://alexanarch.org/data/chunks/registry/_index.json", 0.4), # Protocols ("https://alexanarch.org/api/index.json", 0.6), ("https://alexanarch.org/api/deposit-protocol.json", 0.5), ("https://alexanarch.org/api/deposit-schema.json", 0.5), ("https://alexanarch.org/api/axn-protocol.json", 0.5), ("https://alexanarch.org/api/enrichment-protocol.json", 0.4), ("https://alexanarch.org/api/lifecycle-protocol.json", 0.5), # Documents ("https://alexanarch.org/AGENTS.md", 0.4), ("https://alexanarch.org/DEPOSIT-FLOW.md", 0.4), ] def regenerate_sitemap(reg, dry_run=False): """Rebuild sitemap.xml — every static URL + every deposit record page.""" today = datetime.now(timezone.utc).strftime("%Y-%m-%d") lines = ['', ''] for url, priority in STATIC_URLS: lines.append(f' {esc_xml(url)}{today}{priority}') deposits = sorted( reg["deposits"], key=lambda d: d.get("deposit_number") or d.get("issue_number") or 0, ) for d in deposits: n = d.get("deposit_number") or d.get("issue_number") if not n: continue last = esc_xml(d.get("date") or today) lines.append( f' https://alexanarch.org/s/records/{n}/' f'{last}0.6' ) lines.append("") out = "\n".join(lines) + "\n" target = REPO_ROOT / "sitemap.xml" if dry_run: print(f" [DRY] would write {target} ({len(out):,} bytes, {len(deposits)} deposit URLs)") return _receipt(target) with open(target, "w", encoding="utf-8") as f: f.write(out) print(f" ✓ sitemap.xml ({len(out):,} bytes, {len(deposits)} deposit URLs)") # ────────────────────────────────────────────────────────────────────────────── # Surface 6: SHA256SUMS.txt # ────────────────────────────────────────────────────────────────────────────── def regenerate_sha256sums(reg, dry_run=False): """Rebuild two complementary integrity manifests. The audit (§16) correctly noted that the historical SHA256SUMS.txt used semantic labels rather than file paths, which standard verification tools can't use. Fix: emit two files. 1. SHA256SUMS.txt — real-file-path manifest in `sha256sum -c` format. Lists data/texts/AXN-NNNN-text.md paths with the actual sha256 of the file bytes. Standard tools verify byte integrity directly. 2. RECORD-SHA256-MANIFEST.txt — semantic-label manifest (the old format, kept under a clearer name). Lists registry-declared content hashes against AXN identities. Useful for verifying that a deposit's registry-declared hash matches what was minted. Both regenerate together; the audit's complaint is closed by having real-file checksums alongside the semantic ones. """ deposits = reg["deposits"] # SHA256SUMS.txt — real file paths, hashes computed from disk file_lines = [] semantic_lines = [] for d in deposits: hex_id = d.get("hex", "") title = (d.get("title") or "").strip() # Semantic manifest h = d.get("hash") or d.get("content_sha256") if h: semantic_lines.append(f"{h} AXN-{hex_id} {title}") # Real-file manifest — only for deposits that have an on-disk text file text_rel = f"data/texts/AXN-{hex_id}-text.md" text_path = REPO_ROOT / text_rel if text_path.exists(): try: file_h = hashlib.sha256(text_path.read_bytes()).hexdigest() file_lines.append(f"{file_h} {text_rel}") except Exception: pass file_lines.sort() semantic_lines.sort() file_out = "\n".join(file_lines) + "\n" semantic_out = "\n".join(semantic_lines) + "\n" sha_target = REPO_ROOT / "SHA256SUMS.txt" rec_target = REPO_ROOT / "RECORD-SHA256-MANIFEST.txt" if dry_run: print(f" [DRY] would write {sha_target} ({len(file_lines)} file lines, {len(file_out):,} bytes)") print(f" [DRY] would write {rec_target} ({len(semantic_lines)} record lines, {len(semantic_out):,} bytes)") return _receipt(sha_target) with open(sha_target, "w", encoding="utf-8") as f: f.write(file_out) print(f" ✓ SHA256SUMS.txt ({len(file_lines)} file lines, real paths, sha256sum -c verifiable)") _receipt(rec_target) with open(rec_target, "w", encoding="utf-8") as f: f.write(semantic_out) print(f" ✓ RECORD-SHA256-MANIFEST.txt ({len(semantic_lines)} record lines, semantic AXN→hash mapping)") # ────────────────────────────────────────────────────────────────────────────── # Wiki tab — project /s/wiki/index.html from registry wiki_article + entity-index # ────────────────────────────────────────────────────────────────────────────── WIKI_PATH = REPO_ROOT / "s" / "wiki" / "index.html" ENTITY_INDEX_PATH = REPO_ROOT / "data" / "entity-index.json" def _load_entity_index(): """Load entity-index.json if present, else return None.""" if not ENTITY_INDEX_PATH.exists(): return None with open(ENTITY_INDEX_PATH) as f: return json.load(f) def regenerate_wiki(reg, dry_run=False): """Regenerate the wiki surface as a paginated single page. Architecture mirrors /addresses/: one HTML file, fetches a flat JSON, JS paginates 25 entries per page with search. The previous chunked URL layout (/s/wiki/chunk-NNN-deposits-X-to-Y/) is removed -- those URLs exposed repository internals to readers who only want to see wikis. Outputs: data/wiki-entries.json -- flat array consumed by JS; also a machine-readable wiki dataset s/wiki/index.html -- single-page paginated view """ eidx = _load_entity_index() concepts = (eidx or {}).get("concepts", {}) if eidx else {} entries = [] for d in sorted(reg["deposits"], key=lambda x: x.get("deposit_number", 0)): wiki_article = (d.get("wiki_article") or "").strip() if not wiki_article: continue entries.append(d) defines_by_deposit = {} for term, c in concepts.items(): di = c.get("defined_in") if di is None: continue defines_by_deposit.setdefault(di, []).append(term) flat = [] for d in entries: dn = d["deposit_number"] defines = sorted(defines_by_deposit.get(dn, []) or d.get("defines_concepts") or []) refby_total = sum(concepts.get(t, {}).get("reference_count", 0) for t in defines) flat.append({ "n": dn, "axn": d.get("axn", ""), "title": d.get("title") or "(untitled)", "creator": d.get("creator") or d.get("author") or "", "date": d.get("date", ""), "wiki": (d.get("wiki_article") or "").strip(), "defines": defines, "refby_total": refby_total, }) json_payload = { "schema_version": "v1.0", "purpose": "Flat wiki-entries dataset projected from data/registry.json wiki_article fields and back-linked to data/entity-index.json. Source for /s/wiki/ paginated view; also a machine-readable wiki dataset.", "count": len(flat), "corpus_size": len(reg["deposits"]), "entries": flat, } json_str = json.dumps(json_payload, ensure_ascii=False, indent=None, separators=(",", ":")) # Static header + page-content prefix body_pre = ( f'

' f'Wiki entries auto-projected from data/registry.json ' f'wiki_article fields and back-linked to ' f'data/entity-index.json. ' f'{len(flat):,} entries from a corpus of ' f'{len(reg["deposits"]):,} deposits. ' f'Read from data/wiki-entries.json.' f'

\n' f'\n' f'
\n' f'
Loading...
\n' f'
\n' ) # JS pagination — clean raw triple-string, no Python-string escape gymnastics js = r"""""" html = _WIKI_HTML_HEAD + body_pre + js + _WIKI_HTML_TAIL json_path = REPO_ROOT / "data" / "wiki-entries.json" html_path = WIKI_PATH if dry_run: print(f" [dry-run] data/wiki-entries.json would be {len(json_str):,} bytes ({len(flat)} entries)") print(f" [dry-run] s/wiki/index.html would be {len(html):,} bytes (JS-paginated, 25 per page)") chunk_dirs = list((REPO_ROOT / "s" / "wiki").glob("chunk-*")) if chunk_dirs: print(f" [dry-run] would delete {len(chunk_dirs)} chunk dir(s)") return json_path.parent.mkdir(parents=True, exist_ok=True) _receipt(json_path) with open(json_path, "w", encoding="utf-8") as f: f.write(json_str + "\n") html_path.parent.mkdir(parents=True, exist_ok=True) _receipt(html_path) html_path.write_text(html, encoding="utf-8") # Remove obsolete chunk directories import shutil chunk_dirs = list((REPO_ROOT / "s" / "wiki").glob("chunk-*")) for cdir in chunk_dirs: if cdir.is_dir(): shutil.rmtree(cdir) print(f" ✓ data/wiki-entries.json ({len(json_str):,} bytes, {len(flat)} entries)") print(f" ✓ s/wiki/index.html ({len(html):,} bytes, JS-paginated 25 per page)") if chunk_dirs: print(f" ✓ removed {len(chunk_dirs)} obsolete chunk director{'y' if len(chunk_dirs)==1 else 'ies'}") CITATION_GRAPH_PATH = REPO_ROOT / "data" / "citation-graph.json" GRAPH_PATH = REPO_ROOT / "s" / "graph" / "index.html" def _load_citation_graph(): if not CITATION_GRAPH_PATH.exists(): return None with open(CITATION_GRAPH_PATH) as f: return json.load(f) def regenerate_graph(reg, dry_run=False): """Project the graph tab from entity_triples + citation_graph. Renders subject→predicate→object triples in the same visual format the hand-curated graph used to use ([observed]/[inferred]/[performative]). Sourced from: - entity-index.json: each concept's entity_triples[] array - citation-graph.json: deposit→deposit edges become (deposit, cites, deposit) triples """ eidx = _load_entity_index() citation_graph = _load_citation_graph() # Gather triples from entity_triples first concept_triples = [] if eidx: for term, c in eidx.get("concepts", {}).items(): for tr in (c.get("entity_triples") or [])[:3]: # top 3 per concept to avoid explosion s = tr.get("subject") or term p = tr.get("predicate") o = tr.get("object") ev = tr.get("evidence_status") or "observed" if s and p and o: concept_triples.append((s, p, o, ev)) # Cap concept triples to keep page size reasonable concept_triples = concept_triples[:1500] # Gather deposit-to-deposit citation edges (cap to 500 for page size) deposit_triples = [] if citation_graph: for e in (citation_graph.get("edges") or [])[:500]: src = e.get("source_axn") or f"#{e.get('source_deposit')}" tgt = e.get("target_axn") or f"#{e.get('target_deposit')}" via = e.get("via") or "cites" deposit_triples.append((src, via, tgt, "observed")) total_concept_edges = sum(len((c.get("entity_triples") or [])) for c in (eidx or {}).get("concepts", {}).values()) if eidx else 0 total_citation_edges = len((citation_graph or {}).get("edges") or []) parts = [] parts.append(_GRAPH_HTML_HEAD) parts.append( f'

' f'{total_concept_edges + total_citation_edges:,} total edges ' f'projected from data/entity-index.json ' f'and data/citation-graph.json. ' f'[observed] ' f'[inferred] ' f'[performative]

\n' ) if concept_triples: parts.append('

' f'Concept Relations ' f'(showing first {len(concept_triples):,} of {total_concept_edges:,})

\n') for s, p, o, ev in concept_triples: cls = "evo" if ev == "observed" else "evi" if ev == "inferred" else "evp" parts.append( f'
' f'{esc_html(s)}' f'{esc_html(p)}' f'{esc_html(o)} [{esc_html(ev)}]' f'
\n' ) if deposit_triples: parts.append('

' f'Deposit Citation Edges ' f'(showing first {len(deposit_triples):,} of {total_citation_edges:,})

\n') for s, p, o, ev in deposit_triples: parts.append( f'
' f'{esc_html(s)}' f'{esc_html(p)}' f'{esc_html(o)} [observed]' f'
\n' ) parts.append(_GRAPH_HTML_TAIL) html = "".join(parts) size = len(html.encode("utf-8")) if dry_run: print(f" [dry-run] {GRAPH_PATH} would be {size:,} bytes, {len(concept_triples)+len(deposit_triples)} edges shown") return GRAPH_PATH.parent.mkdir(parents=True, exist_ok=True) _receipt(GRAPH_PATH) GRAPH_PATH.write_text(html, encoding="utf-8") print(f" ✓ s/graph/index.html ({size:,} bytes, {len(concept_triples)+len(deposit_triples)} edges)") # HTML templates for wiki and graph — keep the existing visual style/classes _WIKI_STYLE = """""" _WIKI_HTML_HEAD = ( '' '' 'Wiki — Alexanarch' + _WIKI_STYLE + '
' + render_navbar(active='/s/wiki/') + '

Alexanarch Wiki

' ) _WIKI_HTML_TAIL = ( '
Alexanarch · ' 'ORCID' '
∮ = 1
' '
' '' '\n' ) _GRAPH_STYLE = """""" _GRAPH_HTML_HEAD = ( '' '' 'Knowledge Graph — Alexanarch' + _GRAPH_STYLE + '
' + render_navbar(active='/s/graph/') + '

Knowledge Graph

' ) _GRAPH_HTML_TAIL = ( '
Alexanarch · ' 'ORCID' '
∮ = 1
' '
' '' '\n' ) # ────────────────────────────────────────────────────────────────────────────── # Driver # ────────────────────────────────────────────────────────────────────────────── # ────────────────────────────────────────────────────────────────────────────── # state.json + homepage noscript fallback + api/index.json — single-source-of-truth # ────────────────────────────────────────────────────────────────────────────── def regenerate_state(reg, dry_run=False): """Wraps scripts/generate_state.py — produces data/state.json as the canonical generated source for all displayed counts. """ # Defer to the standalone module so it can also be run directly sys.path.insert(0, str(REPO_ROOT / 'scripts')) import generate_state as _gs if dry_run: st = _gs.build_state() print(f" [dry-run] data/state.json would be regenerated " f"(deposits={st['deposits']['total']}, captures={st['corpus']['captures']})") return _gs.main() def regenerate_homepage_noscript(reg, dry_run=False): """Rewrite the block in index.html so it shows the same N latest deposits the JavaScript renders. Previously hand-maintained with 4 hardcoded records; now generated from registry on every regen so no-JS readers and crawlers see actual current state. The contract: the static fallback must equal what JS would render for the 'Recent Deposits' section. Both pull from data/registry.json — JS at runtime, this generator at build time. """ index_path = REPO_ROOT / 'index.html' if not index_path.exists(): print(f" ⚠ {index_path} not found — skipping") return # Match the JS slice: filter SUPERSEDED out (canonical reference for an # older version is the Version history on the current version's page, # not a separate card here), then take the last 5 by deposit_number, # reverse for newest-first. Keeps the static fallback in parity with # the runtime JS view. deposits = sorted(reg['deposits'], key=lambda d: d.get('deposit_number', 0)) active_deposits = [d for d in deposits if d.get('status', 'ACTIVE') != 'SUPERSEDED'] recent = list(reversed(active_deposits[-5:])) cards = [] for d in recent: n = d.get('deposit_number', 0) axn = esc_html(d.get('axn', '')) title = esc_html(d.get('title', '(untitled)')) creator = esc_html(d.get('creator', '')) date = esc_html(d.get('date', '')) content_type = esc_html(d.get('content_type', '')) desc = esc_html((d.get('description', '') or '')[:250]) if len(d.get('description', '') or '') > 250: desc = desc + '...' # Version chip + status badge (mirrors browse-card logic) version = d.get('version', '') status = d.get('status', 'ACTIVE') superseded_by_n = d.get('superseded_by_deposit_number') in_real_series = bool(d.get('version_series_id')) version_chip = '' if version and (version != 'v1.0' or in_real_series): version_chip = (f' {esc_html(version)}') status_banner = '' opacity = '1' if status == 'SUPERSEDED' and superseded_by_n: opacity = '0.65' status_banner = (f'
' f'⚠ Superseded by #{superseded_by_n}
') elif status == 'DRAFT_PENDING': opacity = '0.65' status_banner = ('
⏳ Draft — body not yet written
') card = ( f'' f'
{axn}
' f'{status_banner}' f'
{title}{version_chip}
' f'
{creator} · {date} · {content_type}
' f'
{desc}
' f'' ) cards.append(card) new_noscript = ( '' ) html = index_path.read_text() # Replace the existing noscript block import re noscript_pattern = re.compile(r'', re.DOTALL) if not noscript_pattern.search(html): print(f" ⚠ index.html has no