@polycode-projects/the-mechanical-code-talker 2.7.12 → 2.7.13

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

@@ -0,0 +1,88 @@
+// adventure-browser-entry.mjs — the esbuild entry for the adventure's
+// full-screen/home-page pages (public/adventure-browser.bundle.js, built by
+// scripts/build-adventure-bundle.mjs), mirroring
+// spider-fly-browser-entry.mjs's own session-factory shape.
+//
+// Unlike spider-fly's board, Ashcombe Hall's own facts+rules cannot be
+// regenerated in-browser from a pure JS module — its canonical definition is
+// a Node-only JSONL corpus source, read through an fs/gzip provider the
+// browser cannot run. So this session takes the world as data
+// (`worldPayload`, `{ name, facts, rules, opening }`), embedded into the page
+// at build time by scripts/build-demo-site.mjs's own read through the real
+// worlds-pack provider (see adventure-viz.mjs's header for the full
+// rationale) — the bootstrap below then just appends it, exactly the shape
+// openAdventure() itself writes for a real chat session.
+//
+// This session exposes ONLY a raw autoplay tick and a read-only snapshot —
+// no chat dock. Every state-changing command adventure.mjs's own
+// runWorldCommand issues (go/take/open/...) already re-narrates itself
+// through the extractive completions digest on every turn (the
+// "auto-relook"), so this bundle carries the same wink-nlp/completions
+// dependency chain chat.mjs's own runTurn does; a second, lighter path was
+// not available to duck under it. Nothing here calls runTurn, though — the
+// one entry point exercised is adventureTurn itself, via
+// adventure-autoplay.mjs, which is the "auto-play is a caller of the
+// existing interpreter, never a second one" contract this whole feature
+// rests on.
+import {
+  createInMemoryStore, appendFacts, appendRule, loadMemory, readFactRows,
+} from "../../adapters/memory/core.mjs";
+import { foldWorldState, worldDigestRows } from "../../services/adventure.mjs";
+import { runAdventureAutoplayTick } from "../../services/adventure-autoplay.mjs";
+import { resolveSpriteForClass, SPRITE_REGISTRY } from "../../domain/sprite-map.mjs";
+
+/** A live in-memory adventure this page's ticker drives one auto-play tick
+ *  at a time. Returns `{ memoryDir, autoplayTick, snapshot }`.
+ *  `worldPayload.facts`/`.rules` seed the store exactly the way
+ *  openAdventure() itself does for a real session; `planHolder.state` is set
+ *  the same way, so adventureTurn treats every subsequent call as a live,
+ *  already-open world rather than a fresh opening line. */
+export async function createAdventureSession(worldPayload) {
+  const memoryDir = createInMemoryStore();
+  const tag = `world:${worldPayload.name}`;
+  await appendFacts(memoryDir, worldPayload.facts.map((f) => ({
+    subject: f.subject, predicate: f.predicate, object: f.object, provenance: tag,
+  })));
+  for (const rule of worldPayload.rules) {
+    await appendRule(memoryDir, { name: rule.name, kind: rule.ruleKind, slots: rule.slots, provenance: tag });
+  }
+
+  const planHolder = { state: { adventure: { world: worldPayload.name } } };
+  const sessionId = globalThis.crypto?.randomUUID?.() ?? String(Date.now());
+  let exposedRoomIds = new Set();
+  const openingRows = readFactRows(await loadMemory(memoryDir));
+  const openingHere = foldWorldState(openingRows).placements.get("player")?.object ?? null;
+  if (openingHere) exposedRoomIds = new Set([openingHere]);
+
+  return {
+    memoryDir,
+
+    /** One auto-play tick: infer the goal, execute exactly one move through
+     *  adventureTurn (adventure-autoplay.mjs's own contract), thread the
+     *  exposed-room set forward. Returns runAdventureAutoplayTick's own
+     *  `{ turn, goal, plan, done, stalled }` unmodified. */
+    async autoplayTick() {
+      const result = await runAdventureAutoplayTick(memoryDir, {
+        exposedRoomIds, planHolder, sessionId, env: {},
+      });
+      exposedRoomIds = result.exposedRoomIds;
+      return result;
+    },
+
+    /** A read-only fold of the current room — no engine advance — for the
+     *  page's own redraw after boot and after every tick. */
+    async snapshot() {
+      const rows = readFactRows(await loadMemory(memoryDir));
+      const state = foldWorldState(rows);
+      const here = state.placements.get("player")?.object ?? null;
+      return { rows, state, here, turn: state.turnCount };
+    },
+  };
+}
+
+// Re-exported so the page's own rendering script (adventure-viz.mjs) never
+// has to duplicate sprite resolution or the digest reader — the same posture
+// spider-fly-browser-entry.mjs's own globalThis.tmctSpiderFly re-export takes.
+globalThis.tmctAdventure = {
+  createAdventureSession, resolveSpriteForClass, SPRITE_REGISTRY, worldDigestRows,
+};

package/src/surfaces/web/memory-ask-browser.bundle.js

@@ -23574,6 +23574,7 @@ ${JSON.stringify(envelope, null, 2)}`;
   // src/services/spider-fly.mjs
   init_planning();
   init_core();
+  init_hash();
 
   // src/services/spider-fly-turn.mjs
   init_core();

package/src/surfaces/web/spider-fly-browser-entry.mjs

@@ -52,7 +52,7 @@ import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
 import {
   worldFactRows, WORLD_NAME, WORLD_OPENING, cellId, parseCellId, DIRECTION_DELTA, visibleCells,
 } from "../../domain/spider-fly-world.mjs";
-import { foldSpiderFlyState, runSpiderFlyTick, startSpiderFlyGame, DEFAULT_VISION_RADIUS } from "../../services/spider-fly.mjs";
+import { foldSpiderFlyState, runSpiderFlyTick, startSpiderFlyGame, liveWebs, DEFAULT_VISION_RADIUS } from "../../services/spider-fly.mjs";
 import { resolveSpriteForClass, SPRITE_REGISTRY } from "../../domain/sprite-map.mjs";
 
 /** A live in-memory game the page's ticker and chat dock can both drive.
@@ -77,8 +77,8 @@ export async function createSpiderFlySession({ flyCount = 1 } = {}) {
   const { facts: startFacts } = await startSpiderFlyGame(memoryDir, { flyCount });
   const initialAgents = {};
   for (const f of startFacts) {
-    if (f.predicate !== "mgx:currently-in") continue;
-    initialAgents[f.subject] = { cell: f.object };
+    if (f.predicate === "mgx:currently-in") initialAgents[f.subject] = { ...initialAgents[f.subject], cell: f.object };
+    else if (f.predicate === "mgx:mass") initialAgents[f.subject] = { ...initialAgents[f.subject], mass: Number(f.object) };
   }
 
   const graph = parseEntities({ individuals: [], objectProperties: [] });
@@ -93,7 +93,7 @@ export async function createSpiderFlySession({ flyCount = 1 } = {}) {
     memoryDir,
     sessionId,
     opening: WORLD_OPENING,
-    initial: { turn: 0, agents: initialAgents },
+    initial: { turn: 0, agents: initialAgents, activeWebs: [] },
     taxonomyRows,
 
     /** Run one real engine turn directly. Returns spider-fly.mjs's own
@@ -127,16 +127,18 @@ export async function createSpiderFlySession({ flyCount = 1 } = {}) {
 
     /** A read-only fold of the CURRENT board — no engine advance, no goal
      *  lines (see the header comment: only a raw tick() recomputes those).
-     *  Lets the page resync positions/turn count after a chat-driven tick. */
+     *  Lets the page resync positions/turn count/mass/active webs after a
+     *  chat-driven tick. Web individuals are never listed as agents (that's
+     *  spider-1/fly-1/... only) — they surface only through activeWebs. */
     async snapshot() {
       const rows = readFactRows(await loadMemory(memoryDir));
       const state = foldSpiderFlyState(rows);
       const agents = {};
       for (const [id, place] of state.placements) {
-        if (state.removed.has(id)) continue;
-        agents[id] = { cell: place.cell };
+        if (state.removed.has(id) || /^web-\d+$/.test(id)) continue;
+        agents[id] = { cell: place.cell, mass: state.mass.get(id)?.value ?? null };
       }
-      return { turn: state.turnCount, agents };
+      return { turn: state.turnCount, agents, activeWebs: liveWebs(state.webs, state.turnCount) };
     },
   };
 }