@maka/maka-cli 5.382.0 → 5.384.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.382.0",
+  "version": "5.384.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",

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 } from '../utilities/room-grid.js';
+import { isSolid, isVoid, roomAtCell, wallsBetween } from '../utilities/district-plane.js';
+import { 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
@@ -964,16 +973,31 @@ 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>          a dome around them
+     *   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) {
         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 +1005,195 @@ 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>". 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';
+            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);
+                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;
+                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;
+            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();
+            const nameWords = lead === 'at' || lead === 'on' || lead === 'around' ? words.slice(1) : words;
+            if (nameWords.length === 0)
+                return usage;
+            const candidates = this.scene.getActorsInRoom(room).filter(a => a === actor || ((a.plane === 'meat' || a.plane === actor.plane) && actor.canPerceive(a)));
+            const picked = fuzzyPickName(nameWords.join(' '), candidates.map(a => a.name));
+            const target = 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;
+            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);
     }
+    /** 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/command-registry.js

@@ -1,7 +1,7 @@
 // src/commands/command-registry.ts
 import { CommandFactory } from '../factories/command-factory.js';
 import { Logger } from '../utilities/logger.js';
-import { authorizeNpcAction } from '../utilities/npc-authorization.js';
+import { authorizeNpcAction, clientHoldsTheMeet } from '../utilities/npc-authorization.js';
 export class CommandRegistry {
     scene;
     constructor(scene) {
@@ -74,6 +74,14 @@ export class CommandRegistry {
                 return { args, refusal: verdict.reason ?? `That is not yours to do.` };
             }
         }
+        // The meet's Johnson keeps his seat (npc-authorization.ts).
+        if (declaring.isMovement() && !this.scene.isHumanControlled(actor)) {
+            const held = clientHoldsTheMeet(this.scene, actor);
+            if (held) {
+                Logger.getInstance().write(`Refused "${commandString.trim()}" from ${actor.name}: the client keeps his seat.`);
+                return { args, refusal: held };
+            }
+        }
         return { command, args };
     }
 }

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

@@ -46,6 +46,16 @@ export class Command {
         // whether or not it also remembered to say so here.
         return this.humanOnly ? 'human-only' : this.npcPolicy;
     }
+    /**
+     * THIS VERB MOVES THE ACTOR'S OWN BODY -- across the room (move, run,
+     * sprint, fly), out of it (go) or after someone (follow). Read by
+     * CommandRegistry.parse for AI-driven actors only: a Johnson holding a
+     * meet keeps his seat (npc-authorization.ts clientHoldsTheMeet).
+     */
+    static movesActor = false;
+    static isMovement() {
+        return this.movesActor;
+    }
     static verb;
     static description; // Make this static
     actor;

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/follow.js

@@ -124,6 +124,7 @@ export function dragFollowers(scene, mover, origin, logger) {
     }
 }
 export class FollowCommand extends Command {
+    static movesActor = true;
     static verb = 'follow';
     static description = 'Tail another runner: "follow <name>" and their room changes take you with them. Bare "follow" (or "unfollow") peels off. It breaks on its own if you get caught in a fight, fall behind, or they leave the run. Same room, same plane, real players only -- NPC companions already heel by nature ("order" sends them).';
     /** The scene's other humans -- the only legal targets. */

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';
@@ -96,6 +97,7 @@ export class GoCommand extends Command {
             return false;
         return GoCommand.HEELS_ON[c.kind](plane);
     }
+    static movesActor = true;
     static verb = 'go';
     static description = 'Move in the specified direction ("go back" retraces your last move). Fleeing someone you just fought hands them one free parting shot. Jacked in, the grid sees no distance: "go <any room>" jumps your persona straight there ("map" lights the icons). Inside a host there is no distance to cross at all -- "exit" first.';
     /** See MoveCommand.execute: going through a door is a walk too, and
@@ -635,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) {
@@ -648,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 = '';