holo-evicted-publish: player +4 object(s)

b/00b8cf7da4a06ec9ee95edda7ea2277e08218c7998cd4dd834cd88031be37d25

@@ -0,0 +1,137 @@
+// holo-library.mjs — THE PLANE: the κ-addressed universe catalog at runtime (HOLO-TV-LIBRARY-PROMPT.md L2).
+//
+// A lean resolver over the forge's shards: the tiny root (feed/library-index.json) names every shard by
+// TWO hashes — blake3 (the κ-mirror path) and sha256 (the verify key). Reads are verify-or-refuse (Law
+// L5): bytes are cached raw in CacheStorage and RE-HASHED on every read; a tampered shard is refused by
+// name, never parsed. Once cached, the whole universe browses OFFLINE and every facet pivot is a plain
+// in-memory scan over compact rows — ~19k titles filter in well under a frame, no bitset machinery needed.
+//
+// Dependency-injected (fetch + cache + sha256) so Node witnesses it with fake shards — no network.
+// Browser binding: window.HoloLibrary.live() → { load, query, search, person, personsIndex, rows, root }.
+
+// createLibrary({ root, fetch, cacheGet, cachePut, sha256hex })
+//   root      : the parsed library-index.json (or null → loadRoot() fetches it)
+//   cacheGet  : async (sha) → Uint8Array | null      cachePut: async (sha, bytes) → void
+//   sha256hex : async (Uint8Array) → hex
+export function createLibrary({ root = null, fetch: f, cacheGet, cachePut, sha256hex, rootUrl = "feed/library-index.json" } = {}) {
+  const doFetch = f || (typeof fetch !== "undefined" ? fetch.bind(globalThis) : null);
+  if (!doFetch) throw new Error("holo-library: fetch required");
+  let R = root, rows = [], byKey = new Map(), loaded = false, personsCache = null, searchIdx = null;
+  const stats = { shardsFromCache: 0, shardsFromNet: 0, refused: 0 };
+
+  async function loadRoot() {
+    if (R) return R;
+    // network-first (fresh universe), then HTTP cache, then the LAST GOOD root parked in the object cache —
+    // a returning user boots the whole library with the network gone (P4 offline-first).
+    try { R = await (await doFetch(rootUrl + "?v=" + Date.now(), { cache: "no-store" })).json(); }
+    catch { try { R = await (await doFetch(rootUrl)).json(); } catch { R = null; } }
+    if (R && cachePut) { try { await cachePut("root", new TextEncoder().encode(JSON.stringify(R))); } catch {} }
+    if (!R && cacheGet) { const c = await cacheGet("root"); if (c) R = JSON.parse(new TextDecoder().decode(c)); }
+    if (!R) throw new Error("holo-library: no root reachable (network + cache empty)");
+    return R;
+  }
+  // verify-or-refuse read of ONE named object { sha256, blake3 }
+  async function readObject(ref, name) {
+    if (cacheGet) {
+      const c = await cacheGet(ref.sha256);
+      if (c) {
+        if ((await sha256hex(c)) === ref.sha256) { stats.shardsFromCache++; return c; }
+        stats.refused++; console.warn("holo-library: REFUSED tampered cache object", name, ref.sha256.slice(0, 12));
+      }
+    }
+    const res = await doFetch(R.mirror + ref.blake3);
+    if (!res.ok) throw new Error("holo-library: mirror " + res.status + " for " + name);
+    const bytes = new Uint8Array(await res.arrayBuffer());
+    if ((await sha256hex(bytes)) !== ref.sha256) { stats.refused++; throw new Error("holo-library: REFUSED " + name + " — bytes do not re-derive"); }
+    stats.shardsFromNet++;
+    if (cachePut) await cachePut(ref.sha256, bytes);
+    return bytes;
+  }
+  const dec = (u8) => JSON.parse(new TextDecoder().decode(u8));
+
+  // load(onShard) — pull all shards (parallel), verify each, build the in-memory plane.
+  async function load(onShard = null) {
+    if (loaded) return rows;
+    await loadRoot();
+    const parts = await Promise.all(R.shards.map(async (ref, n) => {
+      const s = dec(await readObject(ref, "shard" + n));
+      if (onShard) try { onShard(n, s.rows.length); } catch {}
+      return s.rows;
+    }));
+    rows = parts.flat();
+    byKey = new Map(rows.map((r) => [r.k + r.i, r]));
+    loaded = true;
+    return rows;
+  }
+
+  // ── facet algebra — one scan, every dimension composable ────────────────────────────────────────────────
+  // q: { kind:"m"|"t", genres:[ids], moods:[keys], decades:[1980,…], runtimeMax, runtimeMin, ratingMin,
+  //      votesMax (hidden gems), lang, person (id), exclude:Set(keys), limit, sort:"top"|"new"|"old"|"az" }
+  function query(q = {}) {
+    let list = rows;
+    if (q.person != null) { const p = personsCache && personsCache[q.person]; list = p ? p.t.map((k) => byKey.get(k)).filter(Boolean) : []; }
+    const out = [];
+    for (const r of list) {
+      if (q.kind && r.k !== q.kind) continue;
+      if (q.genres && q.genres.length && !q.genres.some((g) => r.g.includes(g))) continue;
+      if (q.moods && q.moods.length && !q.moods.some((m) => r.m.includes(m))) continue;
+      if (q.decades && q.decades.length && !q.decades.includes(r.dec)) continue;
+      if (q.runtimeMax && !(r.rt && r.rt <= q.runtimeMax)) continue;
+      if (q.runtimeMin && !(r.rt && r.rt >= q.runtimeMin)) continue;
+      if (q.ratingMin && !(r.r >= q.ratingMin)) continue;
+      if (q.votesMax && !(r.v <= q.votesMax)) continue;
+      if (q.lang && r.l !== q.lang) continue;
+      if (q.exclude && q.exclude.has(r.k + r.i)) continue;
+      out.push(r);
+    }
+    const score = (r) => r.r * Math.log10(1 + r.v);                    // quality × confidence
+    if (q.sort === "az") out.sort((a, b) => a.t.localeCompare(b.t));
+    else if (q.sort === "new") out.sort((a, b) => b.y - a.y || score(b) - score(a));
+    else if (q.sort === "old") out.sort((a, b) => a.y - b.y || score(b) - score(a));
+    else out.sort((a, b) => score(b) - score(a));
+    return q.limit ? out.slice(0, q.limit) : out;
+  }
+
+  // search-as-you-type over the full index (lazy lowercase map; prefix beats substring)
+  function search(text, limit = 40) {
+    const t = String(text || "").toLowerCase().trim();
+    if (!t) return [];
+    if (!searchIdx) searchIdx = rows.map((r) => [r.t.toLowerCase(), r]);
+    const pre = [], sub = [];
+    for (const [lt, r] of searchIdx) {
+      if (lt.startsWith(t)) pre.push(r);
+      else if (lt.includes(t)) sub.push(r);
+      if (pre.length >= limit) break;
+    }
+    const sc = (r) => r.r * Math.log10(1 + r.v);
+    pre.sort((a, b) => sc(b) - sc(a)); sub.sort((a, b) => sc(b) - sc(a));
+    return [...pre, ...sub].slice(0, limit);
+  }
+
+  // persons (lazy) — person id → { n: name, t: [rowKeys] }; enables the "tap a face → filmography" pivot
+  async function personsIndex() {
+    if (personsCache) return personsCache;
+    await loadRoot();
+    personsCache = dec(await readObject(R.persons, "persons")).persons;
+    return personsCache;
+  }
+  async function person(id) { return (await personsIndex())[id] || null; }
+
+  return {
+    load, query, search, person, personsIndex, loadRoot,
+    get rows() { return rows; }, get root() { return R; }, get loaded() { return loaded; },
+    rowByKey: (k) => byKey.get(k) || null, stats: () => ({ ...stats }),
+  };
+}
+
+// ── browser binding — CacheStorage raw-bytes tier + SubtleCrypto verify ─────────────────────────────────
+if (typeof window !== "undefined") {
+  const CACHE = "holo-library-objects";   // content-addressed: entries never change, only appear
+  const sha256hex = async (u8) => [...new Uint8Array(await crypto.subtle.digest("SHA-256", u8))].map((b) => b.toString(16).padStart(2, "0")).join("");
+  const cacheGet = async (sha) => { try { const c = await caches.open(CACHE); const r = await c.match("https://holo.local/lib/" + sha); return r ? new Uint8Array(await r.arrayBuffer()) : null; } catch { return null; } };
+  const cachePut = async (sha, bytes) => { try { const c = await caches.open(CACHE); await c.put("https://holo.local/lib/" + sha, new Response(bytes)); } catch {} };
+  let one = null;
+  window.HoloLibrary = { createLibrary, live() { return one || (one = createLibrary({ sha256hex, cacheGet, cachePut })); } };
+}
+
+export default { createLibrary };

b/0546f3b90f9f5b7318967dabc5afed0247424f3b59fedb8746042fb0599c6f90

@@ -0,0 +1,115 @@
+{
+ "$comment": "Holo TV Library root — the κ-addressed universe catalog. Each shard/persons object lives on the κ-mirror at b/<blake3>; sha256 is the verify key (SubtleCrypto at runtime, verify-or-refuse). Rows are compact: i/k/t/y/dec/g[]/m[](moods)/r/v/p/b/rt/imdb/col/c3/dir. Mood taxonomy is a fixed rule table in holo-library-forge.mjs.",
+ "version": 2,
+ "thumbhash": true,
+ "moodTaxonomyVersion": 1,
+ "generatedAt": "2026-07-11",
+ "counts": {
+  "titles": 18712,
+  "movies": 14474,
+  "series": 4238,
+  "persons": 1856
+ },
+ "mirror": "https://huggingface.co/HOLOGRAMTECH/holo-messenger-shell/resolve/main/b/",
+ "moods": [
+  "feelgood",
+  "dark",
+  "mindbending",
+  "cozy",
+  "adrenaline",
+  "tearjerker",
+  "scary",
+  "romantic",
+  "epic",
+  "quirky",
+  "truestory",
+  "family"
+ ],
+ "shards": [
+  {
+   "sha256": "d2e261229323a13aeb96964794e53b8666dbe0d7ff74767fec3001dfa7527852",
+   "blake3": "a92629dbd613fa4d9f5beffdc129b988e59c1de4134512709a05660391e7fea4",
+   "bytes": 318860
+  },
+  {
+   "sha256": "a38f1234acbeec00c823ee9c31eaa5b51d4d840fddae11bb0644b58d858dd881",
+   "blake3": "16ecc4e9c94e1c19661e2618b5ed11bbaa4b5b250366f9643fe388d6693a0078",
+   "bytes": 325376
+  },
+  {
+   "sha256": "b9a56739fdb6c7945d7dca6f6c942b56ba0d91f4339dbee6628d1e632dbdfdb3",
+   "blake3": "577d031f65706f04ca4e53501bba6c33ab18c8c4f15fb6033b03e6335ed3e33d",
+   "bytes": 311092
+  },
+  {
+   "sha256": "032e2dbfe0cb95cd5111a676c9e732255796b374ab1551332c386f1f01cd52a2",
+   "blake3": "20e7fc59b9c3e09f06db096b748d908c2ad2704ef5ea9a874c20e5e97f244ca7",
+   "bytes": 320466
+  },
+  {
+   "sha256": "f76bfbc163a1067c6d95cc350723a316b8d12859dbb92f35eee1ab6b380caa49",
+   "blake3": "07d695bf2d9d9cd2306f7b35cf398a02bded8824bb7a242ee47f1f045a81b998",
+   "bytes": 307474
+  },
+  {
+   "sha256": "2feb5fa70aee133edc0bfac0c778f022e92c5f234bd2cda299ba9586447a395b",
+   "blake3": "70897235fb9455bc9fb526cb96fb67734395c626be4654ad9e4d57a73d918e99",
+   "bytes": 323573
+  },
+  {
+   "sha256": "9e09e6580ce873f8f3eba3d0876b0cda13111d6fa132f70a63f23317c9c9d279",
+   "blake3": "afa09ba7128ecee94541eefe4bd45c4f3c8e509ddb4d65be4996682124806105",
+   "bytes": 316769
+  },
+  {
+   "sha256": "56b7382403180510cdce4324b4cd43fc9b55ffda7253e09e8c42c2ea4e819554",
+   "blake3": "70febd6a953f13218655baaad9ac5b79e6fec3650481555204b9d3c1ef787659",
+   "bytes": 297402
+  },
+  {
+   "sha256": "1d76736fc7d920d4bfcfb546c2cdf159369033ce1145400787caef7aff6d3b72",
+   "blake3": "eecd2cfa43d503a1fa0f8360abf1dee47c46289d68782920a122b7422410bd58",
+   "bytes": 303760
+  },
+  {
+   "sha256": "007be2d4e0b8cb3d1f24252f3ad26252574f9d369cab2c400091768dbe384edb",
+   "blake3": "c7b58078fd43b8b87cc21b553a91481d99eb396b4e8e753ef626bbc1fd0667ca",
+   "bytes": 309154
+  },
+  {
+   "sha256": "162976700a78c3579bbb2ba8f779457ee62682b01f981c87fd2160fcb00b6cb8",
+   "blake3": "620a8d3cdf0fbccc7107512e02543390fafe47ae8a95c3a2a97e6196da5271c3",
+   "bytes": 310759
+  },
+  {
+   "sha256": "f78c0b2b516d01a556e24339e6cf9f476ad8e787fa62f27136645b18937257ed",
+   "blake3": "27953cfa655cccd43477b9929932772d80af8f0ad7898ffac87a9bf162b60f09",
+   "bytes": 328843
+  },
+  {
+   "sha256": "a228cf9548613e6e1c0d474cee5ba89762fe3b9ce920b889e234ff2c748cd319",
+   "blake3": "83b144dcc6fcfbcd91f4970b7dcbce2b9d29ff3cee266b7b3007958dbb922e40",
+   "bytes": 332231
+  },
+  {
+   "sha256": "ebe97488b2244dff262fc776483b98bee10e9cdce0ee4132c1992e4880e53344",
+   "blake3": "46c77e4286f2c148681cefe4d57d1e3c9ba4d602a44c82b0800798c559cdf133",
+   "bytes": 304097
+  },
+  {
+   "sha256": "e095069d38d1a8985b4d6743a1550b5e18b23c1400642d2ef371d2855bc2f0cd",
+   "blake3": "007e6e4e9dd1ae84eb84a628fca3aba0a63628b3b278018062b5cdca9d2a10a9",
+   "bytes": 304596
+  },
+  {
+   "sha256": "8f05fbb5f221014512abff69dc51876255cc4950108f6fe77612a0fb8dec0dbe",
+   "blake3": "861b40c8f8f61aee3036deee1594745f810a5a55e23777ddc36131d0378c7508",
+   "bytes": 311049
+  }
+ ],
+ "persons": {
+  "sha256": "5d86ef6c1b5ec78c7e0ddd11a8d3ada0b24d6a879f2e7e5567b8a6dcb28a7531",
+  "blake3": "3c6d39d693bc0cb5e46d572037269e20b6379985350e4d72bb6fbfdf2831670e",
+  "bytes": 179005
+ }
+}

b/1d14232cc5710fada7b165e6dae8f481b5bac754d82963b8c9f93d59a2a99354

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+// holo-library-forge.mjs — THE FORGE: the movie/TV universe → κ (HOLO-TV-LIBRARY-PROMPT.md L1).
+//
+// Sweeps TMDb /discover by year × kind (vote floors keep it real titles, not noise), enriches the head
+// of the popularity curve with one append_to_response call each (runtime · imdb · collection · top cast ·
+// director · keywords→moods), and mints the whole catalog as CONTENT-ADDRESSED shards:
+//
+//   rows      → 16 shards (hash(id)%16), each a raw-JSON κ-object (sha256 of bytes = verify key,
+//               blake3 of bytes = the κ-mirror path b/<hex>)
+//   persons   → ONE inverse posting object (person → their title ids; persons with ≥3 titles)
+//   root      → feed/library-index.json (tiny, published in the Q repo): shard κs + counts + taxonomy
+//
+// Deterministic: same input → same rows → same κs (rows sorted by id; JSON.stringify of plain objects
+// with fixed key order; undefined fields OMITTED — the RFC-8785 lesson). Moods are a FIXED rule table
+// (versioned below), never a model call. Resumable: every network page lands in a checkpoint file first.
+//
+//   node holo-library-forge.mjs             sweep + enrich + mint + UPLOAD + write root
+//   node holo-library-forge.mjs --dry       sweep + mint locally, print κs + sizes, no upload/root
+//   node holo-library-forge.mjs --no-net    re-mint from the checkpoint only (deterministic re-derive)
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { createHash } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const HOLOGRAM = path.resolve(HERE, "../../..");
+const { blake3hex } = await import(pathToFileURL(path.join(HOLOGRAM, "holo-os/system/os/usr/lib/holo/holo-blake3.mjs")).href);
+
+const DRY = process.argv.includes("--dry");
+const NO_NET = process.argv.includes("--no-net");
+// --thumbhash <map.json> — P1 (INSTANT PLANE): merge key→holo-thumbhash (~26B) into each row as `h`,
+// so the whole universe paints its own colours from the shards alone (see holo-thumbhash.mjs).
+const THUMBS = (() => { const i = process.argv.indexOf("--thumbhash"); if (i < 0) return null; try { return JSON.parse(readFileSync(process.argv[i + 1], "utf8")); } catch { throw new Error("--thumbhash map unreadable"); } })();
+const KEY = "45f791c5f6a6940a50403bb3890c7b86";           // the built-in community key (holo-tmdb.mjs)
+const API = "https://api.themoviedb.org/3";
+const CKPT = path.join(HERE, ".library-forge-checkpoint.json");
+const SHARDS = 16;
+const YEARS = { movie: [1940, new Date().getFullYear()], tv: [1950, new Date().getFullYear()] };
+const FLOOR = { movie: 200, tv: 100 };                     // vote_count floors (L0-probed: ≈19k titles)
+const ENRICH_TOP = 5000;                                   // head of the curve gets runtime/cast/keywords
+const MIRROR = "https://huggingface.co/HOLOGRAMTECH/holo-messenger-shell/resolve/main/b/";
+const HF_REPO = "HOLOGRAMTECH/holo-messenger-shell";
+
+// ── mood taxonomy v1 — FIXED deterministic rules (genres ∪ keyword clusters); versioned, never a model ──
+export const MOOD_TAXONOMY_VERSION = 1;
+const KW = {
+  mindbending: ["time travel", "time loop", "parallel", "memory", "dream", "simulation", "plot twist", "identity", "surreal", "nonlinear"],
+  tearjerker: ["grief", "terminal illness", "cancer", "tragedy", "loss of", "death of", "holocaust", "euthanasia"],
+  quirky: ["surreal", "absurd", "black comedy", "dark comedy", "satire", "offbeat", "deadpan", "mockumentary"],
+  truestory: ["based on true story", "based on a true story", "biography", "based on real events", "true events", "biopic"],
+};
+const kwHit = (kws, list) => list.some((n) => kws.some((k) => k.includes(n)));
+// g = tmdb genre ids (movie+tv unioned); rt minutes|0; r rating; v votes; kws lowercase keyword names
+export function moodsOf({ g = [], rt = 0, r = 0, v = 0, kws = [] }) {
+  const has = (...ids) => ids.some((x) => g.includes(x));
+  const m = [];
+  if (has(35, 10402, 10751) && r >= 6.5) m.push("feelgood");
+  if (has(80, 53, 9648) && !has(10751, 16) ) m.push("dark");
+  if ((has(878, 10765) && has(9648)) || kwHit(kws, KW.mindbending)) m.push("mindbending");
+  if (has(10751, 16, 10749) && (!rt || rt <= 115) && r >= 6) m.push("cozy");
+  if (has(28, 53, 10759)) m.push("adrenaline");
+  if (has(18) && (kwHit(kws, KW.tearjerker) || (has(10749) && r >= 7.2))) m.push("tearjerker");
+  if (has(27)) m.push("scary");
+  if (has(10749)) m.push("romantic");
+  if (has(12, 10752, 36, 14, 10765, 10768) && ((rt >= 140) || v >= 5000)) m.push("epic");
+  if (has(35) && kwHit(kws, KW.quirky)) m.push("quirky");
+  if (kwHit(kws, KW.truestory) || has(36, 99)) m.push("truestory");
+  if (has(10751, 16, 10762)) m.push("family");
+  return m;
+}
+export const MOODS = ["feelgood", "dark", "mindbending", "cozy", "adrenaline", "tearjerker", "scary", "romantic", "epic", "quirky", "truestory", "family"];
+
+// ── polite, resumable TMDb ───────────────────────────────────────────────────────────────────────────────
+let inflight = 0, lastTick = 0;
+async function tmdb(p, params = {}) {
+  const u = new URL(API + p); u.searchParams.set("api_key", KEY);
+  for (const [k, v] of Object.entries(params)) u.searchParams.set(k, String(v));
+  for (let attempt = 0; ; attempt++) {
+    const wait = Math.max(0, lastTick + 34 - Date.now());               // ≈29 req/s ceiling
+    lastTick = Math.max(Date.now(), lastTick + 34);
+    if (wait) await new Promise((r) => setTimeout(r, wait));
+    const res = await fetch(u).catch(() => null);
+    if (res && res.status === 429) { await new Promise((r) => setTimeout(r, 1500 * (attempt + 1))); continue; }
+    if (!res || !res.ok) { if (attempt >= 3) throw new Error("tmdb " + (res ? res.status : "net") + " " + p); await new Promise((r) => setTimeout(r, 800 * (attempt + 1))); continue; }
+    return res.json();
+  }
+}
+
+// ── the sweep (checkpointed) ─────────────────────────────────────────────────────────────────────────────
+const ckpt = existsSync(CKPT) ? JSON.parse(readFileSync(CKPT, "utf8")) : { discover: {}, enrich: {} };
+const saveCkpt = () => writeFileSync(CKPT, JSON.stringify(ckpt));
+
+async function sweep() {
+  for (const kind of ["movie", "tv"]) {
+    const [y0, y1] = YEARS[kind];
+    for (let y = y0; y <= y1; y++) {
+      const ck = kind + ":" + y;
+      if (ckpt.discover[ck]) continue;
+      const yearParam = kind === "movie" ? { primary_release_year: y } : { first_air_date_year: y };
+      const base = { ...yearParam, "vote_count.gte": FLOOR[kind], sort_by: "vote_count.desc", include_adult: false };
+      const first = await tmdb(`/discover/${kind}`, { ...base, page: 1 });
+      const pages = Math.min(first.total_pages || 1, 500);
+      const rows = [...(first.results || [])];
+      for (let pg = 2; pg <= pages; pg++) rows.push(...((await tmdb(`/discover/${kind}`, { ...base, page: pg })).results || []));
+      ckpt.discover[ck] = rows.map((t) => ({
+        id: t.id, kind, title: kind === "movie" ? t.title : t.name,
+        year: parseInt((kind === "movie" ? t.release_date : t.first_air_date) || "0") || 0,
+        g: t.genre_ids || [], r: Math.round((t.vote_average || 0) * 10) / 10, v: t.vote_count || 0,
+        p: t.poster_path || null, b: t.backdrop_path || null, l: t.original_language || "",
+      }));
+      saveCkpt();
+      if (y % 10 === 0) console.log(`sweep ${ck}: ${rows.length} titles`);
+    }
+  }
+}
+
+async function enrich(all) {
+  const head = [...all].sort((a, b) => b.v - a.v).slice(0, ENRICH_TOP);
+  let done = 0;
+  for (const t of head) {
+    const ck = t.kind + ":" + t.id;
+    if (!(ck in ckpt.enrich)) {
+      try {
+        const d = await tmdb(`/${t.kind}/${t.id}`, { append_to_response: "keywords,credits,external_ids" });
+        const kws = ((d.keywords && (d.keywords.keywords || d.keywords.results)) || []).map((k) => (k.name || "").toLowerCase());
+        const cast = ((d.credits && d.credits.cast) || []).slice(0, 3).map((c) => [c.id, c.name]);
+        const dir = ((d.credits && d.credits.crew) || []).find((c) => c.job === "Director" || c.job === "Creator");
+        ckpt.enrich[ck] = {
+          rt: d.runtime || (Array.isArray(d.episode_run_time) && d.episode_run_time[0]) || 0,
+          imdb: (d.external_ids && d.external_ids.imdb_id) || d.imdb_id || null,
+          col: (d.belongs_to_collection && d.belongs_to_collection.id) || null,
+          colName: (d.belongs_to_collection && d.belongs_to_collection.name) || null,
+          c3: cast.length ? cast : null, dir: dir ? [dir.id, dir.name] : null, kws,
+          seasons: d.number_of_seasons || null,
+        };
+      } catch { ckpt.enrich[ck] = {}; }
+      if (++done % 250 === 0) { saveCkpt(); console.log(`enrich ${done}/${head.length}`); }
+    }
+  }
+  saveCkpt();
+}
+
+// ── mint: rows → shards → κ ──────────────────────────────────────────────────────────────────────────────
+const sha256hex = (buf) => createHash("sha256").update(buf).digest("hex");
+function mint() {
+  const seen = new Set(); const all = [];
+  for (const rows of Object.values(ckpt.discover)) for (const t of rows) {
+    const k = t.kind + ":" + t.id;
+    if (seen.has(k) || !t.year || !t.p) continue;   // no art or no year = not library-grade
+    seen.add(k); all.push(t);
+  }
+  const persons = new Map();   // id → { n: name, t: [rowKey…] }
+  const rows = all.map((t) => {
+    const e = ckpt.enrich[t.kind + ":" + t.id] || {};
+    const kws = e.kws || [];
+    const row = {
+      i: t.id, k: t.kind === "movie" ? "m" : "t", t: t.title, y: t.year, dec: Math.floor(t.year / 10) * 10,
+      g: t.g, m: moodsOf({ g: t.g, rt: e.rt || 0, r: t.r, v: t.v, kws }),
+      r: t.r, v: t.v, p: t.p, b: t.b || undefined, l: t.l || undefined,
+      rt: e.rt || undefined, imdb: e.imdb || undefined, col: e.col || undefined, cn: e.colName || undefined,
+      sn: e.seasons || undefined,
+      h: (THUMBS && THUMBS[(t.kind === "movie" ? "m" : "t") + t.id]) || undefined,   // ~26B poster soul (P1)
+    };
+    const key = row.k + row.i;
+    for (const pers of [...(e.c3 || []), ...(e.dir ? [e.dir] : [])]) {
+      const rec = persons.get(pers[0]) || { n: pers[1], t: [] };
+      rec.t.push(key); persons.set(pers[0], rec);
+    }
+    if (e.c3) row.c3 = e.c3.map((c) => c[0]);
+    if (e.dir) row.dir = e.dir[0];
+    return JSON.parse(JSON.stringify(row));         // strips undefined — κ-stable bytes
+  }).sort((a, b) => (a.k + a.i < b.k + b.i ? -1 : 1));
+
+  const shards = Array.from({ length: SHARDS }, () => []);
+  for (const r of rows) shards[(r.i + (r.k === "t" ? 7 : 0)) % SHARDS].push(r);
+  const personsObj = Object.fromEntries([...persons].filter(([, v]) => v.t.length >= 3).sort((a, b) => a[0] - b[0]));
+
+  const objects = shards.map((s, n) => ({ name: "shard" + n, bytes: Buffer.from(JSON.stringify({ v: 1, n, rows: s })) }));
+  objects.push({ name: "persons", bytes: Buffer.from(JSON.stringify({ v: 1, persons: personsObj })) });
+  for (const o of objects) { o.sha256 = sha256hex(o.bytes); o.blake3 = blake3hex(new Uint8Array(o.bytes)); }
+  return { rows, objects, personsCount: Object.keys(personsObj).length };
+}
+
+// ── upload + root ────────────────────────────────────────────────────────────────────────────────────────
+async function upload(objects) {
+  const token = readFileSync(path.join(os.homedir(), ".cache/huggingface/token"), "utf8").trim();
+  const missing = [];
+  for (const o of objects) if (!(await fetch(MIRROR + o.blake3, { method: "HEAD" })).ok) missing.push(o);
+  console.log(`mirror: ${objects.length - missing.length} present, ${missing.length} to upload`);
+  if (missing.length) {
+    const ndjson = [JSON.stringify({ key: "header", value: { summary: `holo-library-forge: ${missing.length} catalog object(s)` } })]
+      .concat(missing.map((o) => JSON.stringify({ key: "file", value: { path: "b/" + o.blake3, content: o.bytes.toString("base64"), encoding: "base64" } })))
+      .join("\n");
+    const r = await fetch(`https://huggingface.co/api/models/${HF_REPO}/commit/main`, {
+      method: "POST", headers: { Authorization: "Bearer " + token, "Content-Type": "application/x-ndjson" }, body: ndjson,
+    });
+    if (!r.ok) throw new Error("HF commit failed: " + r.status + " " + (await r.text()).slice(0, 200));
+    console.log("HF commit ✓");
+  }
+  for (const o of objects) {   // refuse-at-boundary: every object must re-derive from the mirror
+    const back = new Uint8Array(await (await fetch(MIRROR + o.blake3)).arrayBuffer());
+    if (blake3hex(back) !== o.blake3 || sha256hex(Buffer.from(back)) !== o.sha256) throw new Error("mirror does not re-derive: " + o.name);
+  }
+  console.log("mirror re-derives ✓ all", objects.length);
+}
+
+// ── run ──────────────────────────────────────────────────────────────────────────────────────────────────
+if (!NO_NET) { await sweep(); }
+const preAll = Object.values(ckpt.discover).flat();
+if (!NO_NET) { await enrich(preAll.filter((t) => t.p && t.year)); }
+const { rows, objects, personsCount } = mint();
+const total = objects.reduce((s, o) => s + o.bytes.length, 0);
+console.log(`minted ${rows.length} titles (${rows.filter((r) => r.k === "m").length} movies · ${rows.filter((r) => r.k === "t").length} series) · ${personsCount} persons · ${objects.length} objects · ${(total / 1048576).toFixed(1)} MB`);
+for (const o of objects) console.log(`  ${o.name}: ${(o.bytes.length / 1024).toFixed(0)} KB sha256:${o.sha256.slice(0, 12)}… blake3:${o.blake3.slice(0, 12)}…`);
+
+if (!DRY) {
+  await upload(objects);
+  const root = {
+    $comment: "Holo TV Library root — the κ-addressed universe catalog. Each shard/persons object lives on the κ-mirror at b/<blake3>; sha256 is the verify key (SubtleCrypto at runtime, verify-or-refuse). Rows are compact: i/k/t/y/dec/g[]/m[](moods)/r/v/p/b/rt/imdb/col/c3/dir. Mood taxonomy is a fixed rule table in holo-library-forge.mjs.",
+    version: THUMBS ? 2 : 1, thumbhash: !!THUMBS, moodTaxonomyVersion: MOOD_TAXONOMY_VERSION, generatedAt: new Date().toISOString().slice(0, 10),
+    counts: { titles: rows.length, movies: rows.filter((r) => r.k === "m").length, series: rows.filter((r) => r.k === "t").length, persons: personsCount },
+    mirror: MIRROR, moods: MOODS,
+    shards: objects.filter((o) => o.name.startsWith("shard")).map((o) => ({ sha256: o.sha256, blake3: o.blake3, bytes: o.bytes.length })),
+    persons: (({ sha256, blake3, bytes }) => ({ sha256, blake3, bytes: bytes.length }))(objects.find((o) => o.name === "persons")),
+  };
+  writeFileSync(path.join(HERE, "feed/library-index.json"), JSON.stringify(root, null, 1) + "\n");
+  console.log("root written: feed/library-index.json ✓");
+}

b/c4b2125423bba7997b58b761894a40a671b6da3a0f754d214cfac8da2f039025

@@ -0,0 +1,56 @@
+// holo-thumbhash.mjs — the poster's SOUL in ~26 bytes, shipped inside its κ-row (INSTANT-PLANE P1).
+//
+// A 4×6 RGB332 micro-thumbnail: enough to paint every tile in the library with its own colours in ONE
+// frame, from the shards alone — offline, before a single image request exists. The real artwork then
+// crossfades over it (same colours by construction, so it never pops). Self-consistent codec: WE encode
+// (forge, Node) and WE decode (player, browser) — no external format to match, nothing to drift.
+//
+//   encode: rgbaToHash(rgba, w, h)  — rgba = Uint8Array RGBA at EXACTLY w×h (forge downsamples first)
+//   decode: hashToDataURL(b64)      — tiny canvas → smoothed PNG data URL (browser only)
+
+const W = 4, H = 6;                 // grid — portrait 2:3, matches poster tiles
+export const GRID = { W, H };
+
+// RGB → one byte: RRRGGGBB (3-3-2). Blurred to bits anyway; hue survives, weight stays tiny.
+const pack = (r, g, b) => ((r >> 5) << 5) | ((g >> 5) << 2) | (b >> 6);
+const unpack = (v) => [((v >> 5) & 7) * 36.5, ((v >> 2) & 7) * 36.5, (v & 3) * 85];
+
+// rgba (w×h×4) → base64 hash. Header byte = 0x1 (version) — future grids can coexist.
+export function rgbaToHash(rgba, w = W, h = H) {
+  if (!rgba || rgba.length < w * h * 4) return null;
+  const out = new Uint8Array(1 + w * h);
+  out[0] = 0x1;
+  for (let i = 0; i < w * h; i++) out[1 + i] = pack(rgba[i * 4], rgba[i * 4 + 1], rgba[i * 4 + 2]);
+  return typeof Buffer !== "undefined" ? Buffer.from(out).toString("base64") : btoa(String.fromCharCode(...out));
+}
+
+export function hashToBytes(b64) {
+  try {
+    const bin = typeof Buffer !== "undefined" ? new Uint8Array(Buffer.from(b64, "base64")) : (() => { const s = atob(b64); const u = new Uint8Array(s.length); for (let i = 0; i < s.length; i++) u[i] = s.charCodeAt(i); return u; })();
+    return bin[0] === 0x1 && bin.length === 1 + W * H ? bin : null;
+  } catch { return null; }
+}
+
+// browser: hash → data URL (memoized — same hash decodes once per session)
+const memo = typeof Map !== "undefined" ? new Map() : null;
+export function hashToDataURL(b64) {
+  if (!b64) return null;
+  if (memo && memo.has(b64)) return memo.get(b64);
+  const bin = hashToBytes(b64);
+  if (!bin || typeof document === "undefined") return null;
+  const c = document.createElement("canvas"); c.width = W; c.height = H;
+  const ctx = c.getContext("2d");
+  const id = ctx.createImageData(W, H);
+  for (let i = 0; i < W * H; i++) { const [r, g, b] = unpack(bin[1 + i]); id.data[i * 4] = r; id.data[i * 4 + 1] = g; id.data[i * 4 + 2] = b; id.data[i * 4 + 3] = 255; }
+  ctx.putImageData(id, 0, 0);
+  // upscale with smoothing so the placeholder is a soft gradient, not visible blocks
+  const up = document.createElement("canvas"); up.width = W * 8; up.height = H * 8;
+  const uctx = up.getContext("2d"); uctx.imageSmoothingEnabled = true; uctx.imageSmoothingQuality = "high";
+  uctx.drawImage(c, 0, 0, up.width, up.height);
+  const url = up.toDataURL("image/png");
+  if (memo) memo.set(b64, url);
+  return url;
+}
+
+if (typeof window !== "undefined") window.HoloThumbHash = { rgbaToHash, hashToDataURL, hashToBytes, GRID };
+export default { rgbaToHash, hashToDataURL, hashToBytes, GRID };