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

b/23e4f84b126619414ef90eba73a97fc398e2629b8ced8c90d5390df35caaca26

@@ -0,0 +1,222 @@
+// holo-media-item.mjs — the ONE render-item shape for Holo Player, and the TMDb → item normalizers.
+//
+// Holo Player has always had a single item shape (holo-jellyfin.js: native κ-store + real Jellyfin).
+// This module is the SOURCE OF TRUTH for that shape's superset — it adds, additively:
+//   • a series hierarchy   (kind: movie|series|season|episode; seriesId/seasonNumber/episodeNumber/parentId)
+//   • a rich metadata block (overview, genres, cast, rating, backdrop, logo, tagline, trailer)
+//   • "where to watch"      (providers[] from TMDb watch-providers — the Netflix/Hulu *feel*)
+//   • honest availability   (metadata ≠ bytes: a title is browsable without being playable)
+// Every field the existing player already reads (name, topics, channel, quality, posterUrl, backdrop,
+// blurb, runtimeSec, kappa, playSrc, source, provider, license …) is preserved, so pool()/HoloRank/rails
+// consume a TMDb item with ZERO rail-code change. The shape IS the contract.
+//
+// Pure ESM, no globals, no network — so Node can witness the normalizers exactly. holo-tmdb.mjs wires the
+// network + κ-cache on top; this module never fetches.
+
+// TMDb genre id → human name (movie + tv ids unioned). Used to label rails and feed affinity.
+export const TMDB_GENRES = {
+  28: "Action", 12: "Adventure", 16: "Animation", 35: "Comedy", 80: "Crime", 99: "Documentary",
+  18: "Drama", 10751: "Family", 14: "Fantasy", 36: "History", 27: "Horror", 10402: "Music",
+  9648: "Mystery", 10749: "Romance", 878: "Science Fiction", 10770: "TV Movie", 53: "Thriller",
+  10752: "War", 37: "Western", 10759: "Action & Adventure", 10762: "Kids", 10763: "News",
+  10764: "Reality", 10765: "Sci-Fi & Fantasy", 10766: "Soap", 10767: "Talk", 10768: "War & Politics",
+};
+
+// Human genre → the player's existing topic keys (so genre rails + HoloRank affinity light up). Genres
+// without a legacy key still flow through as their lowercased name (the player makes genre rails dynamic).
+const GENRE_TO_TOPIC = {
+  "Science Fiction": "scifi", "Sci-Fi & Fantasy": "scifi", Animation: "animation", Fantasy: "fantasy",
+  Comedy: "comedy", Action: "action", "Action & Adventure": "action", Music: "music",
+  Documentary: "nature", Family: "comedy", Adventure: "action",
+};
+
+// TMDb image CDN — no API key needed for images. Sized per surface so cards are crisp without overfetch.
+export const TMDB_IMG = "https://image.tmdb.org/t/p";
+export const posterURL = (p, w = "w500") => (p ? `${TMDB_IMG}/${w}${p}` : null);
+export const backdropURL = (p, w = "w1280") => (p ? `${TMDB_IMG}/${w}${p}` : null);
+// Key-free artwork fallback (Stremio metahub, by IMDb id) — gives every catalog title real, beautiful
+// posters/backdrops with NO TMDb key (the same CDN Cinemeta uses). Used only when TMDb ships no image
+// (the offline seed): a live TMDb fetch, which has its own poster_path, always wins.
+export const METAHUB = "https://images.metahub.space";
+export const metahubPoster = (imdb) => (imdb && /^tt\d+$/.test(imdb) ? `${METAHUB}/poster/medium/${imdb}/img` : null);
+export const metahubBackdrop = (imdb) => (imdb && /^tt\d+$/.test(imdb) ? `${METAHUB}/background/medium/${imdb}/img` : null);
+const yearOf = (d) => (d && /^\d{4}/.test(d) ? +d.slice(0, 4) : null);
+
+const genreNames = (t) => {
+  if (Array.isArray(t.genres)) return t.genres.map((g) => g.name).filter(Boolean);
+  if (Array.isArray(t.genre_ids)) return t.genre_ids.map((id) => TMDB_GENRES[id]).filter(Boolean);
+  return [];
+};
+// topics = legacy keys (for affinity/genre rails) ∪ lowercased raw genres (for dynamic rails). Deduped.
+const topicsOf = (names) => [...new Set(names.flatMap((n) => [GENRE_TO_TOPIC[n], n.toLowerCase()]).filter(Boolean))];
+
+// The honest seam: metadata is not bytes. A freshly-discovered title is browsable, not playable, until a
+// source binds (Phase 2). Callers can pass a pre-resolved source; default = browse-only.
+export const browseOnly = () => ({ playable: false, source: null, kappa: "", playSrc: "", type: "" });
+
+// ── deep-metadata extractors (tolerant: return empty when the append_to_response field is absent) ──────────
+export const DEFAULT_REGION = "US";
+const headshot = (p) => (p ? posterURL(p, "w185") : null);
+// official trailer/teaser key (YouTube) for the ambient hero.
+export function trailerOf(t) {
+  const v = (t.videos && t.videos.results) || [];
+  const f = v.find((x) => x.site === "YouTube" && /Trailer/i.test(x.type)) || v.find((x) => x.site === "YouTube" && /Teaser/i.test(x.type)) || v.find((x) => x.site === "YouTube");
+  return f ? f.key : (t.trailerKey || null);
+}
+function castOf(t) { return ((t.credits && t.credits.cast) || []).slice(0, 12).map((p) => ({ id: p.id, name: p.name, character: p.character || "", profile: headshot(p.profile_path) })); }
+function crewOf(t, kind) {
+  if (kind === "series") return ((t.created_by) || []).map((p) => p.name);
+  return ((t.credits && t.credits.crew) || []).filter((p) => p.job === "Director").map((p) => p.name);
+}
+function certOf(t, kind, region = DEFAULT_REGION) {
+  if (kind === "series") { const r = (t.content_ratings && t.content_ratings.results) || []; const m = r.find((x) => x.iso_3166_1 === region) || r[0]; return (m && m.rating) || ""; }
+  const rd = (t.release_dates && t.release_dates.results) || []; const m = rd.find((x) => x.iso_3166_1 === region) || rd[0];
+  return m ? ((m.release_dates || []).map((x) => x.certification).find(Boolean) || "") : "";
+}
+function logoOf(t) {
+  const lg = (t.images && t.images.logos) || [];
+  if (lg.length) { const en = lg.find((x) => x.iso_639_1 === "en" && /\.png$/i.test(x.file_path)) || lg.find((x) => x.iso_639_1 === "en") || lg[0]; return posterURL(en.file_path, "w300"); }
+  return t.logo_path ? posterURL(t.logo_path, "w300") : null;
+}
+function keywordsOf(t) { const k = (t.keywords && (t.keywords.keywords || t.keywords.results)) || []; return k.slice(0, 10).map((x) => x.name); }
+function imdbOf(t) { return (t.external_ids && t.external_ids.imdb_id) || t.imdb_id || null; }
+// a lightweight item for "More like this" (no recursive append extraction).
+function liteItem(x) {
+  const isTv = !!(x.first_air_date) || (x.name && !x.title) || x.media_type === "tv";
+  const names = genreNames(x);
+  return { id: "tmdb:" + (isTv ? "series" : "movie") + ":" + x.id, tmdbId: x.id, kind: isTv ? "series" : "movie",
+    name: x.title || x.name || "Untitled", year: yearOf(x.release_date || x.first_air_date),
+    posterUrl: posterURL(x.poster_path), backdrop: backdropURL(x.backdrop_path), rating: typeof x.vote_average === "number" ? x.vote_average : null,
+    topics: topicsOf(names), genres: names, channel: "TheMovieDB", quality: x.vote_average ? Math.min(1, x.vote_average / 10) : 0.7,
+    source: "tmdb", provider: "tmdb", kappa: "", holoKappa: "tmdb:" + (isTv ? "series" : "movie") + ":" + x.id, availability: browseOnly() };
+}
+function recsOf(t) {
+  const all = [...(((t.recommendations && t.recommendations.results) || [])), ...(((t.similar && t.similar.results) || []))];
+  const seen = new Set(), out = [];
+  for (const x of all) { const it = liteItem(x); if (seen.has(it.id)) continue; seen.add(it.id); out.push(it); if (out.length >= 12) break; }
+  return out;
+}
+
+// ── normalizers — every one returns the canonical shape ──────────────────────────────────────────────────
+export function normalizeMovie(t, { availability, region } = {}) {
+  const names = genreNames(t);
+  const cd = castOf(t);
+  const imdb = imdbOf(t);
+  return {
+    id: "tmdb:movie:" + t.id, tmdbId: t.id, kind: "movie", name: t.title || t.name || "Untitled",
+    year: yearOf(t.release_date), releaseDate: t.release_date || "",
+    overview: t.overview || "", blurb: t.overview || "", tagline: t.tagline || "",
+    genres: names, topics: topicsOf(names),
+    cast: cd.length ? cd.map((c) => c.name) : (t.cast || []).slice(0, 8), castDetail: cd, directors: crewOf(t, "movie"),
+    rating: typeof t.vote_average === "number" ? t.vote_average : null, certification: certOf(t, "movie", region),
+    keywords: keywordsOf(t), recommendations: recsOf(t), imdbId: imdb,
+    runtimeSec: t.runtime ? t.runtime * 60 : 0,
+    posterUrl: posterURL(t.poster_path) || metahubPoster(imdb), backdrop: backdropURL(t.backdrop_path) || metahubBackdrop(imdb), logoUrl: logoOf(t),
+    trailerKey: trailerOf(t),
+    providers: t.providers || [],
+    channel: "TheMovieDB", quality: t.vote_average ? Math.min(1, t.vote_average / 10) : 0.7, license: "",
+    source: "tmdb", provider: "tmdb", kappa: "", holoKappa: "tmdb:movie:" + t.id,
+    availability: availability || browseOnly(),
+  };
+}
+
+export function normalizeSeries(t, { availability, region } = {}) {
+  const names = genreNames(t);
+  const imdb = imdbOf(t);
+  return {
+    id: "tmdb:series:" + t.id, tmdbId: t.id, kind: "series", name: t.name || t.title || "Untitled",
+    year: yearOf(t.first_air_date), releaseDate: t.first_air_date || "",
+    overview: t.overview || "", blurb: t.overview || "", tagline: t.tagline || "",
+    genres: names, topics: topicsOf(names),
+    cast: (() => { const cd = castOf(t); return cd.length ? cd.map((c) => c.name) : (t.cast || []).slice(0, 8); })(), castDetail: castOf(t), creators: crewOf(t, "series"),
+    rating: typeof t.vote_average === "number" ? t.vote_average : null, certification: certOf(t, "series", region),
+    keywords: keywordsOf(t), recommendations: recsOf(t), imdbId: imdb, networks: (t.networks || []).map((n) => n.name),
+    seasonCount: t.number_of_seasons || (Array.isArray(t.seasons) ? t.seasons.filter((s) => s.season_number > 0).length : 0),
+    episodeCount: t.number_of_episodes || 0,
+    seasons: Array.isArray(t.seasons)
+      ? t.seasons.filter((s) => s.season_number != null).map((s) => ({
+          id: "tmdb:season:" + t.id + ":" + s.season_number, seriesId: "tmdb:series:" + t.id, seasonNumber: s.season_number,
+          name: s.name || "Season " + s.season_number, episodeCount: s.episode_count || 0,
+          posterUrl: posterURL(s.poster_path), overview: s.overview || "",
+        }))
+      : [],
+    runtimeSec: 0,
+    posterUrl: posterURL(t.poster_path) || metahubPoster(imdb), backdrop: backdropURL(t.backdrop_path) || metahubBackdrop(imdb), logoUrl: logoOf(t),
+    trailerKey: trailerOf(t),
+    providers: t.providers || [],
+    channel: "TheMovieDB", quality: t.vote_average ? Math.min(1, t.vote_average / 10) : 0.7, license: "",
+    source: "tmdb", provider: "tmdb", kappa: "", holoKappa: "tmdb:series:" + t.id,
+    availability: availability || browseOnly(),
+  };
+}
+
+export function normalizeEpisode(ep, series, { availability } = {}) {
+  const sid = "tmdb:series:" + (series.tmdbId ?? series.id);
+  return {
+    id: "tmdb:ep:" + (series.tmdbId ?? series.id) + ":" + ep.season_number + ":" + ep.episode_number,
+    tmdbId: ep.id, kind: "episode",
+    name: ep.name || `Episode ${ep.episode_number}`,
+    seriesId: sid, seriesName: series.name, parentId: "tmdb:season:" + (series.tmdbId ?? series.id) + ":" + ep.season_number,
+    seasonNumber: ep.season_number, episodeNumber: ep.episode_number,
+    overview: ep.overview || "", blurb: ep.overview || "",
+    rating: typeof ep.vote_average === "number" ? ep.vote_average : null,
+    runtimeSec: ep.runtime ? ep.runtime * 60 : 0, releaseDate: ep.air_date || "",
+    posterUrl: backdropURL(ep.still_path, "w300") || series.posterUrl, backdrop: series.backdrop,
+    topics: series.topics || [], genres: series.genres || [],
+    channel: "TheMovieDB", quality: series.quality ?? 0.7, license: "",
+    source: "tmdb", provider: "tmdb", kappa: "", holoKappa: "tmdb:ep:" + (series.tmdbId ?? series.id) + ":" + ep.season_number + ":" + ep.episode_number,
+    availability: availability || browseOnly(),
+  };
+}
+
+// TMDb /watch/providers → a flat, region-stamped list. Honest: provider availability is region- AND
+// time-variant, so the caller stamps the fetch time; we stamp the region here.
+export function normalizeWatchProviders(payload, region = "US") {
+  const r = payload && payload.results && payload.results[region];
+  if (!r) return [];
+  const out = [];
+  for (const type of ["flatrate", "free", "ads", "rent", "buy"]) {
+    for (const p of r[type] || []) out.push({ name: p.provider_name, type, region, logo: posterURL(p.logo_path, "w92"), link: r.link || "" });
+  }
+  // de-dup by provider name keeping the best (flatrate/free) tier
+  const seen = new Map();
+  for (const p of out) if (!seen.has(p.name)) seen.set(p.name, p);
+  return [...seen.values()];
+}
+
+// generic dispatch for a /trending or /search/multi mixed list
+export function normalizeAny(t, opts) {
+  const mt = t.media_type || (t.title ? "movie" : t.name && t.first_air_date !== undefined ? "tv" : t.title ? "movie" : "tv");
+  if (mt === "tv" || t.first_air_date != null || t.number_of_seasons != null) return normalizeSeries(t, opts);
+  return normalizeMovie(t, opts);
+}
+
+// "Where to watch" → a "go watch it there" link. TMDb gives platform NAMES + ONE aggregate JustWatch link per
+// title (no per-provider deep-links), so we open each platform's SEARCH for the title — the honest take-me-there.
+// Unknown platform → the title's JustWatch link, else a web search. Makes the where-to-watch chips ACTIONABLE.
+const WATCH_URLS = {
+  "netflix": (q) => "https://www.netflix.com/search?q=" + q,
+  "disney plus": (q) => "https://www.disneyplus.com/search?q=" + q,
+  "hulu": (q) => "https://www.hulu.com/search?q=" + q,
+  "amazon prime video": (q) => "https://www.amazon.com/s?k=" + q + "&i=instant-video",
+  "amazon video": (q) => "https://www.amazon.com/s?k=" + q + "&i=instant-video",
+  "max": (q) => "https://play.max.com/search?q=" + q,
+  "hbo max": (q) => "https://play.max.com/search?q=" + q,
+  "apple tv": (q) => "https://tv.apple.com/search?term=" + q,
+  "apple tv plus": (q) => "https://tv.apple.com/search?term=" + q,
+  "youtube": (q) => "https://www.youtube.com/results?search_query=" + q,
+  "peacock": (q) => "https://www.peacocktv.com/search?q=" + q,
+  "paramount plus": (q) => "https://www.paramountplus.com/search/?query=" + q,
+  "paramount+": (q) => "https://www.paramountplus.com/search/?query=" + q,
+  "crunchyroll": (q) => "https://www.crunchyroll.com/search?q=" + q,
+};
+export function watchLink(providerName, item, fallbackLink) {
+  const q = encodeURIComponent((item && item.name) || "");
+  const key = String(providerName || "").toLowerCase().replace(/\s+with\s+ads$/, "").trim();
+  const fn = WATCH_URLS[key];
+  if (fn) return fn(q);
+  if (fallbackLink) return fallbackLink;                                  // TMDb's aggregate JustWatch link for the title
+  return "https://www.google.com/search?q=" + q + "%20watch%20online";    // last resort
+}
+
+export default { normalizeMovie, normalizeSeries, normalizeEpisode, normalizeWatchProviders, normalizeAny, browseOnly, posterURL, backdropURL, watchLink, TMDB_GENRES, TMDB_IMG };

b/52cf82d28c69b7ff9b5ae3df553c65957cf10295013dd6837a1c78e427874ef5

@@ -0,0 +1,16 @@
+{
+  "when": "2026-07-11T08:29:23.457Z",
+  "pass": true,
+  "checks": {
+    "loadsUniverse": true,
+    "verifyRefuse": true,
+    "worksOffline": true,
+    "facetAlgebra": true,
+    "pivotUnderFrame": true,
+    "searchFast": true,
+    "personPivot": true
+  },
+  "fail": [],
+  "p95ms": 1.91,
+  "searchMs": 1.89
+}

b/5f654b793ccf0c8d9b4e6bc530dd15f7a032fd440f7bb353496cbf6692b7374f

@@ -0,0 +1,114 @@
+{
+ "$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": 1,
+ "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": "899d357cb5004de5addb181458ec52a4e282fabfd8cebb62ccf589a8ef1d8dcf",
+   "blake3": "57268b6ebc99004d38c72b7f966ccd8dd8fe3cccb5dd0f62a3d9a15ac1cdd150",
+   "bytes": 267733
+  },
+  {
+   "sha256": "e3fa688522ea3ce62d92cd6f4673729dce85883952d4dd9f5b6de8dfa6d0a20f",
+   "blake3": "6a6a84772313bcfd73301c11c78754cf1d685b1546d7d0420f30b12423b0390b",
+   "bytes": 273045
+  },
+  {
+   "sha256": "b9f4f511bbe1e52f388ee5c2a1cdb54783cd10661b25516f3bdf4eec2c3604b2",
+   "blake3": "a37412bc4a78d83579e7dd734d4d37790a8093db4c0c36926162c4a79be68361",
+   "bytes": 261298
+  },
+  {
+   "sha256": "fcdec94954cf10119e6eebf88986a59911894c862528953f64c82721fcb55adb",
+   "blake3": "15ed6838730d14422d136357d4a4c2f23decb4cc4b8ff37d3043022252fedad7",
+   "bytes": 269554
+  },
+  {
+   "sha256": "1c0d04b28758892b8df09f004c00247f14b6005dd22d7cddcc0c88aad7a0ec3c",
+   "blake3": "b077e38fe5b37f0ca78f07e03fb4753e820d0e5bf176b5c9a1d449c3c7e1ecda",
+   "bytes": 257809
+  },
+  {
+   "sha256": "0ecb222e1fc41a7bfc42f0840eafc951405c4ebb923a8e075d5f9a8e23994b1c",
+   "blake3": "e108d9fa3b23f072cd603b083e689212a17efb410cf5ca44e83031a8f35315fc",
+   "bytes": 271457
+  },
+  {
+   "sha256": "a9359b860826572f5ca186162152869ff62a674988a040bfcd820937e617a8cc",
+   "blake3": "8db5d6e27b8bca40c7d09a8747f8ab10b48912a68408ada34e1d019eda2bdb99",
+   "bytes": 265943
+  },
+  {
+   "sha256": "307563503bdd8834ecab0d9b41c99e864f79ccb78e8603623361a306cdfa40c0",
+   "blake3": "285af202571902c3d5a6ef284ea419ecc37479eb1cdd5bfc8e616b48bec8f3ef",
+   "bytes": 249973
+  },
+  {
+   "sha256": "478f1a92f61e4807bab0c11b8f20b39cee74027287674ef11757187f5debeba1",
+   "blake3": "9cc700200ebfaf0c7c0bab7070de7c704122d4a7a2eac1f99be1ba25aa76958a",
+   "bytes": 255471
+  },
+  {
+   "sha256": "8d830344e9ace494855c063f44407868a21ccd0da178dfdac22fb17cf5b7e5ac",
+   "blake3": "bc51eb2b230db9ebe767cb0583c593e13af1a9bacb8bda30d189ec0c960413de",
+   "bytes": 259790
+  },
+  {
+   "sha256": "f05ee9415de028e9dba4de0d007a22ddfb249ea6a8af8580cb59cbe312d2772b",
+   "blake3": "31be625986b020bca96ecd931d97d67db93c003c5f93a7cf452ba6b4f4c290f3",
+   "bytes": 261008
+  },
+  {
+   "sha256": "e06268932c02d558fad1d36ce1327317190dbba086e5f8b74a9fa9fa5ef7307b",
+   "blake3": "7ef6dfe21b07713cc73e5188df264e5465de9ad49f93c07b23adda17c4779e40",
+   "bytes": 276469
+  },
+  {
+   "sha256": "622bf2bdc0dabd2ef04943988fa4f4a1c0b56e80d5cb56684528135cb53fb823",
+   "blake3": "3d5a39676cce4996cb7cac51d09f6c76ba4a9934033b950046be2ca687ba2738",
+   "bytes": 278653
+  },
+  {
+   "sha256": "062cf09c49de97e943a4973030d9e75cd56a2dac457dcc65fb470950773585da",
+   "blake3": "873b3e87caf5b6641a890d7e21f11d7afd44f3a0b4ab2868e1c6734bc3ec87ad",
+   "bytes": 255464
+  },
+  {
+   "sha256": "85a3270652ccaa4aa69e972da9be0f7dfab00280f96d2d7e10f0f97aabc7fb9b",
+   "blake3": "1f2875d3d4608a221fecb6624b18f79e9caf3283ecf0946f0524e8328045fa85",
+   "bytes": 255963
+  },
+  {
+   "sha256": "493b149742c721385f4d2aecec8c2196945bc6aed3df7535664c830823cc27ac",
+   "blake3": "e2b5fcf26615db3e673cf1e4c365e916d7a687f0016b5d9d457c25eee2478a39",
+   "bytes": 261255
+  }
+ ],
+ "persons": {
+  "sha256": "5d86ef6c1b5ec78c7e0ddd11a8d3ada0b24d6a879f2e7e5567b8a6dcb28a7531",
+  "blake3": "3c6d39d693bc0cb5e46d572037269e20b6379985350e4d72bb6fbfdf2831670e",
+  "bytes": 179005
+ }
+}

b/a43249f4f27206cc010c369c220b1469ee0564c4d75f798d63d2c18425d063be

@@ -0,0 +1,226 @@
+#!/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");
+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,
+    };
+    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: 1, 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/e8e3471220a882a17984b9b6efb6a498bb3c82fcdb7a3547dc3905eed732c2fe

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+// holo-library-witness.mjs — proves the Library plane: verify-or-refuse, offline, and under-a-frame pivots
+// on a universe-scale synthetic catalog. Fake mirror + Map cache — no network, no key.
+//
+// Checks:
+//   1 loadsUniverse    — all shards load, rows concatenated, byKey resolves.
+//   2 verifyRefuse     — a TAMPERED cached shard is refused (re-fetched clean), a tampered MIRROR shard throws.
+//   3 worksOffline     — warm cache + dead network → full load still succeeds (0 fetches).
+//   4 facetAlgebra     — genre ∩ decade ∩ mood ∩ runtime compose correctly (hand-checked expectations).
+//   5 pivotUnderFrame  — 6-way facet pivot over 19,000 rows completes in < 16 ms (p95 of 50 runs).
+//   6 searchFast       — search-as-you-type over 19k titles < 30 ms, prefix beats substring.
+//   7 personPivot      — person posting resolves to their titles via rowByKey.
+//
+// node holo-library-witness.mjs   (from holo-apps/apps/player/)
+
+import { writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { createLibrary } from "./holo-library.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const checks = {}; const fail = [];
+const ok = (n, c, d = "") => { checks[n] = !!c; if (!c) fail.push(n + (d ? ` — ${d}` : "")); return !!c; };
+const sha256hex = async (u8) => createHash("sha256").update(u8).digest("hex");
+
+// ── synthetic universe: 19,000 deterministic rows across 16 shards + persons ────────────────────────────
+const GENRES = [28, 35, 18, 27, 878, 10749, 80, 12, 16, 9648];
+const MOODS = ["feelgood", "dark", "mindbending", "cozy", "adrenaline", "scary", "romantic", "epic"];
+const N = 19000;
+const mk = (i) => ({
+  i, k: i % 4 === 0 ? "t" : "m", t: "Title " + i + (i % 7 === 0 ? " Prefixable" : ""), y: 1940 + (i % 86),
+  dec: Math.floor((1940 + (i % 86)) / 10) * 10, g: [GENRES[i % 10], GENRES[(i + 3) % 10]],
+  m: [MOODS[i % 8]], r: 5 + (i % 50) / 10, v: 100 + (i % 9000), p: "/p" + i + ".jpg", rt: 60 + (i % 120),
+});
+const rows = Array.from({ length: N }, (_, i) => mk(i));
+const shards = Array.from({ length: 16 }, () => []);
+for (const r of rows) shards[(r.i + (r.k === "t" ? 7 : 0)) % 16].push(r);
+const objects = shards.map((s, n) => Buffer.from(JSON.stringify({ v: 1, n, rows: s })));
+const personsObj = { 7: { n: "Test Person", t: [rows[1].k + rows[1].i, rows[2].k + rows[2].i, rows[5].k + rows[5].i] } };
+objects.push(Buffer.from(JSON.stringify({ v: 1, persons: personsObj })));
+const refs = await Promise.all(objects.map(async (b) => ({ sha256: await sha256hex(b), blake3: "fake" + (await sha256hex(b)).slice(0, 8), bytes: b.length })));
+const ROOT = { version: 1, mirror: "https://mirror.test/b/", shards: refs.slice(0, 16), persons: refs[16], counts: { titles: N } };
+const byBlake = new Map(refs.map((r, idx) => [r.blake3, objects[idx]]));
+
+let fetches = 0, netDown = false;
+const fakeFetch = async (url) => {
+  if (netDown) throw new Error("network down");
+  fetches++;
+  const hex = String(url).split("/b/")[1];
+  const b = byBlake.get(hex);
+  return b ? { ok: true, arrayBuffer: async () => new Uint8Array(b).buffer } : { ok: false, status: 404 };
+};
+const kv = new Map();
+const cacheGet = async (sha) => kv.get(sha) || null;
+const cachePut = async (sha, bytes) => { kv.set(sha, bytes); };
+
+// 1 loadsUniverse
+const lib = createLibrary({ root: ROOT, fetch: fakeFetch, cacheGet, cachePut, sha256hex });
+await lib.load();
+ok("loadsUniverse", lib.rows.length === N && lib.rowByKey("m1") && lib.rowByKey("t4"), `rows=${lib.rows.length}`);
+
+// 2 verifyRefuse — tamper a cache entry → refused + healed from mirror; tamper the mirror → throws
+const someSha = ROOT.shards[3].sha256;
+kv.set(someSha, new Uint8Array([1, 2, 3]));
+const lib2 = createLibrary({ root: ROOT, fetch: fakeFetch, cacheGet, cachePut, sha256hex });
+await lib2.load();
+const healed = lib2.stats().refused >= 1 && lib2.rows.length === N && (await sha256hex(kv.get(someSha))) === someSha;
+let mirrorRefused = false;
+{
+  const badFetch = async () => ({ ok: true, arrayBuffer: async () => new Uint8Array([9, 9, 9]).buffer });
+  const lib3 = createLibrary({ root: ROOT, fetch: badFetch, cacheGet: async () => null, cachePut: null, sha256hex });
+  try { await lib3.load(); } catch (e) { mirrorRefused = /REFUSED/.test(String(e)); }
+}
+ok("verifyRefuse", healed && mirrorRefused, `healed=${healed} mirrorRefused=${mirrorRefused}`);
+
+// 3 worksOffline — cache is warm from check 1; kill the network entirely
+netDown = true; fetches = 0;
+const lib4 = createLibrary({ root: ROOT, fetch: fakeFetch, cacheGet, cachePut, sha256hex });
+await lib4.load();
+ok("worksOffline", lib4.rows.length === N && fetches === 0, `rows=${lib4.rows.length} fetches=${fetches}`);
+netDown = false;
+
+// 4 facetAlgebra — hand-checked compositions
+const q1 = lib.query({ genres: [35], decades: [1980] });
+const truth1 = rows.filter((r) => r.g.includes(35) && r.dec === 1980).length;
+const q2 = lib.query({ genres: [35], decades: [1980], moods: ["feelgood"], runtimeMax: 100 });
+const truth2 = rows.filter((r) => r.g.includes(35) && r.dec === 1980 && r.m.includes("feelgood") && r.rt && r.rt <= 100).length;
+const q3 = lib.query({ kind: "t", ratingMin: 8 });
+const truth3 = rows.filter((r) => r.k === "t" && r.r >= 8).length;
+ok("facetAlgebra", q1.length === truth1 && q2.length === truth2 && q3.length === truth3, `${q1.length}/${truth1} ${q2.length}/${truth2} ${q3.length}/${truth3}`);
+
+// 5 pivotUnderFrame — p95 of 50 six-way pivots < 16ms
+const times = [];
+for (let i = 0; i < 50; i++) {
+  const t0 = performance.now();
+  lib.query({ kind: "m", genres: [GENRES[i % 10]], moods: [MOODS[i % 8]], decades: [1970 + (i % 5) * 10], runtimeMax: 150, ratingMin: 6, limit: 60 });
+  times.push(performance.now() - t0);
+}
+times.sort((a, b) => a - b);
+const p95 = times[Math.floor(times.length * 0.95)];
+ok("pivotUnderFrame", p95 < 16, `p95=${p95.toFixed(2)}ms`);
+
+// 6 searchFast — prefix beats substring, < 30ms
+const t0 = performance.now(); const sr = lib.search("title 7"); const searchMs = performance.now() - t0;
+ok("searchFast", searchMs < 30 && sr.length > 0 && sr[0].t.toLowerCase().startsWith("title 7"), `ms=${searchMs.toFixed(2)} first=${sr[0] && sr[0].t}`);
+
+// 7 personPivot
+const p = await lib.person(7);
+const titles = p ? p.t.map((k) => lib.rowByKey(k)).filter(Boolean) : [];
+ok("personPivot", !!p && titles.length === 3 && p.n === "Test Person", JSON.stringify(p));
+
+// ── verdict ─────────────────────────────────────────────────────────────────────────────────────────────
+const pass = fail.length === 0;
+console.log("\nholo-library witness — the κ-addressed universe plane: verified, offline, under-a-frame\n");
+for (const [n, c] of Object.entries(checks)) console.log(`  ${c ? "✓" : "✗"}  ${n}`);
+console.log(pass ? `\n  WITNESSED ✓  ${N} titles · pivot p95 ${p95.toFixed(1)}ms · search ${searchMs.toFixed(1)}ms · tamper refused · offline whole\n` : `\n  FAILED: ${fail.join("; ")}\n`);
+writeFileSync(join(here, "holo-library-witness.result.json"), JSON.stringify({ when: new Date().toISOString(), pass, checks, fail, p95ms: +p95.toFixed(2), searchMs: +searchMs.toFixed(2) }, null, 2));
+process.exit(pass ? 0 : 1);