@runmu.sh/ext-scene 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.3.0
+
+- The room on games that send only its name. Evennia games such as Underspire send no GMCP `Room.Info` or `Room.Players` over telnet, so the Scene showed a title and nothing else. The extension now reads the room look the game prints (title, description, who is here, the exits line) and GMCP `Room.Name` and `Player.Context`, and fills the description, Present and Exits, as Underspire's own panel does. Moving fills the next room from its auto-look.
+- It steps aside as soon as a game sends GMCP `Room.Info` or MSDP `ROOM_EXITS` / `ROOM_VNUM`: those games are unchanged.
+- New setting **Read the room from the game text** (per world, default on).
+- Asks for `read-output` as well as `send-commands`: it reads the game text (an observe stage: read only, live lines only).
+- Exports `roomOf`, `exitsOf`, `peopleOf`, `roomNameOf`, `contextOf` and `TEXT_PRIORITY`.
+
 ## 1.2.0
 
 - Alt+R (*Go to scene*) is now the extension's own command, `focus.scene`, in Settings → Keys under Scene: Focus. On μClient with extension API 1.14 it focuses the Scene panel when it is open; a rebinding you made keeps working. On an older μClient the client's own Alt+R stays in place.

package/README.md

@@ -16,6 +16,24 @@ The host keeps one scene per session and fills it from:
 | GMCP `Char.Items.List` / `Add` / `Remove` with `location: "room"` | Present (items; `hostile: true` is marked) |
 | MSDP `ROOM_NAME`, `ROOM_VNUM`, `ROOM_EXITS`, `AREA_NAME` (or `ROOM.*`) | Title, exits, area |
 | Another extension: `mu.scene.set({ title, area, desc, atmosphere, pose, exits, present, items })` | Any field |
+| This extension, from the game (1.3.0): GMCP `Room.Name` (a string or `{ name }`), `Player.Context` (`room`, `pose_line`, `presence`, without your own `character`), and the room text | Title, description, pose, Present (people), exits |
+
+### Games that send only the room name (1.3.0)
+Evennia games such as Underspire send no `Room.Info` or `Room.Players` over telnet: only `Room.Name`, and `Player.Context` once at login. For those the extension reads the room look the game prints:
+
+```
+Shard intake                                        ← title (no closing punctuation)
+A vast data space, humming with virtual activity.   ← description
+                                                    
+The intake terminal is installed here.              ← things in the room (skipped)
+                                                    
+^A2PGUE is standing here. You are standing here.    ← Present (you are left out)
+There are exits to the san junipero (back).         ← exits, by name; ends the look
+```
+
+The exits line (`There are exits to …`, `There is an exit to …`, `Exits: …`) closes a look; the lines before it are read back to the nearest title line. A typed command in between starts over, so the text of a `look` at a person or an item is not taken for a room. An exit button sends the exit's name (`san junipero`), which Evennia accepts as well as its alias.
+
+The text reader provides at priority 10, over the MSDP adapter's room name, and turns itself off for a session as soon as the game sends GMCP `Room.Info` or MSDP `ROOM_EXITS` / `ROOM_VNUM`; its fields are then released to the adapters. MSDP `ROOM_NAME` alone (Underspire mirrors `Room.Name` there) does not turn it off. Setting **Read the room from the game text** (per world, default on) turns it off.
 
 Package names are case-insensitive. Entering a new room clears Present. The room title is also the session's location (the world switcher shows it).
 
@@ -29,10 +47,10 @@ The panel is the region `scene`. **Alt+R** (*Go to scene*, command `focus.scene`
 - **Show panel: auto** (per world, on the extension's settings page: off / auto / on). On auto the Scene joins Views and adds itself the first time a session knows its room, whatever the room came from (GMCP, MSDP, another extension); once per world on this device, so a Scene you closed stays closed.
 - A redraw in the same room (someone arrives, an item drops) keeps your scroll position; moving to another room scrolls back to the top. When the game sends no room id, every update counts as a move.
 - Right-click (or long-press) an exit or a room item for the menus other extensions add to them. The extension registers the context kinds `scene.exit` (title *Exit*, `data: { exit }`) and `scene.item` (title *Scene item*, `data: { item: { id, name, hostile? } }`), each with a schema the host checks. On a μClient before API 1.14 it publishes the 1.12 kinds `scene-exit` and `scene-item` instead; on 1.14 an entry written for the old kinds still receives the new targets in the old shape.
-- It sends nothing to the game except the exits you click, and reads no GMCP itself: the room adapters fill the scene.
+- It sends nothing to the game except the exits you click. On a game with GMCP `Room.Info` or MSDP rooms the room adapters fill the scene; otherwise it reads `Room.Name`, `Player.Context` and the room text itself (1.3.0, above).
 
 ## Contract
-The extension reads no GMCP and sends none, so it declares no GMCP packages or payload contracts; the room adapters declare `Room 1` and feed `mu.scene` (`SceneView`). Capability: `send-commands` (the exit buttons).
+The extension sends no GMCP and declares no packages or payload contracts; the room adapters declare `Room 1` and feed `mu.scene` (`SceneView`). It listens to `Room.Name` and `Player.Context` (Evennia sends them unasked) and `Room.Info` / MSDP `ROOM_EXITS` / `ROOM_VNUM` only to step aside. Capabilities: `read-output` (the room text, an `observe` line stage: read only, live lines only) and `send-commands` (the exit buttons).
 
 ## Exported API (`@runmu.sh/ext-scene`, types in `src/types.ts`)
 No `ctx.exports` API. The module exports, for tests and other renderers:
@@ -43,11 +61,13 @@ No `ctx.exports` API. The module exports, for tests and other renderers:
 | `presentOf(scene)` | People first, then room items, each name once: `{ name, hostile? }[]`. |
 | `COPY`, `SCENE_CSS` | The drawn copy and the stylesheet (every rule under `.ext-panel[data-ext="scene"] .mu-scene`). |
 | `ITEM_KIND`, `EXIT_KIND`, `KIND_SCHEMAS` | `'scene.item'`, `'scene.exit'` and their `data` schemas. |
+| `roomOf(lines)`, `exitsOf(line)`, `peopleOf(line)` | The room text reader (1.3.0): a `ScenePatch` (`title`, `desc`, `exits`, `present`) from lines ending in an exits line, or `null`; the exit names of an exits line; the people (not you) of a who-is-here line. |
+| `roomNameOf(data)`, `contextOf(data)`, `TEXT_PRIORITY` | `Room.Name` → title; `Player.Context` → `{ title, pose, present }`; the provider priority (10). |
 
 `src/types.ts` augments the SDK's `ContextKinds` with `scene.item` (`SceneItemData`) and `scene.exit` (`SceneExitData`), so an extension that imports it gets `t.data` typed in `mu.menus.context({ target: 'scene.exit', … })`.
 
 ## SDK
-`api` `^1.12`. SDK 1.12: `mu.panels.register` with `show: 'auto'`, `mu.panels.touch`, `mu.sessions.each`, `mu.scene.watch` (and `SceneView.id`), `mu.sessions.send(dir, { sid })`, `mu.menus.target`, `h` and `mu.ui.css`, `mu.ui.style`. SDK 1.14, used when the host has them: `mu.menus.kind` (with `JsonSchema` and `ContextKinds`), `mu.panels.focus` with `mu.commands.register`. The manifest declares `focus.scene` in `contributes.commands`, so Alt+R is listed and bound before the extension activates.
+`api` `^1.12`. SDK 1.12: `mu.panels.register` with `show: 'auto'`, `mu.panels.touch`, `mu.sessions.each`, `mu.scene.watch` (and `SceneView.id`), `mu.sessions.send(dir, { sid })`, `mu.menus.target`, `h` and `mu.ui.css`, `mu.ui.style`, `mu.scene.provide`, `mu.gmcp.on` / `state`, `mu.msdp.on` / `state`, `mu.lines.stage` (phase `observe`), `mu.settings.define`. SDK 1.14, used when the host has them: `mu.menus.kind` (with `JsonSchema` and `ContextKinds`), `mu.panels.focus` with `mu.commands.register`. The manifest declares `focus.scene` in `contributes.commands`, so Alt+R is listed and bound before the extension activates.
 
 ## Develop
 Made with `npm create @runmu.sh/extension` ([the quickstart](https://runmu.sh/docs/extensions/quickstart)).

package/dist/index.js

@@ -5,7 +5,80 @@ import { defineExtension, h } from "@muclient/sdk";
 var ITEM_KIND = "scene.item";
 var EXIT_KIND = "scene.exit";
 
+// src/room.ts
+var EXITS_RE = /^(?:there (?:are|is) (?:an? )?(?:exits?|ways?(?: out)?) (?:to|leading to) |(?:obvious )?exits?: )(.+?)\.?$/i;
+var HERE_RE = /^(.+?) (?:is|are) (?:[a-z]+ )?here\.?$/i;
+var MAX_TITLE = 80;
+function exitsOf(line) {
+  const m = EXITS_RE.exec(line.trim());
+  if (!m) return null;
+  const out = [];
+  for (let part of m[1].split(/\s*,\s*(?:and\s+)?|\s+and\s+/)) {
+    part = part.replace(/\s*\([^)]*\)\s*$/, "").replace(/^the\s+/i, "").trim();
+    if (part && !out.includes(part)) out.push(part);
+  }
+  return out;
+}
+function peopleOf(line) {
+  const out = [];
+  for (const s of line.trim().split(/(?<=\.)\s+/)) {
+    const m = HERE_RE.exec(s);
+    if (!m) continue;
+    for (const n of m[1].split(/\s*,\s*(?:and\s+)?|\s+and\s+/)) {
+      const name = n.trim();
+      if (name && !/^you$/i.test(name) && !out.includes(name)) out.push(name);
+    }
+  }
+  return out;
+}
+var looksTitle = (t) => t.length > 0 && t.length <= MAX_TITLE && !/[.!?:;,"')>\]]$/.test(t);
+function roomOf(lines, maxSections = 4) {
+  if (!lines.length) return null;
+  const exits = exitsOf(lines[lines.length - 1]);
+  if (!exits) return null;
+  const sections = [[]];
+  for (const raw of lines.slice(0, -1)) {
+    const l = raw.trim();
+    if (l) sections[sections.length - 1].push(l);
+    else if (sections[sections.length - 1].length) sections.push([]);
+  }
+  if (!sections[sections.length - 1].length) sections.pop();
+  if (!sections.length) return null;
+  const tail = sections[sections.length - 1];
+  const people = tail.some((l) => peopleOf(l).length || /^you (?:are|is) [a-z ]*here\.?$/i.test(l));
+  for (let i = sections.length - 1; i >= Math.max(0, sections.length - maxSections); i--) {
+    const sec = sections[i];
+    let t = -1;
+    for (let j = sec.length - 1; j >= 0; j--) if (looksTitle(sec[j]) && !HERE_RE.test(sec[j])) {
+      t = j;
+      break;
+    }
+    if (t < 0) continue;
+    if (i === sections.length - 1 && people) continue;
+    const present = people ? [...new Set(tail.flatMap(peopleOf))] : [];
+    return { title: sec[t], desc: sec.slice(t + 1).join("\n"), exits, present };
+  }
+  return null;
+}
+function roomNameOf(data) {
+  if (typeof data === "string") return data.trim();
+  if (data && typeof data === "object" && typeof data.name === "string") return data.name.trim();
+  return "";
+}
+function contextOf(data) {
+  if (!data || typeof data !== "object") return null;
+  const d = data;
+  const me = typeof d.character === "string" ? d.character.trim().toLowerCase() : "";
+  const patch = {};
+  if (typeof d.room === "string" && d.room.trim()) patch.title = d.room.trim();
+  if (typeof d.pose_line === "string") patch.pose = d.pose_line.trim();
+  if (Array.isArray(d.presence)) patch.present = [...new Set(d.presence.filter((n) => typeof n === "string" && !!n.trim() && n.trim().toLowerCase() !== me).map((n) => n.trim()))];
+  return Object.keys(patch).length ? patch : null;
+}
+
 // src/index.ts
+var TEXT_PRIORITY = 10;
+var KEEP = 40;
 var COPY = {
   title: "Scene",
   awaiting: "No room yet",
@@ -153,6 +226,76 @@ var index_default = defineExtension({
         mu.panels.focus?.("scene");
       } });
     }
+    mu.settings.define({
+      title: "Scene",
+      items: [{
+        key: "fromText",
+        label: "Read the room from the game text",
+        default: true,
+        kind: "toggle",
+        scope: "both",
+        hint: "For games that send only the room name over GMCP (Evennia games such as Underspire): the description, who is here and the exits come from the room text. A game that sends GMCP Room.Info is unaffected."
+      }]
+    });
+    const fromText = (sid) => mu.settings.get("fromText", { sid }) !== false;
+    const hasRoom = (sid) => mu.gmcp.state("Room.Info", sid) !== void 0 || mu.msdp.state("ROOM_EXITS", sid) !== void 0 || mu.msdp.state("ROOM_VNUM", sid) !== void 0;
+    const given = /* @__PURE__ */ new Map();
+    const give = (sid, patch) => {
+      given.set(sid, mu.scene.provide(sid, patch, { priority: TEXT_PRIORITY }));
+    };
+    const release = (sid) => {
+      given.get(sid)?.();
+      given.delete(sid);
+    };
+    const seen = /* @__PURE__ */ new Map();
+    const titles = /* @__PURE__ */ new Map();
+    ctx.subscriptions.push(
+      mu.gmcp.on("Room.Info", (_d, m) => release(m.sid)),
+      mu.msdp.on("ROOM_EXITS", (_v, m) => release(m.sid)),
+      mu.msdp.on("ROOM_VNUM", (_v, m) => release(m.sid)),
+      mu.gmcp.on("Room.Name", (d, m) => {
+        const title = roomNameOf(d);
+        if (!title || hasRoom(m.sid) || !fromText(m.sid)) return;
+        if (titles.get(m.sid) !== title) {
+          titles.set(m.sid, title);
+          give(m.sid, { title });
+        }
+      }),
+      mu.gmcp.on("Player.Context", (d, m) => {
+        const patch = contextOf(d);
+        if (!patch || hasRoom(m.sid) || !fromText(m.sid)) return;
+        if (patch.title) titles.set(m.sid, patch.title);
+        give(m.sid, patch);
+      }),
+      // Observe: read only, live lines only (not backlog). A typed command starts a new block.
+      mu.lines.stage({
+        id: "room-text",
+        phase: "observe",
+        run: (line, c) => {
+          if (line.kind === "echo") {
+            seen.delete(c.sid);
+            return;
+          }
+          if (line.kind !== "output" && line.kind !== "prompt") return;
+          const buf = seen.get(c.sid) ?? [];
+          buf.push(line.text);
+          if (buf.length > KEEP) buf.splice(0, buf.length - KEEP);
+          seen.set(c.sid, buf);
+          const room = roomOf(buf);
+          if (!room) return;
+          seen.delete(c.sid);
+          if (hasRoom(c.sid) || !fromText(c.sid)) return;
+          const moved = titles.get(c.sid) !== room.title;
+          titles.set(c.sid, room.title ?? "");
+          give(c.sid, moved ? { ...room, pose: "", items: [] } : room);
+        }
+      }),
+      mu.sessions.each((s) => () => {
+        seen.delete(s.id);
+        titles.delete(s.id);
+        given.delete(s.id);
+      })
+    );
     ctx.subscriptions.push(mu.sessions.each((s) => {
       let done = false;
       return mu.scene.watch((v) => {
@@ -170,7 +313,14 @@ export {
   ITEM_KIND,
   KIND_SCHEMAS,
   SCENE_CSS,
+  TEXT_PRIORITY,
+  contextOf,
   index_default as default,
+  exitsOf,
+  peopleOf,
   presentOf,
-  renderScene
+  renderScene,
+  roomNameOf,
+  roomOf
 };
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/index.ts", "src/types.ts", "src/room.ts"],
  "sourcesContent": ["/**\n * Scene (@runmu.sh/ext-scene): the Scene panel. The host tracks the room per session (the room adapters fill\n * `mu.scene` from GMCP Room.* and Char.Items.*, MSDP, or `mu.scene.set`); this extension draws it, through\n * `mu.scene.watch`, so it works the same on every protocol. On a game that sends only `Room.Name` (Evennia, such\n * as Underspire) it also provides the room from `Player.Context` and the room text it prints (`./room.ts`).\n *\n * Composed as Underspire's room panel: title (uppercase glow, bottom rule), area, atmosphere (italic dim),\n * description, pose line (italic with a left rule), then \u2524PRESENT\u251C over a \u25B8 list (\"none\" when empty) and, when the\n * room has exits, \u2524EXITS\u251C over a \u25B8 list. Before any room it reads NO ROOM YET. An exit is a button that sends the\n * direction; exits and room items are context-menu targets for other extensions, of the kinds `scene.exit` and\n * `scene.item` this extension registers (SDK 1.14). On an older host they are the 1.12 kinds `scene-exit` and\n * `scene-item`.\n *\n * Alt+R (`focus.scene`, Go to scene) focuses the panel through `mu.panels.focus` (SDK 1.14). Before 1.14 the host\n * binds Alt+R itself, so the command is registered only when `mu.panels.focus` exists.\n *\n * Shown 'auto': the panel joins Views and adds itself (right top) the first time a session knows its room; the\n * player can set it off / auto / on per world (the host's \"Show panel\" row).\n */\nimport { defineExtension, h, type ContextTarget, type Dispose, type JsonSchema, type Mu, type PanelMountCtx, type SceneView } from '@muclient/sdk';\nimport type { PresentEntry, RenderOptions, SceneCopy, SceneCss } from './types';\nimport { EXIT_KIND, ITEM_KIND } from './types';\nimport { contextOf, roomNameOf, roomOf } from './room';\n\nexport type { PresentEntry, RenderOptions, SceneCopy, SceneCss, SceneExitData, SceneItemData } from './types';\nexport { EXIT_KIND, ITEM_KIND } from './types';\nexport { contextOf, exitsOf, peopleOf, roomNameOf, roomOf } from './room';\n\n/**\n * Above the room adapters (priority 0), so the people read from the text are not hidden by the MSDP adapter's\n * `present: []` on a room name. A game that sends a full room (GMCP Room.Info, MSDP ROOM_EXITS or ROOM_VNUM) turns\n * the text reader off for the session and its fields are released, so the adapters own the scene there.\n */\nexport const TEXT_PRIORITY = 10;\n/** Lines kept per session while waiting for a room's exits line. */\nconst KEEP = 40;\n\nexport const COPY: SceneCopy = {\n  title: 'Scene',\n  awaiting: 'No room yet',\n  present: 'Present',\n  exits: 'Exits',\n  none: 'none',\n  hostile: 'hostile',\n  go: (dir: string) => `go ${dir}`,\n  focus: 'Go to scene',\n  itemKind: 'Scene item',\n  exitKind: 'Exit',\n};\n\n/** The `data` schemas of the two context kinds, checked by the host on every `mu.menus.target` call. */\nexport const KIND_SCHEMAS: Record<typeof ITEM_KIND | typeof EXIT_KIND, JsonSchema> = {\n  [ITEM_KIND]: {\n    type: 'object', required: ['item'],\n    properties: { item: { type: 'object', required: ['id', 'name'], properties: { id: { type: 'string' }, name: { type: 'string' }, hostile: { type: 'boolean' } } } },\n  },\n  [EXIT_KIND]: { type: 'object', required: ['exit'], properties: { exit: { type: 'string' } } },\n};\n\nconst R = '.ext-panel[data-ext=\"scene\"] .mu-scene';\n/** Theme tokens only. Every rule is under `.ext-panel[data-ext=\"scene\"] .mu-scene`; the section heads are the host's `.sec-head`. */\nexport const SCENE_CSS = `\n${R} { height: 100%; overflow-y: auto; background: var(--bg-elev); padding: .7rem .85rem 1rem; font-family: var(--font-mono); font-size: .9rem; color: var(--fg); box-sizing: border-box; }\n${R}:focus { outline: none; }\n${R} .title { margin: 0 0 .5rem; padding-bottom: .4rem; font-weight: 400; font-size: .9rem; letter-spacing: .16em; text-transform: uppercase; color: var(--accent-bright); border-bottom: 1px solid var(--border-bright); }\n${R} .area { font-size: .66rem; letter-spacing: .2em; text-transform: uppercase; color: var(--fg-faint); margin: -.2rem 0 .4rem; }\n${R} .atmo { color: var(--fg-dim); font-style: italic; margin: 0 0 .4rem; }\n${R} .desc { margin: 0 0 .4rem; white-space: pre-wrap; }\n${R} .pose { color: var(--fg-dim); font-style: italic; margin: 0 0 .5rem; padding-left: .5rem; border-left: 2px solid var(--border-bright); }\n${R} .list { list-style: none; margin: 0; padding: 0; }\n${R} .list li { padding: .08rem 0; color: var(--fg); }\n${R} .sigil { color: var(--accent); margin-right: .6ch; }\n${R} .exit { display: inline-flex; align-items: center; min-height: 24px; color: inherit; text-align: left; transition: color .12s ease; }\n${R} .exit:hover { color: var(--accent-bright); }\n${R} .exit:focus-visible { outline: 2px solid var(--accent-bright); outline-offset: -2px; }\n${R} .hostile { color: var(--alert); font-size: .72rem; margin-left: 6px; }\n${R} .none { margin: .1rem 0; font-style: normal; color: var(--fg-faint); }\n${R} .awaiting { margin: 0; color: var(--fg-faint); font-style: normal; font-size: .64rem; letter-spacing: .14em; text-transform: uppercase; }\n`;\n\n/** The host's class names (`mu.ui.css`), used when `renderScene` is called without them. */\nconst HOST_CSS: SceneCss = { secHead: 'sec-head', secClose: 'sec-close', empty: 'empty', glow: 'glow-text' };\n\n/** People first, then room items, each name once (as the reference does). Exported for tests. */\nexport function presentOf(s: Pick<SceneView, 'present' | 'items'>): PresentEntry[] {\n  const seen = new Set<string>();\n  const out: PresentEntry[] = [];\n  for (const n of s.present ?? []) if (!seen.has(n)) { seen.add(n); out.push({ name: n }); }\n  for (const it of s.items ?? []) if (!seen.has(it.name)) { seen.add(it.name); out.push(it.hostile ? { name: it.name, hostile: true } : { name: it.name }); }\n  return out;\n}\n\nconst sigil = () => h('span', { class: 'sigil', 'aria-hidden': 'true' }, '\u25B8');\n\n/**\n * The panel's children for one scene; `go` sends an exit. Exported for tests. The 1.0 signature\n * `renderScene(s, go)` still works; `opts` (1.1) passes the host classes and a context-target hook.\n */\nexport function renderScene(s: SceneView | null, go: (dir: string) => void, opts: RenderOptions = {}): HTMLElement[] {\n  const c: SceneCss = { ...HOST_CSS, ...opts.css };\n  const mark = (el: HTMLElement, what: Parameters<NonNullable<RenderOptions['target']>>[1]) => { opts.target?.(el, what); return el; };\n  if (!s || !s.known) return [h('p', { class: `${c.empty} awaiting`, 'data-testid': 'scene-empty' }, COPY.awaiting)];\n  const head = (label: string) => h('div', { class: c.secHead, role: 'heading', 'aria-level': '3' }, label, h('span', { class: c.secClose, 'aria-hidden': 'true' }));\n  const out: HTMLElement[] = [h('h3', { class: `title ${c.glow}`, role: 'heading', 'aria-level': '2', 'data-testid': 'scene-title' }, s.title)];\n  if (s.area) out.push(h('div', { class: 'area', 'data-testid': 'scene-area' }, s.area));\n  if (s.atmosphere) out.push(h('p', { class: 'atmo' }, s.atmosphere));\n  if (s.desc) out.push(h('p', { class: 'desc' }, s.desc));\n  if (s.pose) out.push(h('p', { class: 'pose' }, s.pose));\n\n  // \u2524PRESENT\u251C always (with \"none\"), then \u2524EXITS\u251C only when there are exits, as the reference.\n  out.push(head(COPY.present));\n  const items = new Map((s.items ?? []).map((it) => [it.name, it] as const));\n  const people = new Set(s.present ?? []);\n  const present = presentOf(s);\n  if (present.length) {\n    const ul = h('ul', { class: 'list', 'data-testid': 'scene-present' });\n    for (const p of present) {\n      const it = people.has(p.name) ? undefined : items.get(p.name);\n      const li = h('li', { class: 'entity-ref', 'data-item-id': it?.id || undefined }, sigil(), p.name, p.hostile ? h('span', { class: 'hostile' }, COPY.hostile) : null);\n      ul.append(it ? mark(li, { item: it }) : mark(li, { person: p.name }));\n    }\n    out.push(ul);\n  } else out.push(h('p', { class: `${c.empty} none` }, COPY.none));\n\n  if (s.exits.length) {\n    out.push(head(COPY.exits));\n    const ul = h('ul', { class: 'list', 'data-testid': 'scene-exits' });\n    for (const dir of s.exits) {\n      const b = h('button', { class: 'exit', type: 'button', title: COPY.go(dir), onclick: () => go(dir) }, sigil(), dir);\n      ul.append(h('li', {}, mark(b, { exit: dir })));\n    }\n    out.push(ul);\n  }\n  return out;\n}\n\nexport default defineExtension({\n  activate(ctx) {\n    const mu: Mu = ctx.mu;\n    mu.ui.style(SCENE_CSS);\n    const css: SceneCss = { secHead: mu.ui.css.secHead, secClose: mu.ui.css.secClose, empty: mu.ui.css.empty, glow: mu.ui.css.glow };\n\n    // SDK 1.14 registered kinds; a 1.12 or 1.13 host has no `menus.kind` and gets the old flat kinds.\n    const kinds = typeof mu.menus.kind === 'function';\n    if (kinds) {\n      ctx.subscriptions.push(\n        mu.menus.kind({ id: ITEM_KIND, title: COPY.itemKind, schema: KIND_SCHEMAS[ITEM_KIND] }),\n        mu.menus.kind({ id: EXIT_KIND, title: COPY.exitKind, schema: KIND_SCHEMAS[EXIT_KIND] }),\n      );\n    }\n    const exitTarget = (sid: string, exit: string): ContextTarget => (kinds ? { kind: EXIT_KIND, sid, data: { exit } } : { kind: 'scene-exit', sid, exit });\n    const itemTarget = (sid: string, item: SceneView['items'][number]): ContextTarget => (kinds ? { kind: ITEM_KIND, sid, data: { item } } : { kind: 'scene-item', sid, item });\n\n    const mount = (host: HTMLElement, pc: PanelMountCtx): Dispose => {\n      const root = h('section', { class: 'mu-scene', 'aria-label': COPY.title, 'data-focus-region': 'scene', tabindex: '-1', 'data-testid': 'scene' });\n      host.append(root);\n      const sid = pc.sid;\n      if (!sid) { root.replaceChildren(...renderScene(null, () => {}, { css })); return () => root.remove(); }\n      // A click is the player's: no key (north twice is twice), and never blocked by replay.\n      const go = (dir: string) => { void mu.sessions.send(dir, { sid }); };\n      let targets: Array<() => void> = [];\n      const untarget = () => { for (const d of targets) d(); targets = []; };\n      const target: RenderOptions['target'] = (el, what) => {\n        if ('exit' in what) targets.push(mu.menus.target(el, exitTarget(sid, what.exit)));\n        else if ('item' in what) targets.push(mu.menus.target(el, itemTarget(sid, what.item)));\n      };\n      let room: string | null = null;\n      const off = mu.scene.watch((s) => {\n        // A move resets the scroll; an update in the same room (someone arrives) keeps it. No id: every update may be a move.\n        const moved = !s.known || !s.id || s.id !== room;\n        room = s.known && s.id ? s.id : null;\n        const top = root.scrollTop;\n        untarget();\n        root.replaceChildren(...renderScene(s, go, { css, target }));\n        root.scrollTop = moved ? 0 : top;\n      }, sid);\n      return () => { off(); untarget(); root.remove(); };\n    };\n\n    mu.panels.register({ id: 'scene', title: COPY.title, singleton: true, defaultPosition: 'right-top', order: 10, show: 'auto', mount });\n    // Alt+R. A 1.12 or 1.13 host registers `focus.scene` itself (registering it again throws there), and has no `panels.focus`.\n    if (typeof mu.panels.focus === 'function') {\n      mu.commands.register({ id: 'focus.scene', title: COPY.focus, keys: ['Alt+R'], group: 'Focus', when: 'session', run: () => { mu.panels.focus?.('scene'); } });\n    }\n    mu.settings.define({\n      title: 'Scene',\n      items: [{ key: 'fromText', label: 'Read the room from the game text', default: true, kind: 'toggle', scope: 'both',\n        hint: 'For games that send only the room name over GMCP (Evennia games such as Underspire): the description, who is here and the exits come from the room text. A game that sends GMCP Room.Info is unaffected.' }],\n    });\n    const fromText = (sid: string) => mu.settings.get<boolean>('fromText', { sid }) !== false;\n    // The game's own full room wins. MSDP ROOM_NAME alone is not one (Underspire mirrors Room.Name there).\n    const hasRoom = (sid: string) => mu.gmcp.state('Room.Info', sid) !== undefined || mu.msdp.state('ROOM_EXITS', sid) !== undefined || mu.msdp.state('ROOM_VNUM', sid) !== undefined;\n    const given = new Map<string, Dispose>();\n    const give = (sid: string, patch: Parameters<Mu['scene']['provide']>[1]) => { given.set(sid, mu.scene.provide(sid, patch, { priority: TEXT_PRIORITY })); };\n    const release = (sid: string) => { given.get(sid)?.(); given.delete(sid); };\n    const seen = new Map<string, string[]>();\n    const titles = new Map<string, string>();\n    ctx.subscriptions.push(\n      mu.gmcp.on('Room.Info', (_d, m) => release(m.sid)),\n      mu.msdp.on('ROOM_EXITS', (_v, m) => release(m.sid)),\n      mu.msdp.on('ROOM_VNUM', (_v, m) => release(m.sid)),\n      mu.gmcp.on('Room.Name', (d, m) => {\n        const title = roomNameOf(d);\n        if (!title || hasRoom(m.sid) || !fromText(m.sid)) return;\n        if (titles.get(m.sid) !== title) { titles.set(m.sid, title); give(m.sid, { title }); }\n      }),\n      mu.gmcp.on('Player.Context', (d, m) => {\n        const patch = contextOf(d);\n        if (!patch || hasRoom(m.sid) || !fromText(m.sid)) return;\n        if (patch.title) titles.set(m.sid, patch.title);\n        give(m.sid, patch);\n      }),\n      // Observe: read only, live lines only (not backlog). A typed command starts a new block.\n      mu.lines.stage({\n        id: 'room-text', phase: 'observe',\n        run: (line, c) => {\n          if (line.kind === 'echo') { seen.delete(c.sid); return; }\n          if (line.kind !== 'output' && line.kind !== 'prompt') return;\n          const buf = seen.get(c.sid) ?? [];\n          buf.push(line.text);\n          if (buf.length > KEEP) buf.splice(0, buf.length - KEEP);\n          seen.set(c.sid, buf);\n          const room = roomOf(buf);\n          if (!room) return;\n          seen.delete(c.sid);\n          if (hasRoom(c.sid) || !fromText(c.sid)) return;\n          // A new room drops the pose and items the last one had.\n          const moved = titles.get(c.sid) !== room.title;\n          titles.set(c.sid, room.title ?? '');\n          give(c.sid, moved ? { ...room, pose: '', items: [] } : room);\n        },\n      }),\n      mu.sessions.each((s) => () => { seen.delete(s.id); titles.delete(s.id); given.delete(s.id); }),\n    );\n\n    // Listed and auto-added once per session, the first time its scene knows a room: GMCP, MSDP or a provider alike.\n    ctx.subscriptions.push(mu.sessions.each((s) => {\n      let done = false;\n      return mu.scene.watch((v) => { if (!done && v.known) { done = true; mu.panels.touch('scene', s.id); } }, s.id);\n    }));\n  },\n});\n", "/**\n * The exported API of `@runmu.sh/ext-scene` (id `scene`). The extension sends no GMCP: it draws the host's scene\n * model (`mu.scene.watch`, `SceneView`), which the room adapters fill from GMCP `Room.*`, `Char.Items.*`, MSDP and\n * other extensions (`mu.scene.set`). On games with none of those (Evennia: only `Room.Name`) it provides the room\n * itself from `Room.Name`, `Player.Context` and the room text (1.3.0, `src/room.ts`). This file and the README\n * change together.\n */\nimport type { SceneView } from '@muclient/sdk';\n\n/** One row of \u2524PRESENT\u251C: a person (from `present`) or a room item (from `items`). */\nexport interface PresentEntry {\n  name: string;\n  /** Set on hostile room items; drawn as a small `hostile` tag. */\n  hostile?: boolean;\n  /** The room item's id, when the row is an item with one (people have none). @since 1.1.0 */\n  id?: string;\n}\n\n/** The class names `renderScene` uses for the host primitives; defaults are the host's (`mu.ui.css`). @since 1.1.0 */\nexport interface SceneCss {\n  secHead: string;\n  secClose: string;\n  empty: string;\n  glow: string;\n}\n\n/** Options for {@link renderScene} beyond the 1.0 signature. @since 1.1.0 */\nexport interface RenderOptions {\n  /** `mu.ui.css` (or the part of it used). */\n  css?: Partial<SceneCss>;\n  /**\n   * Called for every exit button and every present row as it is created, so the caller can mark it as a context\n   * target (`mu.menus.target`). Return a function to undo it; those run on the next render or unmount.\n   */\n  target?: (el: HTMLElement, what: { exit: string } | { item: SceneView['items'][number] } | { person: string }) => void | (() => void);\n}\n\n/** Drawn copy. */\nexport interface SceneCopy {\n  title: string;\n  awaiting: string;\n  present: string;\n  exits: string;\n  none: string;\n  hostile: string;\n  go(dir: string): string;\n  /** The `focus.scene` command's title. @since 1.2.0 */\n  focus: string;\n  /** The context kinds' titles (the menu's accessible label). @since 1.2.0 */\n  itemKind: string;\n  exitKind: string;\n}\n\n/** The context kind of a room item in \u2524PRESENT\u251C (SDK 1.14). @since 1.2.0 */\nexport const ITEM_KIND = 'scene.item';\n/** The context kind of an exit button (SDK 1.14). @since 1.2.0 */\nexport const EXIT_KIND = 'scene.exit';\n\n/** `data` of a `scene.item` target. @since 1.2.0 */\nexport interface SceneItemData { item: SceneView['items'][number] }\n/** `data` of a `scene.exit` target. @since 1.2.0 */\nexport interface SceneExitData { exit: string }\n\n/**\n * Types `t.data` in another extension's `mu.menus.context({ target: 'scene.item' | 'scene.exit', \u2026 })` once it\n * imports this file. @since 1.2.0\n */\ndeclare module '@muclient/sdk' {\n  interface ContextKinds {\n    'scene.item': SceneItemData;\n    'scene.exit': SceneExitData;\n  }\n}\n", "/**\n * The room from the game's own text, for games that send no `Room.Info` (Evennia games such as Underspire send\n * only `Room.Name` and, at login, `Player.Context`). Pure functions: `index.ts` feeds them the session's lines.\n *\n * An Evennia room look is: the title, the description, a blank line, things in the room, a blank line, who is\n * there (\"Ash is standing here. You are standing here.\"), then the exits line (\"There are exits to the market\n * (m) and the gate (g).\"). The exits line closes the block, so a look at anything but a room reads nothing.\n */\nimport type { ScenePatch } from '@muclient/sdk';\n\n/** \"There are exits to \u2026\" / \"There is an exit to \u2026\" / \"Exits: \u2026\". */\nconst EXITS_RE = /^(?:there (?:are|is) (?:an? )?(?:exits?|ways?(?: out)?) (?:to|leading to) |(?:obvious )?exits?: )(.+?)\\.?$/i;\n/** One sentence of the who-is-here line: \"<name> is|are <posture> here.\" */\nconst HERE_RE = /^(.+?) (?:is|are) (?:[a-z]+ )?here\\.?$/i;\nconst MAX_TITLE = 80;\n\n/** The exits line's names, in order: \"the market (m), the well and Shard services (s)\" \u2192 market, the well, Shard services. */\nexport function exitsOf(line: string): string[] | null {\n  const m = EXITS_RE.exec(line.trim());\n  if (!m) return null;\n  const out: string[] = [];\n  for (let part of m[1].split(/\\s*,\\s*(?:and\\s+)?|\\s+and\\s+/)) {\n    part = part.replace(/\\s*\\([^)]*\\)\\s*$/, '').replace(/^the\\s+/i, '').trim();\n    if (part && !out.includes(part)) out.push(part);\n  }\n  return out;\n}\n\n/** The people in a who-is-here line, without you: \"Ash and Ivo are sitting here. You are standing here.\" \u2192 Ash, Ivo. */\nexport function peopleOf(line: string): string[] {\n  const out: string[] = [];\n  for (const s of line.trim().split(/(?<=\\.)\\s+/)) {\n    const m = HERE_RE.exec(s);\n    if (!m) continue;\n    for (const n of m[1].split(/\\s*,\\s*(?:and\\s+)?|\\s+and\\s+/)) {\n      const name = n.trim();\n      if (name && !/^you$/i.test(name) && !out.includes(name)) out.push(name);\n    }\n  }\n  return out;\n}\n\nconst looksTitle = (t: string) => t.length > 0 && t.length <= MAX_TITLE && !/[.!?:;,\"')>\\]]$/.test(t);\n\n/**\n * The scene a room look ends in, from the session's recent lines oldest first, the last being the exits line; null\n * when they do not end in a room look. Read backwards from the exits line, in blank-separated sections: the one\n * just before it (with the exits line) holds who is here; the nearest section with a title line (no closing\n * punctuation) is the header, its title then the description. Things in the room sit between and are skipped.\n */\nexport function roomOf(lines: readonly string[], maxSections = 4): ScenePatch | null {\n  if (!lines.length) return null;\n  const exits = exitsOf(lines[lines.length - 1]);\n  if (!exits) return null;\n  const sections: string[][] = [[]];\n  for (const raw of lines.slice(0, -1)) {\n    const l = raw.trim();\n    if (l) sections[sections.length - 1].push(l);\n    else if (sections[sections.length - 1].length) sections.push([]);\n  }\n  if (!sections[sections.length - 1].length) sections.pop();\n  if (!sections.length) return null;\n  const tail = sections[sections.length - 1];\n  const people = tail.some((l) => peopleOf(l).length || /^you (?:are|is) [a-z ]*here\\.?$/i.test(l));\n  for (let i = sections.length - 1; i >= Math.max(0, sections.length - maxSections); i--) {\n    const sec = sections[i];\n    let t = -1;\n    for (let j = sec.length - 1; j >= 0; j--) if (looksTitle(sec[j]) && !HERE_RE.test(sec[j])) { t = j; break; }\n    if (t < 0) continue;\n    // The title line must not be the who-is-here section itself.\n    if (i === sections.length - 1 && people) continue;\n    const present = people ? [...new Set(tail.flatMap(peopleOf))] : [];\n    return { title: sec[t], desc: sec.slice(t + 1).join('\\n'), exits, present };\n  }\n  return null;\n}\n\n/** `Room.Name`: a bare string, or `{ name }`. */\nexport function roomNameOf(data: unknown): string {\n  if (typeof data === 'string') return data.trim();\n  if (data && typeof data === 'object' && typeof (data as { name?: unknown }).name === 'string') return (data as { name: string }).name.trim();\n  return '';\n}\n\n/** `Player.Context` (Evennia, Underspire): `{ room, pose_line, presence, character }` \u2192 title, pose and the people present (not you). */\nexport function contextOf(data: unknown): ScenePatch | null {\n  if (!data || typeof data !== 'object') return null;\n  const d = data as { room?: unknown; pose_line?: unknown; presence?: unknown; character?: unknown };\n  const me = typeof d.character === 'string' ? d.character.trim().toLowerCase() : '';\n  const patch: ScenePatch = {};\n  if (typeof d.room === 'string' && d.room.trim()) patch.title = d.room.trim();\n  if (typeof d.pose_line === 'string') patch.pose = d.pose_line.trim();\n  if (Array.isArray(d.presence)) patch.present = [...new Set(d.presence.filter((n): n is string => typeof n === 'string' && !!n.trim() && n.trim().toLowerCase() !== me).map((n) => n.trim()))];\n  return Object.keys(patch).length ? patch : null;\n}\n"],
  "mappings": "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",
  "names": []
}


package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@runmu.sh/ext-scene",
-  "version": "1.2.0",
-  "description": "The Scene panel: the room you are in (title, area, atmosphere, description, pose), who is present and its exits as buttons, from GMCP Room.*, Char.Items.*, MSDP or another extension.",
+  "version": "1.3.0",
+  "description": "The Scene panel: the room you are in (title, area, atmosphere, description, pose), who is present and its exits as buttons, from GMCP Room.*, Char.Items.*, MSDP, another extension, or the room text (Evennia games such as Underspire).",
   "keywords": [
     "scene",
     "room",
@@ -49,7 +49,7 @@
     "api": "^1.12",
     "source": "src/index.ts",
     "displayName": "Scene",
-    "description": "The Scene panel: the current room, who is present and its exits as buttons, from GMCP Room.*, Char.Items.*, MSDP or another extension.",
+    "description": "The Scene panel: the current room, who is present and its exits as buttons, from GMCP Room.*, Char.Items.*, MSDP, another extension, or the room text on games that send only the room name.",
     "categories": [
       "interface",
       "mapping"
@@ -75,6 +75,7 @@
       ]
     },
     "capabilities": [
+      "read-output",
       "send-commands"
     ],
     "publisher": "bitmuse"

package/src/types.ts

@@ -1,7 +1,9 @@
 /**
- * The exported API of `@runmu.sh/ext-scene` (id `scene`). The extension reads no GMCP and sends none: it draws the
- * host's scene model (`mu.scene.watch`, `SceneView`), which the room adapters fill from GMCP `Room.*`,
- * `Char.Items.*`, MSDP and other extensions (`mu.scene.set`). This file and the README change together.
+ * The exported API of `@runmu.sh/ext-scene` (id `scene`). The extension sends no GMCP: it draws the host's scene
+ * model (`mu.scene.watch`, `SceneView`), which the room adapters fill from GMCP `Room.*`, `Char.Items.*`, MSDP and
+ * other extensions (`mu.scene.set`). On games with none of those (Evennia: only `Room.Name`) it provides the room
+ * itself from `Room.Name`, `Player.Context` and the room text (1.3.0, `src/room.ts`). This file and the README
+ * change together.
  */
 import type { SceneView } from '@muclient/sdk';