@maka/maka-cli 5.386.0 → 5.389.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.386.0",
+  "version": "5.389.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/cast.js

@@ -6,10 +6,10 @@ import { rollPool, formatRoll, rollD6Total } from '../utilities/dice.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { describeFledTarget } from '../utilities/pursuit.js';
 import { crossPlaneRefusal } from '../utilities/planes.js';
-import { spotOf, ensureAtSpot, furnitureCells, standingOccupants } from '../utilities/spots.js';
+import { spotOf, ensureAtSpot, furnitureCells, standingOccupants, visibleActorsIn, concealedFrom } from '../utilities/spots.js';
 import { key as gridKey, METERS_PER_CELL, distanceMeters, line3D } from '../utilities/room-grid.js';
 import { isSolid, isVoid, roomAtCell, wallsBetween } from '../utilities/district-plane.js';
-import { DIRECTIONAL_WALL_FORCE, DOME_FORCE, forceForWall, buildBarrier, clipFaces, formatCoord, isCoordToken, parseCoord, planDirectionalWall, planDome, planWall, FACE_LABEL, allBreached, damageFace, pierces } from '../utilities/barrier-geometry.js';
+import { DIRECTIONAL_WALL_FORCE, DOME_FORCE, forceForWall, buildBarrier, clipFaces, formatCoord, isCoordToken, parseCoord, planDirectionalWall, planDome, planWall, FACE_LABEL, BARRIER_FOG, allBreached, damageFace, pierces } from '../utilities/barrier-geometry.js';
 import { NPC } from '../models/npc.js';
 import { spellFor, catalogSpells } from '../utilities/catalog.js';
 import { getAspect } from '../aspects.js';
@@ -91,6 +91,11 @@ const COMBAT_SPELL_FLAVOR = {
  * inherited from BypassCommand -- now gated on actually having magic gear,
  * instead of being a free-floating coin flip anyone could attempt.
  */
+/**
+ * BLIND FIRE (p.178): "the same as the Total Darkness modifier", -6 -- the
+ * number p.197 gives for a target completely hidden from the attacker.
+ */
+const BLIND_FIRE = -6;
 export class CastCommand extends BypassCommand {
     static verb = 'cast';
     /** Touches another actor: authorized per-act for AI-driven actors
@@ -99,6 +104,8 @@ export class CastCommand extends BypassCommand {
     static description = 'Cast a spell you know, at a FORCE you choose: "cast manabolt 8 at <target>" (default Force = your Magic; drain scales with it, and OVERCASTING past your talent makes the drain PHYSICAL). "spells" lists what you know. Barriers take map coordinates: "cast barrier 3 3,4 3,6" (a wall), "cast barrier 3 5,5" (a dome), "cast barrier east 2". Area spells too: "cast fireball 4 at 12,7" (a point) or "cast fireball 4 at <someone>" -- Force m around it, friend and foe. A ward is "dispel <direction>".';
     deviceKind = 'ward';
     verbName = 'cast';
+    /** The bolt in flight is at someone the caster cannot see (castCombatSpell). */
+    unseenTarget = false;
     noDeviceMessage = "There's nothing here to cast at.";
     /** Backlash drain when a ward-bypass fails -- resisted with Willpower,
      * like any drain. The nastiest drain in the game: forcing a hostile
@@ -520,9 +527,10 @@ export class CastCommand extends BypassCommand {
         }
         const armor = target.plane === 'meat' ? target.getArmorValue() : 0;
         const modifiedArmor = Math.max(0, armor - force);
+        const blind = this.unseenTarget ? BLIND_FIRE : 0;
         return {
-            label: label(force) + (weave ? ` -- through a Force ${weave} mana barrier` : ''),
-            pool: this.actor.getMagicPool() + this.actor.consumeEdgeBoost(),
+            label: label(force) + (weave ? ` -- through a Force ${weave} mana barrier` : '') + (blind ? ` -- thrown BLIND (${blind}, p.178)` : ''),
+            pool: Math.max(0, this.actor.getMagicPool() + this.actor.consumeEdgeBoost() + blind),
             damageBase: force,
             soakPool: Math.max(0, target.getSoakPool() - armor + modifiedArmor) + through,
             modifiedArmor: target.plane === 'meat' ? modifiedArmor : undefined,
@@ -623,6 +631,16 @@ export class CastCommand extends BypassCommand {
         if (target.isIncapacitated()) {
             return `${target.name} is already down. The fight is over.`;
         }
+        // LINE OF SIGHT (p.281, p.283). Seeing them is the one question
+        // visibleActorsIn answers for the map and `look`: on a plane you
+        // perceive and not hidden in cover. A DIRECT spell needs it -- it
+        // reaches through your own sight, with nothing to aim but that. An
+        // INDIRECT one only needs "a clear line of fire": you can throw it
+        // blind, at the Blind Fire penalty (p.178; -6, p.197).
+        this.unseenTarget = !visibleActorsIn(room, this.actor).includes(target);
+        if (this.unseenTarget && spellFor(spellKey)?.soak !== 'armor') {
+            return `You can't see ${target.name} -- a ${spellKey} reaches through your own eyes, and they have nothing to fix on (LOS, p.281).${hint(' (An indirect spell can be thrown blind, at -6.)')}`;
+        }
         // One exchange at a time per combatant, same as attack.ts: the player
         // is refused cleanly, an NPC caster waits out the exchange and re-runs
         // (see CombatExchange.waitForLull and the rationale in attack.ts).
@@ -980,13 +998,17 @@ export class CastCommand extends BypassCommand {
         this.scene.addWorldEvent(`${actor.name} ${flavor.act} ${aimedAt} in ${room.name}.`);
         const lines = [];
         const meta = [];
-        const pool = actor.getMagicPool() + actor.consumeEdgeBoost();
+        // Seen through a Physical Barrier, the point is in Light Fog: -1 on
+        // the casting test (p.294, p.175). An indirect ball meets the barrier
+        // itself, below, so only a direct one pays this.
+        const fog = spell.soak !== 'armor' && this.scene.barrierOnLine?.(from, aim, 'physical') ? BARRIER_FOG : 0;
+        const pool = Math.max(0, actor.getMagicPool() + actor.consumeEdgeBoost() + fog);
         const roll = rollPool(pool, force);
         const header = `${actor.name} casts ${spellKey} at Force ${force}${overcast ? ' (OVERCAST)' : ''}, ${this.castingLabel()}, at ${aimedAt}`;
         const hurt = [];
         if (spell.soak !== 'armor') {
             // ---- DIRECT: one test, opposed by each target it can see. ----
-            meta.push(`${header}: casting ${formatRoll(roll)}`);
+            meta.push(`${header}: casting ${formatRoll(roll)}${fog ? ` (${fog} through a force barrier, Light Fog p.175)` : ''}`);
             lines.push(`${header} -- ${force} m of ${spell.type === 'mana' ? 'raw mana' : 'force'} around ${aimedAt}.`);
             const caught = everyone.filter(a => {
                 const c = this.scene.worldCellOf?.(a);
@@ -994,7 +1016,12 @@ export class CastCommand extends BypassCommand {
                     return false;
                 // "...that you can see" (p.281): your own body counts; others must
                 // be perceived and in plain sight of you.
-                return a === actor || (actor.canPerceive(a) && this.inSight(plane, from, c));
+                // Hidden in cover is not seen either (visibleActorsIn's rule).
+                if (a === actor)
+                    return true;
+                if (!actor.canPerceive(a) || !this.inSight(plane, from, c))
+                    return false;
+                return a.currentLocation !== room || !concealedFrom(room, actor, a);
             });
             if (caught.length === 0)
                 lines.push(`  The spell washes over empty ground.`);

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

@@ -43,6 +43,18 @@ const DRIFT_WAYS = new Set([
     Direction.NORTH, Direction.SOUTH, Direction.EAST, Direction.WEST,
     Direction.UP, Direction.DOWN,
 ]);
+/**
+ * IS THIS DOOR LOCKED TO SOMEONE LEAVING `from`. A tenant lock
+ * (Game.lockForeignResidences) is a flat's deadbolt: it keeps the street
+ * out and opens from inside, so nobody standing in the flat -- a save
+ * made there before the lock existed, a runner who breached in -- is
+ * shut in by it.
+ */
+function lockedFrom(door, from) {
+    if (!door.checkIfLocked())
+        return false;
+    return !(door.tenantLocked && from.residenceTier !== undefined);
+}
 export class GoCommand extends Command {
     /**
      * WHICH PLANE A COMPANION CAN HEEL ON, one rule per kind.
@@ -738,7 +750,7 @@ export class GoCommand extends Command {
             const way = wayOut(currentRoom, direction, here);
             const plane = way?.kind === 'seam' ? this.scene?.ensurePlane?.() : undefined;
             const at = plane?.placements.get(roomKey(currentRoom.name));
-            const gated = exit instanceof Door && exit.checkIfLocked();
+            const gated = exit instanceof Door && lockedFrom(exit, currentRoom);
             if (way?.kind === 'seam' && at && here && !gated) {
                 const world = { x: at.origin.x + way.door.x, y: at.origin.y + way.door.y, z: at.origin.z + way.door.z };
                 const there = plane.placements.get(roomKey(way.target.name));
@@ -772,7 +784,7 @@ export class GoCommand extends Command {
         // crossExit). Asked BEFORE the walk: the bolt is visible from
         // across the room, and a runner told about it here is not made to
         // cross the floor to hear it.
-        if (exit instanceof Door && exit.checkIfLocked() && this.actor.plane === 'meat') {
+        if (exit instanceof Door && lockedFrom(exit, currentRoom) && this.actor.plane === 'meat') {
             this.actor.performAction('is prevented by locked door', currentRoom.name);
             // NAME THE ROUTE (blocker 2026-08-27). This is FIRST CONTACT --
             // what a player types before they know a barrier is even there
@@ -815,7 +827,7 @@ export class GoCommand extends Command {
      */
     async crossExit(exit, direction, currentRoom, crossNote) {
         if (exit instanceof Door) {
-            if (exit.checkIfLocked() && this.actor.plane === 'meat') {
+            if (lockedFrom(exit, currentRoom) && this.actor.plane === 'meat') {
                 this.actor.performAction('is prevented by locked door', currentRoom.name);
                 return `${crossNote}The door in the direction "${direction}" is locked.${lockedRouteHint(currentRoom, direction, exit)}`;
             }

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

@@ -109,7 +109,16 @@ export class RestCommand extends Command {
         // lifestyleChoices residence against the rooms the seed provides.
         // It answers "may someone of this tier live in this scene", never
         // "is this particular room your bedroom".
-        const isResidence = room.roomType?.toLowerCase() === 'residence';
+        //
+        // AND A BED IS YOURS OR IT IS NOT A BED (kL23W3ufgsF5MZ2bt). "The
+        // roomType of _homeRoom and of nothing else" stopped being true when
+        // every district above Tacoma authored its own residence: a Street
+        // runner visiting Everett slept in Mill Court Flats on somebody
+        // else's lease. A residence a district authors FOR A TIER is the
+        // tenant's and nobody else's; any other Residence room (the runtime
+        // hole, a bench's `home` fixture) keeps the room-type answer.
+        const foreignFlat = room.residenceTier !== undefined && room !== this.game?.homeRoom;
+        const isResidence = room.roomType?.toLowerCase() === 'residence' && !foreignFlat;
         if (actor.stunTaken === 0 && actor.damageTaken === 0 && damagedDevices.length === 0 && damagedDrones.length === 0 && damagedImplants.length === 0) {
             // Nothing to heal -- but sleeping is its own point now (needs
             // system: edge refills only fed-and-slept, see Game.

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

@@ -83,6 +83,23 @@ export class TravelCommand extends Command {
             return `The driver takes the ${charge.paid} you have and doesn't ask twice.`;
         return `The fare takes its ${fare}.`;
     }
+    /**
+     * A CAB TAKES BODIES (6pdp3ELhsT8ihgtwH: "when using travel while
+     * projecting, my body is moved to the district, and am no longer
+     * projecting -- and when I return there is a duplicate body"). The
+     * ride moved the whole runner while the form was out, and bodyRoom
+     * kept a flesh in the room it had just left. call.ts's taxi has always
+     * refused off the meat plane; the ride across the sprawl is the same
+     * cab, so it asks the same question.
+     */
+    offPlaneRefusal() {
+        switch (this.actor.plane) {
+            case 'astral': return `Cabs take bodies, not ghosts -- "return" first.`;
+            case 'matrix': return `Cabs take bodies, not personas -- "jack out" first.`;
+            case 'drone': return `Your body is slumped where you left it and the frame can't hail a cab -- "jump out" first.`;
+            default: return undefined;
+        }
+    }
     async execute(args = []) {
         const game = this.game;
         // "travel to the safehouse" is "travel safehouse" (player 2026-09-25:
@@ -113,6 +130,9 @@ export class TravelCommand extends Command {
             if (!goingHome && destination === undefined) {
                 return `Nowhere called "${wanted}" that a cab will take you.${hint(' ("travel" on its own lists the districts; "travel home" leaves.)')}`;
             }
+            const offPlane = this.offPlaneRefusal();
+            if (offPlane)
+                return offPlane;
             if (!game.onLeaveSpaceRequested)
                 return `The door sticks -- the way home is not answering. Try again in a moment.`;
             if (inLiveCombat(this.scene, this.actor))
@@ -173,6 +193,9 @@ export class TravelCommand extends Command {
                 return `No crew, no table -- seat a table or take a seat first.${hint(' ("crew invite <runner>", or accept an invite.)')}`;
             if (!this.scene.isHumanControlled(this.actor))
                 return `The crew's table is for the crew, not the help.`;
+            const offPlane = this.offPlaneRefusal();
+            if (offPlane)
+                return offPlane;
             if (game.hasOpenRun)
                 return `Not with a job left open -- finish it or walk out first.`;
             if (inLiveCombat(this.scene, this.actor))
@@ -251,6 +274,9 @@ export class TravelCommand extends Command {
                 ? `You are home.`
                 : `You are already in ${districts.find(d => d.id === targetId)?.label ?? targetId}.`;
         }
+        const offPlane = this.offPlaneRefusal();
+        if (offPlane)
+            return offPlane;
         // THE FARE IS READ OFF BOTH ENDS, so it has to be computed before the move
         // -- afterwards `districtId` is the destination and the origin is gone.
         const hereRating = game.districtPressure?.neighborhood;

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

@@ -3380,5 +3380,21 @@
 // - A mana barrier between adds its Force to defence/soak; a physical
 //   barrier stops an indirect spell, which hits the face instead.
 // - Fireball drains F - 1 (catalog v36).
-export const ENGINE_VERSION = '1.198.0';
+// 1.199.0 (2026-10-05): SPELLS NEED SIGHT (p.281, p.283, p.178). A
+//   direct bolt at someone the caster cannot see -- off their plane or
+//   hidden in cover (visibleActorsIn) -- is refused before any drain; an
+//   indirect one flies blind at -6 (Blind Fire). Direct area spells pass
+//   over anyone hidden in cover inside them.
+// 1.200.0 (2026-10-05): A PHYSICAL BARRIER IS LIGHT FOG (p.294): a spell
+//   or ranged attack whose line crosses a standing face is at -1, the
+//   Light Fog row of the Environmental Modifiers table (p.175; confirmed
+//   against the rules index and SR5 references online). Melee is exempt.
+// 1.201.0 (2026-10-05): A CAB TAKES BODIES (6pdp3ELhsT8ihgtwH): `travel`
+//   refuses a runner who is projecting, jacked in or jumped in, as `call
+//   taxi` always has -- the ride moved the form and left a body behind.
+//   SOMEBODY ELSE'S FLAT IS LOCKED (kL23W3ufgsF5MZ2bt): an authored
+//   residence that is not the runner's home has its street door locked
+//   (Game.lockForeignResidences; opens from inside), and `rest` counts
+//   only the runner's own home as a bed.
+export const ENGINE_VERSION = '1.201.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -3522,6 +3522,7 @@ export default class Game {
         // cosmetics below, ask whether this district authors a building for
         // the tier now being paid for, and move house if it does.
         this.rebindHomeForTier();
+        this.lockForeignResidences();
         /**
          * AN AUTHORED RESIDENCE IS THE SEED'S, NOT THE TIER TABLE'S.
          *
@@ -3634,6 +3635,50 @@ export default class Game {
         return Object.values(this.scene?.getRooms?.() ?? {})
             .find(r => r.residenceTier === this.lifestyle.name);
     }
+    /**
+     * SOMEBODY ELSE'S FLAT IS LOCKED (kL23W3ufgsF5MZ2bt: "I'm able to enter
+     * and use an apartment for a lifestyle I don't pay for").
+     *
+     * Every district above Tacoma authors one residence, for its own tier,
+     * and that room used to stand open to anyone on the street: a Street
+     * runner visiting Everett walked into Mill Court Flats and slept in its
+     * bed. The address is the lease's, so the door is locked to everyone
+     * but its tenant -- and unlocked again the day the lease is theirs.
+     * Only the locks this put on are ever lifted: a door a seed or a device
+     * locked keeps its own reasons.
+     *
+     * Breaking in is still a way in (breach); this is a lock, not a wall.
+     */
+    lockForeignResidences() {
+        const rooms = Object.values(this.scene?.getRooms?.() ?? {});
+        for (const room of rooms) {
+            if (room.residenceTier === undefined)
+                continue;
+            const ours = room === this._homeRoom;
+            const doors = new Set();
+            for (const r of rooms) {
+                for (const ex of r.exits.values()) {
+                    if (ex instanceof Door && (ex.roomA === room || ex.roomB === room))
+                        doors.add(ex);
+                }
+            }
+            for (const door of doors) {
+                // YOUR OWN DOOR: lifted whether or not this session put the lock
+                // on -- a hub overlay restores isLocked but not the flag, so a
+                // flat locked on a visit and moved into later would otherwise
+                // come back shut on its tenant. Keyed and device-held locks are
+                // the seed's, and stay.
+                if (ours && door.isLocked && !door.heldBy && (door.tenantLocked || !door.unlockItemOrSolution)) {
+                    door.isLocked = false;
+                    door.tenantLocked = false;
+                }
+                else if (!ours && !door.isLocked && !door.heldBy) {
+                    door.isLocked = true;
+                    door.tenantLocked = true;
+                }
+            }
+        }
+    }
     rebindHomeForTier() {
         const current = this._homeRoom;
         if (current === undefined)
@@ -5750,6 +5795,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         this.gangedRooms.clear();
         this.peopledRooms.clear();
         this.patrolledRooms.clear();
+        // Arrived in a district with somebody else's flat on it (or your own).
+        this.lockForeignResidences();
         const arrivalLines = this.unfoldCompanionsOnArrival();
         this.repaintForScene();
         this.refreshLogLabel();
@@ -6450,6 +6497,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // everything stored since.
         const world = elsewhere ? this._hubArchive[here] : save.hub;
         applyHubOverlay(this.scene, world ? { ...world, home: save.hub.home } : save.hub, this.player, this._homeRoom, here);
+        // The overlay restores door locks; whose flat is whose is decided now.
+        this.lockForeignResidences();
         this._homeDistrictId = save.game.homeDistrictId;
         this._birthDistrictId = save.game.birthDistrictId;
         this._tier = save.game.tier;

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

@@ -8,6 +8,10 @@ export class Door extends AbstractDoor {
     unlockItemOrSolution;
     /** Set when a Device holds this door shut -- see IDoorHolder. */
     heldBy;
+    /** Locked because it is the street door of a residence that is not the
+     *  runner's own (Game.lockForeignResidences) -- the lock that lifts the
+     *  day the lease is theirs. */
+    tenantLocked;
     logger;
     isLockable;
     constructor(config) {

package/bundle/typescript/src/commands/game/sideQuest/utilities/barrier-geometry.js

@@ -35,6 +35,11 @@ export function forceForWall(a, b) {
 }
 /** The directional wall is three cells across: Force 3. */
 export const DIRECTIONAL_WALL_FORCE = 3;
+/**
+ * Seeing through a Physical Barrier: "equivalent to Light Fog" (p.294),
+ * the Light Fog row of the Environmental Modifiers table -- -1 (p.175).
+ */
+export const BARRIER_FOG = -1;
 /** A dome with no Force named rises one full 3 m storey: Force 3. */
 export const DOME_FORCE = METERS_PER_LEVEL;
 /**

package/bundle/typescript/src/commands/game/sideQuest/utilities/combat-exchange.js

@@ -1,4 +1,4 @@
-import { allBreached, damageFace, penetrationBoxes, pierces } from './barrier-geometry.js';
+import { allBreached, damageFace, penetrationBoxes, pierces, BARRIER_FOG } from './barrier-geometry.js';
 import { recoilCompensation, recoilPenalty } from './recoil.js';
 import { Category } from '../types/shared/item-enum.js';
 import { crashIC } from './ic-actors.js';
@@ -648,6 +648,20 @@ export class CombatExchange {
         const spatial = isMelee ? { meters: 0 } : this.spatialContext(attacker, defender);
         const weaponClass = strike.weaponItem?.isFirearm() ? classifyWeapon(strike.weaponItem) : undefined;
         const range = weaponClass ? rangePenalty(spatial.meters, weaponClass) : 0;
+        // THROUGH A PHYSICAL BARRIER (p.294: it is "equivalent to Light Fog"
+        // and impedes spellcasting only by visibility): the Light Fog row of
+        // the Environmental Modifiers table, -1 (p.175), on a ranged attack or
+        // a spell whose line crosses a standing face. Melee never reaches
+        // through one. Only the worst condition counts (p.173), and this is
+        // the only environmental condition the engine models, so it stands
+        // alone.
+        let fog = 0;
+        if (!isMelee) {
+            const a = this.scene.worldCellOf?.(attacker);
+            const d = this.scene.worldCellOf?.(defender);
+            if (a && d && this.scene.barrierOnLine?.(a, d, 'physical'))
+                fog = BARRIER_FOG;
+        }
         const rangeMod = range === 'out-of-range' ? -6 : range;
         // p.190 grants the bonus to a defender who "uses a Take Cover
         // action" -- so the dice follow the ACTION, not the address.
@@ -692,7 +706,7 @@ export class CombatExchange {
         // charging, a running defender, surprise, Full Defense and the
         // dodge/block/parry interrupts -- see turnModifiers below.
         const turn = this.turnModifiers(attacker, defender, isMelee, strike, meta);
-        const attack = rollPool(strike.pool + directed + rangeMod + attackerFloor + targetDown + turn.attack + recoil, attackLimit);
+        const attack = rollPool(strike.pool + directed + rangeMod + attackerFloor + targetDown + turn.attack + recoil + fog, attackLimit);
         // A DIRECT SPELL IS NOT DODGED (p.283): the target opposes the
         // casting test with Body or Willpower, and only counterspelling (and
         // a teammate's inspiration) helps -- not cover, posture, surprise or
@@ -708,7 +722,7 @@ export class CombatExchange {
         const recoilNote = recoil < 0 && strike.weaponItem
             ? ` (${recoil} recoil -- round ${attacker.recoilRoundsFired} against RC ${recoilCompensation(attacker, strike.weaponItem)})`
             : '';
-        meta.push(`  Attack:  ${formatRoll(attack)}${directed > 0 ? ` (+${directed} directed)` : ''}${rangeNote}${recoilNote}`);
+        meta.push(`  Attack:  ${formatRoll(attack)}${directed > 0 ? ` (+${directed} directed)` : ''}${rangeNote}${recoilNote}${fog ? ` (${fog} through a force barrier, Light Fog p.175)` : ''}`);
         const coverNote = coverDice > 0 ? ` (+${coverDice} cover -- the ${spotOf(defender)})` : '';
         meta.push(`  Defense: ${formatRoll(defense)}${inspired > 0 ? ` (+${inspired} inspired)` : ''}${counterspell > 0 ? ` (+${counterspell} counterspell${counterspellSource ? ` -- ${counterspellSource}'s cover` : ''})` : ''}${coverNote}`);
         const dryWarning = strike.weaponItem?.isFirearm() && strike.weaponItem.ammo === 0

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

@@ -1643,6 +1643,10 @@ export function lockSeenFromOutside(building, side, door) {
         return ` ${device.name} holds it, and it is worked from inside.`;
     if (door.heldBy)
         return ` It's barred from ${door.heldBy.room} -- ${door.heldBy.device} is in there.`;
+    // SOMEBODY'S FLAT (kL23W3ufgsF5MZ2bt): a residence that is not yours
+    // is locked to you; Game.lockForeignResidences put the lock on.
+    if (door.tenantLocked)
+        return ` Somebody's flat -- the lease on it isn't yours, and neither is the key.`;
     if (door.unlockItemOrSolution)
         return ` It's keyed -- it takes ${door.unlockItemOrSolution}, from inside.`;
     return ` Bolted from the inside -- nothing on this side of it to work.`;

package/package.json

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