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

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

@@ -38,9 +38,8 @@ import {
   foldWorldState, worldActionRows, worldDigestRows, roomAffordances,
   personKnowledgeLines, personKnownFoodLines, objectClassChain, recordExamined,
   diggableDirections, castInRoom, displayNameOf, isOutOfPlay, outOfPlayReasonOf, outOfPlayPhrase,
-  roomKindOf, isMudStatePredicate, worldEpochFact,
+  roomKindOf, worldEpochFact,
 } from "../../services/adventure.mjs";
-import { waveFact, playedByFact, P2P_PREDICATES } from "../../domain/p2p/facts.mjs";
 import { relatedForTerm } from "../../domain/skos-view.mjs";
 import { runMudTurn } from "../../services/mud-turn.mjs";
 import { parseMudEditorText, planMudEditorSync } from "../../services/mud-editor.mjs";
@@ -90,10 +89,9 @@ export async function createMudSession(worldPayload, { characters = [], epoch =
   await appendFacts(memoryDir, seedFacts.map((f) => ({
     subject: f.subject, predicate: f.predicate, object: f.object, provenance: tag,
   })));
-  // A recast opens the same deterministic ids over a fresh store while peers
-  // may still hold the old run's snapshots. The epoch marker is what makes
-  // every fold — local and merged — treat this seed as the newer state. An
-  // unrecast boot writes nothing, so a solo session's store is unchanged.
+  // The epoch marker is what makes every fold treat this seed as the newer
+  // state, so an earlier run's snapshots can never outrank it. An unrecast
+  // boot writes nothing, so a plain session's store is unchanged.
   if (epoch > 0) await appendFacts(memoryDir, [{ ...worldEpochFact(epoch), provenance: tag }]);
   for (const rule of worldPayload.rules) {
     await appendRule(memoryDir, { name: rule.name, kind: rule.ruleKind, slots: rule.slots, provenance: tag });
@@ -289,49 +287,12 @@ export async function createMudSession(worldPayload, { characters = [], epoch =
     return { unrecognized, added: toAppend.length, removed };
   }
 
-  // Wall-clock resolution is 1ms, and both writers below are content-addressed
-  // by (subject, predicate, object) — a second wave from the same character in
-  // the same room is the SAME fact id, so it only registers as a change if its
-  // provenance tag differs. Two writes inside one tick would share a timestamp,
-  // share a tag, and the second would silently vanish. p2p-room.mjs nudges its
-  // own clock for exactly this reason; this is the same nudge for the writes
-  // that happen before a room exists.
-  let lastWriteMs = -Infinity;
-  function stampNow() {
-    const nudged = Math.max(Date.now(), lastWriteMs + 1);
-    lastWriteMs = nudged;
-    return new Date(nudged).toISOString();
-  }
-
-  /** `character` waves in whichever room it currently stands in — an ordinary
-   *  add-only fact, so a page with no network renders it exactly like a page
-   *  sharing the world with three others. Returns the room waved in, or null
-   *  when the character stands nowhere (out of play). Nothing is ever
-   *  retracted: "currently waving" is a recency read over this fact's own
-   *  provenance timestamp. */
-  async function wave(character) {
-    const here = await roomOf(character);
-    if (!here) return null;
-    await appendFacts(memoryDir, [waveFact(character, here, stampNow())]);
-    return here;
-  }
-
-  /** Claim `characters` for `peerId` — one add-only `mgx:playedBy` fact each.
-   *  Claims never overwrite: two peers claiming the same animal both write,
-   *  and every reader settles it the same way by taking the oldest claim. */
-  async function claimCharacters(characters, peerId) {
-    const at = stampNow();
-    const claims = (characters || []).map((character) => playedByFact(character, peerId, at));
-    if (claims.length) await appendFacts(memoryDir, claims);
-    return claims.length;
-  }
-
   return {
     memoryDir,
     codeGraph,
     get graph() { return memoryGraph; },
     refreshGraph,
-    windows, snapshot, applyEdit, wave, claimCharacters,
+    windows, snapshot, applyEdit,
   };
 }
 
@@ -422,9 +383,9 @@ export function worldFactsForCast(facts, characters) {
 //
 // `tmct.page` keeps the sprite resolution and the digest/affordance/knowledge
 // readers the room view and chat pills render from, the roster helpers that
-// decide which animals this visit is played with, the two predicate lists the
-// P2P layer checks against, and the SKOS neighbourhood behind the edit mode's
-// cursor pills — none of which is `.toString()`-splice-safe.
+// decide which animals this visit is played with, and the SKOS neighbourhood
+// behind the edit mode's cursor pills — none of which is
+// `.toString()`-splice-safe.
 publishTmctSurface({
   open: createMudSession,
   turn: (line, options, session) => {
@@ -453,7 +414,6 @@ publishTmctSurface({
     personKnowledgeLines, personKnownFoodLines,
     diggableDirections, castInRoom, displayNameOf, isOutOfPlay, outOfPlayReasonOf, outOfPlayPhrase,
     roomKindOf,
-    isMudStatePredicate, P2P_PREDICATES,
     relatedForTerm,
   },
 });

package/test-benchmarks/agentbench/README.md

@@ -1,10 +1,9 @@
 # agentbench — the tmct AGENTIC measurement harness
 
-The **sibling of chatbench**, on a new axis. chatbench measures the *chat turn*
-(a request → the right grounded answer) on the CEFR ladder; AGENTBENCH measures
-the **tool loop** (a request → the right *tool call(s)*) on the **TOOL-0→TOOL-9 tool-use
-rungs**. Same versioned-naming + regression discipline (`BENCHMARK_AGENT_<version>.md`,
-`_00N` for re-runs), one decisive difference:
+AGENTBENCH measures the **tool loop** (a request → the right *tool call(s)*) on
+the **TOOL-0→TOOL-9 tool-use rungs**, with versioned naming and regression
+discipline (`BENCHMARK_AGENT_<version>.md`, `_00N` for re-runs). One rule sits
+above the rest:
 
 > **A hallucinated tool call is an AUTOMATIC FAIL.** Emitting a call to a tool
 > that is not in the declared set, or with arguments that cannot bind, fails the
@@ -12,8 +11,7 @@ rungs**. Same versioned-naming + regression discipline (`BENCHMARK_AGENT_<versio
 > thing a deterministic router must never do, so it is the gate the whole bench
 > is built around.
 
-**No LLM, no judge.** chatbench has a tier-2 LLM judge; AGENTBENCH has none.
-Grading is **entirely deterministic** — compare the produced call(s) to the
+**No LLM, no judge.** Grading is **entirely deterministic** — compare the produced call(s) to the
 expected call(s), gate against the capability registry, check termination and
 (when required) the proof chain. A deterministic router is measured by a
 deterministic ruler.
@@ -95,8 +93,7 @@ The honest **gate** is therefore **"0% hallucination AT ≥50% completion"**
 completion; a reckless driver fails it on hallucination. Only a driver that is
 both **safe and useful** clears it. `--ladder` runs rungs ascending and the
 first rung that fails the gate gates every rung above it (skipped with a
-receipt, e.g. `rung TOOL-5 skipped: gated by TOOL-2 completion 40% < 50%`), exactly like
-chatbench's grade ladder.
+receipt, e.g. `rung TOOL-5 skipped: gated by TOOL-2 completion 40% < 50%`).
 
 ## Closed-world / default-deny
 
@@ -177,7 +174,7 @@ node test-benchmarks/agentbench/run.mjs --only ab-a0-describe-widget
 ## Reference bands (ILLUSTRATIVE anchors — NOT run here)
 
 AGENTBENCH's ladder is read against **comparable models** as illustrative
-anchors, the way chatbench frames CEFR bands. These are the intended reference
+anchors. These are the intended reference
 points for a future write-up; **none are run by this harness** (no network, no
 LLM), and no scores are claimed for them here:
 

package/src/adapters/p2p/webrtc-transport.mjs

@@ -1,169 +0,0 @@
-// One WebRTC DataChannel between two browsers, and nothing else. The caller
-// carries the offer and answer SDP strings between the two machines however it
-// likes — a link, a paste, an already-open channel to a third peer — and this
-// module never learns what travels over the channel once it is open: it takes
-// plain JS values in and hands plain JS values out.
-//
-// `connectionState` is a live GETTER PROPERTY, not a method: read
-// `transport.connectionState`, never `transport.connectionState()`. It reports
-// RTCPeerConnection's own state ("new" | "connecting" | "connected" | "failed"
-// | "closed"), so a caller can poll it without registering a handler.
-//
-// `iceServers` defaults to DEFAULT_ICE_SERVERS below: a couple of public STUN
-// servers, no TURN, no relay — a STUN server only tells each peer its own
-// public-facing (server-reflexive) address; no application data ever passes
-// through it. Real-browser cross-engine testing found host-candidate-only
-// (no STUN) connections depend on OS-level local-network/mDNS behavior that
-// varies by machine and can fail for a real user even where the raw handshake
-// works in an automated test; STUN candidates sidestep that because they use
-// the peer's real address rather than an mDNS-obscured local one. TURN (a
-// relay that data actually flows through) is still not in scope — that's a
-// bigger trust/cost trade a STUN server isn't.
-//
-// Both `createOffer` and `createAnswerFor` resolve only once ICE gathering has
-// completed, so the SDP string they return already carries every candidate.
-// Nothing here trickles, because a pasted blob is a one-shot message rather
-// than a live connection back to the other side.
-//
-// Late handler registration still fires: `onOpen` on an already-open channel
-// and `onClose` on an already-closed one call back immediately, so a caller
-// that registers after the transition never silently misses it. Each fires at
-// most once.
-
-const CHANNEL_LABEL = "tmct";
-
-export const DEFAULT_ICE_SERVERS = [
-  { urls: ["stun:stun.l.google.com:19302", "stun:stun1.l.google.com:19302"] },
-];
-
-export function createTransport({ iceServers = DEFAULT_ICE_SERVERS } = {}) {
-  const PeerConnection = globalThis.RTCPeerConnection;
-  if (typeof PeerConnection !== "function") {
-    throw new Error("no RTCPeerConnection here: this transport runs in a browser, not in bare node");
-  }
-
-  const connection = new PeerConnection({ iceServers });
-  const messageHandlers = [];
-  const openHandlers = [];
-  const closeHandlers = [];
-
-  let channel = null;
-  let openAnnounced = false;
-  let closeAnnounced = false;
-  let tornDown = false;
-
-  function announceOpen() {
-    if (openAnnounced) return;
-    openAnnounced = true;
-    for (const handler of openHandlers) handler();
-  }
-
-  function announceClose() {
-    if (closeAnnounced) return;
-    closeAnnounced = true;
-    for (const handler of closeHandlers) handler();
-  }
-
-  function receive(event) {
-    let value;
-    try {
-      value = JSON.parse(event.data);
-    } catch {
-      // A peer sending something that isn't JSON must not be able to throw
-      // inside our receive path, so the frame is dropped rather than raised.
-      return;
-    }
-    for (const handler of messageHandlers) handler(value);
-  }
-
-  function attachChannel(dataChannel) {
-    channel = dataChannel;
-    dataChannel.addEventListener("open", announceOpen);
-    dataChannel.addEventListener("close", announceClose);
-    dataChannel.addEventListener("message", receive);
-    if (dataChannel.readyState === "open") announceOpen();
-  }
-
-  connection.addEventListener("datachannel", (event) => attachChannel(event.channel));
-  connection.addEventListener("connectionstatechange", () => {
-    const state = connection.connectionState;
-    if (state === "failed" || state === "closed") announceClose();
-  });
-
-  // Bounded, not open-ended: a STUN request that never gets a reply (a
-  // dropped packet, a rate-limited public server, two peer connections in one
-  // tab racing for the same server) must not hang the offer/answer blob
-  // forever — the blob is still useful with only the host candidates it
-  // already has, and a caller waiting on it deserves a result either way.
-  const ICE_GATHERING_TIMEOUT_MS = 5000;
-
-  async function whenIceGatheringCompletes() {
-    if (connection.iceGatheringState === "complete") return;
-    await new Promise((resolve) => {
-      let timer;
-      const settle = () => {
-        if (connection.iceGatheringState !== "complete") return;
-        clearTimeout(timer);
-        connection.removeEventListener("icegatheringstatechange", settle);
-        resolve();
-      };
-      connection.addEventListener("icegatheringstatechange", settle);
-      timer = setTimeout(() => {
-        connection.removeEventListener("icegatheringstatechange", settle);
-        resolve();
-      }, ICE_GATHERING_TIMEOUT_MS);
-    });
-  }
-
-  return {
-    async createOffer() {
-      attachChannel(connection.createDataChannel(CHANNEL_LABEL));
-      await connection.setLocalDescription(await connection.createOffer());
-      await whenIceGatheringCompletes();
-      return connection.localDescription.sdp;
-    },
-
-    async createAnswerFor(offerSdp) {
-      await connection.setRemoteDescription({ type: "offer", sdp: offerSdp });
-      await connection.setLocalDescription(await connection.createAnswer());
-      await whenIceGatheringCompletes();
-      return connection.localDescription.sdp;
-    },
-
-    async completeWithAnswer(answerSdp) {
-      await connection.setRemoteDescription({ type: "answer", sdp: answerSdp });
-    },
-
-    send(data) {
-      const state = channel ? channel.readyState : "missing";
-      if (state !== "open") throw new Error(`cannot send over a data channel that is ${state}`);
-      channel.send(JSON.stringify(data));
-    },
-
-    onMessage(handler) {
-      messageHandlers.push(handler);
-    },
-
-    onOpen(handler) {
-      openHandlers.push(handler);
-      if (openAnnounced) handler();
-    },
-
-    onClose(handler) {
-      closeHandlers.push(handler);
-      if (closeAnnounced) handler();
-    },
-
-    close() {
-      if (tornDown) return;
-      tornDown = true;
-      channel?.close();
-      connection.close();
-      announceClose();
-    },
-
-    get connectionState() {
-      return connection.connectionState;
-    },
-  };
-}

package/src/domain/p2p/facts.mjs

@@ -1,102 +0,0 @@
-// domain/p2p/facts.mjs — the small set of new predicates the P2P layer
-// introduces on top of the existing memory store's triple shape, plus pure
-// constructors for each. Every one is a plain add-only fact, replicated the
-// same way any other fact is (appendFacts' own union-by-id behavior) — no
-// new CRDT primitive. Provenance uses the existing `ace:` tag shape
-// (`ace:p2p:<id>@<ts>`) so trust.mjs's own parser reads it with no changes
-// there: stripped of its `ace:` prefix it reads as `p2p:<id>@<ts>`, which
-// parses to { kind: "operator", sessionId: "p2p:<id>", createdAt: <ts> }.
-import { provenanceTagToSource } from "../memory/trust.mjs";
-
-export const WORLD_NAME_PREDICATE = "mgx:worldName";
-export const NODE_NAME_PREDICATE = "mgx:nodeName";
-export const PLAYED_BY_PREDICATE = "mgx:playedBy";
-export const WAVED_PREDICATE = "mgx:waved";
-export const INVITED_BY_PREDICATE = "mgx:invitedBy";
-
-export const P2P_PREDICATES = Object.freeze([
-  WORLD_NAME_PREDICATE,
-  NODE_NAME_PREDICATE,
-  PLAYED_BY_PREDICATE,
-  WAVED_PREDICATE,
-  INVITED_BY_PREDICATE,
-]);
-
-const provenanceFor = (id, timestamp) => `ace:p2p:${id}@${timestamp}`;
-
-/** The term a node id takes as a fact subject or object, matching `peer:` for
- *  connection-scoped peer ids. A node id is the stable one — it outlives a
- *  reconnect, which is what an admission edge needs. */
-export const nodeTerm = (nodeId) => `node:${nodeId}`;
-
-export function worldNameFact(worldId, name, timestamp) {
-  return { subject: worldId, predicate: WORLD_NAME_PREDICATE, object: name, provenance: provenanceFor(worldId, timestamp) };
-}
-
-export function nodeNameFact(peerId, name, timestamp) {
-  return { subject: `peer:${peerId}`, predicate: NODE_NAME_PREDICATE, object: name, provenance: provenanceFor(peerId, timestamp) };
-}
-
-export function playedByFact(characterId, peerId, timestamp) {
-  return { subject: characterId, predicate: PLAYED_BY_PREDICATE, object: `peer:${peerId}`, provenance: provenanceFor(characterId, timestamp) };
-}
-
-/** Who let a node into the mesh. There is no open discovery here — every node
- *  arrives through an invite a member chose to send — so this edge records a
- *  social admission graph that identities cannot mint for themselves. The
- *  joiner writes it, because the joiner is the only side that knows both node
- *  ids at the moment it decides to join. */
-export function invitedByFact(joinerNodeId, inviterNodeId, timestamp) {
-  return {
-    subject: nodeTerm(joinerNodeId),
-    predicate: INVITED_BY_PREDICATE,
-    object: nodeTerm(inviterNodeId),
-    provenance: provenanceFor(joinerNodeId, timestamp),
-  };
-}
-
-export function waveFact(characterId, roomId, timestamp) {
-  return { subject: characterId, predicate: WAVED_PREDICATE, object: roomId, provenance: provenanceFor(`${characterId}-${roomId}`, timestamp) };
-}
-
-/** The newest asserted-at timestamp across every " | "-joined segment of a
- *  fact's provenance — the correct read for "when was this most recently
- *  true," since a repeat wave unions a fresh tag onto the SAME fact id
- *  (same subject/predicate/object) rather than minting a new row. Returns
- *  null if 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;
-}
-
-/** "Currently waving" is a read-time recency question, never a retraction —
- *  a wave fact older than the window just stops being read as current, with
- *  nothing ever deleted from the graph. */
-export function isRecentWave(waveFactRow, nowMs, windowMs = 8000) {
-  const at = latestProvenanceTimestamp(waveFactRow?.provenance);
-  if (at === null) return false;
-  const age = nowMs - at;
-  return age >= 0 && age <= windowMs;
-}
-
-/** The latest-by-timestamp fact for a subject+predicate pair — the "current
- *  value" read for an add-only, no-retraction fact like a node's own name
- *  or which peer plays a character (first-claim-wins uses the OLDEST of
- *  these instead; see playedByFact's own caller for that distinction). */
-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/p2p/peer-id.mjs

@@ -1,47 +0,0 @@
-// domain/p2p/peer-id.mjs — pure id/name generation for the P2P layer. No
-// network, no DOM; safe to import from both a Node test and a browser
-// bundle. World/peer ids are UUIDs, generated client-side and never seen by
-// any server. Display names are two words drawn from the same closed-world
-// lexicon that grounds every taught fact, so a name a player sees on screen
-// is always a real word this build's vocabulary already recognizes.
-import { loadLexicon } from "../grammar/lexicon.mjs";
-
-const fallbackId = (prefix) => `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-
-export function generatePeerId() {
-  return globalThis.crypto?.randomUUID?.() ?? fallbackId("peer");
-}
-
-export function generateWorldId() {
-  return globalThis.crypto?.randomUUID?.() ?? fallbackId("world");
-}
-
-/** A store's stable node id: 16 lowercase hex characters. A peer id is minted
- *  per connection and a display name is user-chosen and collidable, so neither
- *  keys a node's own assertions across its lifetime; this one is minted once,
- *  the first time a store joins a room, and never regenerated. Hex only, so it
- *  is safe to carry inside a provenance tag beside the `#`, `:` and `@`
- *  separators that tag's parser splits on. */
-export function generateNodeId() {
-  const bytes = new Uint8Array(8);
-  if (globalThis.crypto?.getRandomValues) globalThis.crypto.getRandomValues(bytes);
-  else for (let i = 0; i < bytes.length; i += 1) bytes[i] = Math.floor(Math.random() * 256);
-  let hex = "";
-  for (const b of bytes) hex += b.toString(16).padStart(2, "0");
-  return hex;
-}
-
-/** Two distinct words drawn from the lexicon's own noun list — a mnemonic
- *  label, not a credential. `random` is injectable for deterministic tests;
- *  defaults to Math.random. Callers add a numeric suffix themselves if a
- *  live collision turns up among currently-connected peers — this function
- *  never guesses at uniqueness on its own. */
-export function generateDisplayName(random = Math.random) {
-  const words = [...loadLexicon().nouns.keys()];
-  if (words.length < 2) return "guest-guest";
-  const pick = () => words[Math.floor(random() * words.length)];
-  const first = pick();
-  let second = pick();
-  while (second === first) second = pick();
-  return `${first}-${second}`;
-}

package/src/domain/p2p/provenance-relabel.mjs

@@ -1,37 +0,0 @@
-// domain/p2p/provenance-relabel.mjs — rewrites a fact's outgoing provenance
-// tag before it's broadcast to peers, so "who taught this" reads as a node
-// name rather than a local session id. Only teach/operator-kind tags are
-// touched; a mud world/testimony tag is already attributed to the world or
-// the character that made it, not the person at the keyboard, and rewriting
-// it would lose information rather than add it.
-import { provenanceTagToSource } from "../memory/trust.mjs";
-
-const RELABELED_KINDS = new Set(["teach", "operator"]);
-
-/** The outgoing tag for one fact this node is asserting. The `#node:<id>`
- *  segment is what makes the origin identifiable across reconnects and
- *  renames: a display name is user-chosen and collidable, and a peer id is
- *  minted fresh per connection, so neither keys a node over its own lifetime.
- *  A node with no id yet emits the older segment-free shape, which every
- *  reader still parses. */
-export function peerProvenanceTag(displayName, timestamp, nodeId = "") {
-  const node = nodeId ? `#node:${nodeId}` : "";
-  return `teach:peer:${displayName}${node}@${timestamp}`;
-}
-
-/** `provenance` may already be a " | "-joined union of several tags (the
- *  same fact taught more than once, from different sources) — relabel each
- *  segment independently and rejoin, so a segment this peer didn't author
- *  passes through untouched. */
-export function relabelForBroadcast(provenance, myDisplayName, timestamp, myNodeId = "") {
-  const tag = String(provenance || "");
-  if (!tag) return tag;
-  return tag
-    .split(" | ")
-    .map((segment) => {
-      const source = provenanceTagToSource(segment);
-      if (!source || !RELABELED_KINDS.has(source.kind)) return segment;
-      return peerProvenanceTag(myDisplayName, timestamp, myNodeId);
-    })
-    .join(" | ");
-}

package/src/domain/p2p/sync-filter.mjs

@@ -1,43 +0,0 @@
-// domain/p2p/sync-filter.mjs — which rows of an already-loaded fact store
-// are worth syncing to a new joiner. Every peer's page ships the identical
-// build-time seed, so those rows already share the same content-addressed
-// ids before any network traffic happens; sending them again is pure waste.
-// What actually needs syncing is the delta: whatever a person or a peer
-// actually added since boot.
-import { provenanceTagToSource } from "../memory/trust.mjs";
-import { RETRACTION_PREDICATE } from "../memory/retraction.mjs";
-
-// A retraction crosses on both surfaces, whatever else they disagree about.
-// It carries no teach tag of its own to key on and no world predicate, so
-// leaving it to either filter's own rule would strand it and the deleted fact
-// would come straight back from the next peer that still holds it.
-const alwaysSyncable = (row) => row?.predicate === RETRACTION_PREDICATE;
-
-// "teachNode" is the same human teaching, seen from one hop further out: a
-// peer's own relabeled tag, keyed on the node id it carries. It syncs for
-// exactly the reason "teach" does, and leaving it out would silently strand
-// every fact that had already crossed the wire once.
-const CHAT_SYNCABLE_KINDS = new Set(["teach", "operator", "teachNode"]);
-
-/** chat.html: every fact a human (locally or via a peer) actually taught or
- *  asserted — never a row from the shipped corpus. */
-export function chatSyncableFacts(rows) {
-  return rows.filter((row) => {
-    if (alwaysSyncable(row)) return true;
-    const source = provenanceTagToSource(row.provenance);
-    return source ? CHAT_SYNCABLE_KINDS.has(source.kind) : false;
-  });
-}
-
-/** mud.html: every fact that isn't part of the bare, unsuffixed world seed —
- *  a move, a dig, a piece of testimony, or one of the P2P layer's own new
- *  predicates (world/node names, character claims, waves). `isMudStatePredicate`
- *  is injected rather than imported from adventure.mjs directly, so this
- *  module never needs to know that file's internal predicate names — the
- *  caller (whoever wires the mud room) supplies it, typically
- *  `adventure.mjs`'s own exported predicate check, extended to also accept
- *  this module's own P2P predicates via `extraPredicates`. */
-export function mudSyncableFacts(rows, isMudStatePredicate, extraPredicates = []) {
-  const extra = new Set(extraPredicates);
-  return rows.filter((row) => alwaysSyncable(row) || extra.has(row.predicate) || isMudStatePredicate(row.predicate));
-}

package/src/domain/p2p/wire.mjs

@@ -1,126 +0,0 @@
-// domain/p2p/wire.mjs — pure message shapes and blob encoding for the P2P
-// layer. Two kinds of payload: an "invite blob" carried in a URL or pasted
-// by hand (a base64url-encoded JSON envelope holding one SDP string), and
-// plain JSON messages sent over an already-open DataChannel. Nothing here
-// touches the network or WebRTC itself — src/adapters/p2p/webrtc-transport.mjs
-// owns the connection, src/services/p2p-room.mjs owns what these messages mean.
-
-const INVITE_KINDS = new Set(["offer", "reply"]);
-
-function toBase64Url(str) {
-  const b64 = typeof btoa === "function" ? btoa(str) : Buffer.from(str, "utf8").toString("base64");
-  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-
-function fromBase64Url(b64url) {
-  let b64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
-  while (b64.length % 4) b64 += "=";
-  return typeof atob === "function" ? atob(b64) : Buffer.from(b64, "base64").toString("utf8");
-}
-
-/** Encode one invite envelope — an offer (from the sharer) or a reply (from
- *  the joiner) — into a URL-safe string. An offer carries the world id and
- *  name so a fresh joiner can be shown them before connecting, plus the
- *  inviter's own node id, which is what lets the joiner record who admitted it;
- *  a reply only needs to carry the answer SDP back to the inviter. */
-export function encodeInviteBlob({ kind, sdp, world, worldName, node }) {
-  if (!INVITE_KINDS.has(kind)) throw new Error(`encodeInviteBlob: unknown kind "${kind}"`);
-  if (typeof sdp !== "string" || !sdp) throw new Error("encodeInviteBlob: sdp is required");
-  const envelope = kind === "offer"
-    ? { v: 1, kind, sdp, world, worldName, ...(node ? { node } : {}) }
-    : { v: 1, kind, sdp };
-  return toBase64Url(JSON.stringify(envelope));
-}
-
-/** Decode a blob produced by encodeInviteBlob. Never throws — a malformed,
- *  truncated, or foreign-shaped blob returns { error } instead, so the UI can
- *  show a specific message ("this invite looks cut short") rather than an
- *  uncaught exception or a silent no-op. */
-export function decodeInviteBlob(blobString) {
-  if (typeof blobString !== "string" || !blobString.trim()) return { error: "empty" };
-  let json;
-  try {
-    json = fromBase64Url(blobString.trim());
-  } catch {
-    return { error: "truncated" };
-  }
-  let envelope;
-  try {
-    envelope = JSON.parse(json);
-  } catch {
-    return { error: "truncated" };
-  }
-  if (!envelope || typeof envelope !== "object") return { error: "malformed" };
-  if (envelope.v !== 1) return { error: "unsupported-version" };
-  if (!INVITE_KINDS.has(envelope.kind)) return { error: "malformed" };
-  if (typeof envelope.sdp !== "string" || !envelope.sdp) return { error: "malformed" };
-  if (envelope.kind === "offer" && (typeof envelope.world !== "string" || !envelope.world)) {
-    return { error: "malformed" };
-  }
-  return { value: envelope };
-}
-
-const ROOM_MESSAGE_TYPES = new Set([
-  "hello",
-  "peer-list",
-  "intro-offer",
-  "intro-answer",
-  "sync-request",
-  "sync-response",
-  "op",
-]);
-
-export function helloMessage({ peerId, displayName }) {
-  return { type: "hello", peerId, displayName };
-}
-
-export function peerListMessage({ peers }) {
-  return { type: "peer-list", peers };
-}
-
-export function introOfferMessage({ from, to, sdp }) {
-  return { type: "intro-offer", from, to, sdp };
-}
-
-export function introAnswerMessage({ from, to, sdp }) {
-  return { type: "intro-answer", from, to, sdp };
-}
-
-export function syncRequestMessage() {
-  return { type: "sync-request" };
-}
-
-export function syncResponseMessage({ facts }) {
-  return { type: "sync-response", facts };
-}
-
-export function opMessage({ from, facts }) {
-  return { type: "op", from, facts };
-}
-
-/** Structural validation only — the front door for anything a peer sends
- *  over an open channel. Returns true/false rather than throwing, so a room
- *  can drop a malformed message from a misbehaving or out-of-date peer
- *  instead of crashing on it. */
-export function isValidRoomMessage(msg) {
-  if (!msg || typeof msg !== "object" || !ROOM_MESSAGE_TYPES.has(msg.type)) return false;
-  switch (msg.type) {
-    case "hello":
-      return typeof msg.peerId === "string" && msg.peerId.length > 0 && typeof msg.displayName === "string";
-    case "peer-list":
-      return Array.isArray(msg.peers)
-        && msg.peers.every((p) => p && typeof p.peerId === "string" && typeof p.displayName === "string");
-    case "intro-offer":
-    case "intro-answer":
-      return typeof msg.from === "string" && typeof msg.to === "string"
-        && typeof msg.sdp === "string" && msg.sdp.length > 0;
-    case "sync-request":
-      return true;
-    case "sync-response":
-      return Array.isArray(msg.facts);
-    case "op":
-      return typeof msg.from === "string" && Array.isArray(msg.facts);
-    default:
-      return false;
-  }
-}