@polycode-projects/the-mechanical-code-talker 6.0.21 → 7.0.0

package/src/domain/memory/provenance-time.mjs

@@ -0,0 +1,35 @@
+// memory/provenance-time.mjs — reading "when" off a fact's provenance tag.
+//
+// A fact's provenance is a " | "-joined union of tags, because appendFacts
+// unions a fresh tag onto the SAME fact id when a triple is asserted again
+// rather than minting a second row. So "when was this most recently true" is a
+// question about the newest segment, not about the string as a whole.
+import { provenanceTagToSource } from "./trust.mjs";
+
+/** The newest asserted-at timestamp across every segment of `provenance`, in
+ *  milliseconds. Null when no segment parses to a timestamp at all. */
+export function latestProvenanceTimestamp(provenance) {
+  const tag = String(provenance || "");
+  if (!tag) return null;
+  let latest = null;
+  for (const segment of tag.split(" | ")) {
+    const source = provenanceTagToSource(segment);
+    const at = source?.createdAt ? Date.parse(source.createdAt) : NaN;
+    if (!Number.isNaN(at) && (latest === null || at > latest)) latest = at;
+  }
+  return latest;
+}
+
+/** The latest-by-timestamp row for a subject+predicate pair — the "current
+ *  value" read for an add-only fact that is never retracted. A first-wins read
+ *  takes the oldest of these instead. */
+export function latestFact(rows, subject, predicate) {
+  let best = null;
+  let bestAt = -Infinity;
+  for (const row of rows) {
+    if (row.subject !== subject || row.predicate !== predicate) continue;
+    const at = latestProvenanceTimestamp(row.provenance) ?? -Infinity;
+    if (at > bestAt) { best = row; bestAt = at; }
+  }
+  return best;
+}

package/src/domain/memory/retraction.mjs

@@ -23,17 +23,15 @@
 // Max is a join too, so that field merges in either order and agrees.
 //
 // Pure: this module plans, merges and encodes retraction RECORDS. core.mjs owns
-// the store, p2p-room.mjs owns the wire. Its own class, its own id suffix and
-// its own predicate keep it clear of compaction — a compacted record and a
+// the store. Its own class, its own id suffix and its own predicate keep it
+// clear of compaction — a compacted record and a
 // retracted one mean opposite things, and one namespace would let a summary
 // read as a tombstone. The CRDT vocabulary above is pinned in
 // docs/references/papers/crdt.md.
 
 export const RETRACTION_CLASS = "Retraction";
 
-/** The predicate a retraction travels under. The sync filters admit it on its
- *  own, because a retraction has to cross a wire that a chat room gates on
- *  provenance kind and a mud room gates on world predicates. */
+/** The predicate a retraction travels under. */
 export const RETRACTION_PREDICATE = "mgx:retracted";
 
 export const RETRACTED_RECORD_IDS_PROP = "mgx:retractedRecordIds";

package/src/domain/memory/trust.mjs

@@ -33,12 +33,12 @@ function parseChatTagRest(rest) {
 const PEER_NODE_MARKER = "#node:";
 const PEER_TAG_PREFIX = "peer:";
 
-/** `peer:<displayName>#node:<nodeId>@<ts>` — the wire shape a broadcasting peer
- *  relabels its own teach/operator tags into. The node id is the origin's
- *  stable identity and the only part that keys the Source; the display name is
+/** `peer:<displayName>#node:<nodeId>@<ts>` — the shape a tag takes when it
+ *  names the node that authored it. The node id is the origin's stable
+ *  identity and the only part that keys the Source; the display name is
  *  user-chosen, mutable and collidable, so it records who to SHOW, not who it
  *  is — the same discipline `child:`'s term and `world:`'s turn segments hold.
- *  Null for anything without the segment, so an older peer tag falls through to
+ *  Null for anything without the segment, so a tag missing it falls through to
  *  the plain teach parse unchanged. */
 function parsePeerNodeTagRest(rest) {
   if (!rest.startsWith(PEER_TAG_PREFIX)) return null;
@@ -79,11 +79,11 @@ function parsePeerNodeTagRest(rest) {
  *   teach:chat:<session>@<ts>  -> { kind:"teach",     createdAt:<ts>, sessionId:<session> }
  *   teach:peer:<name>#node:<id>@<ts>
  *                              -> { kind:"teachNode", nodeId:<id>, displayName:<name>, createdAt:<ts> }
- *     (a peer's own tag, relabeled for the wire by whichever node authored it.
- *      The node id keys the Source; the display name is presentation only. A
- *      peer tag with no `#node:` segment predates the segment and parses as a
- *      plain "teach" whose session slot is the whole name — which is what lets
- *      old and new readers share one wire.)
+ *     (a tag another node authored. The node id keys the Source; the display
+ *      name is presentation only, so two nodes that chose the same name stay
+ *      separate Sources. A tag with no `#node:` segment predates the segment
+ *      and parses as a plain "teach" whose session slot is the whole name, so
+ *      a store holding both shapes reads both.)
  *   web:<url> | url:<url>      -> { kind:"web",       url:<url> }
  *   reference:<pack>:<article>[@revid] -> { kind:"reference", pack, article }
  *     (split on the first two colons only; the article keeps any @revid and
@@ -198,8 +198,8 @@ export function provenanceTagToSource(tag) {
   }
   if (head.startsWith("teach:")) {
     const rest = head.slice("teach:".length);
-    // teach:peer:<name>#node:<id>@<ts> — a peer's own relabeled tag off the
-    // wire, keyed on the node id rather than the name beside it.
+    // teach:peer:<name>#node:<id>@<ts> — a tag another node authored, keyed on
+    // the node id rather than the name beside it.
     const peerNode = parsePeerNodeTagRest(rest);
     if (peerNode) return peerNode;
     // the chat teach lane's natural frames — chat.mjs's teachProvenanceTag

package/src/domain/news-feed.mjs

@@ -2,7 +2,7 @@
 // sub-graphs, assemble news items, and render the fixed paraphrase paragraph
 // (PLAN_NEWS_FEED.md sections 8.2-8.3). Pure throughout: no clock, no I/O, no
 // reliance on the caller's row order — feeding one fact set in two different
-// orders yields byte-identical items, the same discipline p2p-room.mjs's
+// orders yields byte-identical items, the same discipline rows.mjs's
 // sortFactIndividualsById holds for a CRDT-merged fact set.
 
 import { sha256Bytes, normFactTerm } from "./hash.mjs";

package/src/domain/seeded-random.mjs

@@ -3,12 +3,12 @@
 // it. Both are pure arithmetic (no I/O, no imports), so a seed reproduces the
 // same sequence on every machine and every run.
 //
-// The bench case generators (infbench, chatbench's graded pool) draw their
-// committed fixtures through these, so the byte sequence they produce is part of
-// those artifacts' identity: two callers on one seed must shuffle identically or
-// the committed cases.jsonl / graded pool drift. That is the same reason the
-// content-address hashes live once in hash.mjs beside this file — a deterministic
-// primitive shared across writers has exactly one definition.
+// The bench case generators (infbench) draw their committed fixtures through
+// these, so the byte sequence they produce is part of those artifacts' identity:
+// two callers on one seed must shuffle identically or the committed cases.jsonl
+// drifts. That is the same reason the content-address hashes live once in
+// hash.mjs beside this file — a deterministic primitive shared across writers has
+// exactly one definition.
 
 /** mulberry32 PRNG — small, seedable, deterministic across platforms. */
 export function mulberry32(seed) {

package/src/services/adventure.mjs

@@ -181,13 +181,13 @@ async function resumedPosition(memoryDir) {
 
 // ---- the world-state fold ----------------------------------------------------
 
-/** Which run of the world a store is on. Recasting a shared world (mud.html's
+/** Which run of the world a store is on. Recasting a world (mud.html's
  *  RESET, a slider, the scenario dropdown) reopens the same deterministic
- *  instance ids over a fresh store while peers may still hold the old run's
- *  snapshots — this marker is how every reader agrees the world has started
- *  over. It is an ordinary add-only fact: each recast appends a larger value,
- *  the fold takes the max, and merging two peers' stores converges because max
- *  is order-free. */
+ *  instance ids over a fresh store, so the old run's snapshots can still be
+ *  sitting in a store somewhere — this marker is how every reader agrees the
+ *  world has started over. It is an ordinary add-only fact: each recast
+ *  appends a larger value, the fold takes the max, and merging two stores
+ *  converges because max is order-free. */
 export const WORLD_EPOCH_PREDICATE = "mgx:world-epoch";
 const WORLD_EPOCH_SUBJECT = "world";
 
@@ -257,36 +257,6 @@ export function worldActionRows(rows) {
   });
 }
 
-// The predicates a played turn can write. Every one of them already exists
-// above as a private constant; this set is the one place they are gathered so
-// a caller outside this file can ask "is this fact part of the live world"
-// without learning each name. rdf:type and the display name earn their place
-// alongside the folded ones: a dug room and a dug object are minted mid-play,
-// and a reader that never receives their class or their plain name cannot draw
-// them at all.
-const MUD_STATE_PREDICATES = new Set([
-  ...PLACEMENT_PREDICATES,
-  ...POSITION_PREDICATES,
-  OPEN_PREDICATE,
-  MASS_PREDICATE,
-  KNOWS_ABOUT_PREDICATE,
-  DISPLAY_NAME_PREDICATE,
-  "rdf:type",
-  // Which run the world is on IS live world state: a peer that misses the
-  // recast marker keeps folding the old run's snapshots as current.
-  WORLD_EPOCH_PREDICATE,
-]);
-
-/** Whether `predicate` carries live world state — where a thing stands, what
- *  it weighs, whether it is open, what somebody knows, which way a room leads,
- *  and the class and name a dug thing is minted with. The P2P sync filter
- *  reads this to tell a fact a turn produced from the page chrome around it.
- *  Pure. */
-export function isMudStatePredicate(predicate) {
-  const p = String(predicate || "");
-  return MUD_STATE_PREDICATES.has(p) || EXIT_PREDICATE_RE.test(p);
-}
-
 /** Every individual the world names — its rooms, its cast, its props, and
  *  anything dug up since — as the plain id strings a parser has to have
  *  DECLARED before it can resolve them. @turnN snapshots are skipped: a
@@ -308,7 +278,7 @@ export function worldIndividualNames(rows) {
  *  stored), and the epoch itself.
  *
  *  Rows rank by the (epoch, turn) pair, so a recast can never be outranked by
- *  the run it replaced: a peer's turn-9 snapshot from before the recast loses
+ *  the run it replaced: a turn-9 snapshot from before the recast loses
  *  to a turn-1 snapshot written after it. Base rows carry no stamp of their
  *  own and rank as turn 0 of the CURRENT epoch — a recast re-seeds the same
  *  deterministic ids, so the shard's own rows are exactly the state the new
@@ -653,10 +623,9 @@ async function writeWorldTurn(memoryDir, world, k, facts, cache) {
 // the last carrot appends a SECOND claim to the same edge, tagged `:gone`, and
 // appendFacts unions the two tags onto the one fact exactly as it unions any
 // repeat assertion. "The carrot was here on turn 2" and "the carrot is gone on
-// turn 5" are both true; the reader's job is to say which one rules, the same
-// recency question the p2p layer asks of its own tags. So reading knowledge
-// back means reading the newest claim per edge, never the union of every claim
-// ever made.
+// turn 5" are both true; the reader's job is to say which one rules. So
+// reading knowledge back means reading the newest claim per edge, never the
+// union of every claim ever made.
 
 const VOIDED_TESTIMONY_SUFFIX = ":gone";