@maka/maka-cli 5.137.0 → 5.138.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.137.0",
+  "version": "5.138.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/game.js

@@ -2341,7 +2341,17 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
     static HOME_DIRECTION_PRIORITY = [
         Direction.DOWN, Direction.UP, Direction.SOUTH, Direction.NORTH, Direction.EAST, Direction.WEST,
     ];
-    constructor(player, sceneSeed) {
+    /**
+     * IN-PROCESS CONDITION REPORTING (2026-09-07): a site-hosted headless
+     * session hands this in so `onConditionChanged` below can skip HubLink
+     * entirely -- see condition-report.ts's `ConditionSink` doc comment for
+     * why this lives on the instance rather than as module state. Absent
+     * for the interactive CLI, which keeps today's HubLink/DDP behavior
+     * unchanged.
+     */
+    _conditionSink;
+    constructor(player, sceneSeed, conditionSink) {
+        this._conditionSink = conditionSink;
         this.player = player;
         this.sceneSeed = sceneSeed;
         this.initialized = false;
@@ -2356,11 +2366,12 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 return;
             // Checked HERE too, before the import -- a dynamic import after a
             // Jest file's teardown is itself the failure, so the gate cannot
-            // live only on the far side of one.
-            if (process.env.MAKA_NO_DDP === '1')
+            // live only on the far side of one. Irrelevant when a conditionSink
+            // is wired (no DDP hop for that path to silence).
+            if (!this._conditionSink && process.env.MAKA_NO_DDP === '1')
                 return;
             void import('./utilities/condition-report.js')
-                .then(m => m.reportConditionSoon(this.player))
+                .then(m => m.reportConditionSoon(this.player, this._conditionSink))
                 .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

@@ -18,6 +18,7 @@ import { currentSession, runInSession } from './utilities/session-context.js';
 import { restorePlayer, serializePlayer } from './utilities/persistence.js';
 import { renderMapViewport, mapCaption } from './utilities/map-view.js';
 import { renderRoomLayoutCompact, crewOfTable, roomCaption } from './utilities/room-view.js';
+import { serializeRoomGrid } from './utilities/room-grid.js';
 import { entrySpotFor, spotOf } from './utilities/spots.js';
 import { equipIntoEmptySlots } from './archetypes.js';
 /**
@@ -191,7 +192,7 @@ export async function createHeadlessSession(opts) {
     const ctx = { sessionId: opts.sessionId, logger };
     return runInSession(ctx, async () => {
         const primary = buildPlayerFromSave(opts.players[0]);
-        const game = new Game(primary, opts.seed);
+        const game = new Game(primary, opts.seed, opts.conditionSink);
         // The run's tier, stated rather than defaulted -- see
         // HeadlessOptions.tier and Game.tier.
         if (typeof opts.tier === 'number')
@@ -325,7 +326,21 @@ export async function createHeadlessSession(opts) {
                     if (roomLines.length > 0) {
                         roomLines.push(mapCaption(roomCaption(here, p)));
                     }
-                    logger.system(roomLines.join('\n'), { actor: p.name }, 'room');
+                    // STRUCTURED ROOM GEOMETRY, ADDITIVE (2026-09-07): the ASCII
+                    // above stays the log-adjacent text every consumer already
+                    // reads; a browser client wanting the site's real SVG DotMap
+                    // instead reads `data.grid` off this SAME event -- no new
+                    // event kind, no publication change (GameEvent.data already
+                    // round-trips end to end). ensureGrid() always synthesizes now
+                    // ("EVERY ROOM IS MATRIXED", room.ts:357-370, the 2026-08-25
+                    // ruling that retired the spotless-room compat gap) -- the
+                    // `undefined` in its return type is a vestige, kept guarded
+                    // here anyway rather than asserted, since a decoration must
+                    // never take down the room push (same reasoning as the
+                    // try/catch this sits inside).
+                    const grid = here.ensureGrid();
+                    const data = grid ? { grid: serializeRoomGrid(grid, here.name) } : undefined;
+                    logger.system(roomLines.join('\n'), { actor: p.name }, 'room', data);
                 }
                 catch (err) {
                     logger.write(`Room overlay render failed for ${p.name} in ${here.name}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);

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

@@ -18,7 +18,24 @@ import { hostLabel } from './grid-names.js';
  * storm into a single report of where the monitors LANDED.
  */
 const COALESCE_MS = 250;
-let pending;
+/**
+ * KEYED PER PLAYER, NOT A SINGLE SLOT (fixed 2026-09-07 alongside the
+ * ConditionSink work above). A lone real terminal process only ever
+ * calls this for its own primary, so a single `pending` variable never
+ * showed a problem: every arm captured the SAME player object, and
+ * reading its state at fire time was always correct regardless of which
+ * call armed the timer. That stops being true the moment more than one
+ * `Game` can be reporting condition in the same process -- exactly what
+ * ConditionSink exists for. With one shared slot, a second session's
+ * mutation arriving while the first session's beat is still gathering
+ * hit `if (pending) return` and vanished silently: not delayed, not
+ * coalesced into the wrong report -- simply never sent, for that
+ * session, for that beat. Keying the map on the Player instance gives
+ * each session (each primary Player is a distinct object) its own
+ * independent 250ms coalescing window, with no change to the
+ * single-session behavior this always had.
+ */
+const pendingByPlayer = new WeakMap();
 /** The method name is the server's -- co-owned; do not rename alone. */
 export const REPORT_METHOD = 'characterSheet.reportCondition';
 /**
@@ -215,21 +232,21 @@ function noteRefusal(why) {
         catch { /* no session */ }
     }
 }
-export function reportConditionSoon(player) {
+export function reportConditionSoon(player, sink) {
     // 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
     // MAKA_NO_DDP nothing is armed at all -- the same switch the whole
-    // live layer honors.
-    if (process.env.MAKA_NO_DDP === '1')
+    // live layer honors. Irrelevant to a caller-supplied sink: there is no
+    // DDP hop to silence when reporting stays in-process.
+    if (!sink && process.env.MAKA_NO_DDP === '1')
         return;
-    if (pending)
-        return; // a beat is already gathering
-    pending = setTimeout(() => {
-        pending = undefined;
+    if (pendingByPlayer.has(player))
+        return; // a beat is already gathering for THIS player
+    const timer = setTimeout(() => {
+        pendingByPlayer.delete(player);
         void (async () => {
-            const [{ HubLink }, { saveSlug }, { arSightUp }] = await Promise.all([
-                import('./shared-run.js'),
+            const [{ saveSlug }, { arSightUp }] = await Promise.all([
                 import('./persistence.js'),
                 import('./ar.js'),
             ]);
@@ -244,6 +261,14 @@ export function reportConditionSoon(player) {
             // beat fires next. All read at FIRE time, like position.
             const report = buildConditionReport(player, { saveSlug, arSightUp });
             noteRoster(report);
+            if (sink) {
+                // IN-PROCESS: no HubLink, no MAKA_NO_DDP gate, no version-skew
+                // retry -- the engine module and its caller are always the same
+                // deployed version here (see ConditionSink's doc comment).
+                await sink(report);
+                return;
+            }
+            const { HubLink } = await import('./shared-run.js');
             try {
                 await HubLink.call(REPORT_METHOD, report);
             }
@@ -270,10 +295,11 @@ export function reportConditionSoon(player) {
             noteRefusal(err instanceof Error ? err.message : String(err));
         });
     }, COALESCE_MS);
-    pending.unref?.();
+    pendingByPlayer.set(player, timer);
+    timer.unref?.();
 }
-/** Test seam: is a beat currently gathering? */
-export function conditionReportPending() {
-    return pending !== undefined;
+/** Test seam: is a beat currently gathering for this player? */
+export function conditionReportPending(player) {
+    return pendingByPlayer.has(player);
 }
 //# sourceMappingURL=condition-report.js.map

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

@@ -800,6 +800,37 @@ export function synthesizeGrid(input) {
 // the module doc); Room.ensureGrid queries this cell by that same
 // string. A rename on either side must update both.
 export const OPEN_FLOOR_NAME = 'open floor';
+/** Flattens a live IRoomGrid's Maps into ISerializedRoomGrid. Spots ship
+ *  UNFILTERED (the caller resolves actor positions against the full
+ *  list, open floor included -- see room-view.ts's seatingIn); only the
+ *  DRAWN footprints skip the open-floor anchor, matching the site's own
+ *  filter. */
+export function serializeRoomGrid(grid, roomName) {
+    const spots = [...grid.spotCells.entries()].map(([name, c]) => ({
+        name, x: c.x, y: c.y, z: c.z,
+    }));
+    const doors = [...grid.exitCells.entries()].map(([dir, c]) => ({
+        dir: String(dir), x: c.x, y: c.y, z: c.z,
+    }));
+    const footprints = [...grid.spotFootprints.entries()]
+        .filter(([name]) => name !== OPEN_FLOOR_NAME)
+        .map(([name, cells]) => ({
+        name,
+        cells: cells.map(c => ({ x: c.x, y: c.y, z: c.z })),
+    }));
+    const vertical = [...grid.vertical.entries()].map(([cellKey, link]) => {
+        const [x, y, z] = cellKey.split(',').map(Number);
+        return { kind: link.kind, x, y, z };
+    });
+    return {
+        name: roomName,
+        dims: { x: grid.dims.x, y: grid.dims.y, z: grid.dims.z },
+        spots,
+        doors,
+        footprints,
+        vertical,
+    };
+}
 function clamp(n, lo, hi) { return Math.max(lo, Math.min(hi, n)); }
 function jitter(rng) { return Math.floor(rng() * 3) - 1; }
 function chebyshev(a, b) { return Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y)); }

package/package.json

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