@maka/maka-cli 5.391.0 → 5.392.0

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

@@ -245,8 +245,9 @@ export function mulberry32(seed) {
 function cellExists(grid, c, levelCells) {
     if (c.x < 0 || c.y < 0 || c.x >= grid.dims.x || c.y >= grid.dims.y)
         return false;
+    // A HOLE in an outdoor area is a cell something else owns (GROUND_HOLES).
     if (c.z === 0)
-        return true;
+        return !GROUND_HOLES.get(grid)?.has(`${c.x},${c.y}`);
     return levelCells.get(c.z)?.has(`${c.x},${c.y}`) ?? false;
 }
 /** Whether `c` is a cell of this grid at all -- in bounds, and on a
@@ -400,10 +401,12 @@ export function distanceMeters(a, b) {
  *  time (the const is bound long before any consumer runs). */
 export function levelFootprint(grid, z) {
     if (z === 0) {
+        const holes = GROUND_HOLES.get(grid);
         const out = [];
         for (let x = 0; x < grid.dims.x; x++) {
             for (let y = 0; y < grid.dims.y; y++)
-                out.push({ x, y, z: 0 });
+                if (!holes?.has(`${x},${y}`))
+                    out.push({ x, y, z: 0 });
         }
         return out;
     }
@@ -573,6 +576,8 @@ export function pathClimbSteps(grid, path) {
  *  cellExists needs but doesn't belong on the public IRoomGrid shape --
  *  associated by identity so callers never juggle it themselves. */
 const LEVEL_CELLS = new WeakMap();
+/** An outdoor area's holes, per grid (IGridSynthesisInput.holes). */
+const GROUND_HOLES = new WeakMap();
 const WALL_REGIONS = {
     north: (d) => ({ x0: 0, x1: d.x - 1, y0: 0, y1: 0 }),
     south: (d) => ({ x0: 0, x1: d.x - 1, y0: d.y - 1, y1: d.y - 1 }),
@@ -647,6 +652,8 @@ export function synthesizeGrid(input) {
         exitCells: new Map(), terrain: new Map(),
     };
     LEVEL_CELLS.set(grid, levelCells);
+    if (input.holes && input.holes.size > 0)
+        GROUND_HOLES.set(grid, input.holes);
     const exists = (c) => cellExists(grid, c, levelCells);
     const freeCellNear = (region, z) => {
         const candidates = [];
@@ -706,6 +713,11 @@ export function synthesizeGrid(input) {
             // a room's width away from.
             cell = nearestFreeOnWall(cell, wallSide, occupied, dims, exists);
         }
+        else if (authored && exists({ x: authored.x, y: authored.y, z: 0 }) && !occupied.has(key({ x: authored.x, y: authored.y, z: 0 }))) {
+            // A STAIR WHERE THE AUTHOR PUT IT (exit seed `cell`), on the
+            // ground level of the room, unless something already stands there.
+            cell = { x: authored.x, y: authored.y, z: 0 };
+        }
         else {
             // up/down (and anything exotic): no natural wall -- an open
             // z=0 cell near the centroid, same free-cell picker as unplaced
@@ -740,6 +752,28 @@ export function synthesizeGrid(input) {
         if (exists(approach))
             claim(approach);
     }
+    // --- AUTHORED SPOTS: exactly where the author put them. ---
+    //
+    // Player-built runs (2026-10-06: "real coordinates are a must"). A spot
+    // that carries its own cells takes them -- anchor first, the rest its
+    // footprint -- before anything is chosen for it. No rng is drawn here,
+    // so a room with no authored spot runs every pass below exactly as
+    // before, cell for cell. Doors and their approaches were claimed first
+    // and stay won: an authored cell on one is the audit's to report, not
+    // this pass's to move.
+    const fixed = new Set();
+    for (const spot of input.spots) {
+        if (spot.perch || !spot.cells || spot.cells.length === 0)
+            continue;
+        const cells = spot.cells.filter(c => exists(c));
+        if (cells.length === 0)
+            continue;
+        for (const c of cells)
+            claim(c);
+        grid.spotCells.set(spot.name, cells[0]);
+        grid.spotFootprints.set(spot.name, cells);
+        fixed.add(spot.name);
+    }
     // Seat each exit-serving spot, now that we know how many exits it
     // serves. ONE exit: the spot IS that doorway, so it takes the cell
     // (Mama Wu's "door" -> its east wall). SEVERAL: the spot is the hub
@@ -751,6 +785,8 @@ export function synthesizeGrid(input) {
     // directions also come off the stalls"). The doorways stay on their
     // own walls; the hub sits where all of them are plausibly reachable.
     for (const [spotName, served] of exitCellsBySpot.entries()) {
+        if (fixed.has(spotName))
+            continue; // the author already put it somewhere
         if (served.length === 1) {
             // FURNITURE BESIDE THE DOOR, NOT IN IT (XanDMPmRrbJQ8ta8e,
             // 2026-09-12: "the corner booth is right in front of the door
@@ -910,6 +946,9 @@ export function synthesizeGrid(input) {
             grid.spotFootprints.set(name, []);
             continue;
         }
+        // An authored spot already has the footprint its author drew.
+        if (fixed.has(name))
+            continue;
         if (name === OPEN_FLOOR_NAME || exitKeys.has(key(anchor))) {
             grid.spotFootprints.set(name, [anchor]);
             continue;
@@ -1036,7 +1075,12 @@ function placePerches(grid, input, base, levelCells, occupied, furnitureKeys) {
         const wanted = perch.place && SIDES.includes(perch.place) ? perch.place : undefined;
         const order = wanted ? [wanted, ...SIDES.filter(s => s !== wanted)] : SIDES;
         let cell;
-        for (const side of order) {
+        // AN AUTHORED LENS hangs exactly where its author put it, before any
+        // draw from this stream -- so authored perches move nothing else.
+        const fixedAt = perch.cells?.[0];
+        if (fixedAt && !taken.has(`${fixedAt.x},${fixedAt.y}`))
+            cell = { x: fixedAt.x, y: fixedAt.y };
+        for (const side of cell ? [] : order) {
             const free = wallCells(side).filter(c => usable(c.x, c.y));
             // Prefer clear of the claimed cells (an exit's approach, say) --
             // standing room under the lens -- but take what there is.
@@ -1230,6 +1274,8 @@ export function serializeRoomGrid(grid, roomName, plane) {
         vertical,
         terrain,
         levels,
+        // The ground's missing cells: what other rooms own (GROUND_HOLES).
+        ...(GROUND_HOLES.get(grid) ? { holes: [...GROUND_HOLES.get(grid)].map(k => { const [x, y] = k.split(',').map(Number); return { x, y }; }) } : {}),
         origin: plane?.origin,
         walls: plane?.walls,
     };

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

@@ -0,0 +1,50 @@
+import { NPC } from '../models/npc.js';
+/**
+ * SPIDERS: an NPC that starts the run jacked into a host (player-built
+ * runs, 2026-10-06; SR5 p.267-268, Data Trails p.168-169 -- marks and
+ * ownership belong to the persona). Not ice: a persona with a body, so
+ * NPC.isConstruct() leaves them out and they talk, hear and act like the
+ * person they are. The body slumps where they sat (planes.ts
+ * shellsInRoom) and is attackable there; one solid hit slams them back
+ * into it with dumpshock (p.229), exactly as for a runner.
+ *
+ * Seated at scene build, without the jack-in's narration: the run opens
+ * with them already in. The GATES are the jack-in's own (commands/
+ * jack.ts) -- a rig to ride, VR needs a DNI (p.222-223), a living
+ * persona is hot-sim only (p.250) -- in one function the factory and the
+ * authored audit both read, so the editor's fault and the boot agree.
+ */
+/** Why this NPC cannot be jacked in as asked, or undefined when they can. */
+export function spiderRefusal(npc, mode) {
+    if (npc.plane !== 'meat')
+        return `${npc.name} is not in the meat to jack in from.`;
+    const rig = npc.chooseRig();
+    if (!rig) {
+        if (!npc.isTechnomancer())
+            return `${npc.name} carries no cyberdeck or commlink to jack in on (p.222).`;
+        if (mode === 'cold')
+            return `${npc.name} rides a living persona, which is hot-sim only (p.250).`;
+        return undefined;
+    }
+    if (!npc.hasDirectNeuralInterface())
+        return `${npc.name} has no datajack or trode net -- VR needs a direct neural interface (p.222-223).`;
+    return undefined;
+}
+/** Seats the persona inside the host, the body slumped in its room. Returns the refusal when they cannot be. */
+export function seatSpider(scene, npc, host, mode) {
+    const refusal = spiderRefusal(npc, mode);
+    if (refusal)
+        return refusal;
+    npc.bodyRoom = npc.currentLocation;
+    npc.plane = 'matrix';
+    npc.simMode = mode;
+    npc.setActiveRig(npc.chooseRig());
+    npc.matrixPosition = { kind: 'host', host };
+    scene.addWorldEvent?.(`${npc.name} is jacked into ${host.name}.`, { plane: 'matrix' });
+    return undefined;
+}
+/** Every spider riding this host: NPC personas inside it with a body elsewhere. */
+export function spidersIn(scene, host) {
+    return scene.allActors.filter((a) => a instanceof NPC && a.plane === 'matrix' && !!a.bodyRoom && a.icKind === undefined && a.hostInside === host);
+}
+//# sourceMappingURL=spider.js.map

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

@@ -908,7 +908,13 @@ export function stepFrom(room, mover, direction, count) {
         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;
+            const inRect = next.x >= 0 && next.y >= 0 && next.x < grid.dims.x && next.y < grid.dims.y;
+            // A HOLE IS OFF THE EDGE TOO (room-grid.ts GROUND_HOLES): a cell of
+            // this area's rectangle that a building or another street owns. The
+            // plane decides it exactly as it decides past the rectangle -- a
+            // street's ground walks on (move.ts crossOutdoorSeam re-homes you),
+            // a building's floor or wall stops you.
+            const inBounds = inRect && (next.z !== 0 || cellOnGrid(grid, next));
             // Off the edge of an OUTDOOR room is just more street, unless the
             // plane says something is built there.
             if (!inBounds && openOutside(next)) {
@@ -2540,7 +2546,8 @@ export function describeSpotRoster(room, viewer) {
  *  - AN ASTRAL BARRIER. "Astral barriers block astral travel, and you
  *    might run into one before you realize that it's in your way" --
  *    Room.warded, the same flag the aura rules read. Both ways: a ward
- *    keeps you out, and it keeps you in.
+ *    keeps you out, and it keeps you in -- unless `wardStops` says this
+ *    form is its creator, or has just pressed through it (utilities/wards.ts).
  *
  * Returns WORLD cells, not room-local ones, because an astral form is
  * not in a room in the sense a body is -- it is at a point on the
@@ -2550,7 +2557,10 @@ export function describeSpotRoster(room, viewer) {
 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) {
+manaBarrierAt, 
+/** Does this warded room's ward stop THIS form (wards.ts wardHolds)?
+ *  Unset: every ward stops everyone. */
+wardStops) {
     /**
      * UP AND DOWN ARE DIRECTIONS OUT HERE (p.313-314: an astral form
      * "can move in any direction" and is "not limited by gravity").
@@ -2571,7 +2581,7 @@ manaBarrierAt) {
         if (owner === undefined)
             return undefined;
         const room = roomAt(owner);
-        return room?.warded === true ? room : undefined;
+        return room?.warded === true && (wardStops?.(room) ?? true) ? room : undefined;
     };
     let cur = from;
     let taken = 0;

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

@@ -1,4 +1,5 @@
 import { spotOf } from './spots.js';
+import { wallsBetween } from './district-plane.js';
 /**
  * SURVEILLANCE (player go 2026-08-24; canon-shaped, values engine-
  * adapted -- the RAG was down): facilities watch themselves. A room is
@@ -41,12 +42,70 @@ export function isWatched(room) {
 export function cameraMasterHost(rooms, room) {
     if (!isWatched(room))
         return undefined;
+    // An author who wired these lenses to a named host is obeyed.
+    if (room.camerasSlavedTo) {
+        const named = rooms[room.camerasSlavedTo] ?? Object.values(rooms).find(r => r.name === room.camerasSlavedTo);
+        if (named?.hasNode)
+            return named;
+    }
     if (room.hasNode)
         return room;
     // Deterministic pick, and the same set canSnoopFeeds treats as the
     // site network -- whichever host you own, you own these feeds.
     return Object.values(rooms).find(r => r.hasNode);
 }
+/**
+ * THE HOST ONE LENS IS SLAVED TO (user 2026-10-06: "I can have a camera
+ * outside every shop, and they should slave to the shop host, not the
+ * outdoor strip"). A lens an author wired to a named host answers to
+ * that host; every other lens answers to its room's master
+ * (cameraMasterHost). One room's lenses can therefore feed several hosts.
+ */
+export function lensMaster(rooms, room, cam) {
+    const named = (n) => (n ? (rooms[n] ?? Object.values(rooms).find(r => r.name === n)) : undefined);
+    const own = named(cam.masterHost);
+    if (own?.hasNode)
+        return own;
+    // BOLTED TO A BUILDING: that building's host.
+    const wall = named(cam.mountedOn);
+    const building = wall ? buildingHost(wall) : undefined;
+    if (building)
+        return building;
+    return cameraMasterHost(rooms, room);
+}
+/**
+ * THE HOST OF THE BUILDING A ROOM BELONGS TO (user 2026-10-06: "the 2nd
+ * story room can have a camera attached to the outside wall, as the host
+ * is on the first floor"): the room's own, else the nearest one through
+ * its inside doors and stairs -- never across open ground, which is a
+ * different building. Undefined when the whole building has none.
+ */
+export function buildingHost(room) {
+    const seen = new Set([room]);
+    let frontier = [room];
+    while (frontier.length > 0) {
+        const hit = frontier.find(r => r.hasNode);
+        if (hit)
+            return hit;
+        const next = [];
+        for (const r of frontier) {
+            for (const exit of r.exits.values()) {
+                const other = typeof exit.getOtherSide === 'function'
+                    ? exit.getOtherSide(r) : undefined;
+                if (!other || seen.has(other) || other.outdoors)
+                    continue;
+                seen.add(other);
+                next.push(other);
+            }
+        }
+        frontier = next;
+    }
+    return undefined;
+}
+/** An author named this lens's master -- on the lens or for its room. */
+function explicitMaster(rooms, room, cam) {
+    return cam.masterHost || cam.mountedOn || room.camerasSlavedTo ? lensMaster(rooms, room, cam) : undefined;
+}
 /**
  * DO THESE LENSES BROADCAST AT ALL (reporter's ruling 2026-09-17,
  * eJANPpm7qCaCAJBJw)?
@@ -75,6 +134,12 @@ export function cameraMasterHost(rooms, room) {
 export function camerasBroadcast(rooms, room) {
     if (!isWatched(room))
         return false;
+    if (room.camerasWireless !== undefined && !onPole(room))
+        return room.camerasWireless;
+    // Any lens that broadcasts (lensBroadcasts) puts the cluster on the air.
+    const cams = room.ensureCameras();
+    if (cams.length > 0)
+        return cams.some(c => lensBroadcasts(rooms, room, c));
     if (room.camerasWireless !== undefined)
         return room.camerasWireless;
     return !cameraMasterHost(rooms, room);
@@ -175,7 +240,7 @@ export function describeCamera(rooms, room, cam, viewer) {
     const where = `up under the ceiling on the ${cam.wall} wall, three metres off the floor`;
     if (cam.destroyed)
         return `The ${cam.name}, ${where}: smashed -- a cracked housing hanging off its cable. (${cam.summary()})`;
-    const knows = cam.knownOffBy.has(viewer.name) || canSnoopFeeds(rooms, room, viewer);
+    const knows = cam.knownOffBy.has(viewer.name) || canSnoopLens(rooms, room, cam, viewer);
     const state = knows && cam.bricked ? ' Bricked -- dead glass, though nothing shows it from down here.'
         : knows && cam.looped ? ' Looped -- it records an empty hallway for the house.'
             : cam.damage > 0 ? ' Chipped, still turning.' : '';
@@ -200,9 +265,26 @@ export function camerasLive(rooms, room) {
     // 2026-10-01): looped by Control Device, bricked by a Data Spike
     // (commands/disable.ts), or shot off the wall (commands/attack.ts).
     // One lens still recording is one lens too many.
+    //
+    // AND EACH LENS ANSWERS TO ITS OWN MASTER (lensMaster): cracking the
+    // shop's host blinds the lens slaved to it and not its neighbour.
     const cams = room.ensureCameras();
-    if (cams.length > 0 && !cams.some(c => c.working))
+    if (cams.length > 0)
+        return cams.some(c => lensLive(rooms, room, c));
+    return roomFeedsLive(rooms, room);
+}
+/** Is this one lens still recording for the house? */
+export function lensLive(rooms, room, cam) {
+    if (!cam.working)
         return false;
+    const master = explicitMaster(rooms, room, cam);
+    if (master)
+        return !master.hostCracked;
+    return roomFeedsLive(rooms, room);
+}
+/** The engine's default for lenses nobody wired: the room's own node, or
+ *  -- a hostless watched room riding the site network -- any host. */
+function roomFeedsLive(rooms, room) {
     if (room.hasNode)
         return !room.hostCracked;
     const hosts = Object.values(rooms).filter(r => r.hasNode);
@@ -230,12 +312,16 @@ export function liveFootage(rooms, camSeen) {
         const room = Object.values(rooms).find(r => r.name === name);
         if (!room || !camerasLive(rooms, room))
             continue;
-        const master = cameraMasterHost(rooms, room);
-        if (!master)
-            continue;
-        const list = byHost.get(master) ?? [];
-        list.push(room);
-        byHost.set(master, list);
+        // Each live lens's footage is on ITS master (lensMaster).
+        const cams = room.ensureCameras().filter(c => lensLive(rooms, room, c));
+        const masters = new Set(cams.length > 0 ? cams.map(c => lensMaster(rooms, room, c)) : [cameraMasterHost(rooms, room)]);
+        for (const master of masters) {
+            if (!master)
+                continue;
+            const list = byHost.get(master) ?? [];
+            list.push(room);
+            byHost.set(master, list);
+        }
     }
     let best;
     for (const [host, seen] of byHost) {
@@ -251,9 +337,108 @@ export function liveFootage(rooms, camSeen) {
 export function canSnoopFeeds(rooms, room, viewer) {
     if (!isWatched(room))
         return false;
+    const cams = room.ensureCameras();
+    if (cams.length > 0)
+        return cams.some(c => canSnoopLens(rooms, room, c, viewer));
+    return canSnoopRoom(rooms, room, viewer);
+}
+/** This lens answers to the viewer: its master cracked or marked by them. */
+export function canSnoopLens(rooms, room, cam, viewer) {
+    if (!isWatched(room))
+        return false;
+    const master = explicitMaster(rooms, room, cam);
+    if (master)
+        return master.hostCracked || (master.hostMarksBy.get(viewer.name) ?? 0) > 0;
+    return canSnoopRoom(rooms, room, viewer);
+}
+/** The engine's default: the room's own node, or any of the site's hosts. */
+function canSnoopRoom(rooms, room, viewer) {
     if (room.hasNode) {
         return room.hostCracked || (room.hostMarksBy.get(viewer.name) ?? 0) > 0;
     }
     return Object.values(rooms).some(r => r.hasNode && (r.hostCracked || (r.hostMarksBy.get(viewer.name) ?? 0) > 0));
 }
+/** THE LOWEST HOST RATING THAT RUNS CABLE UNDER A STREET (user ruling
+ *  2026-10-06; SR5 p.247 puts "local police" at Host Rating 5-6). A
+ *  pole camera -- one on an outdoor area, not on a building -- slaved to
+ *  a host below it must broadcast: nobody else hardlines a lamp-post. */
+export const POLE_HARDLINE_RATING = 5;
+/** A lens on an outdoor area: on a pole, not on a building. */
+export function onPole(room) {
+    return room.outdoors === true;
+}
+/**
+ * DOES THIS ONE LENS BROADCAST? A pole camera on a host below
+ * POLE_HARDLINE_RATING must (it cannot be hardlined); otherwise the
+ * room's own switch, else the default -- slaved means dark.
+ */
+export function lensBroadcasts(rooms, room, cam) {
+    const master = lensMaster(rooms, room, cam);
+    // HARDLINED when it is bolted to its own host's building; otherwise an
+    // outdoor lens is cabled only by a police-grade host.
+    const wall = cam.mountedOn ? (rooms[cam.mountedOn] ?? Object.values(rooms).find(r => r.name === cam.mountedOn)) : undefined;
+    const hardlined = !!wall && !!master && buildingHost(wall) === master;
+    if (onPole(room) && master && !hardlined && master.hostRating < POLE_HARDLINE_RATING)
+        return true;
+    if (room.camerasWireless !== undefined)
+        return room.camerasWireless;
+    return !master;
+}
+/**
+ * WHICH WORKING CAMERA SEES THIS ACTOR, IF ANY (user ruling 2026-10-06:
+ * "LOS only, no radius ... same rule everywhere. No LOS, no view").
+ * Canon gives a camera no range at all -- the sensor table's Camera row
+ * reads "--" (SR5 p.446) -- so there is none here: a live lens sees what
+ * it has a clear line to.
+ *
+ * - Indoors, a lens sees everyone in its own room.
+ * - Outdoors, a lens sees anyone on any outdoor area of the storey --
+ *   its own included -- with no wall between them on the plane (district-plane.ts wallsBetween) --
+ *   the pole on the corner watches the strip and the ground alike. A
+ *   building's walls hide its inside, and it never sees out.
+ *
+ * Plain Invisibility is a mana illusion and never fools a camera (SR5
+ * p.289-291); Improved Invisibility, which would, is not in the engine.
+ */
+export function cameraSeeing(rooms, actor) {
+    const where = actor.bodyRoom ?? actor.currentLocation;
+    if (!where)
+        return undefined;
+    const ownRoom = () => {
+        for (const cam of isWatched(where) ? where.ensureCameras() : []) {
+            if (lensLive(rooms, where, cam))
+                return { room: where, cam };
+        }
+        return undefined;
+    };
+    if (!onPole(where))
+        return ownRoom();
+    // Nowhere on the plane to draw a line from (a body left behind, or a
+    // runner not yet stood on a cell): the area's own lenses, as before.
+    const plane = where.scene?.ensurePlane();
+    const mine = plane?.placements.get(where.name.trim().toLowerCase());
+    const at = actor.atCell;
+    if (!plane || !mine || !at || actor.bodyRoom)
+        return ownRoom();
+    const me = { x: mine.origin.x + at.x, y: mine.origin.y + at.y, z: mine.origin.z + at.z };
+    for (const room of Object.values(rooms)) {
+        if (!onPole(room) || !isWatched(room))
+            continue;
+        const there = plane.placements.get(room.name.trim().toLowerCase());
+        if (!there || there.origin.z !== me.z)
+            continue;
+        const grid = room.ensureGrid();
+        for (const cam of room.ensureCameras()) {
+            if (!lensLive(rooms, room, cam))
+                continue;
+            const perch = grid?.spotCells.get(cam.perch);
+            if (!perch)
+                continue;
+            const lens = { x: there.origin.x + perch.x, y: there.origin.y + perch.y, z: there.origin.z };
+            if (wallsBetween(plane, lens, me) === 0)
+                return { room, cam };
+        }
+    }
+    return undefined;
+}
 //# sourceMappingURL=surveillance.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/use-target.js

@@ -4,7 +4,7 @@
  * `use` was inventory-only. With the puzzle mechanic removed and its
  * barriers becoming room-owned Devices, one verb now has to serve two
  * populations that were never in the same namespace: the gear in your
- * pack and the keypads, grates and wards bolted to the room.
+ * pack and the keypads and grates bolted to the room.
  *
  * That makes resolution a LADDER, and the order is the whole design.
  * Item lookup in this game is deliberately generous -- Inventory's

package/bundle/typescript/src/commands/game/sideQuest/utilities/verb-index.js

@@ -17,7 +17,7 @@ import { SPRITE_POWERS } from '../sprite-powers.js';
  * leave them stuck on a word that works.
  */
 export const HELP_CATEGORIES = [
-    { title: 'moving', entries: [['look'], ['go'], ['move', 'walk', 'approach'], ['fly'], ['run'], ['sprint'], ['climb', 'mantle', 'scale', 'clamber'], ['descend'], ['sit', 'kneel'], ['lie', 'prone'], ['stand'], ['follow'], ['unfollow'], ['map', 'exits'], ['search'], ['sneak']] },
+    { title: 'moving', entries: [['look'], ['go'], ['move', 'walk', 'approach'], ['fly'], ['run'], ['sprint'], ['climb', 'mantle', 'scale', 'clamber'], ['descend'], ['leap'], ['sit', 'kneel'], ['lie', 'prone'], ['stand'], ['follow'], ['unfollow'], ['map', 'exits'], ['search'], ['sneak']] },
     { title: 'gear', entries: [['inv', 'inventory'], ['equipment', 'eq'], ['take'], ['loot'], ['drop'], ['give'], ['store'], ['dumpster'], ['open'], ['close'], ['put'], ['equip'], ['unequip'], ['fit'], ['unfit'], ['brandish', 'draw'], ['holster'], ['reload'], ['use'], ['read']] },
     { title: 'combat', entries: [['attack'], ['kill'], ['quickdraw'], ['subdue', 'stun', 'knock'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['nudge'], ['surrender'], ['edge'], ['rest'], ['heal', 'firstaid', 'bandage', 'patch']] },
     // The party layer: everyone who walks (or flies, or manifests) at
@@ -30,7 +30,7 @@ export const HELP_CATEGORIES = [
     // entered like any other -- "mark jackpoint" takes its invitation
     // (utilities/invitations.ts), "enter jackpoint" walks in. The bare word is still
     // caught before the typo matcher (game.ts) so it cannot read as `jack`.
-    { title: 'matrix', entries: [['jack'], ['deck'], ['load'], ['unload'], ['hack'], ['force', 'brute', 'smash'], ['mark', 'marks'], ['unmark'], ['disable'], ['brick'], ['download'], ['upload'], ['transfer'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['pan'], ['wireless'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
+    { title: 'matrix', entries: [['jack'], ['deck'], ['load'], ['unload'], ['hack'], ['force', 'brute', 'smash'], ['mark', 'marks'], ['unmark'], ['disable'], ['brick'], ['download'], ['upload'], ['transfer'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['crack'], ['disarm'], ['pan'], ['wireless'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
     // The Emerged get their own shelf (player request: "there MUST be
     // resonance" -- matrix is the place, Resonance is the talent).
     // `sustain` shelves here and not under magic: the command is

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

@@ -0,0 +1,116 @@
+import { rollPool, formatRoll } from './dice.js';
+import { astralLimit } from './limits.js';
+import { pierces } from './barrier-geometry.js';
+/** Does this room's ward stop this form? Not its creator, and not the
+ *  form holding a pass it just pressed for. */
+export function wardHolds(room, actor) {
+    if (!room?.warded)
+        return false;
+    if (room.wardCreator !== undefined && room.wardCreator === actor.name)
+        return false;
+    return actor.wardPass !== room.name;
+}
+/** The ward an astral form crosses going from one room to another --
+ *  entering `to`'s, or leaving `from`'s -- or undefined. */
+export function wardBetween(from, to, actor) {
+    if (from === to)
+        return undefined;
+    if (wardHolds(to, actor))
+        return to;
+    if (wardHolds(from, actor))
+        return from;
+    return undefined;
+}
+/**
+ * PRESS THROUGH (p.316): Magic + Charisma [Astral] v. Force x 2. Any net
+ * hits and the form is through -- it holds a pass for THIS ward until
+ * the crossing is made. A breach is something the creator knows (p.357).
+ */
+export function pressThroughWard(scene, logger, actor, ward) {
+    const press = rollPool(actor.magic + actor.charisma, astralLimit(actor));
+    const hold = rollPool(ward.wardForce * 2);
+    const meta = `Press through the ward (p.316): Magic + Charisma ${formatRoll(press)} v. Force ${ward.wardForce} x 2 ${formatRoll(hold)}`;
+    if (press.hits - hold.hits <= 0) {
+        actor.performAction('is stopped by a ward', ward.name);
+        return { through: false, meta };
+    }
+    actor.wardPass = ward.name;
+    actor.performAction('presses through a ward', ward.name);
+    alertWard(scene, logger, ward, actor, 'breached');
+    return { through: true, meta };
+}
+/** Spend the pass once the crossing it bought is made. */
+export function spendWardPass(actor) {
+    actor.wardPass = undefined;
+}
+/**
+ * THE CREATOR KNOWS (p.316, p.357): "will know when it has been
+ * breached, attacked, or destroyed and will inform whoever is to be
+ * contacted in the protected organization". The site goes on alert the
+ * way a tripped device puts it there; a creator on site hears it.
+ */
+export function alertWard(scene, logger, ward, actor, how) {
+    scene.raiseAlarm(`the ward over ${ward.name} was ${how}`);
+    scene.addWorldEvent(`The ward over ${ward.name} was ${how} -- whoever raised it knows.`);
+    const creator = ward.wardCreator ? scene.getPlayers().find(p => p.name === ward.wardCreator) : undefined;
+    if (creator && creator !== actor) {
+        logger?.log(`Your ward over ${ward.name} has been ${how}${how === 'attacked' ? ` (${ward.wardDamage}/${ward.wardForce})` : ''} (p.316).`, { actor: creator.name });
+    }
+}
+/**
+ * HITTING A WARD from the astral (p.316, "Getting Around Mana Barriers"):
+ * the same unopposed shape as a mana barrier spell -- the attack's hits
+ * add to the DV, a DV that does not exceed Armor does nothing (p.197),
+ * the rest is resisted with Structure + Armor, both equal to the Force.
+ * Structure filled is a ward torn down, for the rest of the run.
+ */
+export function resolveWardStrike(scene, logger, attacker, ward) {
+    const world = [];
+    const meta = [];
+    const force = ward.wardForce;
+    const profile = attacker.getWeaponProfile();
+    const roll = rollPool(attacker.getAttackPool(), attacker.getAttackLimit(null));
+    meta.push(`Attack on the ward over ${ward.name} (unopposed, p.197): ${formatRoll(roll)}`);
+    attacker.sneaking = false;
+    if (roll.criticalGlitch) {
+        world.push(`${attacker.name} goes for the ward over ${ward.name} -- and it goes catastrophically wrong.`);
+        return { world, meta, destroyed: false };
+    }
+    const dv = profile.damage + roll.hits;
+    const ap = profile.armorPen ?? 0;
+    meta.push(`  DV ${profile.damage} + ${roll.hits} = ${dv} v. Armor ${force} (Force, p.316)`);
+    if (!pierces(dv, force, ap)) {
+        world.push(`${attacker.name} strikes the ward over ${ward.name} -- the lattice drinks it. Too weak to mark it (DV ${dv} against Armor ${force}, p.197).`);
+        alertWard(scene, logger, ward, attacker, 'attacked');
+        return { world, meta, destroyed: false };
+    }
+    const armor = Math.max(0, force + ap);
+    const soak = rollPool(force + armor);
+    const dealt = Math.max(0, dv - soak.hits);
+    meta.push(`  Resist: Structure ${force} + Armor ${armor}: ${formatRoll(soak)} -- ${dealt} box${dealt === 1 ? '' : 'es'} through`);
+    ward.wardDamage += dealt;
+    logger.write(`${attacker.name} dealt ${dealt} boxes to the ward over ${ward.name} (${ward.wardDamage}/${force}).`);
+    if (ward.wardDamage < force) {
+        world.push(`${attacker.name} strikes the ward over ${ward.name} -- ${dealt > 0 ? `${dealt} box${dealt === 1 ? '' : 'es'}` : 'it holds, unmarked'}. (${ward.wardDamage}/${force})`);
+        alertWard(scene, logger, ward, attacker, 'attacked');
+        return { world, meta, destroyed: false };
+    }
+    ward.warded = false;
+    ward.wardDamage = 0;
+    world.push(`${attacker.name} tears the ward over ${ward.name} apart -- the lattice frays to nothing, and the astral there is open ground.`);
+    alertWard(scene, logger, ward, attacker, 'destroyed');
+    scene.addWorldEvent(`${attacker.name} brought down the ward over ${ward.name}.`);
+    return { world, meta, destroyed: true };
+}
+/** End of a Combat Turn: every standing ward is whole again (p.316). */
+export function mendWards(rooms) {
+    const mended = [];
+    for (const r of rooms) {
+        if (!r.warded || r.wardDamage <= 0)
+            continue;
+        r.wardDamage = 0;
+        mended.push(r);
+    }
+    return mended;
+}
+//# sourceMappingURL=wards.js.map

package/package.json

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