@maka/maka-cli 5.160.0 → 5.162.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.160.0",
+  "version": "5.162.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",

package/bundle/typescript/src/commands/game/sideQuest/commands/equip.js

@@ -125,7 +125,7 @@ export class EquipCommand extends Command {
             // hear which wetware that is (user, 2026-09-02).
             const dni = actor.dniSource();
             const link = dni?.kind === 'datajack' ? `It cables straight into your datajack -- VR ready.`
-                : dni?.kind === 'trodes' ? `It rides your ${dni.item?.name ?? 'trode net'}${dni.worn ? '' : ' (in the bag -- "equip" it to wear it)'} -- VR ready.`
+                : dni?.kind === 'trodes' ? `It rides your ${dni.item?.name ?? 'trode net'}${dni.host ? ` built into your ${dni.host.name}${dni.worn ? '' : ' (in the bag -- "equip" the helmet to wear it)'}` : dni.worn ? '' : ' (in the bag -- "equip" it to wear it)'} -- VR ready.`
                     : dni?.kind === 'technomancer' ? `Your living persona is the interface.`
                         : `No direct neural interface yet: AR only until you wear a trode net or install a datajack.`;
             return `The ${name} doesn't wear -- it's a slab of hardware in your kit. ${link} "jack in" when you're ready to ride it${hint(`, "pan" to see your network`)}.`;

package/bundle/typescript/src/commands/game/sideQuest/commands/equipment.js

@@ -75,7 +75,7 @@ export class EquipmentCommand extends Command {
                 ? `none -- AR only${hint(' (a trode net from any electronics shelf, or a datajack at the clinic)')}`
                 : dni.kind === 'technomancer' ? 'living persona -- VR ready'
                     : dni.kind === 'datajack' ? 'datajack (implanted) -- VR ready'
-                        : `${dni.item?.name ?? 'trode net'} (${dni.worn ? 'worn' : 'in the bag'}) -- VR ready`;
+                        : `${dni.item?.name ?? 'trode net'} (${dni.host ? `built into your ${dni.host.name}${dni.worn ? '' : ', in the bag'}` : dni.worn ? 'worn' : 'in the bag'}) -- VR ready`;
             lines.push(`  Interface: ${dniLine}`);
             if (link) {
                 lines.push(`  Commlink:  ${link.name}${actor.runningSilent ? ' -- running silent' : ''}`);

package/bundle/typescript/src/commands/game/sideQuest/commands/look.js

@@ -5,6 +5,8 @@ import { matchesHostName, matchesCameraName, hostLabel } from '../utilities/grid
 import { Door } from '../models/door.js';
 import { Item } from '../models/item.js';
 import { NPC } from '../models/npc.js';
+import { Player } from '../models/player.js';
+import { readDetails } from '../utilities/clue-reading.js';
 import { Category } from '../types/shared/item-enum.js';
 import { Command } from './command.js';
 import { shellsInRoom, planeTintItemName, emphasizeFind, fileReach } from '../utilities/planes.js';
@@ -579,7 +581,16 @@ export class LookCommand extends Command {
         if (!item) {
             return `You don't see any ${itemName} here.`;
         }
-        const prose = item.details || item.description || `It's just a regular ${itemName}.`;
+        // A CODE ON THE PAGE IS A PERCEPTION TEST (Xxbwtgffkyq8uCHfR): a
+        // scrap of paper with a combination on it is read here, not by
+        // "read" (which is the Book verb), so it takes the same test -- one
+        // gate for one credential, whichever verb reaches it.
+        const details = readDetails(this.scene, item, {
+            reader: this.actor instanceof Player ? this.actor : undefined,
+            logger: this.logger,
+            isPlayer: this.scene.isHumanControlled(this.actor),
+        });
+        const prose = details || item.description || `It's just a regular ${itemName}.`;
         if (item.category == Category.Book) {
             // A book's payload IS its detail -- "read" is the verb that opens
             // it, and saying so beats a stat block on a paperback.

package/bundle/typescript/src/commands/game/sideQuest/commands/read.js

@@ -1,5 +1,7 @@
 import { Command } from './command.js';
 import { Category } from '../types/shared/item-enum.js';
+import { Player } from '../models/player.js';
+import { readDetails } from '../utilities/clue-reading.js';
 export class ReadCommand extends Command {
     static verb = 'read';
     static description = 'Read a book from your surroundings.';
@@ -21,7 +23,16 @@ export class ReadCommand extends Command {
         // "details" is where clue/note content is meant to live, but "description"
         // is a reasonable fallback if a scene ever puts it there instead -- better
         // to show something real than a dead "blank pages" non-answer.
-        return item.details || item.description || `You flip through "${item.name}" but it's mostly blank pages.`;
+        //
+        // A CODE ON THE PAGE IS A PERCEPTION TEST (Xxbwtgffkyq8uCHfR):
+        // utilities/clue-reading.ts rolls it, and hands back the prose with
+        // the credential in or out of it.
+        const details = readDetails(this.scene, item, {
+            reader: this.actor instanceof Player ? this.actor : undefined,
+            logger: this.logger,
+            isPlayer: this.scene.isHumanControlled(this.actor),
+        });
+        return details || item.description || `You flip through "${item.name}" but it's mostly blank pages.`;
     }
 }
 //# sourceMappingURL=read.js.map

package/bundle/typescript/src/commands/game/sideQuest/engine-version.js

@@ -392,5 +392,9 @@
 //   aggressor and their target; the world event carries it; "initiative"
 //   marks them. Hostiles are red on the room map by stance or by live
 //   enmity, not by the retired exchange flag.
-export const ENGINE_VERSION = '1.44.0';
+// 1.45.0 (2026-09-11): THE MAPS AS DATA. The condition beat carries the
+//   room's live grid, every body's engine-resolved square, and the room
+//   panel's own hostile test; the map event carries the fog-applied
+//   district layout (data.district). Envelope and beat shape both grew.
+export const ENGINE_VERSION = '1.45.0';
 //# sourceMappingURL=engine-version.js.map

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-chunks.js

@@ -419,7 +419,9 @@ ${JSON_ONLY}
                           // exit's "guard"; people are got past socially, not picked.
     "grantsItem"?: string // an items[].name with role "reward" -- what opening it hands
                            // over. Omit for a device that holds a door: the open way IS
-                           // the reward.
+                           // the reward. REQUIRED for a device on no exit (a safe, a
+                           // lockbox, a cabinet): a device is a promise of something
+                           // behind it, and a safe that opens onto nothing is refused.
   }],
   "items": [{
     "name": string,
@@ -929,6 +931,20 @@ export function validateSkeleton(skeleton, player, crew) {
         // record -- and which looked like random flakiness precisely
         // because it varied with the character.
         const kind = device.kind ?? 'panel';
+        // A DEVICE IS A PROMISE OF SOMETHING BEHIND IT (bPiyyWu9TQ4pBfGbM,
+        // Jynx: "it looks like the safe is open, but it never dropped
+        // anything"). The Blood Ledger's skeleton declared a floor safe as
+        // a bare "lock" in the back office -- on no exit, granting no item
+        // -- while the prize sat in another room and the details pass,
+        // taking the safe at its word, wrote a combination clue for it.
+        // Every rule below checks that a device's way THROUGH is findable;
+        // none checked that there was anything on the other side. A safe
+        // that opens onto nothing is not a puzzle, it is a lie the room
+        // description tells, and the only honest fix is to refuse the
+        // skeleton before four detail passes build on it.
+        if (refs === 0 && !device.grantsItem) {
+            fail(`device "${device.name}" holds no door and grants nothing -- a device is a promise of something behind it. Declare an exit from "${device.room}" with "device": "${device.name}", or give it "grantsItem" naming a "reward"-role item.`);
+        }
         if (kind === 'panel') {
             const clue = skeleton.items.find(i => i.role === 'clue' && i.forDevice === device.name);
             if (!clue) {
@@ -955,8 +971,12 @@ export function validateSkeleton(skeleton, player, crew) {
             const holdsDoor = refs > 0;
             const keyed = skeleton.rooms.some(r => (r.exits ?? []).some(e => e.device === device.name && e.keyRequired));
             const looseKey = skeleton.items.some(i => i.role === 'key');
-            if (holdsDoor && !keyed && !looseKey) {
-                fail(`lock "${device.name}" holds a door with no "keyRequired" and the scene has no "key"-role item -- a runner without locksmith has no way through it. Add a key.`);
+            // The same floor for a lock that holds a PRIZE rather than a
+            // door (a safe): its findable way in is a key, and "holdsDoor"
+            // used to exempt it -- so a keyless safe passed here and then
+            // stood in play with only breach options (bPiyyWu9TQ4pBfGbM).
+            if (!keyed && !looseKey) {
+                fail(`lock "${device.name}" ${holdsDoor ? 'holds a door with no "keyRequired"' : 'holds a prize'} and the scene has no "key"-role item -- a runner without locksmith has no way through it. Add a key.`);
             }
         }
         // A WARD is the exception no clue can rescue: there is no findable

package/bundle/typescript/src/commands/game/sideQuest/game.js

@@ -2401,7 +2401,11 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             if (!this._conditionSink && process.env.MAKA_NO_DDP === '1')
                 return;
             void import('./utilities/condition-report.js')
-                .then(m => m.reportConditionSoon(this.player, this._conditionSink))
+                .then(m => m.reportConditionSoon(this.player, this._conditionSink, {
+                // The room panel's own red (updateExits below): stance OR live
+                // enmity in the viewer's encounter. Same predicate, same map.
+                isHostile: a => hostileByStance(a) || enemyInFight(this.scene, this.player, a),
+            }))
                 .catch(() => undefined);
         };
         // A ROOM CHANGE IS A SAVE BEAT (player request 2026-09-02): where you

package/bundle/typescript/src/commands/game/sideQuest/headless.js

@@ -16,7 +16,8 @@ import { Player, Room } from './models/_index.js';
 import { Logger } from './utilities/logger.js';
 import { currentSession, runInSession } from './utilities/session-context.js';
 import { restorePlayer, serializePlayer } from './utilities/persistence.js';
-import { renderMapViewport, mapCaption } from './utilities/map-view.js';
+import { runWithAuthToken } from './utilities/cloud-saves.js';
+import { renderMapViewport, mapCaption, serializeDistrictMap } from './utilities/map-view.js';
 import { hostileByStance, enemyInFight, renderRoomLayoutCompact, crewOfTable, roomCaption } from './utilities/room-view.js';
 import { serializeRoomGrid } from './utilities/room-grid.js';
 import { entrySpotFor, spotOf } from './utilities/spots.js';
@@ -296,7 +297,18 @@ export async function createHeadlessSession(opts) {
                 const mapLines = renderMapViewport(rooms, here, sealing, eyes);
                 if (mapLines.length > 0)
                     mapLines.push(mapCaption(here.name));
-                logger.system(mapLines.join('\n'), { actor: p.name }, 'map');
+                // STRUCTURED DISTRICT MAP, ADDITIVE (2026-09-11): the same layout
+                // as data, on this same event, so the browser client draws it in
+                // its own style instead of reparsing the text (the `data.grid`
+                // pattern below). A decoration must never kill the push.
+                let district;
+                try {
+                    district = serializeDistrictMap(rooms, here, sealing, eyes);
+                }
+                catch (err) {
+                    logger.write(`District map serialize failed for ${p.name} in ${here.name}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);
+                }
+                logger.system(mapLines.join('\n'), { actor: p.name }, 'map', district ? { district } : undefined);
                 // THE ROOM BOX'S TWIN (playtest 2026-08-27, reported twice:
                 // "the room minimap isn't updating in the shared run, I only
                 // see @open floor"). Game.updateExits early-returns on
@@ -352,12 +364,12 @@ export async function createHeadlessSession(opts) {
         const session = {
             game,
             logger,
-            command: (actorName, input) => runInSession(ctx, async () => {
+            command: (actorName, input, opts) => runInSession(ctx, () => runWithAuthToken(opts?.authToken, async () => {
                 const res = await game.handleInputAs(actorName, input);
                 session.pushStatus();
                 pushMap();
                 return res;
-            }),
+            })),
             addPlayer: (save) => runInSession(ctx, async () => {
                 // REJOIN IS NOT A JOIN (playtest 2026-08-27, Sherry: "got an
                 // internal server error"). A dropped DDP connection -- a

package/bundle/typescript/src/commands/game/sideQuest/models/item.js

@@ -867,6 +867,9 @@ export class Item extends AbstractItem {
     papers = [];
     /** On a license: the name of the fake SIN it was bought for. */
     linkedSin;
+    /** Who has already found the credential written in this item's
+     *  details (utilities/clue-reading.ts): a found code stays found. */
+    revealedTo = [];
     isPaper() {
         return this.category === Category.FakeSIN || this.category === Category.License || this.category === Category.SIN;
     }

package/bundle/typescript/src/commands/game/sideQuest/models/player.js

@@ -703,9 +703,17 @@ export class Player extends AbstractPlayer {
             return true;
         return this.dniSource() !== null;
     }
+    /** Failed reads of a clue, by item name, for p.49's Trying Again
+     *  (-2 per retry). In memory only: a save and reload is the "break"
+     *  the rule says clears it. See utilities/clue-reading.ts. */
+    readAttempts = new Map();
     /** True for the one Electronics item that is a trode net (p.439-440). */
     static isTrodeNet(item) {
-        if (item.hasCapability('dni'))
+        // The item's OWN row, not Item.effects: that getter folds fitted
+        // mods in, so a helmet with a net built into it would read as a
+        // trode net itself and be named as the interface instead of the
+        // net inside it (dniSource reports the net, and the helmet as host).
+        if ((item.row?.effects ?? []).some(e => e.type === 'flag' && e.property === 'dni' && e.value > 0))
             return true;
         if (item.row)
             return false;
@@ -726,8 +734,33 @@ export class Player extends AbstractPlayer {
         const worn = this._equipment.head?.trodes;
         if (worn)
             return { kind: 'trodes', worn: true, item: worn };
-        const bagged = this._inventory.getAllItems().find(i => Player.isTrodeNet(i));
-        return bagged ? { kind: 'trodes', worn: false, item: bagged } : null;
+        // TRODES BUILT INTO HEADGEAR (koz9FKuH8Q685ogcy: "I see my helmet
+        // can hold trodes, this should be where my interface to the
+        // commlink is, right?"). Right: "Adding this to headgear takes two
+        // slots of Capacity" (p.439-440), and the helmet row has advertised
+        // a trodes slot all along -- so a net fitted into a WORN helmet is
+        // a worn net, and reads here as one. Any worn slot is searched, not
+        // just the skull: what the catalog lets hold trodes is the
+        // catalog's business.
+        for (const group of Object.values(this._equipment)) {
+            if (!group)
+                continue;
+            for (const host of Object.values(group)) {
+                if (!host)
+                    continue;
+                const built = host.fitted.find(m => Player.isTrodeNet(m));
+                if (built)
+                    return { kind: 'trodes', worn: true, item: built, host };
+            }
+        }
+        for (const carried of this._inventory.getAllItems()) {
+            if (Player.isTrodeNet(carried))
+                return { kind: 'trodes', worn: false, item: carried };
+            const built = carried.fitted.find(m => Player.isTrodeNet(m));
+            if (built)
+                return { kind: 'trodes', worn: false, item: built, host: carried };
+        }
+        return null;
     }
     /**
      * THE PRICE OF SILENCE (canon p.235-236 "Running Silent",

package/bundle/typescript/src/commands/game/sideQuest/utilities/cloud-saves.js

@@ -3,6 +3,7 @@ import * as os from 'os';
 import * as path from 'path';
 import * as http from 'http';
 import * as https from 'https';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { Logger } from './logger.js';
 import { saveSlug, readSave, writeSaveAtomic, tombstonePathFor } from './persistence.js';
 /**
@@ -90,7 +91,29 @@ export function siteRequest(method, apiPath, token, body) {
     return request(method, apiPath, token, body);
 }
 const GLOBAL_CONFIG_PATH = path.join(os.homedir(), '.meteor', '.maka', 'global-config.json');
+/**
+ * A LOGIN SCOPED TO ONE ASYNC FLOW, for the site's in-process engine
+ * (user 2026-09-10: "I can't record to the backlog while in the web
+ * client -- I AM logged in", answered with "Your login's expired").
+ *
+ * authToken() reads the machine's `maka login` -- right on a terminal,
+ * wrong on www.maka-cli.com, where one Node process hosts every
+ * browser table and the box's own global config holds whichever stale
+ * token last ran `maka` there. The site knows who typed the command;
+ * it hands that user's token to HeadlessSession.command, which runs
+ * the verb inside this store, and every transport that asks
+ * authToken() -- backlog, social, telemetry -- answers as THEM for the
+ * length of that one command. No token, no store: a terminal's
+ * behavior is byte-for-byte what it was.
+ */
+const scopedToken = new AsyncLocalStorage();
+export function runWithAuthToken(token, fn) {
+    return token ? scopedToken.run(token, fn) : fn();
+}
 export function authToken() {
+    const scoped = scopedToken.getStore();
+    if (scoped)
+        return scoped;
     try {
         const cfg = JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, 'utf8'));
         const token = cfg?.token?.authToken;

package/bundle/typescript/src/commands/game/sideQuest/utilities/clue-reading.js

@@ -0,0 +1,84 @@
+import { perceptionTest, PERCEPTION_THRESHOLD } from './perception.js';
+import { rollPool, formatRoll } from './dice.js';
+import { hint } from './hints.js';
+/**
+ * READING A CLUE IS A PERCEPTION TEST (Xxbwtgffkyq8uCHfR, Maka:
+ * 'reading codes on "books" should use a perception check to get
+ * critical information').
+ *
+ * A clue's body is plain prose anyone can read; the CREDENTIAL in it
+ * -- a maglock code in a margin, a combination on a folded page -- is
+ * the detail that "isn't obvious", and p.135 says that is exactly what
+ * a Perception Test is for: Perception + Intuition [Mental], threshold
+ * 2 for something Normal ("street sign, conversation", p.136). Hits at
+ * the threshold and the page gives up the code; short of it the reader
+ * gets the prose and not the number.
+ *
+ * TRYING AGAIN (p.49): a re-read is allowed at a cumulative -2 per
+ * retry, tracked on the reader for the session. A found code stays
+ * found (Item.revealedTo, saved with the item) -- nobody re-rolls for a
+ * number they have already read out loud.
+ *
+ * WHAT COUNTS AS A CODE: the scene's own device codes, matched
+ * verbatim against the item's details -- the same fact ensureClueDetails
+ * guarantees is written there (scene-chunks.ts). No code on the page
+ * means no test: a diary is just a diary.
+ */
+/** The p.49 penalty per failed retry. */
+export const TRYING_AGAIN_PENALTY = 2;
+/** Every device code the scene knows that this item's details spell out. */
+export function codesOnPage(scene, item) {
+    const text = (item.details ?? '').toLowerCase();
+    if (!text)
+        return [];
+    const codes = new Set();
+    for (const room of Object.values(scene.getRooms())) {
+        for (const device of room.devices) {
+            const code = (device.code ?? '').trim();
+            if (code && text.includes(code.toLowerCase()))
+                codes.add(code);
+        }
+    }
+    return [...codes];
+}
+/** The details with every sentence that spells a code taken out. */
+export function redactCodes(details, codes) {
+    const lower = codes.map(c => c.toLowerCase());
+    const kept = details
+        .split(/(?<=[.!?]["'\u201d\u2019)]?)\s+/)
+        .filter(sentence => !lower.some(c => sentence.toLowerCase().includes(c)));
+    return kept.join(' ').trim();
+}
+/**
+ * The text a reader gets from an item's details: everything, when the
+ * page holds no code or the reader already found it; otherwise the
+ * Perception Test decides whether the credential is on the page.
+ */
+export function readDetails(scene, item, opts = {}) {
+    const details = item.details ?? '';
+    const reader = opts.reader;
+    if (!details || !reader)
+        return details;
+    const codes = codesOnPage(scene, item);
+    if (codes.length === 0)
+        return details;
+    if (item.revealedTo.includes(reader.name))
+        return details;
+    const attempts = reader.readAttempts.get(item.name) ?? 0;
+    const { pool, limit } = perceptionTest(reader);
+    const penalty = attempts * TRYING_AGAIN_PENALTY;
+    const roll = rollPool(Math.max(1, pool - penalty), limit);
+    const rollLine = `Perception: ${formatRoll(roll)} (threshold ${PERCEPTION_THRESHOLD.normal}${penalty ? `, trying again -${penalty}` : ''})`;
+    if (opts.isPlayer)
+        opts.logger?.meta(rollLine);
+    const prefix = opts.isPlayer ? '' : `${rollLine}\n`;
+    if (roll.hits >= PERCEPTION_THRESHOLD.normal) {
+        item.revealedTo.push(reader.name);
+        reader.readAttempts.delete(item.name);
+        return `${prefix}${details}`;
+    }
+    reader.readAttempts.set(item.name, attempts + 1);
+    const body = redactCodes(details, codes) || item.description || `You go through "${item.name}" page by page.`;
+    return `${prefix}${body}\nSomething in it is written to be missed -- you have the sense you skimmed past it.${hint(` (read it again: -${TRYING_AGAIN_PENALTY} dice per retry, p.49)`)}`;
+}
+//# sourceMappingURL=clue-reading.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/condition-report.js

@@ -1,6 +1,8 @@
 import { Logger } from './logger.js';
-import { visibleActorsIn } from './spots.js';
+import { visibleActorsIn, seatingIn } from './spots.js';
 import { hostLabel } from './grid-names.js';
+import { serializeRoomGrid } from './room-grid.js';
+import { hostileByStance } from './room-view.js';
 /**
  * THE LIVE CONDITION EMITTER -- the CLI half of the realtime sheet lane
  * (contract agreed with maka-cli.com, 2026-09-01). On every condition
@@ -71,13 +73,56 @@ export function setMarksPlacedResolver(fn) {
 export function setActorRoleResolver(fn) {
     actorRole = fn;
 }
+/**
+ * THE ROOM'S GEOMETRY, ON THE BEAT (2026-09-11, 8bZXzNXLgKwE5wxgh: "no
+ * icons being drawn on the character sheet in the active run"). The web
+ * sheet rebuilt its room from the SAVE's hub seed, and a generated run
+ * room is not in it -- so in a run the sheet had no furniture, no doors,
+ * and no cell to seat a spot-sitting NPC on. The beat already fires on
+ * every position change and is the one channel both the sheet and the
+ * play page read, so the live grid rides it: the SAME wire shape the
+ * room event carries for the browser client (headless.ts pushMap ->
+ * serializeRoomGrid). Physical planes only -- jacked in, the meat map is
+ * a lie the sheet already refuses to draw. A decoration never kills the
+ * beat: any throw here is an absent field, not a lost report.
+ */
+function roomGridFor(player) {
+    const room = player.currentLocation;
+    if (!room || (player.plane !== 'meat' && player.plane !== 'drone'))
+        return undefined;
+    try {
+        const grid = room.ensureGrid();
+        return grid ? serializeRoomGrid(grid, room.name) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function buildConditionReport(player, deps) {
-    const { saveSlug, arSightUp } = deps;
+    const { saveSlug, arSightUp, isHostile } = deps;
     // BRICKED INCLUDED (web report 2026-09-02: "my deck got bricked, but its
     // status still says 4/12"): a forced dump clears activeDeck and
     // getCyberdeck() hides a bricked deck, so the beat read nothing and the
     // sheet froze on the last number. Status reads getAnyCyberdeck.
     const deck = player.activeDeck ?? player.getAnyCyberdeck();
+    // WHERE EVERYONE ACTUALLY STANDS (2026-09-11, user: "movement isn't
+    // snappy" on the web). The beat sent `atCell` alone, and `atCell` is
+    // the EXCEPTION -- set by a tactical step, cleared by "move to <spot>"
+    // and by most arrivals -- so after a plain move the beat carried no
+    // cell, the server kept the last one it had, and the dot on the web
+    // sat still at a square the runner had left. seatingIn is the engine's
+    // one answer to "which square" (the room panel, cover and ranges all
+    // read it), so the web now gets the same square the CLI draws. Read at
+    // fire time like everything else here; a throw means "no seat", never
+    // a lost beat.
+    const room = player.currentLocation;
+    let seats = new Map();
+    if (room && (player.plane === 'meat' || player.plane === 'drone')) {
+        try {
+            seats = seatingIn(room);
+        }
+        catch { /* keep the empty map */ }
+    }
     return {
         slug: saveSlug(player.name),
         damageTaken: player.damageTaken,
@@ -85,7 +130,8 @@ export function buildConditionReport(player, deps) {
         overflow: 0,
         room: player.currentLocation?.name,
         spot: player.atSpot,
-        cell: player.atCell,
+        cell: player.atCell ?? seats.get(player.name),
+        grid: roomGridFor(player),
         plane: player.plane,
         // Where the meat sits while the persona rides the grid (web accepts
         // since 2026-09-02): "jacked in from Your Hideout". Absent in the meat.
@@ -196,11 +242,14 @@ export function buildConditionReport(player, deps) {
             .slice(0, 24)
             .map(a => ({
             name: a.name,
+            // THE SAME RED THE ROOM PANEL USES (see IConditionReportDeps
+            // .isHostile): stance flag OR live enmity, and never a
+            // surrendered one -- hostileByStance owns that clause.
             kind: a.allyOf ? 'ally'
-                : a.hostile ? 'hostile' : 'neutral',
+                : (isHostile?.(a) ?? hostileByStance(a)) ? 'hostile' : 'neutral',
             role: actorRole(a),
             spot: a.atSpot,
-            cell: a.atCell,
+            cell: a.atCell ?? seats.get(a.name),
         })),
     };
 }
@@ -227,7 +276,7 @@ function noteRoster(report) {
 const ADDITIVE_FIELDS = [
     'ar', 'actors', 'deckLine', 'deckDamage', 'astralPerceiving', 'bodyRoom', 'sustainingPenalty',
     'matrix', 'panMarks', 'hostMarksOnYou', 'marksPlaced', 'marksOnYou', 'deckStored', 'droneDamage', 'companions', 'pools', 'initiative',
-    'karma', 'nuyen', 'edge',
+    'karma', 'nuyen', 'edge', 'grid',
 ];
 /** Refusal reasons already written to the session log -- one line each. */
 const announcedRefusals = new Map();
@@ -242,7 +291,10 @@ function noteRefusal(why) {
         catch { /* no session */ }
     }
 }
-export function reportConditionSoon(player, sink) {
+export function reportConditionSoon(player, sink, 
+/** The Scene-side half of the beat (IConditionReportDeps.isHostile);
+ *  the caller that owns a Scene supplies it, nobody else needs to. */
+extra) {
     // Before the TIMER, not just before the call: a scheduled beat firing
     // after a Jest file finished lazy-imported into a torn-down
     // environment and failed CI with every test green (2026-09-01). Under
@@ -269,7 +321,7 @@ export function reportConditionSoon(player, sink) {
             // stance and brandish flow through their accessors' own reports;
             // sustained and deck programs are composed here and ride whatever
             // beat fires next. All read at FIRE time, like position.
-            const report = buildConditionReport(player, { saveSlug, arSightUp });
+            const report = buildConditionReport(player, { saveSlug, arSightUp, isHostile: extra?.isHostile });
             noteRoster(report);
             if (sink) {
                 // IN-PROCESS: no HubLink, no MAKA_NO_DDP gate, no version-skew

package/bundle/typescript/src/commands/game/sideQuest/utilities/map-view.js

@@ -220,6 +220,39 @@ export function renderMapViewport(rooms, here, sealing, eyes, viewW = 21, viewH
     out[halfH] = out[halfH].slice(0, halfW) + `{inverse}${out[halfH][halfW] === ' ' ? '▣' : out[halfH][halfW]}{/inverse}` + out[halfH].slice(halfW + 1);
     return out;
 }
+export function serializeDistrictMap(rooms, here, sealing, eyes) {
+    const floors = layoutFloors(rooms, here, sealing);
+    if (floors.length === 0)
+        return undefined;
+    const eye = fogEye(rooms, eyes?.visited);
+    const ar = eyes?.arEyes !== false;
+    const out = floors.map(floor => {
+        const linkSeen = (k) => {
+            const a = floor.roomAt.get(`${k.ax},${k.ay}`);
+            const b = floor.roomAt.get(`${k.bx},${k.by}`);
+            return !!a && !!b && eye.sees(a) && eye.sees(b) && (eye.knows(a) || eye.knows(b));
+        };
+        const seen = [...floor.posByRoom.entries()].filter(([r]) => eye.sees(r));
+        return {
+            rooms: seen.map(([r, p]) => {
+                const known = eye.knows(r);
+                return {
+                    x: p.x, y: p.y,
+                    ...(known ? { name: r.name } : {}),
+                    known,
+                    here: r === here,
+                    node: known && ar && !!r.hasNode,
+                    up: known && hasWay(r, 'up'),
+                    down: known && hasWay(r, 'down'),
+                };
+            }),
+            links: floor.links.filter(linkSeen).map(k => ({ ...k })),
+        };
+    });
+    const current = Math.max(0, floors.findIndex(f => f.posByRoom.has(here)));
+    const notes = fogNotes(floors[current]?.notes ?? [], rooms, eye);
+    return { current, floors: out, notes };
+}
 /**
  * The DETAILED view (the "map" text command): named cells, box-drawing
  * connections, and annotations -- the renderer shipped in 5.48.0, now

package/bundle/typescript/src/commands/game/sideQuest/utilities/persistence.js

@@ -178,6 +178,8 @@ export function serializeItem(item) {
         out.linkedSin = item.linkedSin;
     if (item.fitted.length > 0)
         out.fitted = item.fitted.map(serializeItem);
+    if (item.revealedTo.length > 0)
+        out.revealedTo = [...item.revealedTo];
     if (item.isCyberdeck() && item.deckOrder.join() !== '0,1,2,3')
         out.deckOrder = item.deckOrder;
     return out;
@@ -231,6 +233,8 @@ export function restoreItem(json) {
         item.linkedSin = json.linkedSin;
     if (json.fitted)
         item.fitted = json.fitted.map(restoreItem);
+    if (json.revealedTo)
+        item.revealedTo = [...json.revealedTo];
     // A running program is in storage by definition -- saves from before
     // storage existed carried only the running set.
     for (const k of item.loadedPrograms)

package/bundle/typescript/src/commands/game/sideQuest/utilities/room-grid.js

@@ -822,6 +822,14 @@ export function serializeRoomGrid(grid, roomName) {
         const [x, y, z] = cellKey.split(',').map(Number);
         return { kind: link.kind, x, y, z };
     });
+    const terrain = [...grid.terrain.values()].map(r => ({
+        id: r.id, label: r.label, cover: r.cover, blocking: r.blocking, cleared: r.cleared,
+        cells: r.cells.map(c => ({ x: c.x, y: c.y, z: c.z })),
+    }));
+    const levels = [];
+    for (let z = 1; z < grid.dims.z; z++) {
+        levels.push({ z, cells: levelFootprint(grid, z).map(c => ({ x: c.x, y: c.y })) });
+    }
     return {
         name: roomName,
         dims: { x: grid.dims.x, y: grid.dims.y, z: grid.dims.z },
@@ -829,6 +837,8 @@ export function serializeRoomGrid(grid, roomName) {
         doors,
         footprints,
         vertical,
+        terrain,
+        levels,
     };
 }
 function clamp(n, lo, hi) { return Math.max(lo, Math.min(hi, n)); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.160.0",
+  "version": "5.162.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",