@maka/maka-cli 5.383.0 → 5.385.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.383.0",
+  "version": "5.385.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/attack.js

@@ -6,9 +6,11 @@ import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { describeFledTarget } from '../utilities/pursuit.js';
 import { shellsInRoom, resolveBodyAttack, crossPlaneRefusal } from '../utilities/planes.js';
 import { heldBy, holding } from '../utilities/grapple.js';
-import { spotOf, ensureAtSpot, ensureAtExit, canReach, spotDistanceMeters, OPEN_FLOOR, inMeleeReach, actorCell, standingRoomNear, spotForCell } from '../utilities/spots.js';
+import { spotOf, ensureAtSpot, ensureAtExit, canReach, spotDistanceMeters, OPEN_FLOOR, inMeleeReach, actorCell, standingRoomNear, spotForCell, ADJACENT_METERS } from '../utilities/spots.js';
 import { distanceMeters } from '../utilities/room-grid.js';
-import { resolveBarrierStrike, resolveCameraStrike } from '../utilities/barrier-combat.js';
+import { wallsBetween } from '../utilities/district-plane.js';
+import { formatCoord, parseCoord } from '../utilities/barrier-geometry.js';
+import { resolveBarrierStrike, resolveCameraStrike, resolveSpellBarrierStrike } from '../utilities/barrier-combat.js';
 import { isWatched, cameraWithinReach, cameraOutOfReach } from '../utilities/surveillance.js';
 import { matchesCameraName } from '../utilities/grid-names.js';
 import { billAction, notYourPhase, phaseHint } from '../utilities/action-cost.js';
@@ -48,7 +50,7 @@ export class AttackCommand extends Command {
     async readyForStrike() {
         return {};
     }
-    static description = 'Attack someone in the room -- dice-pool combat with your equipped weapon. They WILL hit back. "attack <door>" shoots a barrier apart instead (unopposed; its Armor and Structure decide, p.197).';
+    static description = 'Attack someone in the room -- dice-pool combat with your equipped weapon. They WILL hit back. "attack <door>" shoots a barrier apart instead (unopposed; its Armor and Structure decide, p.197). "attack barrier [x,y]" breaks a face of a barrier spell.';
     async execute(args = []) {
         if (!args || args.length === 0) {
             return 'Who do you want to attack? Try: `attack <name>`';
@@ -159,6 +161,36 @@ export class AttackCommand extends Command {
                     return this.scene.isHumanControlled(this.actor) ? '' : lines.join('\n');
                 }
             }
+            // A BARRIER SPELL (2026-10-05; p.197-198, p.294, p.316): "attack
+            // barrier" hits the nearest standing face you can see, "attack
+            // barrier 3,5" the face holding that cell. A Physical Barrier is
+            // matter to the meat; a Mana Barrier is only there for the astral.
+            const spellWall = this.spellBarrierTarget(targetName);
+            if (spellWall) {
+                if ('refusal' in spellWall)
+                    return spellWall.refusal;
+                const held = this.actor.getCarriedWeapon();
+                if (this.scene.encounterFor?.(this.actor)) {
+                    if (held && !this.actor.weaponDrawn) {
+                        return `The ${held.name} is holstered -- "draw" it first (Ready Weapon, a Simple Action, SR5 p.165).`;
+                    }
+                    const bill = billAction(this.scene, this.actor, held?.isFirearm() ? 'simple' : 'complex', 'Attack Barrier', { attack: true });
+                    if (bill)
+                        return bill;
+                }
+                const drawn = this.scene.encounterFor?.(this.actor) ? null : this.actor.drawWeapon();
+                const strike = resolveSpellBarrierStrike(this.scene, this.logger, this.actor, spellWall.barrier, spellWall.face, room, {
+                    heat: (amount, why) => this.game?.addHeat(amount, why),
+                });
+                const lines = [...(drawn ? [`${this.actor.name} draws ${drawn.name}.`] : []), ...strike.world];
+                this.actor.performAction('attacks', `${spellWall.barrier.caster}'s barrier`);
+                this.scene.updateStatus();
+                if (strike.opened)
+                    this.scene.updateExits?.(room);
+                const exchange = new CombatExchange(this.scene, this.logger, this.actor);
+                await exchange.announce(lines, strike.meta);
+                return this.scene.isHumanControlled(this.actor) ? '' : lines.join('\n');
+            }
             // A BARRIER (2026-09-03; SR5 p.197-198): "attack <door>" shoots it
             // apart -- unopposed, AP against its Armor, Structure as its track.
             // Named the way pick/breach name it: the device's name, or the exit
@@ -569,5 +601,59 @@ export class AttackCommand extends Command {
         }
         return null;
     }
+    /**
+     * "barrier", "the force wall", "mana barrier 3,5" -> the standing face
+     * this actor would hit, or a refusal that says why not, or undefined
+     * when the words are not about a barrier spell at all (the door route
+     * and the "who?" answer come next).
+     */
+    spellBarrierTarget(words) {
+        const m = /^(?:the\s+)?(?:(mana|force|physical)\s+)?(?:barrier|wall)(?:\s+(?:at\s+)?(-?\d+,-?\d+(?:,-?\d+)?))?$/i.exec(words.trim());
+        if (!m)
+            return undefined;
+        const kind = this.actor.plane === 'astral' ? 'mana' : 'physical';
+        const all = this.scene.spellBarriers?.(kind) ?? [];
+        if (all.length === 0) {
+            // A door called "the wall" is still the door route's to answer.
+            if (m[1]?.toLowerCase() === 'mana' && kind === 'physical' && (this.scene.spellBarriers?.('mana').length ?? 0) > 0) {
+                return { refusal: `A mana barrier is woven mana -- your ${this.actor.getCarriedWeapon()?.name ?? 'fists'} would pass through it as if it were not there. Only the astral can touch it.` };
+            }
+            return undefined;
+        }
+        const plane = this.scene.ensurePlane?.();
+        const from = this.scene.worldCellOf?.(this.actor);
+        if (!plane || !from)
+            return { refusal: `You can't place yourself well enough to aim at a barrier from here.` };
+        const melee = !this.actor.getCarriedWeapon()?.isFirearm();
+        const reachable = (c) => wallsBetween(plane, from, c) === 0 && (!melee || distanceMeters(from, c) <= ADJACENT_METERS);
+        if (m[2]) {
+            const at = parseCoord(m[2], from.z);
+            const hit = this.scene.barrierAt(at, kind);
+            if (!hit)
+                return { refusal: `There's no standing barrier at ${formatCoord(at)}.` };
+            if (!reachable(at)) {
+                return { refusal: melee ? `${formatCoord(at)} is out of arm's reach -- close in, or bring a gun.` : `You can't see ${formatCoord(at)} from here.` };
+            }
+            return hit;
+        }
+        let best;
+        for (const barrier of all) {
+            for (const face of barrier.faces) {
+                if (face.breached)
+                    continue;
+                for (const c of face.cells) {
+                    if (!reachable(c))
+                        continue;
+                    const d = distanceMeters(from, c);
+                    if (!best || d < best.d)
+                        best = { barrier, face, d };
+                }
+            }
+        }
+        if (!best) {
+            return { refusal: melee ? `No barrier within arm's reach -- close in, or bring a gun.` : `No barrier face in sight from here.` };
+        }
+        return { barrier: best.barrier, face: best.face };
+    }
 }
 //# sourceMappingURL=attack.js.map

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

@@ -6,7 +6,10 @@ import { rollPool, formatRoll } 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 } from '../utilities/spots.js';
+import { spotOf, ensureAtSpot, furnitureCells, standingOccupants } from '../utilities/spots.js';
+import { key as gridKey, METERS_PER_CELL } 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 } from '../utilities/barrier-geometry.js';
 import { NPC } from '../models/npc.js';
 import { spellFor, catalogSpells } from '../utilities/catalog.js';
 import { getAspect } from '../aspects.js';
@@ -93,7 +96,7 @@ export class CastCommand extends BypassCommand {
     /** Touches another actor: authorized per-act for AI-driven actors
      *  (utilities/npc-authorization.ts, aCErAfvEW7G23FWDM). */
     static npcPolicy = 'authorized';
-    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. Bare "cast" tries to unweave a warded barrier.';
+    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". A ward is "dispel <direction>".';
     deviceKind = 'ward';
     verbName = 'cast';
     noDeviceMessage = "There's nothing here to cast at.";
@@ -205,16 +208,11 @@ export class CastCommand extends BypassCommand {
             return this.castSpell(spellName, words.slice(1));
         }
         // An AMBIGUOUS fragment ("cast stun ...", now that stunbolt and
-        // stunball both exist) used to fall silently into the ward-bypass
-        // path and answer with something about barriers. Name the choices
-        // instead -- but only for someone who can actually cast, so "cast
-        // north" still routes to the bypass.
+        // stunball both exist) names the choices rather than guessing.
         const near = this.spellsMatching(words?.[0]);
         if (near.length > 1 && this.actor.isCaster()) {
             return `Which one? ${near.join(', ')}.`;
         }
-        // Ward-bypass path (BypassCommand). Now that casting is a real, gated
-        // ability, throwing magic at a ward requires the talent or the gear.
         // ASPECTED TO ANOTHER GROUP (SR5 p.69): no Sorcery at all -- not even
         // through a formula or focus, which stand in for the SKILL, not the gift.
         if (this.actor.isAspected && !this.actor.canWorkSorcery()) {
@@ -223,7 +221,18 @@ export class CastCommand extends BypassCommand {
         if (!this.actor.isCaster()) {
             return `Casting takes talent you don't have -- you'd need to be Awakened, or have a spell formula, grimoire, or focus on you.`;
         }
-        return super.execute(args);
+        // "CAST <DIRECTION>" IS GONE (user ruling 2026-10-05): it used to
+        // unweave a ward on that exit, which is DISPEL's job and now only
+        // dispel's. A direction gets pointed at both verbs it might mean;
+        // anything else is not a spell this caster knows.
+        const first = words[0]?.toLowerCase();
+        if (!first) {
+            return `Cast what? "spells" lists what you know -- "cast <spell> [force] ...".`;
+        }
+        if (this.isValidDirection(first)) {
+            return `To unweave a ward that way, "dispel ${first}". To wall the way off, "cast barrier ${first} [cells]".`;
+        }
+        return `"${words.join(' ')}" isn't a spell you know. "spells" lists them; a ward is "dispel <it>".`;
     }
     /**
      * ONE REFUSAL FOR THE ASPECT, wherever it is reached from -- the
@@ -298,6 +307,7 @@ export class CastCommand extends BypassCommand {
         const spellDef = spellFor(spellName);
         const safeForce = this.actor.magic > 0 ? this.actor.magic : 4;
         let force = Math.max(1, -(spellDef?.drainOffset ?? -3));
+        let forceGiven = true;
         if (rest[0]?.toLowerCase() === 'force' && /^\d+$/.test(rest[1] ?? '')) {
             force = parseInt(rest[1], 10);
             rest = rest.slice(2);
@@ -306,6 +316,9 @@ export class CastCommand extends BypassCommand {
             force = parseInt(rest[0], 10);
             rest = rest.slice(1);
         }
+        else {
+            forceGiven = false;
+        }
         if (force < 1) {
             return `Force below 1 isn't a spell, it's a wish.`;
         }
@@ -326,7 +339,7 @@ export class CastCommand extends BypassCommand {
             case 'heal': return this.castHeal(force, overcast, rest);
             case 'armor': return this.castArmor(force, overcast, rest);
             case 'sustained-utility': return this.castSustainedUtility(spellName, force, overcast, rest);
-            case 'barrier': return this.castBarrier(spellName, force, overcast, rest);
+            case 'barrier': return this.castBarrier(spellName, force, overcast, rest, forceGiven ? undefined : safeForce);
         }
     }
     /**
@@ -964,16 +977,34 @@ export class CastCommand extends BypassCommand {
         return this.finishSpell(lines);
     }
     /**
-     * PHYSICAL BARRIER (ruling 2026-08-24): "cast barrier <direction>"
-     * seals that exit of the CURRENT room while sustained -- go.ts (and
-     * spot-crossing toward its doorway) refuses everyone, fleeing NPCs
-     * included, the caster too. Same toggle shape as armor: casting
-     * barrier again (any direction) releases the standing one first.
-     * One barrier per caster; -2 sustaining like every held weave.
+     * THE BARRIER SPELLS, CAST AT THE DISTRICT PLANE (SR5 p.294; user
+     * spec 2026-10-05). Coordinates are plane cells -- the numbers on the
+     * map rulers -- and the shape follows from how many points you give:
+     *
+     *   cast barrier [F] <x,y[,z]> <x,y[,z]>   a wall between two points
+     *   cast barrier [F] <x,y[,z]>             a dome around one point
+     *   cast barrier [F] <direction> [n]       a 1x3 wall n cells that way
+     *   cast barrier [F] at <someone> [size]   a dome around them ("me"/"self": you);
+   *                                          size = radius in cells = Force / 2
+     *   cast barrier [F]                       a dome around yourself
+     *   cast barrier off                       let it go (free)
+     *
+     * A wall is Force x 2 m long and Force m high; a dome is Force m in
+     * radius (barrier-geometry.ts). A Physical Barrier's Armor and
+     * Structure are its HITS; a Mana Barrier's are its Force (p.316). One
+     * of each per caster; casting again replaces the standing one, with a
+     * fresh roll and fresh drain. -2 sustaining like every held weave.
+     *
+     * Bare "cast north" no longer reaches a ward from here -- that is
+     * "dispel north" (user ruling 2026-10-05).
      */
-    async castBarrier(spellKey, force, overcast, rest) {
+    async castBarrier(spellKey, force, overcast, rest, 
+    /** Set when no Force was named: the talent a sized cast may reach. */
+    autoUpTo) {
         const actor = this.actor;
         const mana = spellKey === 'manabarrier';
+        const kind = mana ? 'mana' : 'physical';
+        const label = mana ? 'mana barrier' : 'barrier';
         if (actor.plane !== 'meat' && actor.plane !== 'astral') {
             return `Barriers are woven where the world is -- not from the grid.`;
         }
@@ -981,54 +1012,256 @@ export class CastCommand extends BypassCommand {
             return `A physical barrier needs physical hands -- come back to the meat.`;
         }
         const standing = mana ? actor.sustainedManaBarrier : actor.sustainedBarrier;
-        if (standing) {
+        const words = rest.map(w => w.trim()).filter(w => w.length > 0);
+        if (words.length === 1 && /^(off|release|drop|end)$/i.test(words[0])) {
+            if (!standing)
+                return `You aren't holding a ${label}.`;
             if (mana)
                 actor.sustainedManaBarrier = undefined;
             else
                 actor.sustainedBarrier = undefined;
             this.scene.updateStatus();
-            actor.performAction(`releases ${mana ? 'mana barrier' : 'barrier'} spell`, `${standing.direction} in ${standing.roomName}`);
-            if (rest.length === 0) {
-                return this.finishSpell([`You let the ${mana ? 'mana barrier' : 'barrier'} go -- the ${mana ? 'weave' : 'air'} ${standing.roomName === actor.currentLocation.name ? `across the way ${standing.direction}` : `in ${standing.roomName}`} ${mana ? 'unravels' : 'unhardens'}, and the sustaining burden lifts.`]);
-            }
-            // Fall through: a direction was named -- re-seat the wall there.
+            this.scene.updateExits?.(actor.currentLocation);
+            actor.performAction(`releases ${label} spell`, `in ${standing.roomName}`);
+            return this.finishSpell([`You let the ${label} go -- the ${mana ? 'weave unravels' : 'air unhardens'}, and the sustaining burden lifts.`]);
         }
         const room = actor.currentLocation;
-        const wanted = rest.join(' ').trim().toLowerCase();
-        if (!wanted) {
-            return `Seal which way? "cast ${spellKey} <direction>" -- exits here: ${[...room.exits.keys()].join(', ') || 'none'}.`;
+        const plane = this.scene.ensurePlane?.();
+        const from = this.scene.worldCellOf?.(actor);
+        if (!plane || !from) {
+            return `There's no ground here to raise a ${label} on.`;
         }
-        const direction = [...room.exits.keys()].find(d => d.toLowerCase() === wanted || d.toLowerCase().startsWith(wanted));
-        if (!direction) {
-            return `There's no way ${wanted} from here to seal. Exits: ${[...room.exits.keys()].join(', ') || 'none'}.`;
+        // WHAT SHAPE, AND WHERE.
+        let plan;
+        let around;
+        let center;
+        const usage = `"cast ${spellKey} [force] <x,y> <x,y>" (a wall), "cast ${spellKey} [force] <x,y>" (a dome), "cast ${spellKey} [force] <direction> [cells]", or "cast ${spellKey} at <someone|me> [radius in cells]". Leave the Force off and it is sized for you. The map rulers give x and y; you're at ${formatCoord(from)}.`;
+        const unseen = (what) => `You can't see ${what} from here -- a barrier is cast at what you can see (LOS, p.294).`;
+        if (words.length === 0) {
+            center = from;
+            around = 'you';
+            force = this.domeForce(force, autoUpTo);
+            plan = planDome(from, force);
         }
-        // Non-null: castSpell resolved the row and returned early if it
-        // could not, so every routine below is unreachable for a spell the
-        // catalog does not hold. The Record this replaced was typed as
-        // always-present and hid that; spellFor is honest about it.
+        else if (isCoordToken(words[0])) {
+            if (words.length > 2 || (words.length === 2 && !isCoordToken(words[1])))
+                return `Two points at most. ${usage}`;
+            const a = parseCoord(words[0], from.z);
+            if (words.length === 2) {
+                const b = parseCoord(words[1], from.z);
+                const sized = this.sizeForce(spellKey, force, forceForWall(a, b), autoUpTo);
+                if (typeof sized === 'string')
+                    return sized;
+                force = sized;
+                plan = planWall(a, b, force);
+                if (plan.error)
+                    return plan.error;
+                const hidden = [a, b].find(p => !this.inSight(plane, from, p));
+                if (hidden)
+                    return unseen(formatCoord(hidden));
+            }
+            else {
+                center = a;
+                force = this.domeForce(force, autoUpTo);
+                plan = planDome(a, force);
+                if (!this.inSight(plane, from, a))
+                    return unseen(formatCoord(a));
+            }
+        }
+        else if (this.isValidDirection(words[0].toLowerCase())) {
+            if (words.length > 2 || (words.length === 2 && !/^\d+$/.test(words[1]))) {
+                return `"cast ${spellKey} ${words[0]} [cells]" -- the distance is a whole number of cells.`;
+            }
+            const distance = words.length === 2 ? parseInt(words[1], 10) : 1;
+            const sized = this.sizeForce(spellKey, force, DIRECTIONAL_WALL_FORCE, autoUpTo);
+            if (typeof sized === 'string')
+                return sized;
+            force = sized;
+            plan = planDirectionalWall(from, words[0].toLowerCase(), distance, force);
+            if (plan.error)
+                return plan.error;
+            const run = plan.faces[0].cells;
+            const mid = run[Math.floor(run.length / 2)];
+            if (!this.inSight(plane, from, mid))
+                return unseen(`${distance} cell${distance === 1 ? '' : 's'} ${words[0]}`);
+        }
+        else {
+            const lead = words[0].toLowerCase();
+            let nameWords = lead === 'at' || lead === 'on' || lead === 'around' ? words.slice(1) : words;
+            // "at <someone> [size]" (user 2026-10-05): a trailing number is the
+            // dome's RADIUS in map cells. p.294 makes the radius the Force in
+            // metres, so the size IS a Force -- two cells is Force 4.
+            let size;
+            if (nameWords.length > 1 && /^\d+$/.test(nameWords[nameWords.length - 1])) {
+                size = parseInt(nameWords[nameWords.length - 1], 10);
+                nameWords = nameWords.slice(0, -1);
+            }
+            if (nameWords.length === 0)
+                return usage;
+            // "me" / "self" / "myself" are the caster (user 2026-10-05).
+            const selfWord = nameWords.length === 1 && /^(me|self|myself|yourself)$/i.test(nameWords[0]);
+            const candidates = this.scene.getActorsInRoom(room).filter(a => a === actor || ((a.plane === 'meat' || a.plane === actor.plane) && actor.canPerceive(a)));
+            const picked = selfWord ? actor.name : fuzzyPickName(nameWords.join(' '), candidates.map(a => a.name));
+            const target = selfWord ? actor : picked ? candidates.find(a => a.name === picked) : undefined;
+            if (!target)
+                return `You don't see "${nameWords.join(' ')}" here. ${usage}`;
+            const at = this.scene.worldCellOf?.(target);
+            if (!at)
+                return `${target.name} isn't standing anywhere a dome could go round.`;
+            if (target !== actor && !this.inSight(plane, from, at))
+                return unseen(target.name);
+            center = at;
+            around = target === actor ? 'you' : target.name;
+            if (size !== undefined) {
+                if (size < 1)
+                    return `A dome's size is its radius in cells, 1 or more.`;
+                const needed = Math.ceil(size * METERS_PER_CELL);
+                if (autoUpTo === undefined && needed !== force) {
+                    return `A dome's radius IS its Force in metres (p.294): ${size} cell${size === 1 ? '' : 's'} is Force ${needed}, not ${force}. Name one or the other.`;
+                }
+                const sized = this.sizeForce(spellKey, force, needed, autoUpTo, 'dome');
+                if (typeof sized === 'string')
+                    return sized;
+                force = sized;
+            }
+            else {
+                force = this.domeForce(force, autoUpTo);
+            }
+            plan = planDome(at, force);
+        }
+        if (plan.error)
+            return plan.error;
+        // CASTING IS A COMPLEX ACTION in a Combat Turn (p.167).
+        const bill = billAction(this.scene, actor, 'complex', `Cast ${label}`);
+        if (bill)
+            return bill;
+        // The standing one goes first: its cells must not clip the new one.
+        if (standing) {
+            if (mana)
+                actor.sustainedManaBarrier = undefined;
+            else
+                actor.sustainedBarrier = undefined;
+        }
+        // WHAT IT CANNOT STAND IN (barrier-geometry clipFaces).
+        const clipped = clipFaces(plan.faces, c => this.barrierCellOpen(plane, c, kind, center));
+        if (clipped.faces.length === 0) {
+            return `There's no room for a ${label} there -- every cell of it is ${mana ? 'earth or another weave' : 'wall, furniture or somebody'}.`;
+        }
+        // THE CASTING TEST: Magic + Spellcasting [Force] (p.281). Physical
+        // Barrier: Armor and Structure 1 per hit (p.294). Mana Barrier: the
+        // barrier's Armor and Structure are its Force (p.316).
+        const roll = rollPool(actor.getMagicPool(), force);
+        if (this.scene.isHumanControlled(actor))
+            this.logger.meta(`${mana ? 'Mana Barrier' : 'Physical Barrier'} casting: ${formatRoll(roll)}`);
         const spell = spellFor(spellKey);
-        const seat = { roomName: room.name, direction, force };
+        if (!mana && roll.hits === 0) {
+            actor.performAction(`casts ${label}`, 'and nothing holds');
+            const lines = [
+                `${actor.name} casts barrier at Force ${force}, ${this.castingLabel()}:`,
+                `  The air shivers and lets go -- no hits, no wall.`,
+                ...this.applyDrain(spell, force, overcast),
+            ];
+            lines.push(...await this.drainCollapse(new CombatExchange(this.scene, this.logger, this.actor)));
+            return this.finishSpell(lines);
+        }
+        const rating = mana ? force : roll.hits;
+        const barrier = buildBarrier(kind, actor.name, force, rating, room.name, plan.shape, clipped.faces);
         if (mana)
-            actor.sustainedManaBarrier = seat;
+            actor.sustainedManaBarrier = barrier;
         else
-            actor.sustainedBarrier = seat;
-        actor.performAction(`casts ${mana ? 'mana barrier' : 'barrier'}`, `sealing ${direction}`);
+            actor.sustainedBarrier = barrier;
+        const cells = barrier.faces.reduce((n, f) => n + f.cells.length, 0);
+        const first = barrier.faces[0].cells;
+        const where = plan.shape === 'dome'
+            ? `a dome of ${force} m radius around ${around ?? formatCoord(center)}`
+            : `a wall from ${formatCoord(first[0])} to ${formatCoord(first[first.length - 1])}`;
+        actor.performAction(`casts ${label}`, where);
         this.scene.addWorldEvent(mana
-            ? `${actor.name} wove a mana barrier across the way ${direction} in ${room.name}.`
-            : `${actor.name} raised a shimmering force barrier across the way ${direction} in ${room.name}.`);
+            ? `${actor.name} wove a mana barrier in ${room.name}.`
+            : `${actor.name} raised a shimmering force barrier in ${room.name}.`);
         this.scene.updateStatus();
+        // The panels draw it (room-view / map-view): repaint them now.
+        this.scene.updateExits?.(room);
         const burden = sustainBurden(actor.sustainedLedger().find(w => w.key === spellKey), ' to everything else you do');
+        const faces = barrier.faces.length > 1 ? ` ${barrier.faces.length} faces, each with its own damage track.` : '';
         const lines = [
-            `${actor.name} casts ${mana ? 'mana barrier' : 'barrier'} at Force ${force}, ${this.castingLabel()}:`,
+            `${actor.name} casts ${label} at Force ${force}, ${this.castingLabel()}:`,
+            ...(this.scene.isHumanControlled(actor) ? [] : [`  Casting: ${formatRoll(roll)}`]),
             mana
-                ? `  A lattice of woven mana settles across the way ${direction} -- invisible to meat eyes, Force ${force}. SPIRITS and astral forms stop at it; the living walk through without noticing. ${burden.charAt(0).toUpperCase()}${burden.slice(1)}.`
-                : `  The air itself hardens across the way ${direction} -- a faint heat-shimmer wall, Force ${force}. NOBODY passes while you hold it (you included), and ${burden}.`,
-            hint(`  (Cast ${spellKey} again to release it; "dispel ${mana ? 'mana barrier' : 'barrier'}" unweaves it from either side.)`),
+                ? `  A lattice of woven mana settles into ${where} -- ${cells} cell${cells === 1 ? '' : 's'}, invisible to meat eyes. Armor and Structure ${rating}.${faces} SPIRITS and astral forms stop at it; the living walk through without noticing, and so do you. ${burden.charAt(0).toUpperCase()}${burden.slice(1)}.`
+                : `  The air itself hardens into ${where} -- ${cells} cell${cells === 1 ? '' : 's'} of heat-shimmer. Armor and Structure ${rating} (${roll.hits} hit${roll.hits === 1 ? '' : 's'}).${faces} NOTHING physical passes while you hold it (you included), and ${burden}.`,
+            ...(plan.note ? [`  ${plan.note}`] : []),
+            ...(clipped.dropped > 0 ? [`  ${clipped.dropped} cell${clipped.dropped === 1 ? '' : 's'} of it ${mana ? 'stop at earth or another weave' : 'meet wall, furniture or a body and stop there'}.`] : []),
+            hint(`  ("cast ${spellKey} off" lets it go; "dispel ${mana ? 'mana barrier' : 'barrier'}" unweaves it from either side.)`),
             ...this.applyDrain(spell, force, overcast),
         ];
         lines.push(...await this.drainCollapse(new CombatExchange(this.scene, this.logger, this.actor)));
         return this.finishSpell(lines);
     }
+    /**
+     * NO FORCE NAMED: SIZE IT TO THE SHAPE (user 2026-10-05). A wall gets
+     * the least Force that raises it -- never less than the default, and
+     * never past your talent: overcasting turns the drain PHYSICAL (p.281),
+     * and that is a choice to make out loud, not one made for you.
+     */
+    sizeForce(spellKey, force, needed, autoUpTo, what = 'wall') {
+        // A wall only ever grows to fit; a sized dome IS its size.
+        if (autoUpTo === undefined || (what === 'wall' && needed <= force))
+            return force;
+        if (needed > autoUpTo) {
+            return `That ${what} needs Force ${needed}, past your talent (${autoUpTo}) -- name the Force to overcast it on purpose ("cast ${spellKey} ${needed} ..."; the drain lands PHYSICAL, p.281).`;
+        }
+        return needed;
+    }
+    /**
+     * A DOME WITH NO FORCE NAMED stands one storey: Force 3, a dome 3 m
+     * high (p.294: height = radius = Force m). Anything lower would not
+     * cover the person it is raised around. Never past your talent -- a
+     * caster with less Magic gets the tallest dome they can hold safely.
+     */
+    domeForce(force, autoUpTo) {
+        if (autoUpTo === undefined)
+            return force;
+        return Math.max(force, Math.min(DOME_FORCE, autoUpTo));
+    }
+    /** LINE OF SIGHT for an area spell's point (p.281): no wall between. */
+    inSight(plane, from, to) {
+        return wallsBetween(plane, from, to) === 0;
+    }
+    /**
+     * CAN A BARRIER CELL STAND HERE. Physical: not in a wall, not in the
+     * void, not in furniture or a body -- matter is already there. Mana:
+     * the astral is "unimpeded by material objects" (p.313), so only earth,
+     * a warded room you are not inside, and another mana barrier stop it.
+     * The one a dome is raised around is inside it, never in its way.
+     */
+    barrierCellOpen(plane, c, kind, center) {
+        if (center && c.x === center.x && c.y === center.y && c.z === center.z)
+            return true;
+        if (isVoid(plane, c))
+            return false;
+        const ownerKey = roomAtCell(plane, c);
+        const owner = ownerKey ? Object.values(this.scene.getRooms()).find(r => r.name.trim().toLowerCase() === ownerKey) : undefined;
+        if (kind === 'mana') {
+            if (owner?.warded && owner !== this.actor.currentLocation)
+                return false;
+            return !this.scene.barrierAt(c, 'mana');
+        }
+        if (isSolid(plane, c))
+            return false;
+        if (this.scene.barrierAt(c, 'physical'))
+            return false;
+        const place = ownerKey ? plane.placements.get(ownerKey) : undefined;
+        if (!owner || !place)
+            return true;
+        const local = { x: c.x - place.origin.x, y: c.y - place.origin.y, z: c.z - place.origin.z };
+        const lk = gridKey(local);
+        if (furnitureCells(owner).has(lk))
+            return false;
+        if (standingOccupants(owner).has(lk))
+            return false;
+        return true;
+    }
     /**
      * The sustained utility pair (invisibility / increase reflexes), same
      * toggle shape as the armor spell: the BEARER wears the effect, the

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

@@ -3,6 +3,7 @@ import { BypassCommand } from './bypass-command.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { billAction } from '../utilities/action-cost.js';
+import { roomAtCell } from '../utilities/district-plane.js';
 /**
  * The magical barrier's OWN verb (player ruling: "solve" was too broad --
  * a ward wants "dispel", not a generic answer verb), and the second half
@@ -110,16 +111,23 @@ export class DispelCommand extends CastCommand {
                 return `More than one weave of ${named.label} here -- name whose: "dispel ${named.words[0]} on <name>".`;
         }
         // A barrier's WEAVE is here even when its weaver isn't: "dispel
-        // [mana] barrier" from either side of the wall reaches the caster
-        // wherever they stand (the spell seals one of THIS room's exits).
+        // [mana] barrier" reaches the caster wherever they stand, for any
+        // barrier with a cell in this room or cast from it -- or across one
+        // of its doorways, from either side.
         if (!target && (named?.key === 'barrier' || named?.key === 'manabarrier')) {
-            for (const direction of room.exits.keys()) {
-                const seal = this.scene.barrierSealing(room, direction, named.key === 'manabarrier' ? 'mana' : 'physical');
-                if (seal) {
-                    target = this.scene.getPlayers().find(p => p.name === seal.caster);
+            const kind = named.key === 'manabarrier' ? 'mana' : 'physical';
+            const plane = this.scene.ensurePlane?.();
+            const here = room.name.trim().toLowerCase();
+            const standing = this.scene.spellBarriers?.(kind).find(b => b.roomName === room.name
+                || (plane && b.faces.some(f => f.cells.some(c => roomAtCell(plane, c) === here))));
+            let caster = standing?.caster;
+            for (const direction of caster ? [] : room.exits.keys()) {
+                caster = this.scene.barrierSealing(room, direction, kind)?.caster;
+                if (caster)
                     break;
-                }
             }
+            if (caster)
+                target = this.scene.getPlayers().find(p => p.name === caster);
         }
         if (!target)
             return undefined;

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

@@ -5,6 +5,7 @@ import { resolveHostInReach } from '../utilities/grid-reach.js';
 import { planeChangeHint, astralMovesLeft, astralCordWarning, astralCordParts } from '../utilities/planes.js';
 import { CombatExchange } from '../utilities/combat-exchange.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
+import { astralLimit } from '../utilities/limits.js';
 import { walkOut } from '../utilities/movement-cost.js';
 import { frameOf, droneImmobile, droneImmobileLine } from '../utilities/drone-prose.js';
 import { entrySpotFor, arrivalAt, ensureAtExit, spotsActive, highlightSpots, highlightActors, doorwayBlocker, doorwayFurniture, yieldDoorway, lockedRouteHint, lockSeenFromOutside, spotForCell, waysOutOf, actorCell } from '../utilities/spots.js';
@@ -636,11 +637,12 @@ export class GoCommand extends Command {
         // back corner, and nothing said so). Walking out means walking to
         // it first: free out of combat, refused mid-exchange -- the same
         // rule pick/unlock already enforce on the same doors.
-        // SUSTAINED BARRIER SPELL (ruling 2026-08-24): a held force wall
-        // seals this exit for EVERY meat-plane actor -- players, fleeing
-        // NPCs, the caster too. Checked before the walk-to-the-doorway so
-        // nobody strolls up to a wall they can see shimmering from here.
-        // Astral and Matrix forms pass: the spell hardens AIR.
+        // SUSTAINED BARRIER SPELL: a held force wall standing over this
+        // doorway (its cells, barrier-geometry.ts) seals it for EVERY
+        // meat-plane actor -- players, fleeing NPCs, the caster too. Checked
+        // before the walk-to-the-doorway so nobody strolls up to a wall they
+        // can see shimmering from here. Astral and Matrix forms pass: the
+        // spell hardens AIR.
         if (this.actor.plane === 'meat') {
             const seal = this.scene.barrierSealing(currentRoom, direction);
             if (seal) {
@@ -649,12 +651,25 @@ export class GoCommand extends Command {
             }
         }
         // The MANA BARRIER twin (canon p.294): spirits and astral forms
-        // stop at the weave; the living walk through it without noticing.
+        // stop at the weave; the living walk through it without noticing,
+        // and so does its creator (p.315).
         if (this.actor.plane === 'astral') {
-            const seal = this.scene.barrierSealing(currentRoom, direction, 'mana');
+            const seal = this.scene.barrierSealing(currentRoom, direction, 'mana', this.actor.name);
             if (seal) {
-                this.actor.performAction('is stopped by a mana barrier', `${direction} from ${currentRoom.name}`);
-                return `A lattice of woven mana seals the way ${direction} -- Force ${seal.force}, ${seal.caster}'s working. The astral does not pass.`;
+                // PRESSING THROUGH (p.316, "Getting Around Mana Barriers"):
+                // Magic + Charisma [Astral] v. the barrier's Force x 2. Any net
+                // hits and you are through; otherwise the weave holds you.
+                const press = rollPool(this.actor.magic + this.actor.charisma, astralLimit(this.actor));
+                const hold = rollPool(seal.force * 2);
+                const net = press.hits - hold.hits;
+                if (this.scene.isHumanControlled(this.actor)) {
+                    this.logger.meta(`Press through the mana barrier (p.316): Magic + Charisma ${formatRoll(press)} v. Force x 2 ${formatRoll(hold)}`);
+                }
+                if (net <= 0) {
+                    this.actor.performAction('is stopped by a mana barrier', `${direction} from ${currentRoom.name}`);
+                    return `A lattice of woven mana seals the way ${direction} -- Force ${seal.force}, ${seal.caster}'s working. You press against it and it presses back; the astral does not pass.`;
+                }
+                this.actor.performAction('presses through a mana barrier', `${direction} from ${currentRoom.name}`);
             }
         }
         let crossNote = '';