@maka/maka-cli 5.384.0 → 5.386.0

package/bundle/typescript/package.json

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

@@ -2,14 +2,14 @@ import { sustainBurden } from '../utilities/sustaining.js';
 import { BypassCommand } from './bypass-command.js';
 import { hint } from '../utilities/hints.js';
 import { CombatExchange } from '../utilities/combat-exchange.js';
-import { rollPool, formatRoll } from '../utilities/dice.js';
+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 { key as gridKey } from '../utilities/room-grid.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 { buildBarrier, clipFaces, formatCoord, isCoordToken, parseCoord, planDirectionalWall, planDome, planWall } from '../utilities/barrier-geometry.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 { NPC } from '../models/npc.js';
 import { spellFor, catalogSpells } from '../utilities/catalog.js';
 import { getAspect } from '../aspects.js';
@@ -96,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. 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>".';
+    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';
     noDeviceMessage = "There's nothing here to cast at.";
@@ -307,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);
@@ -315,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.`;
         }
@@ -331,11 +335,14 @@ export class CastCommand extends BypassCommand {
         if (!def)
             return `You don't know "${spellName}".`;
         switch (def.cast) {
-            case 'combat': return this.castCombatSpell(spellName, force, overcast, rest);
+            // An AREA combat spell is aimed at a point (castAreaSpell); a bolt at a person.
+            case 'combat': return def.area
+                ? this.castAreaSpell(spellName, force, overcast, rest)
+                : this.castCombatSpell(spellName, force, overcast, rest);
             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);
         }
     }
     /**
@@ -475,6 +482,100 @@ export class CastCommand extends BypassCommand {
         }
         return [];
     }
+    /**
+     * ONE COMBAT SPELL'S NUMBERS AGAINST ONE TARGET, canon (SR5 p.283,
+     * RAG-checked 2026-10-05; user ruling: "fix all of it now").
+     *
+     *  - DIRECT (soak 'willpower' / 'body': manabolt, stunball, powerball):
+     *    the target opposes the casting test with Willpower (mana) or Body
+     *    (physical), plus Magic Resistance (p.76). The damage is the NET
+     *    HITS, and nothing soaks it -- "the target does not get to resist
+     *    the damage, only the Spellcasting test".
+     *  - INDIRECT (soak 'armor': fireball, clout, blast): dodged like a
+     *    bullet with Reaction + Intuition; DV is Force + net hits, AP is
+     *    -Force, resisted with Body + Armor.
+     *
+     * This replaced F-2 + net hits soaked by Willpower/Body for the direct
+     * family and AP floor(F/3) for the indirect one.
+     *
+     * A MANA BARRIER between caster and target (p.316) adds its Force to
+     * the defence (direct) or the resistance (indirect) pool.
+     */
+    spellStrikeProfile(spell, spellKey, force, overcast, target, extraResist = 0) {
+        const label = (ap) => `with a Force ${force} ${spellKey}${overcast ? ' (OVERCAST)' : ''}, ${this.castingLabel()}${ap !== 0 ? ` (AP -${ap})` : ''}`;
+        const weave = this.manaBarrierBetween(target);
+        const through = (weave ?? 0) + extraResist;
+        if (spell.soak !== 'armor') {
+            const resist = (spell.soak === 'willpower' ? target.willpower : target.body) + target.qualityRating('magic-resistance');
+            return {
+                label: label(0) + (weave ? ` -- through a Force ${weave} mana barrier` : ''),
+                pool: this.actor.getMagicPool() + this.actor.consumeEdgeBoost(),
+                damageBase: 0,
+                soakPool: 0,
+                defensePool: resist + through,
+                dealStun: spell.stun,
+                isSpell: true,
+                limit: force,
+            };
+        }
+        const armor = target.plane === 'meat' ? target.getArmorValue() : 0;
+        const modifiedArmor = Math.max(0, armor - force);
+        return {
+            label: label(force) + (weave ? ` -- through a Force ${weave} mana barrier` : ''),
+            pool: this.actor.getMagicPool() + this.actor.consumeEdgeBoost(),
+            damageBase: force,
+            soakPool: Math.max(0, target.getSoakPool() - armor + modifiedArmor) + through,
+            modifiedArmor: target.plane === 'meat' ? modifiedArmor : undefined,
+            dealStun: spell.stun,
+            isSpell: true,
+            limit: force,
+        };
+    }
+    /** The Force of a MANA BARRIER (not the caster's own) standing between
+     *  the caster and someone -- what a spell has to get through (p.316). */
+    manaBarrierBetween(target) {
+        const from = this.scene.worldCellOf?.(this.actor);
+        const to = this.scene.worldCellOf?.(target);
+        if (!from || !to)
+            return undefined;
+        const hit = this.scene.barrierOnLine?.(from, to, 'mana');
+        return hit && hit.barrier.caster !== this.actor.name ? hit.barrier.force : undefined;
+    }
+    /**
+     * AN INDIRECT SPELL IS A THING THAT FLIES (p.283: "a clear line of
+     * fire"), and a Physical Barrier stops it: the bolt hits the wall
+     * instead. Direct spells pass -- the barrier "does not impede
+     * spellcasting" save for indirect ones (p.294). The face takes the
+     * spell's DV (Force + hits, combat spells unchanged against barriers,
+     * p.197) if it beats the Armor.
+     */
+    indirectWallBetween(from, to) {
+        if (!from || !to)
+            return undefined;
+        return this.scene.barrierOnLine?.(from, to, 'physical');
+    }
+    strikeWall(wall, force, spellKey, rolledHits) {
+        const { barrier, face } = wall;
+        // A barrier does not dodge (p.197): the casting test is unopposed
+        // and its hits add to the DV.
+        const hits = rolledHits ?? rollPool(this.actor.getMagicPool(), force).hits;
+        const dv = force + hits;
+        if (!pierces(dv, barrier.armor, 0)) {
+            return [`  The ${spellKey} breaks against ${barrier.caster}'s shimmer-wall -- DV ${dv} against Armor ${barrier.armor} (p.197); nothing gets past it.`];
+        }
+        const soak = rollPool(barrier.structure + barrier.armor);
+        const dealt = Math.max(0, dv - soak.hits);
+        const breached = damageFace(barrier, face, dealt);
+        const out = [`  The ${spellKey} slams into ${barrier.caster}'s barrier instead -- ${dealt} box${dealt === 1 ? '' : 'es'} to ${FACE_LABEL[face.id]} (${face.breached ? 'BREACHED' : `${face.damage}/${barrier.structure}`}).`];
+        if (breached && allBreached(barrier)) {
+            const caster = this.scene.getPlayers().find(p => p.name === barrier.caster);
+            if (caster)
+                caster.sustainedBarrier = undefined;
+            out.push(`  The barrier comes down entirely -- ${barrier.caster}'s spell is over (p.294).`);
+        }
+        this.scene.updateExits?.(this.actor.currentLocation);
+        return out;
+    }
     /**
      * The shared combat-spell engine (manabolt/stunbolt/powerbolt/
      * fireball): one exchange flow, parameterized by what SOAKS the hit
@@ -605,55 +706,28 @@ export class CastCommand extends BypassCommand {
                 if (defender.isIncapacitated())
                     break;
                 if (striker === this.actor) {
-                    // ---- The spell: casting pool vs defense, soaked per its type
-                    // (direct mana = Willpower; direct physical = Body; indirect
-                    // elemental = the full soak pool minus AP floor(F/3)). The
-                    // FORCE dial sets the damage: bolts hit at F-2, the elemental
-                    // hits at full F for letting armor matter. ----
-                    const spellAp = spell.soak === 'armor' ? Math.floor(force / 3) : 0;
-                    const armorEaten = spellAp > 0
-                        ? Math.min(spellAp, target.plane === 'meat' ? target.getArmorValue() : 0)
-                        : 0;
-                    // MAGIC RESISTANCE (p.76): +1 die per rating on the Spell
-                    // Resistance test -- the Willpower or Body roll a mana or
-                    // physical spell is resisted with. Not on the armor soak of an
-                    // elemental effect, which is damage resistance, not spell.
-                    const magicResistance = spell.soak === 'armor' ? 0 : target.qualityRating('magic-resistance');
-                    const soakPool = (spell.soak === 'willpower' ? target.willpower
-                        : spell.soak === 'body' ? target.body
-                            : Math.max(0, target.getSoakPool() - armorEaten)) + magicResistance;
-                    const damageBase = spell.soak === 'armor' ? force : Math.max(1, force - 2);
-                    const strike = exchange.resolveStrike(this.actor, target, {
-                        label: `with a Force ${force} ${spellKey}${overcast ? ' (OVERCAST)' : ''}, ${this.castingLabel()}${armorEaten > 0 ? ` (AP -${armorEaten})` : ''}`,
-                        // An armed edge boost (see edge.ts) supercharges the bolt.
-                        pool: this.actor.getMagicPool() + this.actor.consumeEdgeBoost(),
-                        damageBase,
-                        soakPool,
-                        dealStun: spell.stun,
-                        // Lets an Awakened defender's counterspelling answer it.
-                        isSpell: true,
-                        // Spellcasting + Magic [FORCE] (p.281): the Force you chose
-                        // is the ceiling on the hits it can buy. Overcasting for
-                        // reach costs drain AND raises this cap, which is the whole
-                        // shape of the Force dial -- without it, a Force 1 bolt
-                        // could land as hard as a Force 8 one on a lucky roll.
-                        limit: force,
-                    });
-                    report.push('', ...strike.world, ...strike.meta);
-                    await exchange.announce(strike.world, strike.meta);
+                    // ---- The spell, canon (spellStrikeProfile, p.283): direct is
+                    // opposed by Willpower/Body and does its net hits; indirect is
+                    // dodged, Force + net hits at AP -Force, soaked by Body + Armor.
+                    // An indirect bolt meets a Physical Barrier first. ----
+                    const wall = spell.soak === 'armor'
+                        ? this.indirectWallBetween(this.scene.worldCellOf?.(this.actor), this.scene.worldCellOf?.(target))
+                        : undefined;
+                    if (wall) {
+                        const hit = this.strikeWall(wall, force, spellKey);
+                        report.push('', ...hit);
+                        await exchange.announce(hit);
+                    }
+                    else {
+                        const strike = exchange.resolveStrike(this.actor, target, this.spellStrikeProfile(spell, spellKey, force, overcast, target));
+                        report.push('', ...strike.world, ...strike.meta);
+                        await exchange.announce(strike.world, strike.meta);
+                    }
                     if (target.isDown()) {
                         report.push(...await exchange.resolveDeath(target, this.actor, {
                             fallLine: `${target.name} ${flavor.fall} Their gear scatters across ${room.name}.`,
                         }));
                     }
-                    // AREA (p.284): the blast doesn't stop at the person you aimed
-                    // at. Everyone else hostile in the room resists the same
-                    // damage with the same soak -- no defense roll, there's nothing
-                    // to dodge -- and anyone it drops falls here too.
-                    if (spell.area) {
-                        const splash = await this.splashArea(exchange, spellKey, spell, force, target, damageBase, spellAp);
-                        report.push(...splash);
-                    }
                     // Drain comes due the moment the bolt flies, kill or not.
                     const drain = this.applyDrain(spell, force, overcast);
                     report.push('', ...drain);
@@ -765,27 +839,21 @@ export class CastCommand extends BypassCommand {
         target.combatOpponent = target.combatOpponent ?? actor;
         target.lastExchangeAt = now;
         actor.surrendered = false;
-        // The spell's own numbers -- identical to the exchange path below.
-        const spellAp = spell.soak === 'armor' ? Math.floor(force / 3) : 0;
-        const armorEaten = spellAp > 0
-            ? Math.min(spellAp, target.plane === 'meat' ? target.getArmorValue() : 0)
-            : 0;
-        const magicResistance = spell.soak === 'armor' ? 0 : target.qualityRating('magic-resistance');
-        const soakPool = (spell.soak === 'willpower' ? target.willpower
-            : spell.soak === 'body' ? target.body
-                : Math.max(0, target.getSoakPool() - armorEaten)) + magicResistance;
-        const damageBase = spell.soak === 'armor' ? force : Math.max(1, force - 2);
-        const strike = exchange.resolveStrike(actor, target, {
-            label: `with a Force ${force} ${spellKey}${overcast ? ' (OVERCAST)' : ''}, ${this.castingLabel()}${armorEaten > 0 ? ` (AP -${armorEaten})` : ''}`,
-            pool: actor.getMagicPool() + actor.consumeEdgeBoost(),
-            damageBase,
-            soakPool,
-            dealStun: spell.stun,
-            isSpell: true,
-            limit: force,
-        });
-        report.push('', ...strike.world, ...strike.meta);
-        await exchange.announce(strike.world, strike.meta);
+        // The spell's own numbers -- identical to the exchange path above
+        // (spellStrikeProfile), and an indirect bolt meets a barrier first.
+        const wall = spell.soak === 'armor'
+            ? this.indirectWallBetween(this.scene.worldCellOf?.(actor), this.scene.worldCellOf?.(target))
+            : undefined;
+        if (wall) {
+            const hit = this.strikeWall(wall, force, spellKey);
+            report.push('', ...hit);
+            await exchange.announce(hit);
+        }
+        else {
+            const strike = exchange.resolveStrike(actor, target, this.spellStrikeProfile(spell, spellKey, force, overcast, target));
+            report.push('', ...strike.world, ...strike.meta);
+            await exchange.announce(strike.world, strike.meta);
+        }
         enc.syncWounds();
         if (target.isDown()) {
             report.push(...await exchange.resolveDeath(target, actor, {
@@ -800,10 +868,6 @@ export class CastCommand extends BypassCommand {
                     fallLine: `${target.name} sags and drops -- out cold, breathing. Their gear scatters across ${room.name}.`,
                 })));
         }
-        if (spell.area) {
-            report.push(...await this.splashArea(exchange, spellKey, spell, force, target, damageBase, spellAp));
-            enc.syncWounds();
-        }
         const drain = this.applyDrain(spell, force, overcast);
         report.push('', ...drain);
         await exchange.announce(drain);
@@ -814,61 +878,252 @@ export class CastCommand extends BypassCommand {
         return human ? phaseHint(this.scene, actor).trim() : report.join('\n');
     }
     /**
-     * The rest of the room, for an AREA spell: every other hostile takes
-     * the same damage, resisted with the same soak the primary target
-     * used (minus the spell's AP against armor-soaked elementals). No
-     * attack roll and no defense roll -- a blast doesn't aim and can't be
-     * dodged; the drain the ball spells charge is what pays for it.
+     * AN AREA COMBAT SPELL, CAST AT A POINT (SR5 p.281-284; RAG-checked
+     * 2026-10-05; user spec: "cast at a coordinate").
+     *
+     *   cast <ball> [F] at <x,y[,z]>     the point, in the map rulers' numbers
+     *   cast <ball> [F] at <someone>     the cell they stand in
+     *
+     * "Area spells can be cast on a specific target or a point in space that
+     * you can see ... a sphere centered on the target with a radius in
+     * meters equal to the Force" (p.281). "All targets in the area of effect
+     * that you can see, friend and foe alike, are valid targets" -- the
+     * caster included when they stand in it (user ruling 2026-10-05). This
+     * replaced "everyone hostile in the room, allies spared".
+     *
+     *  - DIRECT balls (manaball, stunball, powerball): ONE casting test,
+     *    opposed by each target's Willpower/Body (+ counterspelling, Magic
+     *    Resistance, a mana barrier's Force); each takes their own net hits.
+     *    Only targets the caster can SEE are touched (p.281).
+     *  - INDIRECT balls (fireball, ball lightning, toxic wave, blast) fly
+     *    and go boom like a grenade (p.283, p.181): Spellcasting + Magic
+     *    [Force] (3). Beat the threshold and it lands where you aimed, its
+     *    net hits on the DV; miss and it SCATTERS 2D6 m, less a metre per
+     *    hit. DV is Force (+ net hits), AP -Force, soaked with Body + Armor
+     *    by everyone the blast reaches -- no dodge. A Physical Barrier in
+     *    its path is where it goes off.
+     *
+     * The area is measured on the district PLANE, so it does not stop at a
+     * room's edge; walls stop the blast and the caster's sight.
      */
-    async splashArea(exchange, spellKey, spell, force, primary, damageBase, spellAp) {
-        const room = this.actor.currentLocation;
-        // Who the blast catches: everyone else standing on this plane --
-        // EXCEPT the caster's own crew and any other player. Canon area
-        // spells don't discriminate, but a shell that murders your companion
-        // because you aimed past them reads as a bug, not a rule (ruling
-        // 2026-08-25); the mage's own people get the benefit of the doubt.
-        const caught = this.scene.getActorsInRoom(room).filter(a => a !== this.actor && a !== primary
-            && a.plane === this.actor.plane
-            && !a.isIncapacitated()
-            && !this.scene.isHumanControlled(a)
-            && !(a instanceof NPC && a.allyOf === this.actor.name));
-        if (caught.length === 0)
-            return [];
-        const lines = ['', `The blast washes over the rest of the room.`];
-        for (const bystander of caught) {
-            const armorEaten = spellAp > 0
-                ? Math.min(spellAp, bystander.plane === 'meat' ? bystander.getArmorValue() : 0)
-                : 0;
-            const soakPool = spell.soak === 'willpower' ? bystander.willpower
-                : spell.soak === 'body' ? bystander.body
-                    : Math.max(0, bystander.getSoakPool() - armorEaten);
-            const soak = rollPool(Math.max(1, soakPool));
-            const dealt = Math.max(0, damageBase - soak.hits);
-            this.logger.meta(`${spellKey} splash on ${bystander.name}: soak ${formatRoll(soak)} vs ${damageBase}`);
-            if (dealt === 0) {
-                lines.push(`  ${bystander.name} rides it out -- shaken, still standing.`);
-                continue;
+    async castAreaSpell(spellKey, force, overcast, rest) {
+        const actor = this.actor;
+        const spell = spellFor(spellKey);
+        const flavor = COMBAT_SPELL_FLAVOR[spellKey] ?? { act: `cast ${spellKey} at`, fall: 'goes down.' };
+        const room = actor.currentLocation;
+        const words = (rest[0]?.toLowerCase() === 'at' ? rest.slice(1) : rest).filter(w => w.trim().length > 0);
+        const plane = this.scene.ensurePlane?.();
+        const from = this.scene.worldCellOf?.(actor);
+        if (!plane || !from)
+            return `There's nowhere here to aim a ${spellKey}.`;
+        const usage = `"cast ${spellKey} [force] at <x,y>" or "cast ${spellKey} [force] at <someone>" -- a ${force} m radius around that point. You're at ${formatCoord(from)}.`;
+        if (words.length === 0)
+            return `Cast it where? ${usage}`;
+        // WHERE IT IS AIMED.
+        let aim;
+        let aimedAt;
+        if (isCoordToken(words[0]) && words.length === 1) {
+            aim = parseCoord(words[0], from.z);
+            aimedAt = formatCoord(aim);
+            if (!this.inSight(plane, from, aim))
+                return `You can't see ${aimedAt} from here -- an area spell is cast at a point you can see (p.281).`;
+        }
+        else {
+            const selfWord = words.length === 1 && /^(me|self|myself)$/i.test(words[0]);
+            const visible = this.scene.getActorsInRoom(room).filter(a => a === actor || (a.plane === actor.plane && actor.canPerceive(a)));
+            const picked = selfWord ? actor.name : fuzzyPickName(words.join(' '), visible.map(a => a.name));
+            const target = picked ? visible.find(a => a.name === picked) : undefined;
+            if (!target) {
+                const cross = crossPlaneRefusal(this.scene, actor, room, words.join(' '), 'spell');
+                if (cross)
+                    return cross;
+                return `You don't see "${words.join(' ')}" here. ${usage}`;
             }
-            if (spell.stun)
-                bystander.takeStun(dealt);
-            else
-                bystander.takeDamage(dealt);
-            this.logger.write(`${this.actor.name}'s ${spellKey} splashed ${dealt} onto ${bystander.name}.`);
-            lines.push(`  ${bystander.name} is caught in it -- ${dealt} ${spell.stun ? 'stun' : 'damage'}.`);
-            if (bystander.isDown()) {
-                lines.push(...await exchange.resolveDeath(bystander, this.actor, {
-                    fallLine: `${bystander.name} goes down in the blast.`,
-                }));
+            aim = this.scene.worldCellOf?.(target);
+            aimedAt = target === actor ? 'yourself' : target.name;
+            if (!aim)
+                return `${target.name} isn't standing anywhere a ${spellKey} could find.`;
+            if (target !== actor && !this.inSight(plane, from, aim))
+                return `You can't see ${target.name} clearly enough to aim at them (p.281).`;
+        }
+        // WHO COULD BE CAUGHT: everyone on the caster's plane with a cell.
+        const sameSide = (a) => a.plane === actor.plane || (actor.plane === 'meat' && a.plane === 'drone') || (actor.plane === 'drone' && a.plane === 'meat');
+        const everyone = this.scene.allActors.filter(a => sameSide(a) && !a.isIncapacitated());
+        // THE COMBAT TURN: a Complex Action and the phase's attack (p.167).
+        const physical = actor.plane === 'meat' || actor.plane === 'drone';
+        const human = this.scene.isHumanControlled(actor);
+        if (physical) {
+            let enc = this.scene.encounterFor?.(actor);
+            const opener = everyone.find(a => a !== actor && a.currentLocation === room && a instanceof NPC);
+            if (!enc && opener) {
+                enc = await this.scene.startEncounter(room, { aggressor: actor, target: opener, ambush: false });
+                if (enc.ended)
+                    return human ? '' : `The fight was over before ${actor.name} could cast.`;
+                if (actor.isIncapacitated())
+                    return human ? `You're down before you can cast.` : `${actor.name} went down before casting.`;
+                if (!enc.isPhaseOf(actor)) {
+                    const who = enc.phaseActor?.name ?? 'the others';
+                    return human
+                        ? `Initiative rolled -- ${who} ${enc.phaseActor ? 'acts' : 'act'} first. Your ${spellKey} waits for your Action Phase.${hint(` ("initiative" shows the order.)`)}`
+                        : `${actor.name} gathers mana -- initiative rolled; ${who} first.`;
+                }
             }
-            else if (bystander.isUnconscious()) {
-                lines.push(...await exchange.resolveDeath(bystander, this.actor, {
-                    fatal: false,
-                    fallLine: `${bystander.name} drops where the blast found them -- out cold, breathing.`,
+            else if (enc && !enc.isPhaseOf(actor)) {
+                return notYourPhase(enc, actor);
+            }
+            const bill = billAction(this.scene, actor, 'complex', `Cast ${spellKey}`, { attack: true });
+            if (bill)
+                return bill;
+        }
+        const exchange = new CombatExchange(this.scene, this.logger, actor);
+        actor.performAction(`casts ${spellKey} at`, aimedAt);
+        this.scene.addWorldEvent(`${actor.name} ${flavor.act} ${aimedAt} in ${room.name}.`);
+        const lines = [];
+        const meta = [];
+        const pool = actor.getMagicPool() + actor.consumeEdgeBoost();
+        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)}`);
+            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);
+                if (!c || distanceMeters(aim, c) > force)
+                    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));
+            });
+            if (caught.length === 0)
+                lines.push(`  The spell washes over empty ground.`);
+            for (const victim of caught) {
+                // Mana touches only the living and the magical (p.284).
+                if (spell.type === 'mana' && victim.plane === 'drone') {
+                    lines.push(`  ${victim.name}'s frame has no aura for mana to bite -- untouched.`);
+                    continue;
+                }
+                const weave = victim === actor ? undefined : this.manaBarrierBetween(victim);
+                const counter = typeof victim.isCaster === 'function' && victim.isCaster() ? victim.skillRating('counterspelling') : 0;
+                const resist = (spell.soak === 'willpower' ? victim.willpower : victim.body)
+                    + victim.qualityRating('magic-resistance') + counter + (weave ?? 0);
+                const defense = rollPool(resist);
+                const net = roll.hits - defense.hits;
+                meta.push(`  ${victim.name}: resists ${formatRoll(defense)}${weave ? ` (+${weave} mana barrier)` : ''}${counter ? ` (+${counter} counterspelling)` : ''} -- ${Math.max(0, net)} net`);
+                if (net <= 0) {
+                    lines.push(`  ${victim.name} holds against it.`);
+                    continue;
+                }
+                lines.push(...this.landAreaDamage(victim, net, !!spell.stun));
+                hurt.push(victim);
+            }
+        }
+        else {
+            // ---- INDIRECT: it flies, and goes off like a grenade. ----
+            const hits = roll.hits;
+            let at = aim;
+            let dv = force;
+            if (hits >= 3) {
+                dv = force + (hits - 3);
+                meta.push(`${header}: Spellcasting + Magic [${force}] (3) ${formatRoll(roll)} -- on target, +${hits - 3} DV (p.283)`);
+            }
+            else {
+                const metres = Math.max(0, rollD6Total(2) - hits);
+                const angle = Math.random() * Math.PI * 2;
+                at = {
+                    x: aim.x + Math.round(Math.cos(angle) * metres / METERS_PER_CELL),
+                    y: aim.y + Math.round(Math.sin(angle) * metres / METERS_PER_CELL),
+                    z: aim.z,
+                };
+                meta.push(`${header}: Spellcasting + Magic [${force}] (3) ${formatRoll(roll)} -- misses the threshold, scatters ${metres} m (p.181)`);
+            }
+            // What it meets on the way: a wall stops it short; so does a barrier.
+            let blocked = false;
+            const path = line3D(from, at);
+            for (let i = 1; i < path.length; i++) {
+                const c = path[i];
+                const wall = this.scene.barrierAt(c, 'physical');
+                if (wall) {
+                    lines.push(`${header} -- it bursts against ${wall.barrier.caster}'s barrier at ${formatCoord(c)}.`);
+                    lines.push(...this.strikeWall(wall, force, spellKey, dv - force));
+                    at = path[i - 1];
+                    blocked = true;
+                    break;
+                }
+                if (isSolid(plane, c)) {
+                    at = path[i - 1];
+                    break;
+                }
+            }
+            if (!blocked)
+                lines.push(`${header} -- it bursts at ${formatCoord(at)}${at.x !== aim.x || at.y !== aim.y ? `, wide of the mark` : ''}: DV ${dv}, AP -${force}, ${force} m.`);
+            const weave = this.scene.barrierOnLine?.(from, at, 'mana');
+            const through = weave && weave.barrier.caster !== actor.name ? weave.barrier.force : 0;
+            const caught = everyone.filter(a => {
+                const c = this.scene.worldCellOf?.(a);
+                if (!c || distanceMeters(at, c) > force)
+                    return false;
+                // The blast reaches what nothing solid shields.
+                return wallsBetween(plane, at, c) === 0 && !this.scene.barrierOnLine?.(at, c, 'physical');
+            });
+            if (caught.length === 0)
+                lines.push(`  The blast catches nobody.`);
+            for (const victim of caught) {
+                const armor = victim.plane === 'meat' ? victim.getArmorValue() : 0;
+                const modified = Math.max(0, armor - force);
+                const soak = rollPool(Math.max(0, victim.getSoakPool() - armor + modified) + through);
+                const dealt = Math.max(0, dv - soak.hits);
+                // p.168: a Physical hit under the modified Armor turns to Stun.
+                const stun = !!spell.stun || (victim.plane === 'meat' && dv < modified);
+                meta.push(`  ${victim.name}: soak ${formatRoll(soak)} v. DV ${dv} (Armor ${armor} -> ${modified})${through ? ` (+${through} mana barrier)` : ''} -- ${dealt}`);
+                if (dealt === 0) {
+                    lines.push(`  ${victim.name} rides it out.`);
+                    continue;
+                }
+                lines.push(...this.landAreaDamage(victim, dealt, stun));
+                hurt.push(victim);
+            }
+        }
+        await exchange.announce(lines, meta);
+        const report = [...lines, ...(human ? [] : meta)];
+        for (const victim of hurt) {
+            if (victim.isDown()) {
+                report.push(...await exchange.resolveDeath(victim, actor, {
+                    fallLine: `${victim.name} ${flavor.fall} Their gear scatters across ${victim.currentLocation.name}.`,
                 }));
             }
+            else if (victim.isUnconscious()) {
+                report.push(...(this.scene.isHumanControlled(victim)
+                    ? await exchange.resolvePlayerKnockout(actor, victim)
+                    : await exchange.resolveDeath(victim, actor, {
+                        fatal: false,
+                        fallLine: `${victim.name} drops where the spell found them -- out cold, breathing.`,
+                    })));
+            }
         }
-        await exchange.announce(lines);
-        return lines;
+        this.scene.encounterFor?.(actor)?.syncWounds();
+        if (!actor.isIncapacitated()) {
+            const drain = this.applyDrain(spell, force, overcast);
+            report.push('', ...drain);
+            await exchange.announce(drain);
+            report.push(...await this.drainCollapse(exchange));
+        }
+        this.scene.encounterFor?.(actor)?.syncWounds();
+        this.scene.updateStatus();
+        return human ? (physical ? phaseHint(this.scene, actor).trim() : '') : report.join('\n');
+    }
+    /** A box count landing on one body caught in an area spell. */
+    landAreaDamage(victim, boxes, stun) {
+        if (stun) {
+            const { stun: s, overflow } = victim.takeStun(boxes);
+            this.logger.write(`${this.actor.name}'s area spell dealt ${boxes} STUN to ${victim.name}.`);
+            return [`  ${victim.name} is caught -- ${s} stun: ${victim.stunSummary()}`,
+                ...(overflow > 0 ? [`  It spills past consciousness -- ${overflow} box${overflow === 1 ? '' : 'es'} physical: ${victim.conditionSummary()}`] : [])];
+        }
+        victim.takeDamage(boxes);
+        this.logger.write(`${this.actor.name}'s area spell dealt ${boxes} to ${victim.name}.`);
+        return [`  ${victim.name} is caught -- ${boxes} box${boxes === 1 ? '' : 'es'}: ${victim.conditionSummary()}`];
     }
     async castHeal(force, overcast, rest = []) {
         const { target, error } = this.resolveAllyTarget(rest);
@@ -980,7 +1235,8 @@ export class CastCommand extends BypassCommand {
      *   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] 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)
      *
@@ -993,7 +1249,9 @@ export class CastCommand extends BypassCommand {
      * 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';
@@ -1028,11 +1286,12 @@ export class CastCommand extends BypassCommand {
         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 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);
         }
         else if (isCoordToken(words[0])) {
@@ -1041,6 +1300,10 @@ export class CastCommand extends BypassCommand {
             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;
@@ -1050,6 +1313,7 @@ export class CastCommand extends BypassCommand {
             }
             else {
                 center = a;
+                force = this.domeForce(force, autoUpTo);
                 plan = planDome(a, force);
                 if (!this.inSight(plane, from, a))
                     return unseen(formatCoord(a));
@@ -1060,6 +1324,10 @@ export class CastCommand extends BypassCommand {
                 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;
@@ -1070,12 +1338,22 @@ export class CastCommand extends BypassCommand {
         }
         else {
             const lead = words[0].toLowerCase();
-            const nameWords = lead === 'at' || lead === 'on' || lead === 'around' ? words.slice(1) : words;
+            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 = fuzzyPickName(nameWords.join(' '), candidates.map(a => a.name));
-            const target = picked ? candidates.find(a => a.name === picked) : undefined;
+            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);
@@ -1085,6 +1363,21 @@ export class CastCommand extends BypassCommand {
                 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)
@@ -1156,6 +1449,32 @@ export class CastCommand extends BypassCommand {
         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;

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

@@ -140,35 +140,35 @@ export class SpellsCommand extends Command {
         // health and manipulation work.
         const book = [
             { key: 'manabolt', cast: 'manabolt', how: 'cast manabolt [force] at <target>',
-                line: 'direct mana: resisted by WILLPOWER alone; armor and muscle mean nothing. Damage F-2, drain F-3.' },
+                line: 'direct mana: they oppose your casting test with WILLPOWER; every net hit is a box, and nothing soaks it. Drain F-3.' },
             { key: 'stunbolt', cast: 'stunbolt', how: 'cast stunbolt at <target>',
-                line: 'direct mana, merciful: same reach as manabolt but the damage is STUN. Damage F-2, drain F-3.' },
+                line: 'direct mana, merciful: as manabolt (Willpower opposes, net hits are boxes), but STUN. Drain F-3.' },
             { key: 'powerbolt', cast: 'powerbolt', how: 'cast powerbolt at <target>',
-                line: 'direct physical: resisted by BODY alone; armor still means nothing. Damage F-2, drain F-3.' },
-            { key: 'fireball', cast: 'fireball', how: 'cast fireball at <target>',
-                line: 'indirect elemental: soaked like a gunshot (Body + armor, AP F/3) but it hits at FULL Force. Drain F-2.' },
+                line: 'direct physical: they oppose your casting test with BODY; net hits are boxes, armor means nothing. Drain F-3.' },
+            { key: 'fireball', cast: 'fireball', how: 'cast fireball [force] at <x,y | someone>',
+                line: 'AREA indirect elemental: Force m of fire. Thrown like a grenade (threshold 3, or it scatters 2D6 m); DV Force + net hits, AP -Force, soaked with Body + armor -- everyone in it, you too. Drain F-1.' },
             { key: 'lightning-bolt', cast: 'lightning-bolt', how: 'cast lightning-bolt at <target>',
-                line: 'indirect elemental: full-Force damage, soaked like a gunshot. Cheaper than fire -- drain F-3.' },
+                line: 'indirect elemental: dodged like a bullet (Reaction + Intuition); DV Force + net hits, AP -Force, Body + armor soaks. Drain F-3.' },
             { key: 'acid-stream', cast: 'acid-stream', how: 'cast acid-stream at <target>',
-                line: 'indirect elemental: full-Force damage that eats armor on the way in. Drain F-3.' },
+                line: 'indirect elemental: dodged like a bullet; DV Force + net hits, AP -Force -- acid eats armor. Drain F-3.' },
             { key: 'flamethrower', cast: 'flamethrower', how: 'cast flamethrower at <target>',
-                line: 'indirect elemental: a washing sheet of flame at full Force, soaked like a gunshot. Drain F-3.' },
+                line: 'indirect elemental: a sheet of flame, dodged like a bullet; DV Force + net hits, AP -Force. Drain F-3.' },
             { key: 'clout', cast: 'clout', how: 'cast clout at <target>',
-                line: 'indirect force: an invisible fist, full Force, damage lands STUN. Drain F-3.' },
+                line: 'indirect force: an invisible fist, dodged like a bullet; DV Force + net hits, AP -Force, STUN. Drain F-3.' },
             { key: 'death-touch', cast: 'death-touch', how: 'cast death-touch at <target>',
-                line: 'direct mana at TOUCH range -- you close first, then they resist with Willpower. Damage F-2, drain F-6.' },
+                line: 'direct mana at TOUCH range -- you close first; Willpower opposes, net hits are boxes. Drain F-6.' },
             { key: 'knockout', cast: 'knockout', how: 'cast knockout at <target>',
-                line: 'direct mana at TOUCH range, STUN damage: the quiet way to take one alive. Damage F-2, drain F-6.' },
+                line: 'direct mana at TOUCH range, STUN: the quiet way to take one alive. Willpower opposes. Drain F-6.' },
             { key: 'shatter', cast: 'shatter', how: 'cast shatter at <target>',
-                line: 'direct physical at TOUCH range -- BODY resists, bone gives. Damage F-2, drain F-6.' },
-            { key: 'manaball', cast: 'manaball', how: 'cast manaball at <target>',
-                line: 'AREA direct mana: your target takes the exchange, everyone else in the room eats the blast. Damage F-2, drain F.' },
-            { key: 'stunball', cast: 'stunball', how: 'cast stunball at <target>',
-                line: 'AREA direct mana, STUN: the room-clearing knockout. Damage F-2, drain F.' },
-            { key: 'powerball', cast: 'powerball', how: 'cast powerball at <target>',
-                line: 'AREA direct physical: BODY resists, armor does not. Damage F-2, drain F.' },
-            { key: 'ball-lightning', cast: 'ball-lightning', how: 'cast ball-lightning at <target>',
-                line: 'AREA indirect elemental: full-Force damage across the room, soaked with armor. Drain F-1.' },
+                line: 'direct physical at TOUCH range -- Body opposes, net hits are boxes, bone gives. Drain F-6.' },
+            { key: 'manaball', cast: 'manaball', how: 'cast manaball [force] at <x,y | someone>',
+                line: 'AREA direct mana: Force m around the point; everyone in it you can SEE, friend or foe (you too), opposes with Willpower and takes their own net hits. Drain F.' },
+            { key: 'stunball', cast: 'stunball', how: 'cast stunball [force] at <x,y | someone>',
+                line: 'AREA direct mana, STUN: as manaball, but the knockout. Drain F.' },
+            { key: 'powerball', cast: 'powerball', how: 'cast powerball [force] at <x,y | someone>',
+                line: 'AREA direct physical: as manaball, Body opposes, armor does not help. Drain F.' },
+            { key: 'ball-lightning', cast: 'ball-lightning', how: 'cast ball-lightning [force] at <x,y | someone>',
+                line: 'AREA indirect elemental: as fireball, in lightning. Drain F-1.' },
             { key: 'heal', cast: 'heal', how: 'cast heal [on <ally>]',
                 line: "knit physical wounds closed, yours or an ally's (touch range); Force caps the boxes. Drain F-4." },
             { key: 'armor', cast: 'armor', how: 'cast armor [on <ally>]',
@@ -177,9 +177,9 @@ export class SpellsCommand extends Command {
                 line: 'sustained: light slides around the bearer, +3 on sneak contests at -2 dice. Drain F-4.' },
             { key: 'reflexes', cast: 'increase reflexes', how: 'cast increase reflexes [on <ally>]',
                 line: 'sustained: +2 initiative for the bearer at -2 dice. Drain F-3.' },
-            { key: 'barrier', cast: 'barrier', how: 'cast barrier [F] <x,y> <x,y> (wall) | <x,y> (dome) | <direction> [cells] | at <someone> | (bare: a dome round you); cast barrier off',
+            { key: 'barrier', cast: 'barrier', how: 'cast barrier [F] <x,y> <x,y> (wall) | <x,y> (dome) | <direction> [cells] | at <someone|me> [radius] | (bare: a dome round you); Force optional -- sized to fit; cast barrier off',
                 line: 'sustained: hardened air -- a wall Force x 2 m long and Force m high, or a Force-metre dome. Armor/Structure = hits, a track per face; nobody meat-side passes (you included) at -2 dice to you. Drain F-1.' },
-            { key: 'manabarrier', cast: 'manabarrier', how: 'cast manabarrier [F] <x,y> <x,y> | <x,y> | <direction> [cells] | at <someone>; cast manabarrier off',
+            { key: 'manabarrier', cast: 'manabarrier', how: 'cast manabarrier [F] <x,y> <x,y> | <x,y> | <direction> [cells] | at <someone|me> [radius]; cast manabarrier off',
                 line: 'sustained: woven mana, same shapes -- stops SPIRITS and astral forms; the living pass freely, and so do you. Armor/Structure = Force. Drain F-2.' },
         ];
         for (const entry of book) {

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

@@ -3355,5 +3355,30 @@
 // - Wire: the room grid carries `barriers` (room-local cells; a mana
 //   barrier only for eyes that can see it). Docks draw x/y rulers in
 //   plane coordinates and the caption gives your x,y,z.
-export const ENGINE_VERSION = '1.196.0';
+// 1.197.0 (2026-10-05): BARRIERS SIZE THEMSELVES. With no Force named, a
+//   wall is cast at the least Force that raises it (a cell of length per
+//   Force, Force 3 a level), the directional wall at Force 3, and a dome
+//   at Force 3 (one storey) -- never past the caster's talent; an
+//   overcast must be named. `cast barrier [F] at <someone> [size]` takes
+//   a radius in cells (size x 2 = Force; a Force and size that disagree
+//   are refused), and "me"/"self" name the caster.
+//   The HUD's sustained line and `spells` show the barrier's Armor,
+//   Structure and every face's damage track.
+// 1.198.0 (2026-10-05): COMBAT SPELLS, CANON (SR5 p.281-284, p.316).
+// - Direct spells (manabolt, stunbolt, powerbolt, the touch three, the
+//   balls) are opposed by Willpower/Body (+ Magic Resistance, counter-
+//   spelling) and do their NET HITS, unsoaked -- not F-2 + net soaked.
+// - Indirect spells are dodged (Reaction + Intuition): DV Force + net
+//   hits, AP -Force, Body + Armor soaks -- not AP floor(F/3).
+// - Area spells are aimed at a point: `cast <ball> [F] at <x,y[,z]>` or
+//   `at <someone>`; everyone within Force metres on the district plane
+//   is caught, friend and foe, the caster too (user ruling). Direct balls
+//   touch only who the caster can see, each opposing one casting test.
+//   Indirect balls fly like a grenade: threshold 3 (hits are capped at
+//   Force), net hits on the DV, else scatter 2D6 m less a metre a hit;
+//   walls shield. Replaces "the room splashes, allies spared".
+// - 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';
 //# sourceMappingURL=engine-version.js.map

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

@@ -149,7 +149,7 @@ import { ForceCommand } from './commands/force.js';
 import { CompleteCommand } from './commands/complete.js';
 import { DisableCommand, BrickCommand } from './commands/disable.js';
 import { CastCommand } from './commands/cast.js';
-import { barrierSpan } from './utilities/barrier-geometry.js';
+import { barrierSpan, barrierStats } from './utilities/barrier-geometry.js';
 import { FollowCommand, UnfollowCommand } from './commands/follow.js';
 import { BringCommand } from './commands/bring.js';
 import { SurrenderCommand } from './commands/surrender.js';
@@ -9478,10 +9478,10 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // the one that strands the team -- and both of them seal an exit
         // that the caster cannot pass either.
         if (player.sustainedBarrier) {
-            heldSpells.push(`physical barrier (${player.sustainedBarrier.shape} ${barrierSpan(player.sustainedBarrier)}, ${player.sustainedBarrier.roomName})`);
+            heldSpells.push(`physical barrier (${player.sustainedBarrier.shape} ${barrierSpan(player.sustainedBarrier)}, ${player.sustainedBarrier.roomName}; ${barrierStats(player.sustainedBarrier)})`);
         }
         if (player.sustainedManaBarrier) {
-            heldSpells.push(`mana barrier (${player.sustainedManaBarrier.shape} ${barrierSpan(player.sustainedManaBarrier)}, ${player.sustainedManaBarrier.roomName})`);
+            heldSpells.push(`mana barrier (${player.sustainedManaBarrier.shape} ${barrierSpan(player.sustainedManaBarrier)}, ${player.sustainedManaBarrier.roomName}; ${barrierStats(player.sustainedManaBarrier)})`);
         }
         // What this character holds on OTHERS -- the caster's burden, named
         // by bearer so the mage knows whose armor is costing them two dice.

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

@@ -22,6 +22,21 @@ export function maxWallCells(force) {
 export function maxWallLevels(force) {
     return Math.max(1, Math.floor(force / METERS_PER_LEVEL));
 }
+/**
+ * THE LEAST FORCE THAT RAISES THIS WALL -- what a cast with no Force
+ * named is sized to (user 2026-10-05: "the force is auto calculated if
+ * omitted"). Length needs Force cells (Force x 2 m); every level past
+ * the first needs another 3 m of height, i.e. Force 3 a level.
+ */
+export function forceForWall(a, b) {
+    const length = Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y)) + 1;
+    const levels = Math.abs(a.z - b.z) + 1;
+    return Math.max(1, Math.ceil(length * METERS_PER_CELL / 2), levels > 1 ? levels * METERS_PER_LEVEL : 1);
+}
+/** The directional wall is three cells across: Force 3. */
+export const DIRECTIONAL_WALL_FORCE = 3;
+/** A dome with no Force named rises one full 3 m storey: Force 3. */
+export const DOME_FORCE = METERS_PER_LEVEL;
 /**
  * A WALL BETWEEN TWO POINTS, ends included. Straight along an axis only:
  * a diagonal run of cells leaves corner gaps an 8-way walker slips
@@ -191,10 +206,19 @@ export function barrierSpan(barrier) {
 }
 export function describeBarrier(barrier) {
     const span = barrierSpan(barrier);
+    return `a ${barrier.shape} over ${span} in ${barrier.roomName}, Force ${barrier.force}, ${barrierStats(barrier)}`;
+}
+/**
+ * Armor and every face's damage track, in one breath: "Armor 3,
+ * Structure 3 [N 0/3, E 1/3, S BREACHED, W 0/3]". The HUD's sustained
+ * line and the spells list both print it -- a barrier you hold is a
+ * thing being shot at, and the track is what tells you which side gives.
+ */
+export function barrierStats(barrier) {
     const tracks = barrier.faces
         .map(f => `${f.id === 'wall' ? 'wall' : f.id.toUpperCase()} ${f.breached ? 'BREACHED' : `${f.damage}/${barrier.structure}`}`)
         .join(', ');
-    return `a ${barrier.shape} over ${span} in ${barrier.roomName}, Force ${barrier.force}, Armor/Structure ${barrier.structure} [${tracks}]`;
+    return `Armor ${barrier.armor}, Structure ${barrier.structure} [${tracks}]`;
 }
 export function allBreached(barrier) {
     return barrier.faces.every(f => f.breached);

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

@@ -693,9 +693,15 @@ export class CombatExchange {
         // 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 defense = turn.noDefense
-            ? rollPool(0)
-            : rollPool(defender.getDefensePool() + inspired + counterspell + coverDice + proneDefence + turn.defense);
+        // 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
+        // a dodge. The profile carries that pool when it applies.
+        const defense = strike.defensePool !== undefined
+            ? rollPool(Math.max(0, strike.defensePool) + inspired + counterspell)
+            : turn.noDefense
+                ? rollPool(0)
+                : rollPool(defender.getDefensePool() + inspired + counterspell + coverDice + proneDefence + turn.defense);
         const rangeNote = weaponClass && spatial.meters > 0
             ? ` (${rangeMod !== 0 ? `${rangeMod} range` : `${rangeBracketName(spatial.meters, weaponClass)} range`} -- ~${Math.round(spatial.meters)} m)`
             : '';

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

@@ -46,6 +46,24 @@ let scriptedInitiative;
 export function scriptInitiative(totals) {
     scriptedInitiative = totals ? [...totals] : undefined;
 }
+/**
+ * A SUM OF D6s, not a hit count -- scatter distance (p.181: 2D6 metres)
+ * and anything else the book measures in pips. Scriptable like the
+ * other seams: each scripted entry is the TOTAL the next call shows.
+ */
+let scriptedTotals;
+export function scriptTotals(totals) {
+    scriptedTotals = totals ? [...totals] : undefined;
+}
+export function rollD6Total(count) {
+    const scripted = scriptedTotals && scriptedTotals.length > 0 ? scriptedTotals.shift() : undefined;
+    if (scripted !== undefined)
+        return scripted;
+    let total = 0;
+    for (let i = 0; i < count; i++)
+        total += 1 + Math.floor(Math.random() * 6);
+    return total;
+}
 export function rollPool(pool, limit, opts = {}) {
     const size = Math.max(0, Math.floor(pool));
     const scripted = scriptedHits && scriptedHits.length > 0 ? scriptedHits.shift() : undefined;

package/package.json

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