@polycode-projects/the-mechanical-code-talker 6.0.20 → 6.0.22

package/src/services/mudiii-viz.mjs

@@ -24,10 +24,6 @@
 // scenario swaps those first two calls for `.bootRiver(...)` once and
 // `.applyRiver(...)` per crossing; the same stage draws the river.
 //
-// Deliberately absent, all P2P (mud.html's #statePill, share/join buttons,
-// the share overlay, the wave button): this is the 1-player page. A later
-// document adds sharing back from the same bundle.
-//
 // The page publishes through the ONE `globalThis.tmct` surface
 // (tmct-surface.mjs), never a page-scoped bag of its own, and
 // `createTicker`/`createSerialQueue` are spliced into the page script from

package/src/services/news.mjs

@@ -953,47 +953,67 @@ async function ingestResearchArticle(ctx, term, provider, article) {
   return { facts: distinct.size, derived };
 }
 
-// The one band this fallback reads. WordNet is dictionary content — real
-// words, not news entities — so it grounds the everyday nouns a headline
-// mentions in passing ("harbor", "senator") without ever costing a KB round
-// trip on those.
-const BAND_TERM_LOOKUP_BAND = "wordnet-complete";
+// The bands this fallback reads. All three are reference content — dictionary
+// senses and everyday commonsense edges, not news entities — so they ground
+// the ordinary nouns a headline mentions in passing ("harbor", "senator",
+// "penguin") without ever costing a KB round trip on those.
+const BAND_TERM_LOOKUP_BANDS = Object.freeze(["child", "conceptnet", "wordnet-complete"]);
 const BAND_TERM_LOOKUP_LIMIT = 50;
 // A local DynamoDB Query has no courtesy throttle and nothing external to
 // protect, but it still has to return: the enrich cycle shares the same wall
 // budget every other phase does, and this runs once per candidate term. A
 // slow or hung Query loses the race and reads as a miss — a timeout is a
 // miss, never a guess — rather than stalling the whole cycle behind it.
+// The bands are read in parallel against one deadline, so the budget buys
+// every band at once: each is a single-partition begins_with read of its own,
+// and the worst case stays one timeout however many bands there are.
 const BAND_TERM_LOOKUP_TIMEOUT_MS = 750;
 
-/** `term`'s rows from the wordnet-complete band, as `{subject, predicate,
- *  object, provenance}` triples ready for `appendFacts` — or `[]` when the
- *  band carries nothing for it, the query errors, or it doesn't return in
- *  time. `ctx.providers.queryBandTerm` is absent on the browser surface and
- *  in most tests, so this is a no-op there by construction, not a special
- *  case here. */
-async function groundTermFromBand(ctx, term) {
-  const queryBandTerm = ctx.providers?.queryBandTerm;
-  if (typeof queryBandTerm !== "function") return [];
-  const timeout = new Promise((resolve) => { setTimeout(() => resolve(null), BAND_TERM_LOOKUP_TIMEOUT_MS); });
+/** `term`'s rows from one band, as `{subject, predicate, object, provenance}`
+ *  triples — or `[]` when the band carries nothing for it or the Query
+ *  throws. A band that fails is a band with nothing to say, so the others'
+ *  rows survive it. */
+async function bandTermFacts(queryBandTerm, band, term) {
   let response;
   try {
-    response = await Promise.race([
-      queryBandTerm({ band: BAND_TERM_LOOKUP_BAND, term, limit: BAND_TERM_LOOKUP_LIMIT }),
-      timeout,
-    ]);
+    response = await queryBandTerm({ band, term, limit: BAND_TERM_LOOKUP_LIMIT });
   } catch {
     return [];
   }
-  if (!response) return [];
   const facts = [];
-  for (const row of response.rows || []) {
+  for (const row of response?.rows || []) {
     const fact = factFromBandRow(row);
     if (fact) facts.push(fact);
   }
   return facts;
 }
 
+/** `term`'s rows from every band, as `{subject, predicate, object,
+ *  provenance}` triples ready for `appendFacts` — or `[]` when no band
+ *  carries it. Each band's Query races the SAME deadline, so a band that
+ *  hangs costs the cycle one timeout rather than one per band, and the bands
+ *  that answered inside it keep their rows. A fact both a band and the seed
+ *  already hold arrives with the band's own provenance, so it corroborates
+ *  rather than duplicating. `ctx.providers.queryBandTerm` is absent on the
+ *  browser surface and in most tests, so this is a no-op there by
+ *  construction, not a special case here. */
+async function groundTermFromBand(ctx, term) {
+  const queryBandTerm = ctx.providers?.queryBandTerm;
+  if (typeof queryBandTerm !== "function") return [];
+  let deadlineTimer;
+  const deadline = new Promise((resolve) => {
+    deadlineTimer = setTimeout(() => resolve(null), BAND_TERM_LOOKUP_TIMEOUT_MS);
+  });
+  try {
+    const perBand = await Promise.all(BAND_TERM_LOOKUP_BANDS.map(
+      (band) => Promise.race([bandTermFacts(queryBandTerm, band, term), deadline]),
+    ));
+    return perBand.flatMap((facts) => facts || []);
+  } finally {
+    clearTimeout(deadlineTimer);
+  }
+}
+
 /** Grounds `term` from `facts` — a band's own rows, already resolved
  *  `{subject, predicate, object, provenance}` triples with no article prose
  *  to walk, so this skips straight to append + syllogise rather than
@@ -1084,10 +1104,10 @@ export async function enrichTopTerms(ctx, { limit } = {}) {
     if (aborted) { markTerm(ledger, entry.term, "pending", nowVal); break; }
     if (!hit) {
       // Every configured KB source came back empty (or none is configured) —
-      // try the wordnet-complete band before giving up. It's another source
-      // the resolver can reach, not a replacement for the KB walk above: a
+      // try the corpus bands before giving up. They're another source the
+      // resolver can reach, not a replacement for the KB walk above: a
       // headline's proper nouns still need a KB lookup, but its everyday
-      // vocabulary is often already sitting in the band.
+      // vocabulary is often already sitting in a band.
       const bandFacts = await groundTermFromBand(ctx, entry.term);
       if (bandFacts.length) {
         const res = await ingestBandFacts(ctx, bandFacts);

package/src/services/pill-complete.mjs

@@ -32,8 +32,7 @@
 // these exact names, because createPillComplete calls the other two by bare
 // name at runtime and that call only resolves if all three sit as siblings
 // in the same inline script. `pillCompleteMarkup` is different: it is a
-// markup BUILDER, the same role `shareOverlayHtml` plays in
-// share-overlay-viz.mjs — it runs once, server/module-side, to produce the
+// markup BUILDER — it runs once, server/module-side, to produce the
 // initial HTML string a page embeds, and is never spliced into the client
 // script. That is the only reason it may (and does) import `escapeHtml`.
 //
@@ -189,10 +188,9 @@ export function matchPills(candidates, typed, opts = {}) {
  * caller can `getElementById` them right after inserting this markup, before
  * constructing `createPillComplete`.
  *
- * Runs once at page-render time (module- or server-side), the same role
- * `shareOverlayHtml` plays in share-overlay-viz.mjs — it is NOT one of the
- * three functions an adopting page splices into its inline script, so it is
- * the one export in this module allowed to import `escapeHtml`.
+ * Runs once at page-render time (module- or server-side) — it is NOT one of
+ * the three functions an adopting page splices into its inline script, so it
+ * is the one export in this module allowed to import `escapeHtml`.
  */
 export function pillCompleteMarkup({ inputId, inputHtml }) {
   const esc = escapeHtml;
@@ -446,8 +444,7 @@ export function createPillComplete({ input, ghostEl, statusEl, railEl, getCandid
  * the one exception: it is structural, not a themed colour choice — the
  * ghost text sits in a layer BEHIND the input, so the input has to be
  * see-through for the ghost's suffix to read at all. Themed through `--pc-*`
- * custom properties defaulting to the site's shared tokens, the way
- * share-overlay-viz.mjs's `--so-*` variables do.
+ * custom properties defaulting to the site's shared tokens.
  */
 export const PILL_COMPLETE_CSS = `
   .pc-field {

package/src/services/predator-prey.mjs

@@ -168,9 +168,7 @@ const MUDIII_STATE_PREDICATE_SET = new Set([
  *  board, who put it there, and the class and model a mid-play mint needs. */
 export const MUDIII_STATE_PREDICATES = Object.freeze([...MUDIII_STATE_PREDICATE_SET].sort());
 
-/** Whether `predicate` carries live town-square state. The P2P sync filter
- *  reads this to tell a fact a turn produced from the page chrome around it.
- *  Pure. */
+/** Whether `predicate` carries live town-square state. Pure. */
 export function isMudiiiStatePredicate(predicate) {
   const p = String(predicate || "");
   return MUDIII_STATE_PREDICATE_SET.has(p) || EXIT_PREDICATE_RE.test(p);
@@ -204,8 +202,8 @@ export function seededSpawnCell(options, { layoutName, epoch = 0, turn = 0, id }
  *
  *  Rows rank by the (epoch, turn) pair, exactly as adventure.mjs's
  *  foldWorldState does, so a recast can never be outranked by the run it
- *  replaced: a peer's turn-9 snapshot from before the recast loses to a turn-1
- *  snapshot written after it. An unstamped row carries no stamp of its own and
+ *  replaced: a turn-9 row written before the recast loses to a turn-1 row
+ *  written after it. An unstamped row carries no stamp of its own and
  *  ranks as turn 0 of the CURRENT epoch — the world pack's own rows are
  *  exactly the state a fresh run starts from.
  *