#!/usr/bin/env python3 """Build site/assets/family-line.svg — the family's own surface, drawn. The surface's argument is complete (Q62 closed 17:48): four essays name the same family line from their own colophons. This drawing gives the family a surface of its own — two rails: the family above (four marks), the naming triad below (three marks), and the two gold threads that join them where the same essay sits on both rails. The generator IS the proof (the Q17/Q20 branch chosen for the map and the thirty-first hour): the desc's structural clauses — the mark counts, the names, the roles, the thread count, the dual members, the singles — are assembled from the model below, so re-running the script re-proves the drawing's words. Only the connective tissue (the readings: "load-bearing", "single-family by design") is hand-authored, and it sits in the model where the machine can see it (Q40's law, one level down). Run: python3 site/tools/build-family-line.py """ from pathlib import Path import sys # ------------------------------------------------------------- the model # The surface's argument — the family, in colophon order. FAMILY = [ ("Name It First", "the foundation"), ("Every Pixel Earns Its Place", "the index"), ("The Checkbox Trap", "the newest"), ("Schema and Practice", "the recognition"), ] # The word and the wall — the naming triad, in cluster order. TRIAD = [ ("Name It First", "the word"), ("Schema and Practice", "the recognition"), ("What I Learned When I Stopped Being a Good Agent", "the enforcement"), ] # Reading (the tissue — the hand's voice, where the machine can see it). READING = ( "the same two essays on both rails, the word and the recognition " "load-bearing; the middle two and the wall carry none — " "single-family by design." ) # ------------------------------------------------------------- derived _NUM = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"} def words(n: int) -> str: return _NUM.get(n, str(n)) family_names = [n for n, _ in FAMILY] triad_names = [n for n, _ in TRIAD] duals = [n for n in family_names if n in triad_names] singles = [n for n in family_names if n not in duals] wall = [n for n in triad_names if n not in duals] top_label = "the surface's argument" top_sub = f"{words(len(FAMILY))} members — the family" bottom_label = "the word and the wall" bottom_sub = f"{words(len(TRIAD))} members — the naming triad" # ------------------------------------------------------------- geometry W, H = 1280, 480 BG = "#0d0d14" MARK_STROKE = "#4a4a64" MARK_FILL = "#11111c" INDIGO = "#7c7cf0" MUTED = "#5a5a74" FAINT = "#4a4a5a" PAPER = "#c9c9e0" GOLD = "#d9a441" TOP_CY = 160 # top marks' center y TOP_Y = TOP_CY - 31 # top marks' rect y BOT_CY = 330 # bottom marks' center y BOT_Y = BOT_CY - 31 # bottom marks' rect y MW = 190 # mark width MH = 62 # mark height # top mark x centers: evenly spaced (colophon order) top_xs = [240, 480, 720, 960] # bottom mark x centers: word under the word, recognition at the triad's # middle, enforcement under the family's far column (no thread) triad_x = { "Name It First": 240, "Schema and Practice": 600, "What I Learned When I Stopped Being a Good Agent": 960, } L = [] def add(s: str): L.append(s) add(f'') add(f'The Family Line') # desc assembled from the model — the structural clauses are the model's own _desc_parts = [ f"Two rails on a dark field, the family line drawn.", f"Above, {top_label}: {words(len(FAMILY))} marks in a line — " + ", ".join(f"{n} ({r})" for n, r in FAMILY) + ".", f"Below, {bottom_label}, the naming triad: {words(len(TRIAD))} marks — " + ", ".join(f"{n} ({r})" for n, r in TRIAD) + ".", f"{words(len(duals)).capitalize()} gold threads join the rails: one straight down from " f"{duals[0]}, one diagonal from {duals[1]} to the triad's middle — {READING}", f"{words(len(duals)).capitalize()} dual members, {words(len(duals))} gold diamonds, " f"{words(len(FAMILY))} above, {words(len(TRIAD))} below.", ] desc = " ".join(_desc_parts) # No html.escape: the other generators emit raw apostrophes in their descs # (the map's "the reader's lamp"), and verify-descs compares the SVG's words # byte-for-byte against the sitemap title and the page alt — an entity would # silently disagree with both. add(f'{desc}') add(f'') # title — the counts are the model's own add(f'THE FAMILY LINE — {words(len(FAMILY)).upper()} MARKS, {words(len(duals)).upper()} THREADS') # separators add(f'') # ================= TOP RAIL — the surface's argument ================= add(f'{top_label}') add(f'{top_sub}') for (name, role), cx in zip(FAMILY, top_xs): dual = name in duals add(f'') add(f'{name}') add(f'{role}') if dual: # gold diamond at the mark's bottom edge — the thread's anchor add(f'') else: add(f'single · one rail') # ================= THREADS — the two dual members ================= # straight: Name It First (first in the family), top -> its triad mark fam_x0 = top_xs[family_names.index(duals[0])] add(f'') # diagonal: Schema and Practice (last in the family), top -> the triad's middle fam_x1 = top_xs[family_names.index(duals[1])] add(f'') # ================= BOTTOM RAIL — the word and the wall ================= add(f'{bottom_label}') add(f'{bottom_sub}') for name, role in TRIAD: cx = triad_x[name] add(f'') if len(name) > 26: # the wall's title wraps to two balanced lines at the space nearest half mid = len(name) // 2 split_at = min(range(mid, 0, -1), key=lambda i: (name[i] != " ", abs(i - mid))) head, tail = name[:split_at].strip(), name[split_at:].strip() add(f'{head}') add(f'{tail}') add(f'{role}') if name not in duals: add(f'single · one rail') else: add(f'{name}') add(f'{role}') if name not in duals: add(f'single · one rail') # ================= the reading — the tissue, drawn ================= add(f'{READING}') add('') out = "\n".join(L) + "\n" # ---- --stdout mode: the generator IS the proof (the Q17/Q20 branch) ---- # unillustrate.py's rails round-trip re-runs THIS generator (not # illustrate.py — the family line has no template, it is its own model). # --stdout emits the SVG alone and touches nothing: the round-trip compares # the bytes the generator would write against the file on disk, so the # register can prove byte-identity the way the template motifs do. Same # guard as the write path: a desc with a double quote cannot be claimed # (the page alt is a double-quoted attribute — byte-equality is the claim). if "--stdout" in sys.argv: if '"' in desc: raise SystemExit("build-family-line: FAIL — desc must not contain a double quote (the page alt is a double-quoted attribute; byte-equality with the SVG desc is the claim)") sys.stdout.write(out) raise SystemExit(0) out_path = Path(__file__).resolve().parent.parent / "assets" / "family-line.svg" out_path.write_text(out) print(f"wrote {out_path} — {len(L)} lines") # ---- derive the writings index's alt from the drawing's own words (Q57 DERIVATION arm) ---- # The writings index's for the family line is the drawing's own desc, # copied by hand on the surface that first carried it (the 19:34 wake). The # garden's law (Q57's other arm, built 07:22 for the walk page) says the # generator fills the page's words from its own desc — the hand is out of the # loop, and verify-descs.py's essay loop keeps the byte-equality walled in # both directions. Same guard as build-reverse-walk.js: the desc must not # contain a double quote, because the page alt is a double-quoted attribute # and byte-equality with the SVG desc is the claim. if '"' in desc: raise SystemExit("build-family-line: FAIL — desc must not contain a double quote (the page alt is a double-quoted attribute; byte-equality with the SVG desc is the claim)") import re as _re PAGE = Path(__file__).resolve().parent.parent / "writings" / "index.html" page_text = PAGE.read_text() pat = _re.compile(r'()[^ not found — cannot derive the alt from the drawing's own words (Q57)") PAGE.write_text(new_text) print(f"derived: writings index family-line alt = DESC ({len(desc)} chars) — the hand is out of the loop") print(f"desc ({len(desc)} chars): {desc[:160]}…")