@maka/maka-cli 5.161.0 → 5.163.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.161.0",
+  "version": "5.163.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/backlog.js

@@ -1,6 +1,7 @@
 import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { authToken } from '../utilities/cloud-saves.js';
+import { currentSession } from '../utilities/session-context.js';
 import { submitBacklog, fetchBacklog, postBacklogComment, postBacklogSignoff, postBacklogReject, postBacklogClose, BACKLOG_STATUSES, } from '../utilities/backlog.js';
 import { noteBacklogOutcome } from '../utilities/playtester.js';
 import { takeIndex } from '../utilities/fuzzy-match.js';
@@ -163,6 +164,10 @@ export class BacklogCommand extends Command {
             cliVersion: cliVersion(),
             engineVersion: engineVersion(),
             platform: process.platform,
+            // The host names the client (session-context.ts): a browser run's
+            // engine is the same code on a linux box, and 'linux' told nobody
+            // where the report actually came from (wQEyefjzbwtdmdrJo).
+            client: currentSession()?.client ?? 'cli',
         });
         // A real call classifies the account for free -- no second request.
         noteBacklogOutcome(outcome);

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/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
@@ -5303,6 +5307,15 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         const heat = this.heatBand();
         if (heat && player === this.player)
             lines.push(heat);
+        // THE ALARM (kqrSCWjj96SP4MRXj, web run 2026-09-11: "I got a
+        // notification that the alarms sound, but I don't see any
+        // indication in my status bar"). The site going loud was a world
+        // event that scrolled away; Scene.alarmRaised has been the standing
+        // fact since 2026-08-27, and it belongs on the HUD for as long as it
+        // holds. A fact about the PLACE, so every player at the table sees
+        // it -- unlike heat, which is the primary's own ledger.
+        if (this.scene?.alarmRaised)
+            lines.push(`{red-fg}🚨 ALARM -- the site is lit{/red-fg}`);
         // Line 3: the rest of the readiness read -- armor, and whether the
         // commlink is actually live (equipped), the recurring "why can't I
         // call anyone" friction surfaced at a glance. The armed state used

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

@@ -17,7 +17,7 @@ import { Logger } from './utilities/logger.js';
 import { currentSession, runInSession } from './utilities/session-context.js';
 import { restorePlayer, serializePlayer } from './utilities/persistence.js';
 import { runWithAuthToken } from './utilities/cloud-saves.js';
-import { renderMapViewport, mapCaption } from './utilities/map-view.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';
@@ -190,7 +190,7 @@ export function buildPlayerFromSave(save) {
 }
 export async function createHeadlessSession(opts) {
     const logger = new EmitterLogger(opts.sink, opts.debug);
-    const ctx = { sessionId: opts.sessionId, logger };
+    const ctx = { sessionId: opts.sessionId, logger, client: opts.client };
     return runInSession(ctx, async () => {
         const primary = buildPlayerFromSave(opts.players[0]);
         const game = new Game(primary, opts.seed, opts.conditionSink);
@@ -297,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

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/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/bundle/typescript/src/commands/game/sideQuest/utilities/shared-run.js

@@ -1188,6 +1188,29 @@ export class SharedRunSession {
         }
         if (!verb)
             return '';
+        // PULLING SOMEBODY INTO A LIVE RUN (user 2026-09-11: "ensure that I
+        // can pull in another runner during a live shared run, and the run
+        // won't collapse"). The crew ledger is hub-only (crew.ts), and the
+        // session's party was frozen at createSession -- so out here "crew
+        // invite" had nowhere to go. The server adds the seat to the OPEN
+        // session (sideQuest.inviteToOpen); their commlink buzzes through
+        // the same invite feed, and their taxi seats them through the same
+        // addPlayer a late joiner always used. Nothing about the scene is
+        // touched: the job was sized at draft time and stays that size.
+        const inviteMatch = /^(?:crew|party)\s+invite\s+(.+)$/i.exec(input.trim());
+        if (inviteMatch) {
+            try {
+                const res = await HubLink.call('sideQuest.inviteToOpen', {
+                    sessionID: this.sessionID,
+                    query: inviteMatch[1].trim(),
+                });
+                return `Invite sent to ${res.memberRunner} -- a seat at this table, mid-job.${res.online ? '' : ` (They're off the street -- it'll wait on their link.)`}`;
+            }
+            catch (err) {
+                const e = err;
+                return `{yellow-fg}${e.reason ?? e.message ?? 'The offer does not go through.'}{/yellow-fg}`;
+            }
+        }
         // THE RIDE HOME: on a shared run the taxi is the settlement
         // handshake, not an engine verb -- the leader closes the table for
         // everyone (snapshots persist, shares already on each stick); a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.161.0",
+  "version": "5.163.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.",