@maka/maka-cli 5.382.0 → 5.384.0

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

@@ -1,7 +1,8 @@
 import { capitalCase } from 'change-case';
 import { Door } from '../models/door.js';
 import { Direction } from '../types/shared/direction-enum.js';
-import { FRONTIER_GLYPH, BLOCKED_GLYPH, UP_GLYPH, DOWN_GLYPH, PLAYER_GLYPH, WALL_GLYPH, DOOR_GLYPH, FLOOR_GLYPH, VOID_GLYPH, TERRAIN_GLYPH, OUTSIDE_GROUND_COLOR, GLYPH_RANK, OFF_EDGE_GLYPH, } from './map-glyphs.js';
+import { FRONTIER_GLYPH, BLOCKED_GLYPH, UP_GLYPH, DOWN_GLYPH, PLAYER_GLYPH, WALL_GLYPH, DOOR_GLYPH, FLOOR_GLYPH, VOID_GLYPH, TERRAIN_GLYPH, OUTSIDE_GROUND_COLOR, GLYPH_RANK, OFF_EDGE_GLYPH, BARRIER_GLYPH, BARRIER_COLOR, MANA_BARRIER_COLOR, } from './map-glyphs.js';
+import { xRulerLine, yRulerLabel } from './map-rulers.js';
 import { roomAtCell, isVoid, wallsBetween, districtBearing, isOpenAir } from './district-plane.js';
 import { distanceMeters, METERS_PER_LEVEL } from './room-grid.js';
 import { isOutdoorsPlace } from './outdoors.js';
@@ -713,8 +714,13 @@ function renderPlaneViewport(plane, rooms, here, eyes, viewW, viewH) {
      */
     const MARGIN = 2;
     const cam = eyes?.at;
-    const wantW = Math.max(1, viewW);
-    const wantH = Math.max(1, viewH);
+    // The rulers come out of the panel, not on top of it: a fixed gutter
+    // (three characters -- the plane is 60 rows deep -- and a space) and
+    // one row for the x labels.
+    const RULER_GUTTER = 3;
+    const rulers = eyes?.rulers === true;
+    const wantW = Math.max(1, viewW - (rulers ? RULER_GUTTER + 1 : 0));
+    const wantH = Math.max(1, viewH - (rulers ? 1 : 0));
     /**
      * ONE CELL, ONE DOT -- 2 m, the same as the room panel.
      *
@@ -1068,6 +1074,21 @@ function renderPlaneViewport(plane, rooms, here, eyes, viewW, viewH) {
                 labels.set(at2, ch);
         });
     }
+    // BARRIER SPELLS (barrier-geometry.ts): a Physical Barrier for every
+    // eye, a Mana Barrier only for its weaver or an eye on the astral.
+    const spellCells = new Map();
+    const seer = eyes?.viewer;
+    const seesAstral = !!seer && (seer.plane === 'astral' || seer.astralPerceiving);
+    for (const b of here.scene?.spellBarriers?.() ?? []) {
+        if (b.kind === 'mana' && !seesAstral && b.caster !== seer?.name)
+            continue;
+        for (const f of b.faces) {
+            if (f.breached)
+                continue;
+            for (const c of f.cells)
+                spellCells.set(`${c.x},${c.y},${c.z}`, b.kind);
+        }
+    }
     const out = [];
     let openStyle = '';
     for (let ry = 0; ry < rows; ry++) {
@@ -1195,6 +1216,9 @@ function renderPlaneViewport(plane, rooms, here, eyes, viewW, viewH) {
                      * not internal detail. The floorplan is what the Room panel
                      * is for, one zoom in.
                      */
+                    const spell = spellCells.get(key);
+                    if (spell)
+                        take(BARRIER_GLYPH, GLYPH_RANK.barrier, spell === 'mana' ? MANA_BARRIER_COLOR : BARRIER_COLOR);
                     const owner = roomAtCell(plane, { x, y, z });
                     const indoors = owner !== undefined && !plane.placements.get(owner).outdoors;
                     const ring = plane.walls.has(key) || (zoomedOut && plane.doorways.has(key) && wallOwner.has(key));
@@ -1300,8 +1324,10 @@ function renderPlaneViewport(plane, rooms, here, eyes, viewW, viewH) {
         openStyle = '';
         // NOT trimmed: a filled row is the point, and trailing ground is
         // still ground.
-        out.push(line);
+        out.push(rulers ? `${yRulerLabel(y0 + Math.floor((ry * spanY) / rows), RULER_GUTTER)} ${line}` : line);
     }
+    if (rulers)
+        out.unshift(`${' '.repeat(RULER_GUTTER + 1)}${xRulerLine(x0, cols, cellsPerDot)}`);
     return out;
 }
 /**

package/bundle/typescript/src/commands/game/sideQuest/utilities/npc-authorization.js

@@ -126,6 +126,33 @@ export function authorizeNpcAction(scene, actor, verb, args) {
     }
     return ALLOWED;
 }
+/**
+ * THE JOHNSON HOLDS THE MEET (CWMrB2aNyL4hhrjyG: "when at the meet, the
+ * johnson shouldn't just keep moving around the room").
+ *
+ * The run's client picks the venue and waits in it (Run Faster's meet,
+ * p.197-198: the Johnson sets the place, the runners come to them). His
+ * AI read every beat as a chance to stage himself -- "Mr. Lacquer moves
+ * to the open floor", "moves to the counter", prod 2026-10-04 -- so the
+ * man the runner came to see wandered the room for the whole briefing.
+ * Prose can still have him turn, lean, or look at the door; the engine
+ * keeps his body where the meet put it until the job is settled, and his
+ * leaving after the settlement is the engine's own beat (game.ts
+ * "Johnsons don't linger"), not his AI's.
+ *
+ * A FIGHT IS NOT A MEET: inside a Combat Turn the turn loop moves him,
+ * and a Johnson ducking for cover is not this rule's business.
+ *
+ * Returns a refusal reason, or undefined when he may move.
+ */
+export function clientHoldsTheMeet(scene, actor) {
+    const client = scene.ownerGame?.currentClient;
+    if (!client || client.name !== actor.name || client.reported || client.dead)
+        return undefined;
+    if (actor.inExchange || scene.encounterIn?.(actor.currentLocation))
+        return undefined;
+    return `You hold your seat for the meet -- the runner came to you, and you stay where you are until the job is settled. Turn, gesture, or speak instead of walking.`;
+}
 /**
  * Is this actor home? A decker jacked into the Matrix, a magician
  * projecting astrally and a rigger jumped into a drone all leave a body

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

@@ -7,6 +7,7 @@ import { fuzzyPickName } from './fuzzy-match.js';
 import { resetOverwatch } from './overwatch.js';
 import { rebootWipe } from './marks.js';
 import { hint } from './hints.js';
+import { codesOnPage } from './clue-reading.js';
 import { actorCell } from './spots.js';
 import { announceGameOver } from './game-over.js';
 import { holdAtBrink } from './not-dead-yet.js';
@@ -624,6 +625,43 @@ export function isObjectiveItem(scene, itemName) {
 export function objectiveMark(scene, itemName) {
     return isObjectiveItem(scene, itemName) ? `{yellow-fg}${OBJECTIVE_GLYPH}{/yellow-fg} ` : '';
 }
+/**
+ * PART OF THE JOB, NOT THE PRIZE (nfrBW27eRRxstJ8uC: "the 'Lot Catalogue
+ * Proof Sheet' isn't marked in my inventory as quest specific").
+ *
+ * The star is the objective alone, so a page the job's route runs
+ * through -- the proof sheet with the vault shutter's code pencilled in
+ * its margin -- sat unmarked among the loot, and the runner could not
+ * tell it from a souvenir. A LEAD is an item this scene's barriers
+ * answer to, read off the same facts the engine itself opens them with:
+ *  - a page that spells one of the scene's device codes (clue-reading.ts
+ *    codesOnPage -- the fact ensureClueDetails guarantees is written), or
+ *  - the key a device declares as its own (Device.keyItem).
+ * Nothing else: a lead the engine cannot point to would be a guess.
+ *
+ * It marks the item, never the code -- whether the runner can READ the
+ * number off the page is still the Perception Test (clue-reading.ts).
+ * Hub scenes have no win condition and mark nothing, like the star.
+ */
+export const LEAD_GLYPH = '☆';
+export function isJobLead(scene, item) {
+    if (!scene?.getWinCondition?.())
+        return false;
+    const name = item.name.trim().toLowerCase();
+    for (const room of Object.values(scene.getRooms())) {
+        for (const device of room.devices ?? []) {
+            if (device.keyItem?.name.trim().toLowerCase() === name)
+                return true;
+        }
+    }
+    return codesOnPage(scene, item).length > 0;
+}
+/** `★ ` for the objective, `☆ ` for a lead (isJobLead), '' otherwise. */
+export function jobMark(scene, item) {
+    if (isObjectiveItem(scene, item.name))
+        return objectiveMark(scene, item.name);
+    return isJobLead(scene, item) ? `{yellow-fg}${LEAD_GLYPH}{/yellow-fg} ` : '';
+}
 /**
  * The "you can see them, but you can't touch them" refusal. When a target
  * name matches someone in the room on a plane the actor perceives but

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

@@ -248,8 +248,23 @@ function cellExists(grid, c, levelCells) {
 export function cellOnGrid(grid, c) {
     return cellExists(grid, c, LEVEL_CELLS.get(grid) ?? new Map());
 }
-/** Whether `c` sits inside an uncleared BLOCKING terrain region. */
+/**
+ * SOMETHING ELSE THAT SEALS A CELL, asked live: a sustained Physical
+ * Barrier (Scene.physicalBarrierAtLocal, registered by Room.ensureGrid).
+ * A spell comes and goes many times over a grid's life, so it is a
+ * question the grid asks rather than terrain baked into it -- and a
+ * rebuilt grid cannot lose a wall that was never stored on it. Keyed by
+ * grid identity like LEVEL_CELLS: per room, never module-wide (several
+ * scenes share this process on the site).
+ */
+const CELL_BLOCKERS = new WeakMap();
+export function setCellBlocker(grid, blocked) {
+    CELL_BLOCKERS.set(grid, blocked);
+}
+/** Whether `c` sits inside an uncleared BLOCKING terrain region, or under a standing barrier spell. */
 function isBlocked(grid, c) {
+    if (CELL_BLOCKERS.get(grid)?.(c))
+        return true;
     const k = key(c);
     for (const region of grid.terrain.values()) {
         if (!region.blocking || region.cleared)
@@ -482,6 +497,9 @@ export function pathClearing(grid, from, to, region) {
     const trial = { ...grid, terrain: new Map(grid.terrain) };
     trial.terrain.set(region.id, { ...region, cleared: true });
     LEVEL_CELLS.set(trial, LEVEL_CELLS.get(grid) ?? new Map());
+    const blocker = CELL_BLOCKERS.get(grid);
+    if (blocker)
+        CELL_BLOCKERS.set(trial, blocker);
     return findPath(trial, from, to);
 }
 /**
@@ -503,6 +521,9 @@ export function pathWithRegionsCleared(grid, from, to, regionIds) {
             trial.terrain.set(id, { ...region, cleared: true });
     }
     LEVEL_CELLS.set(trial, LEVEL_CELLS.get(grid) ?? new Map());
+    const blocker = CELL_BLOCKERS.get(grid);
+    if (blocker)
+        CELL_BLOCKERS.set(trial, blocker);
     return findPath(trial, from, to);
 }
 /** SR5 p.172 (RAG-verified): DV = meters fallen, only beyond 3m; AP-4

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

@@ -4,7 +4,9 @@ import { Direction } from '../types/shared/direction-enum.js';
 import { OPEN_FLOOR, spotOf, visibleActorsIn, exitSpot, seatingIn, theSpot, isPerchSpot } from './spots.js';
 import { placeName } from './log-style.js';
 import { DRONE_COLOUR } from './drone-prose.js';
-import { PLAYER_GLYPH, OTHER_PLAYER_GLYPH, OTHER_PLAYER_COLOR, NEUTRAL_GLYPH, HOSTILE_GLYPH, CREW_GLYPH, DEAD_GLYPH, DOWNED_GLYPH, SPOT_GLYPH, RIGGED_GLYPH, UP_GLYPH, CAMERA_GLYPH, CAMERA_COLOR, CAMERA_DEAD_COLOR, exitGlyph, GLYPH_RANK, } from './map-glyphs.js';
+import { PLAYER_GLYPH, OTHER_PLAYER_GLYPH, OTHER_PLAYER_COLOR, NEUTRAL_GLYPH, HOSTILE_GLYPH, CREW_GLYPH, DEAD_GLYPH, DOWNED_GLYPH, SPOT_GLYPH, RIGGED_GLYPH, UP_GLYPH, CAMERA_GLYPH, CAMERA_COLOR, CAMERA_DEAD_COLOR, BARRIER_GLYPH, BARRIER_COLOR, MANA_BARRIER_COLOR, exitGlyph, GLYPH_RANK, } from './map-glyphs.js';
+import { barriersWire } from './ways-out.js';
+import { xRulerLine, yRulerLabel, yGutterWidth } from './map-rulers.js';
 import { key, levelFootprint, dimsForSize, roomRasterRows, METERS_PER_LEVEL, METERS_PER_CELL, } from './room-grid.js';
 /**
  * WHO THIS PANEL DRAWS: everyone you can see, plus every ARO your AR is
@@ -276,7 +278,16 @@ function buildRenderMaps(grid, room, viewer) {
         if (c)
             cameraAt.set(`${c.x},${c.y}`, { cam, z: c.z });
     }
-    return { cellToSpot, cellToExit, verticalAt, cellTerrain, occupants, corpses, slumpedBody, cameraAt };
+    const barrierAt = new Map();
+    for (const b of barriersWire(room, viewer)) {
+        for (const f of b.faces) {
+            if (f.breached)
+                continue;
+            for (const c of f.cells)
+                barrierAt.set(key(c), b.kind);
+        }
+    }
+    return { cellToSpot, cellToExit, verticalAt, cellTerrain, occupants, corpses, slumpedBody, cameraAt, barrierAt };
 }
 function paint(g) {
     const body = g.inverse ? `{inverse}${g.ch}{/inverse}` : g.ch;
@@ -484,6 +495,9 @@ function glyphAt(c, maps, viewer, isOtherPlayer, isTableAlly, isHostile) {
     const lens = maps.cameraAt.get(`${c.x},${c.y}`);
     if (lens && lens.z >= c.z)
         return cameraGlyph(lens.cam);
+    const wall = maps.barrierAt.get(k);
+    if (wall)
+        return { ch: BARRIER_GLYPH, color: wall === 'mana' ? MANA_BARRIER_COLOR : BARRIER_COLOR, rank: GLYPH_RANK.barrier };
     const terrain = maps.cellTerrain.get(k);
     if (terrain)
         return terrain.blocking ? { ch: '▓', color: 'red', rank: GLYPH_RANK.terrainBlocking } : { ch: '▒', color: 'yellow', rank: GLYPH_RANK.terrainCover };
@@ -552,7 +566,9 @@ function levelPlansFor(room) {
  * glyph used. Returns [] for a spotless room (no grid ever synthesizes
  * -- see Room.ensureGrid).
  */
-export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly, isHostile) {
+export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly, isHostile, 
+/** The room's PLANE origin: rulers in plane coordinates (map-rulers.ts). */
+origin) {
     const grid = room.ensureGrid();
     if (!grid)
         return [];
@@ -569,8 +585,11 @@ export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly, isHos
         const exists = new Set(footprint.map(key));
         if (levelPlans.length > 1)
             rows.push(`{bold}${lvl.label}{/bold}`);
+        const gutter = origin ? yGutterWidth(origin.y + y0, y1 - y0 + 1) + 1 : 0;
+        if (origin)
+            rows.push(`${' '.repeat(gutter)}${xRulerLine(origin.x + x0, x1 - x0 + 1)}`);
         for (let y = y0; y <= y1; y++) {
-            let row = '';
+            let row = origin ? `${yRulerLabel(origin.y + y, gutter - 1)} ` : '';
             for (let x = x0; x <= x1; x++) {
                 const c = { x, y, z: lvl.z };
                 row += exists.has(key(c)) ? cell(glyphAt(c, maps, viewer, isOtherPlayer, isTableAlly, isHostile)) : ' ';
@@ -589,6 +608,11 @@ export function renderRoomLayout(room, viewer, isOtherPlayer, isTableAlly, isHos
         // that reads as a keyword in the description must read as one here.
         legend.push(`{yellow-fg}${SPOT_GLYPH}{/yellow-fg} places: ${places.map(placeName).join(', ')}`);
     }
+    const kinds = new Set(maps.barrierAt.values());
+    if (kinds.has('physical'))
+        legend.push(`{${BARRIER_COLOR}-fg}${BARRIER_GLYPH}{/${BARRIER_COLOR}-fg} force barrier -- nothing physical passes; "attack barrier" to break a face`);
+    if (kinds.has('mana'))
+        legend.push(`{${MANA_BARRIER_COLOR}-fg}${BARRIER_GLYPH}{/${MANA_BARRIER_COLOR}-fg} mana barrier -- stops the astral and spirits; the living walk through`);
     for (const dir of grid.exitCells.keys()) {
         // Name the spot you actually stand in to leave this way -- read
         // from the same resolver movement uses, not from cell coincidence:
@@ -716,10 +740,13 @@ export function rightAlign(text, width) {
     const pad = Math.max(0, width - visibleWidth(text));
     return `${' '.repeat(pad)}${text}`;
 }
-export function roomMetresPerDot(room, availW, viewH) {
+export function roomMetresPerDot(room, availW, viewH, origin) {
     const grid = room.ensureGrid();
     const dims = grid ? { x: grid.dims.x, y: grid.dims.y } : dimsForSize(room.size);
-    return frameScale(dims.x, dims.y, availW, viewH) * METERS_PER_CELL;
+    // The rulers come out of the same raster (frameCells), so the scale
+    // read-out has to subtract them too or it would claim a finer dot.
+    const gutter = origin ? yGutterWidth(origin.y, dims.y) + 1 : 0;
+    return frameScale(dims.x, dims.y, availW - gutter, origin ? viewH - 1 : viewH) * METERS_PER_CELL;
 }
 export function frameScale(width, height, availW, viewH) {
     // One column a dot -- see cell(). The /2 this used to carry was the
@@ -758,15 +785,22 @@ export function frameScale(width, height, availW, viewH) {
  * The block is centred inside a fixed `viewH` rows so the box height
  * never jumps between rooms either.
  */
-function frameCells(cells, availW, viewH) {
+function frameCells(cells, availW, viewH, 
+/** PLANE coordinates of cells[0][0]: draw the x ruler above and the y
+ *  gutter beside (map-rulers.ts). Both come out of the same raster, so
+ *  the box never grows -- the room scales a little harder instead. */
+axes) {
     const height = cells.length;
     const width = Math.max(...cells.map(r => r.length), 0);
-    const scale = frameScale(width, height, availW, viewH);
+    const gutter = axes ? yGutterWidth(axes.y, height) + 1 : 0;
+    const cols = availW - gutter;
+    const rows = axes ? viewH - 1 : viewH;
+    const scale = frameScale(width, height, cols, rows);
     const outW = Math.ceil(width / scale);
     const outH = Math.ceil(height / scale);
     const body = [];
     for (let ry = 0; ry < outH; ry++) {
-        let line = '';
+        let line = axes ? `${yRulerLabel(axes.y + ry * scale, gutter - 1)} ` : '';
         for (let rx = 0; rx < outW; rx++) {
             // The highest-ranked thing in the block wins the dot -- see
             // IGlyph.rank. At scale 1 this is exactly the old behaviour,
@@ -783,6 +817,8 @@ function frameCells(cells, availW, viewH) {
         }
         body.push(line.trimEnd());
     }
+    if (axes)
+        body.unshift(`${' '.repeat(gutter)}${xRulerLine(axes.x, outW, scale)}`);
     // Vertically centre into a fixed height: a short room shouldn't sit
     // jammed against the top while a tall one fills the box.
     const pad = Math.max(0, viewH - body.length);
@@ -968,7 +1004,7 @@ export function renderRoomLayoutCompact(room, viewer, opts = {}) {
     // room is SCALED onto it (frameCells), so this bounds the picture
     // rather than the room: an outdoor room takes its extent from the
     // district plane and can be far deeper than any size class.
-    const { viewH = roomRasterRows(), boxWidth, isOtherPlayer, isTableAlly, isHostile } = opts;
+    const { viewH = roomRasterRows(), boxWidth, isOtherPlayer, isTableAlly, isHostile, origin } = opts;
     // Width left for the grid once the right-justified elevation bar and
     // its gap are reserved.
     const availW = Math.max(6, (boxWidth ?? 27) - ELEVATION_WIDTH - 1);
@@ -1023,7 +1059,7 @@ export function renderRoomLayoutCompact(room, viewer, opts = {}) {
     const lenses = new Map();
     for (const { cam, z: lz } of maps.cameraAt.values())
         lenses.set(lz, [...(lenses.get(lz) ?? []), cam]);
-    return withElevation(frameCells(cells, availW, viewH), 
+    return withElevation(frameCells(cells, availW, viewH, origin ? { x: origin.x + x0, y: origin.y + y0 } : undefined), 
     // Circulating has no level to claim, same as it has no cell.
     elevationColumn(grid, viewerCell ? z : undefined, viewH, partialMeters, lenses), boxWidth);
 }
@@ -1099,6 +1135,10 @@ export function roomCaption(room, viewer) {
     const base = spot ? `at ${spot}` : '(moving through)';
     const { above, below } = actorsOnOtherLevels(room, viewer);
     const notes = [];
+    // WHERE, IN THE RULERS' NUMBERS -- what "cast barrier x,y" is aimed with.
+    const here = room.scene?.worldCellOf?.(viewer);
+    if (here)
+        notes.push(`${here.x},${here.y},${here.z}`);
     if (above > 0)
         notes.push(`+${above} above`);
     if (below > 0)

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

@@ -1,6 +1,6 @@
 import { droneImmobile } from './drone-prose.js';
 import { Direction } from '../types/shared/direction-enum.js';
-import { isOpenGround, isVoid, roomAtCell, streetDoors } from './district-plane.js';
+import { isOpenGround, isVoid, roomAtCell, streetDoors, worldCell } from './district-plane.js';
 import { isOutdoorsPlace } from './outdoors.js';
 import { wayOut } from './ways-out.js';
 import { significantWords, wordsAreCloseEnough } from './fuzzy-match.js';
@@ -889,11 +889,24 @@ export function stepFrom(room, mover, direction, count) {
     const openOutside = openGroundBeyond(room);
     const furniture = furnitureCells(room);
     const bodies = standingOccupants(room, mover);
+    // A BARRIER SPELL is its own word (barrier-geometry.ts): it is drawn,
+    // it shimmers, and "the way is blocked" would hide whose working it is.
+    // Asked on the plane, so it stops a step off an outdoor room's edge too.
+    const scenePlane = room.scene?.spellBarriers?.('physical').length ? room.scene.ensurePlane() : undefined;
+    const barrierHere = (local) => {
+        if (!scenePlane || !room.scene)
+            return undefined;
+        const world = worldCell(scenePlane, room.name, local);
+        return world ? room.scene.barrierAt(world, 'physical')?.barrier.caster : undefined;
+    };
     let cur = start;
     let taken = 0;
     for (let i = 0; i < count; i++) {
         const next = { x: cur.x + step[0], y: cur.y + step[1], z: cur.z };
         const k = key(next);
+        const walledBy = barrierHere(next);
+        if (walledBy !== undefined)
+            return { cell: cur, taken, blockedBy: 'barrier', blocker: walledBy };
         if (!standable.has(k)) {
             const inBounds = next.x >= 0 && next.y >= 0 && next.x < grid.dims.x && next.y < grid.dims.y;
             // Off the edge of an OUTDOOR room is just more street, unless the
@@ -2526,7 +2539,10 @@ export function describeSpotRoster(room, viewer) {
  * district, and the room it happens to be over is a label the caller
  * re-derives.
  */
-export function astralStepFrom(plane, from, direction, count, roomAt) {
+export function astralStepFrom(plane, from, direction, count, roomAt, 
+/** Whose MANA BARRIER stands on a cell, if any (Scene.barrierAt --
+ *  the creator's own weave already excluded, p.315). */
+manaBarrierAt) {
     /**
      * UP AND DOWN ARE DIRECTIONS OUT HERE (p.313-314: an astral form
      * "can move in any direction" and is "not limited by gravity").
@@ -2564,6 +2580,12 @@ export function astralStepFrom(plane, from, direction, count, roomAt) {
         if (here !== there) {
             return { cell: cur, taken, blockedBy: 'ward', ward: (there ?? here)?.name };
         }
+        // A MANA BARRIER SPELL: "solid, hazily opaque walls that stop astral
+        // movement" (p.315-316). `go` always refused one; a `move` drift
+        // used to float straight through it, because this walk never asked.
+        const weaver = manaBarrierAt?.(next);
+        if (weaver !== undefined)
+            return { cell: cur, taken, blockedBy: 'barrier', ward: weaver };
         cur = next;
         taken++;
     }

package/bundle/typescript/src/commands/game/sideQuest/utilities/ways-out.js

@@ -71,7 +71,7 @@ export function wayOut(room, direction, from) {
  * (map-view.ts serializePlane); here a street keeps only what the plane
  * could not place.
  */
-export function roomGridWire(room) {
+export function roomGridWire(room, viewer) {
     const grid = room.ensureGrid();
     if (!grid)
         return undefined;
@@ -83,9 +83,41 @@ export function roomGridWire(room) {
                 damage: cam.damage, structure: cam.structure, destroyed: cam.destroyed,
             }] : [];
     });
-    const wire = cameras.length > 0 ? { ...base, cameras } : base;
+    const withCams = cameras.length > 0 ? { ...base, cameras } : base;
+    const barriers = barriersWire(room, viewer);
+    const wire = barriers.length > 0 ? { ...withCams, barriers } : withCams;
     if (!isOutdoorsPlace(room))
         return wire;
     return { ...wire, doors: wire.doors.filter(d => wayOut(room, d.dir)?.kind === 'grid') };
 }
+/**
+ * The barrier spells a viewer can see around this room, in its local
+ * cells: every standing Physical Barrier with a cell within one of the
+ * footprint (its wall ring included), and a Mana Barrier only for its
+ * weaver or an eye on the astral (p.294: "invisible to the physical
+ * plane"). Breached faces ride along marked, so a client can draw the
+ * gap rather than lose the face.
+ */
+export function barriersWire(room, viewer) {
+    const scene = room.scene;
+    const all = scene?.spellBarriers?.() ?? [];
+    if (!scene || all.length === 0)
+        return [];
+    const frame = scene.ensurePlane().placements.get(roomKey(room.name));
+    if (!frame)
+        return [];
+    const seesAstral = !!viewer && (viewer.plane === 'astral' || viewer.astralPerceiving);
+    const near = (c) => c.x >= frame.origin.x - 1 && c.x <= frame.origin.x + frame.dims.x
+        && c.y >= frame.origin.y - 1 && c.y <= frame.origin.y + frame.dims.y;
+    return all
+        .filter(b => b.kind === 'physical' || seesAstral || b.caster === viewer?.name)
+        .filter(b => b.faces.some(f => f.cells.some(near)))
+        .map(b => ({
+        kind: b.kind, caster: b.caster, shape: b.shape, force: b.force, structure: b.structure,
+        faces: b.faces.map(f => ({
+            id: f.id, damage: f.damage, breached: f.breached,
+            cells: f.cells.map(c => ({ x: c.x - frame.origin.x, y: c.y - frame.origin.y, z: c.z - frame.origin.z })),
+        })),
+    }));
+}
 //# sourceMappingURL=ways-out.js.map

package/package.json

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