@polycode-projects/the-mechanical-code-talker 3.0.1 → 3.0.3

package/src/services/ledger-viz.mjs

@@ -504,8 +504,8 @@ function sparkCaptionHtml(stats) {
  *  different questions (did this render even offer the reference; did the
  *  browser actually manage to load it), and both must hold for the live
  *  path to run. */
-export function renderLedgerHtml({ rows, terms, edges, focus, contradictions, worthALook, payload, meta, memoryAskBundle, stats, ledgerBundleAvailable = false } = {}) {
-  const ledgerJson = embedJson({ rows: rows || [], terms: terms || [], edges: edges || [], focus: focus || null, contradictions: contradictions || [], worthALook: worthALook || null, meta: meta || { shown: 0, total: 0, truncated: false } });
+export function renderLedgerHtml({ rows, terms, edges, focus, contradictions, worthALook, payload, meta, memoryAskBundle, stats, ledgerBundleAvailable = false, focusDigest = null, digestStructures = [] } = {}) {
+  const ledgerJson = embedJson({ rows: rows || [], terms: terms || [], edges: edges || [], focus: focus || null, contradictions: contradictions || [], worthALook: worthALook || null, meta: meta || { shown: 0, total: 0, truncated: false }, focusDigest: focusDigest || null, digestStructures: Array.isArray(digestStructures) ? digestStructures : [] });
   const payloadJson = embedJson(payload || { individuals: [], objectProperties: [] });
   const shown = meta?.shown ?? (rows || []).length;
   const title = `tmct ledger — ${shown} fact${shown === 1 ? "" : "s"}${focus ? ` (focus: ${escapeHtml(focus)})` : ""}`;
@@ -641,6 +641,15 @@ ${THEME_TOKENS_CSS}
   .focuscard { background: var(--card); border: 1px solid var(--line); border-radius: 10px; padding: .8rem 1rem; margin-bottom: 1rem; }
   .focuscard .term { font-size: 1.35rem; font-weight: 700; }
   .focuscard .klass, .focuscard .stats { font-family: ${MONO_STACK}; font-size: .72rem; color: var(--muted); margin-top: .3rem; font-variant-numeric: tabular-nums; }
+  .focuscard .focusdigest { margin-top: .7rem; font-size: .92rem; line-height: 1.5; }
+  .focuscard .focusdigest p { margin: 0 0 .4rem; }
+  .focuscard .focusdigest .dgsrc { font-family: ${MONO_STACK}; font-size: .7rem; color: var(--muted); margin-top: .2rem; }
+  .focuscard .focusdigest .dgfacts { margin-top: .5rem; }
+  .focuscard .focusdigest .dgfacts > summary { font-family: ${MONO_STACK}; font-size: .7rem; color: var(--corpus); cursor: pointer; }
+  .focuscard .focusdigest .dgfacts[open] > summary { margin-bottom: .35rem; }
+  .focuscard .focusdigest .dgfactlist { border-top: 1px solid var(--line); }
+  .focuscard .focusdigest .dgfact { font-size: .72rem; padding: .22rem 0; border-bottom: 1px solid var(--line); word-break: break-word; }
+  .focuscard .focusdigest .dgfact:last-child { border-bottom: none; }
   .group { margin: 1.1rem 0; }
   .group h3 { font-family: ${MONO_STACK}; font-size: .68rem; letter-spacing: .08em; text-transform: uppercase; color: var(--muted); font-weight: 400; margin: 0 0 .35rem; display: flex; align-items: baseline; gap: .5rem; }
   .group h3::after { content: ""; flex: 1; border-top: 1px solid var(--line); transform: translateY(-.2em); }
@@ -805,6 +814,30 @@ ${ledgerBundleAvailable ? `<script src="./ledger-browser.bundle.js"></script>` :
   let trail = focus ? [{ term: focus, label: null }] : [];
   const sel = { prov: new Set(), fam: new Set(), rec: new Set() };
 
+  // The store the client-side digest reads. Defaults to the page's embedded
+  // PAYLOAD (a static viz page never changes it); once a live dock session
+  // exists it points at that session's store, which teach/research grow in
+  // place, so a digest of a just-taught term reads the fresh facts.
+  let getLivePayload = () => PAYLOAD;
+  // Whichever loaded bundle carries the browser digest helper — the demo
+  // ledger's own live engine (tmctLedger) or the committed memory-ask engine
+  // the CLI viz page inlines (tmctMemoryAsk). Null before either loads, and the
+  // focus card then keeps whatever server-computed digest it shipped.
+  const digestHelper = () =>
+    (typeof tmctLedger !== "undefined" && tmctLedger && tmctLedger.digestTermFromPayloadBrowser)
+    || (typeof tmctMemoryAsk !== "undefined" && tmctMemoryAsk && tmctMemoryAsk.digestTermFromPayloadBrowser)
+    || null;
+  // The digest for one term, computed live in the browser from the embedded
+  // structure table, or null when no structures were embedded, no engine has
+  // loaded, or the term holds nothing to compose.
+  function clientDigest(term) {
+    const structures = LEDGER.digestStructures;
+    const helper = digestHelper();
+    if (!term || !helper || !structures || !structures.length) return null;
+    try { return helper(getLivePayload(), term, structures, { budget: 8 }); }
+    catch { return null; }
+  }
+
   const recOf = (r) => {
     const t = Date.parse(r.createdAt);
     if (!Number.isFinite(t)) return "older";
@@ -860,10 +893,28 @@ ${ledgerBundleAvailable ? `<script src="./ledger-browser.bundle.js"></script>` :
     const srcs = new Set(all.map((r) => r.src.split(" | ")[0]));
     const dates = all.map((r) => r.createdAt).filter(Boolean).sort();
     const klass = all.find((r) => r.s === focus && r.family === "is-a");
+    // The digest paragraph recomputes client-side on every focus, from the
+    // embedded structure table over the current store — so a refocus reads the
+    // new term back rather than losing the card. The server-computed focus
+    // digest is the fallback for the initial focus alone, kept for a page whose
+    // engine bundle never loads (its client digest would come back null).
+    const dg = clientDigest(focus)
+      || ((focus === LEDGER.focus && LEDGER.focusDigest && LEDGER.focusDigest.paragraphs && LEDGER.focusDigest.paragraphs.length) ? LEDGER.focusDigest : null);
+    const dgFacts = (dg && Array.isArray(dg.facts)) ? dg.facts : [];
+    const factsEscapeHtml = dgFacts.length
+      ? '<details class="dgfacts"><summary>show the facts (' + dgFacts.length + ')</summary><div class="dgfactlist">' +
+        dgFacts.map((f) => '<div class="dgfact"><span class="mono">' + esc(String(f.subject || "")) + " " + esc(String(f.predicate || "")) + " " + esc(String(f.object || "")) + "</span></div>").join("") +
+        "</div></details>"
+      : "";
+    const digestHtml = dg
+      ? '<div class="focusdigest">' + dg.paragraphs.map((p) => "<p>" + esc(p) + "</p>").join("") +
+        (dg.sources && dg.sources.length ? '<p class="dgsrc">(sources: ' + esc(dg.sources.join("; ")) + ")</p>" : "") +
+        factsEscapeHtml + "</div>"
+      : "";
     let html = '<div class="focuscard"><div class="term">' + esc(focus) + "</div>" +
       '<div class="klass">' + (klass ? esc(klass.phrase + " " + klass.o) : "no class recorded") + "</div>" +
       '<div class="stats">' + all.length + " facts &middot; " + srcs.size + " source" + (srcs.size === 1 ? "" : "s") +
-      (dates.length ? " &middot; first " + esc(dates[0].slice(0, 10)) + " &middot; last " + esc(dates[dates.length - 1].slice(0, 10)) : "") + "</div></div>";
+      (dates.length ? " &middot; first " + esc(dates[0].slice(0, 10)) + " &middot; last " + esc(dates[dates.length - 1].slice(0, 10)) : "") + "</div>" + digestHtml + "</div>";
     const bracketed = new Set();
     for (const fam of FAMS) {
       const rows = mine.filter((r) => r.family === fam && !bracketed.has(r.id));
@@ -998,6 +1049,11 @@ ${ledgerBundleAvailable ? `<script src="./ledger-browser.bundle.js"></script>` :
       rows: freshData.rows, terms: freshData.terms, edges: freshData.edges,
       focus: freshData.focus, contradictions: freshData.contradictions,
       worthALook: freshData.worthALook, meta: freshData.meta,
+      // The embedded structure table is build-time data a re-derivation never
+      // recomputes; carry it across so a digest of the just-taught term still
+      // has a table to compose from. The stale server focusDigest is dropped —
+      // the client recompute over the grown store supersedes it.
+      digestStructures: LEDGER.digestStructures,
     };
     rebuildIndexes();
     el("dash").outerHTML = dashboardHtml(freshData.stats, { fresh: true });
@@ -1069,6 +1125,10 @@ ${ledgerBundleAvailable ? `<script src="./ledger-browser.bundle.js"></script>` :
       if (session) return session;
       await tryLoadWink();
       session = await tmctLedger.createLedgerSession({ seedPayload: PAYLOAD });
+      // From here the live store is the source of truth for the digest, so a
+      // digest of a term taught this session reads its fresh facts — the store
+      // grows in place, so this one closure stays current.
+      getLivePayload = () => session.memoryDir.payload;
       return session;
     }
 

package/src/services/research-viz.mjs

@@ -73,9 +73,14 @@ export function loadProgressLine(parts) {
 }
 
 /** The self-contained research page. Pure — the same output for the same
- *  `title` every time; every piece of state is computed live in the browser
- *  once the sibling research bundle loads. */
-export function renderResearchHtml({ title = DEFAULT_TITLE } = {}) {
+ *  input every time; every piece of state is computed live in the browser once
+ *  the sibling research bundle loads. `digestStructures` are the pre-parsed
+ *  [[structure]] rows of the digest sentence-structure bank, embedded so the
+ *  page can digest a term client-side over its grown store (no TOML parser in
+ *  the browser); an empty list leaves the digest panel degrading to an honest
+ *  "no digest available" the same way the node stub does. */
+export function renderResearchHtml({ title = DEFAULT_TITLE, digestStructures = [] } = {}) {
+  const digestStructuresJson = JSON.stringify(Array.isArray(digestStructures) ? digestStructures : []);
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -148,8 +153,26 @@ ${THEME_TOKENS_CSS}
 
   .chips { display: flex; flex-wrap: wrap; gap: .4rem; }
   .chip { font-family: ${MONO_STACK}; font-size: .74rem; border: 1px solid var(--line); border-radius: 99px; padding: .2rem .6rem; background: var(--bg); }
+  .chip.tapchip { cursor: pointer; }
+  .chip.tapchip:hover { border-color: var(--ink); }
   .chip .deg { color: var(--muted); margin-left: .35rem; }
 
+  /* the term digest: a narrative card, its sources, and the flat fact list one
+     click away behind "show the facts". */
+  .digestpanel .hint { font-size: .78rem; color: var(--muted); margin: 0 0 .55rem; }
+  .digestout { min-height: 1.4rem; }
+  .digestout .empty { color: var(--muted); font-size: .82rem; margin: .2rem 0; }
+  .digestout .miss { color: var(--muted); font-size: .88rem; border: 1px dashed var(--line); border-radius: 8px; padding: .55rem .7rem; }
+  .dgcard { border: 1px solid var(--line); border-radius: 8px; padding: .7rem .85rem .8rem; background: var(--bg); }
+  .dgterm { font-family: ${MONO_STACK}; font-size: .72rem; letter-spacing: .04em; text-transform: uppercase; color: var(--muted); margin-bottom: .4rem; }
+  .dgcard p { margin: 0 0 .5rem; font-size: .95rem; }
+  .dgcard p:last-of-type { margin-bottom: 0; }
+  .dgsrc { font-family: ${MONO_STACK}; font-size: .7rem; color: var(--muted); word-break: break-word; }
+  .dgfacts { margin-top: .6rem; }
+  .dgfacts > summary { font-family: ${MONO_STACK}; font-size: .72rem; color: var(--corpus); cursor: pointer; list-style: revert; }
+  .dgfacts[open] > summary { margin-bottom: .35rem; }
+  .dgfacts .factlist { border-top: 1px solid var(--line); }
+
   /* ask, scoped by source */
   .askRow { display: flex; gap: .5rem; margin: .2rem 0 .7rem; }
   .askRow input { flex: 1; min-width: 0; font-family: ${SERIF_STACK}; font-size: .92rem; background: var(--bg); color: var(--ink); border: 1px solid var(--line); border-radius: 8px; padding: .45rem .7rem; }
@@ -247,6 +270,16 @@ ${THEME_TOKENS_CSS}
       </div>
     </div>
 
+    <h2 class="band">read a term back</h2>
+    <div class="panel digestpanel">
+      <p class="hint">Pick a term the graph knows and it reads back a short narrative &mdash; the facts it holds, composed into sentences with the sources named, deterministic and never a guess. The full fact list stays one click away behind &ldquo;show the facts&rdquo;.</p>
+      <div class="askRow">
+        <input id="digestInput" type="text" autocomplete="off" spellcheck="false" placeholder="a term the graph knows, e.g. dog" aria-label="A term to read back as a digest" disabled>
+        <button type="button" class="btn primary" id="digestGo" disabled>digest</button>
+      </div>
+      <div id="digestOut" class="digestout" aria-live="polite"><p class="empty">Ask for a digest, or click a term under &ldquo;best-connected terms&rdquo; above.</p></div>
+    </div>
+
     <h2 class="band">ask the graph</h2>
     <div class="cols">
       <div class="panel">
@@ -283,6 +316,10 @@ ${THEME_TOKENS_CSS}
   const createTicker = ${createTicker.toString()};
   const prefersReducedMotion = ${prefersReducedMotion.toString()};
   const el = (id) => document.getElementById(id);
+  // The digest sentence-structure bank, pre-parsed at build time — the browser
+  // has no TOML parser, so the page carries the table the client-side digest
+  // composes from.
+  const DIGEST_STRUCTURES = ${digestStructuresJson};
 
   if ("serviceWorker" in navigator) navigator.serviceWorker.register("./tmct-sw.js").catch(() => {});
 
@@ -332,7 +369,7 @@ ${THEME_TOKENS_CSS}
     try { return structuredClone(seedPayload); } catch { return JSON.parse(JSON.stringify(seedPayload)); }
   };
   function newSession() {
-    return window.tmctResearch.createResearchSession({ seedPayload: cloneSeed(), vocabSeeded: Boolean(seedPayload) });
+    return window.tmctResearch.createResearchSession({ seedPayload: cloneSeed(), vocabSeeded: Boolean(seedPayload), digestStructures: DIGEST_STRUCTURES });
   }
 
   // The curated reference pack provider, same fetch seam chat.html registers,
@@ -377,6 +414,8 @@ ${THEME_TOKENS_CSS}
     el("ingestGo").disabled = false;
     el("askInput").disabled = false;
     el("askGo").disabled = false;
+    el("digestInput").disabled = false;
+    el("digestGo").disabled = false;
     el("exportFacts").disabled = false;
   }
 
@@ -427,13 +466,16 @@ ${THEME_TOKENS_CSS}
       return;
     }
     for (const hub of hubs) {
-      const chip = document.createElement("span");
-      chip.className = "chip";
+      const chip = document.createElement("button");
+      chip.type = "button";
+      chip.className = "chip tapchip";
+      chip.setAttribute("aria-label", "read a digest of " + hub.term);
       chip.appendChild(document.createTextNode(hub.term));
       const deg = document.createElement("span");
       deg.className = "deg";
       deg.textContent = hub.degree + (hub.degree === 1 ? " fact" : " facts");
       chip.appendChild(deg);
+      chip.addEventListener("click", () => { el("digestInput").value = hub.term; digest(); });
       box.appendChild(chip);
     }
   }
@@ -544,6 +586,64 @@ ${THEME_TOKENS_CSS}
   el("askGo").addEventListener("click", ask);
   el("askInput").addEventListener("keydown", (e) => { if (e.key === "Enter") { e.preventDefault(); ask(); } });
 
+  // ---- digest a term: the narrative read-back over the grown store ---------
+  function renderDigestFact(fact) {
+    const row = document.createElement("div");
+    row.className = "fact";
+    const dot = document.createElement("span"); dot.className = "dot tone-seed";
+    const subj = document.createElement("span"); subj.className = "subj"; subj.textContent = String(fact.subject || "");
+    const pred = document.createElement("span"); pred.className = "pred"; pred.textContent = String(fact.predicate || "");
+    const obj = document.createElement("span"); obj.className = "obj"; obj.textContent = String(fact.object || "");
+    row.appendChild(dot); row.appendChild(subj); row.appendChild(pred); row.appendChild(obj);
+    return row;
+  }
+  function renderDigest(term, view) {
+    const box = el("digestOut");
+    box.textContent = "";
+    if (!view) {
+      const p = document.createElement("p"); p.className = "miss";
+      p.textContent = 'No grounded digest for "' + term + '" — nothing is stored about it, or nothing the digest could compose. It abstains rather than guess.';
+      box.appendChild(p);
+      return;
+    }
+    const card = document.createElement("div"); card.className = "dgcard";
+    const head = document.createElement("div"); head.className = "dgterm mono"; head.textContent = view.term || term;
+    card.appendChild(head);
+    for (const para of view.paragraphs) {
+      const p = document.createElement("p"); p.textContent = para; card.appendChild(p);
+    }
+    if (view.sources && view.sources.length) {
+      const src = document.createElement("p"); src.className = "dgsrc";
+      src.textContent = "(sources: " + view.sources.join("; ") + ")";
+      card.appendChild(src);
+    }
+    const facts = view.facts || [];
+    if (facts.length) {
+      const det = document.createElement("details"); det.className = "dgfacts";
+      const sum = document.createElement("summary");
+      sum.textContent = "show the facts (" + view.factCount + ")";
+      det.appendChild(sum);
+      const list = document.createElement("div"); list.className = "factlist";
+      for (const f of facts) list.appendChild(renderDigestFact(f));
+      det.appendChild(list);
+      card.appendChild(det);
+    }
+    box.appendChild(card);
+  }
+  async function digest() {
+    const term = el("digestInput").value.trim();
+    if (!term || !session) return;
+    const box = el("digestOut");
+    box.textContent = "";
+    const wait = document.createElement("p"); wait.className = "empty"; wait.textContent = "reading it back…";
+    box.appendChild(wait);
+    let view = null;
+    try { view = await session.digest(term); } catch { view = null; }
+    renderDigest(term, view);
+  }
+  el("digestGo").addEventListener("click", digest);
+  el("digestInput").addEventListener("keydown", (e) => { if (e.key === "Enter") { e.preventDefault(); digest(); } });
+
   // ---- grow: teach by telling --------------------------------------------
   async function teach() {
     const q = el("teachInput").value.trim();

package/src/surfaces/web/digest-client.mjs

@@ -0,0 +1,73 @@
+// digest-client.mjs — the browser-native side of the digest layer's stage-5
+// wiring. The node surfaces (chat, `tmct digest`, the page generators) reach
+// the pure pipeline through adapters/corpus/digest-bank.mjs, which reads the
+// sentence-structure bank off disk with a TOML parser. A browser can't do that,
+// so the bundle scripts stub digest-bank out — and the pages that grow or hold
+// a store IN the browser (research, the ledger dock, the CLI `tmct viz` page)
+// digest from a structure table embedded in the page as JSON at build time.
+//
+// This module is that browser path: it feeds the embedded structures straight
+// into the SAME pure layer (src/domain/digest — buildStructureTable, digestTerm,
+// the store-stats scan) the node seam uses, so the two produce the same article
+// from the same rows. It ships no TOML parser; the page hands it pre-parsed
+// [[structure]] rows.
+
+import { buildStructureTable, digestTerm } from "../../domain/digest/index.mjs";
+import { digestStoreStats, chainsForObjects, isaObjectsOf } from "../../domain/digest/store-stats.mjs";
+import { readFactRows } from "../../adapters/memory/core.mjs";
+
+/**
+ * Digest one term end to end from fact rows and a pre-parsed structure table.
+ * The browser twin of digestTermFromRows: identical pipeline, but the structure
+ * rows arrive as data (embedded JSON) rather than from a filesystem TOML read.
+ *
+ * `structures` is the array of [[structure]] rows the bank parses to. Returns
+ * the term-article shape, or null when no structures were supplied (the page
+ * then falls back to its flat fact list, the same degradation the node stub
+ * gives).
+ */
+export function digestTermFromRowsBrowser(term, termRows, allRows, structures, opts = {}) {
+  const table = buildStructureTable(structures || []);
+  if (!table || table.size === 0) return null;
+  const rows = termRows || [];
+  const store = digestStoreStats(allRows || rows);
+  const chains = chainsForObjects(store.subClassEdges, isaObjectsOf(rows));
+  return digestTerm(term, rows, store, table, { ...opts, chains });
+}
+
+/**
+ * Digest one term straight from a loadMemory()-shaped payload — the shape every
+ * in-browser surface already holds (the ledger's embedded PAYLOAD, the ledger
+ * dock's live memoryDir.payload, the research session's store). Scans the
+ * payload once for the term's own rows and the whole-store statistics, so a
+ * caller never has to run readFactRows itself.
+ *
+ * Returns the render-ready view (see digestViewFromArticle) or null when the
+ * term has no rows, no structures were supplied, or the selector kept nothing.
+ */
+export function digestTermFromPayloadBrowser(payload, term, structures, opts = {}) {
+  const rows = readFactRows(payload || { individuals: [], objectProperties: [] });
+  const termRows = rows.filter((r) => r.subject === term);
+  if (!termRows.length) return null;
+  const article = digestTermFromRowsBrowser(term, termRows, rows, structures, opts);
+  return digestViewFromArticle(article);
+}
+
+/**
+ * The flat, render-ready view a page's DOM code wants from a term article:
+ * the narrative paragraphs, the distinct source strings (the "(sources: …)"
+ * line the chat and CLI surfaces render), and the full fact list behind the
+ * "show the facts" escape. Null when the article carried no narrative, so the
+ * caller falls back to its flat rendering rather than showing an empty card.
+ */
+export function digestViewFromArticle(article) {
+  if (!article || !Array.isArray(article.paragraphs) || !article.paragraphs.length) return null;
+  const facts = (article.detail && Array.isArray(article.detail.facts)) ? article.detail.facts : [];
+  return {
+    term: article.term || "",
+    paragraphs: article.paragraphs.slice(),
+    sources: [...new Set((article.sources || []).map((s) => s.provenance).filter(Boolean))],
+    facts,
+    factCount: (article.detail && Number.isInteger(article.detail.factCount)) ? article.detail.factCount : facts.length,
+  };
+}

package/src/surfaces/web/ledger-browser-entry.mjs

@@ -25,6 +25,7 @@ import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
 import { registerWinkModel } from "../../adapters/wink-model.mjs";
 import { registerResearchProvider } from "../../adapters/corpus/wikipedia-live.mjs";
 import { computeLedgerDataFromPayload } from "../../services/ledger-viz.mjs";
+import { digestTermFromPayloadBrowser } from "./digest-client.mjs";
 
 /**
  * A browser ledger-dock session over the real turn engine — createChatSession's
@@ -101,4 +102,4 @@ export async function exportFactsJsonl(memoryDir) {
 // splitSentences + exportFactsJsonl carry the dock's paste-and-drop ingest and
 // its JSONL export across the bundle boundary, the same one-serializer posture
 // chat-browser-entry.mjs holds for its own page.
-globalThis.tmctLedger = { createLedgerSession, computeLedgerDataFromPayload, normFactTerm, registerWinkModel, registerResearchProvider, splitSentences: splitSentencesPreservingPaths, exportFactsJsonl };
+globalThis.tmctLedger = { createLedgerSession, computeLedgerDataFromPayload, normFactTerm, registerWinkModel, registerResearchProvider, splitSentences: splitSentencesPreservingPaths, exportFactsJsonl, digestTermFromPayloadBrowser };

package/src/surfaces/web/memory-ask-browser-entry.mjs

@@ -8,8 +8,13 @@
 // bypassing the structural-graph parse pipeline this dock has no use for.
 import { factAnswer, factReadBack } from "../../services/chat.mjs";
 import { createInMemoryStore, normFactTerm } from "../../adapters/memory/core.mjs";
+import { digestTermFromPayloadBrowser } from "./digest-client.mjs";
 
 // normFactTerm is re-exported too, for the page's client-side term normalization.
 // factReadBack carries the taught-relation chases (grandfather-style questions)
 // that factAnswer's own lanes don't reach.
-globalThis.tmctMemoryAsk = { factAnswer, factReadBack, createInMemoryStore, normFactTerm };
+// digestTermFromPayloadBrowser lets the CLI `tmct viz` page read a refocused
+// term back as a digest client-side, from the structure table the page embeds —
+// the same narrative the demo ledger's live bundle produces, over the same
+// static store this page already carries.
+globalThis.tmctMemoryAsk = { factAnswer, factReadBack, createInMemoryStore, normFactTerm, digestTermFromPayloadBrowser };