@maka/maka-cli 5.181.0 → 5.183.0

package/bundle/typescript/package.json

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

@@ -10,6 +10,7 @@ import { spotOf, ensureAtSpot, ensureAtExit, canReach, spotDistanceMeters, OPEN_
 import { distanceMeters } from '../utilities/room-grid.js';
 import { resolveBarrierStrike } from '../utilities/barrier-combat.js';
 import { billAction, notYourPhase, phaseHint } from '../utilities/action-cost.js';
+import { arenaOf, inArena } from '../utilities/combat-turn.js';
 import { spendMovementMeters } from '../utilities/movement-cost.js';
 /**
  * Shadowrun-style dice-pool combat, one full exchange per command:
@@ -217,6 +218,9 @@ export class AttackCommand extends Command {
         // holstered dry/jammed piece is not what's being attacked with, so it
         // must not block a bare-fisted attack the player never asked to fail.
         const weaponItem = this.actor.equipment.rightHand?.weapon ?? this.actor.equipment.leftHand?.weapon;
+        if (this.usesEquippedWeapon() && this.actor.weaponDrawn && weaponItem?.isFirearm() && weaponItem.bricked) {
+            return `The ${weaponItem.name} is BRICKED -- its electronics burned out under a Data Spike (p.228). Bench work while you rest brings it back; for now, go in swinging.`;
+        }
         if (this.usesEquippedWeapon() && this.actor.weaponDrawn && weaponItem?.isFirearm() && weaponItem.jammed) {
             return `The ${weaponItem.name}'s smartlink is LOCKED -- someone cracked your PAN. "reboot" to clear it, or go in swinging.`;
         }
@@ -224,11 +228,12 @@ export class AttackCommand extends Command {
             return `Click -- the ${weaponItem.name} is dry. "reload" (needs ammunition), or go in swinging with something else.`;
         }
         // THE COMBAT TURN (utilities/combat-turn.ts): on the physical planes
-        // a fight is a turn/pass loop and this attack is ONE action in the
-        // actor's own Action Phase. The Matrix and the astral keep the older
-        // exchange below -- the Matrix has its own initiative structure
-        // (utilities/ic.ts) and astral combat has not been swept yet.
-        if (this.actor.plane === 'meat' || this.actor.plane === 'drone') {
+        // and the Matrix a fight is a turn/pass loop and this attack is ONE
+        // action in the actor's own Action Phase. The Matrix joined it on
+        // 2026-09-13 (utilities/host-combat.ts): a Data Spike used to roll a
+        // fresh two-actor initiative per command and print "FREEZES" every
+        // time. Only the astral still rides the older exchange below.
+        if (this.actor.plane === 'meat' || this.actor.plane === 'drone' || this.actor.plane === 'matrix') {
             return await this.executeInEncounter(target, room, weaponItem ?? undefined, ambush);
         }
         const report = [];
@@ -340,8 +345,9 @@ export class AttackCommand extends Command {
         const actor = this.actor;
         const human = this.scene.isHumanControlled(actor);
         let enc = this.scene.encounterFor?.(actor);
+        const arena = arenaOf(actor);
         if (!enc) {
-            enc = await this.scene.startEncounter(room, { aggressor: actor, target, ambush });
+            enc = await this.scene.startEncounter(arena, { aggressor: actor, target, ambush });
             if (enc.ended) {
                 return human ? `` : `The fight was over before ${actor.name} got to act.`;
             }
@@ -356,7 +362,7 @@ export class AttackCommand extends Command {
                     ? `Initiative rolled -- ${who} ${enc.phaseActor ? 'acts' : 'act'} first. Your ${this.actionVerb() === 'attacks' ? 'attack' : 'move'} waits for your Action Phase.${hint(` ("initiative" shows the order.)`)}`
                     : `${actor.name} squares up -- initiative rolled; ${who} first.`;
             }
-            if (target.isIncapacitated() || target.currentLocation !== room) {
+            if (target.isIncapacitated() || !inArena(arena, target)) {
                 return human ? `${target.name} is no longer standing in front of you.` : `${target.name} is no longer a target.`;
             }
         }
@@ -372,7 +378,10 @@ export class AttackCommand extends Command {
         // shoot or swing the blade instead? READY WEAPON (p.165) is its own
         // Simple Action -- "draw" first (2jbprbSYqF7EPXrkR).
         const activeWeapon = this.usesEquippedWeapon() && actor.weaponDrawn ? weaponItem : undefined;
-        const isMelee = !activeWeapon || !activeWeapon.isFirearm();
+        // A DATA SPIKE (p.239) is neither a swing nor a shot: no ground to
+        // close, no recoil, a Complex Action. The grid sees no distance.
+        const onGrid = actor.plane === 'matrix';
+        const isMelee = !onGrid && (!activeWeapon || !activeWeapon.isFirearm());
         const report = [];
         // MELEE REACH: ground costs (p.161-162).
         if (isMelee) {
@@ -428,8 +437,8 @@ export class AttackCommand extends Command {
             }
         }
         // THE ACTION.
-        const label = isMelee ? (this.usesEquippedWeapon() ? 'Melee Attack' : 'Subdue') : 'Fire Weapon';
-        const bill = billAction(this.scene, actor, isMelee ? 'complex' : 'simple', label, { attack: true });
+        const label = onGrid ? 'Data Spike' : isMelee ? (this.usesEquippedWeapon() ? 'Melee Attack' : 'Subdue') : 'Fire Weapon';
+        const bill = billAction(this.scene, actor, onGrid || isMelee ? 'complex' : 'simple', label, { attack: true });
         if (bill)
             return bill;
         const exchange = new CombatExchange(this.scene, this.logger, actor);
@@ -442,7 +451,7 @@ export class AttackCommand extends Command {
         target.combatOpponent = target.combatOpponent ?? actor;
         target.lastExchangeAt = now;
         actor.surrendered = false;
-        if (!isMelee) {
+        if (!isMelee && !onGrid) {
             actor.firedThisPhase = true;
             actor.recoilRoundsFired += 1;
         }

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

@@ -0,0 +1,331 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { rollPool, formatRoll } from '../utilities/dice.js';
+import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { hostsInReach, hostOver, gridVicinity, roomsInReach } from '../utilities/grid-reach.js';
+import { hostLabel, matchesCameraName } from '../utilities/grid-names.js';
+import { isWatched, cameraMasterHost } from '../utilities/surveillance.js';
+import { deviceDefensePool, wanDefensePool, hostDefensePool } from '../utilities/matrix-intrusion.js';
+import { accrueOverwatch } from '../utilities/overwatch.js';
+import { leaveMatrix } from '../utilities/planes.js';
+import { applyDeviceOpened } from '../utilities/devices.js';
+import { gridActionModifier, gridNote } from '../utilities/grids.js';
+import { billAction } from '../utilities/action-cost.js';
+import { MAX_MARKS } from '../utilities/marks.js';
+import { sameHostSide } from '../models/player.js';
+/** The marks Control Device wants for a Simple device action (p.238). */
+export const MARKS_TO_CONTROL = 2;
+export class DisableCommand extends Command {
+    static verb = 'disable';
+    static description = 'Control Device (SR5 p.238): with 2 marks on a device, order it -- a maglock unlocks, a camera cluster loops, a smartgun\'s clip drops. Electronic Warfare + Intuition [Sleaze] v. Device Rating + Firewall. "disable loud <icon>" is a Data Spike instead (see "brick").';
+    /** The Data Spike route: `brick` always, `disable loud` by the word. */
+    way(args) {
+        const rest = [...args];
+        if (rest[0]?.toLowerCase() === 'loud' || rest[0]?.toLowerCase() === 'brick') {
+            rest.shift();
+            return { way: 'spike', rest };
+        }
+        if (rest[0]?.toLowerCase() === 'quiet')
+            rest.shift();
+        return { way: 'control', rest };
+    }
+    async execute(args = []) {
+        const actor = this.actor;
+        const { way, rest } = this.way(args);
+        const named = rest.join(' ').trim();
+        if (!named) {
+            return way === 'spike'
+                ? `Brick what? Name the icon: "brick <device>", "brick cameras", "brick <person>" for their gun.`
+                : `Disable what? Name the icon: "disable <device>", "disable cameras", "disable <person>" for their gun.${hint(` (Control Device wants ${MARKS_TO_CONTROL} marks on it -- "hack <it>" first.)`)}`;
+        }
+        // REACH: riding the Matrix, a living persona, or AR with a working
+        // deck in hand -- the same gate a PAN intrusion uses (hack.ts).
+        if (actor.plane === 'astral')
+            return `The Matrix doesn't answer to spirits.`;
+        if (actor.plane !== 'matrix' && !actor.isTechnomancer() && !actor.getCyberdeck()) {
+            return `You'd need to be jacked in, or have a working cyberdeck in hand, to reach a device's icon.`;
+        }
+        const target = this.resolve(named);
+        if (typeof target === 'string')
+            return target;
+        const bill = billAction(this.scene, actor, 'complex', way === 'spike' ? 'Data Spike' : 'Control Device', { attack: way === 'spike' });
+        if (bill)
+            return bill;
+        return way === 'spike' ? this.dataSpike(target) : this.controlDevice(target);
+    }
+    // ------------------------------------------------------------ targets --
+    resolve(named) {
+        const actor = this.actor;
+        const raw = named.toLowerCase();
+        const rooms = this.rooms ?? this.scene.getRooms();
+        // 1. THE CAMERA CLUSTER of the room the persona is over / inside.
+        if (matchesCameraName(named)) {
+            const room = actor.insideHost ?? (actor.plane === 'matrix' ? gridVicinity(actor) : actor.currentLocation);
+            if (!isWatched(room))
+                return `No cameras on ${room.name} -- nothing to loop.`;
+            return { kind: 'camera', room, master: cameraMasterHost(rooms, room) };
+        }
+        // 2. A DEVICE ICON: inside the host, its WAN; from the grid, a slaved
+        //    device you hold a host mark for, or a loose wireless one where
+        //    the body stands. Mirrors hack.ts tryDeviceHack.
+        const matching = (room) => room.openableDevices().filter(d => d.rating > 0).filter(d => d.name.toLowerCase().includes(raw)
+            || (d.opensExit ?? '').toLowerCase() === raw
+            || d.description.toLowerCase().includes(raw));
+        const inside = actor.insideHost;
+        if (inside) {
+            const matches = matching(inside);
+            if (matches.length === 1)
+                return { kind: 'device', device: matches[0], room: inside, host: inside, viaWan: false };
+            if (matches.length > 1)
+                return `More than one thing in here answers to "${named}": ${matches.map(d => d.name).join(', ')}.`;
+        }
+        else {
+            const found = hostsInReach(rooms, actor).map(r => ({ room: r, matches: matching(r) })).filter(x => x.matches.length === 1);
+            if (found.length === 1) {
+                const host = found[0].room;
+                const device = found[0].matches[0];
+                if ((host.hostMarksBy.get(actor.name) ?? 0) < 1) {
+                    return `${device.name} hangs off ${hostLabel(host)}'s WAN -- slaved, and a host's devices answer nobody who holds no mark on the host itself (p.233).${hint(` ("hack ${hostLabel(host)}" for a mark first.)`)}`;
+                }
+                return { kind: 'device', device, room: host, host, viaWan: true };
+            }
+            const here = actor.plane === 'matrix' ? gridVicinity(actor) : actor.currentLocation;
+            const loose = hostOver(here) ? [] : matching(here).filter(d => d.wireless);
+            if (loose.length === 1)
+                return { kind: 'device', device: loose[0], room: here, viaWan: false };
+        }
+        // 3. A PERSON'S GUN, broken out of their PAN (p.219). Same reach as
+        //    a PAN intrusion: bodies on this side of the host wall.
+        const reach = (actor.plane === 'matrix' && !actor.insideHost)
+            ? roomsInReach(rooms, actor)
+            : [{ room: actor.currentLocation, noise: 0 }];
+        const bodies = reach.flatMap(({ room: r }) => this.scene.getActorsInRoom(r)
+            .filter(a => a !== actor && a.plane === 'meat' && !a.isIncapacitated() && sameHostSide(actor, a)));
+        const picked = fuzzyPickName(named, bodies.map(a => a.name));
+        const owner = picked ? bodies.find(a => a.name === picked) : undefined;
+        if (owner) {
+            const gun = owner.equipment.rightHand?.weapon ?? owner.equipment.leftHand?.weapon;
+            if (!gun || !gun.isFirearm())
+                return `${owner.name} has no firearm on the grid to work -- nothing wireless in their hands.`;
+            return { kind: 'gun', owner, gun };
+        }
+        return `Nothing on the grid answers to "${named}".${hint(` ("look" lists the icons in reach.)`)}`;
+    }
+    marksOn(t) {
+        const me = this.actor.name;
+        if (t.kind === 'device')
+            return t.device.marksBy.get(me) ?? 0;
+        if (t.kind === 'camera')
+            return t.master?.hostMarksBy.get(me) ?? 0;
+        return t.owner.panMarksBy.get(me) ?? 0;
+    }
+    nameOf(t) {
+        return t.kind === 'device' ? t.device.name : t.kind === 'camera' ? `the camera cluster on ${t.room.name}` : `${t.owner.name}'s ${t.gun.name}`;
+    }
+    /** What defends: DR + Firewall for an unattended device (the master's
+     *  where higher, seen from the grid), the host for its cameras, the
+     *  owner's Intuition + Firewall for a gun on their PAN. */
+    defence(t) {
+        if (t.kind === 'device') {
+            return t.viaWan && t.host?.host ? wanDefensePool(t.device, t.host.host) : deviceDefensePool(t.device);
+        }
+        if (t.kind === 'camera') {
+            return t.master?.host ? hostDefensePool(t.master.host) : { label: 'Device Rating + Firewall', pool: 4 };
+        }
+        return { label: 'Intuition + Firewall', pool: t.owner.getPanDefensePool('sleaze') };
+    }
+    godBill(defenseHits, why) {
+        const bill = accrueOverwatch(this.scene, this.actor, defenseHits, why);
+        if (bill.converged && this.actor.plane === 'matrix') {
+            bill.lines.push(...leaveMatrix(this.scene, this.actor, { forced: true, reason: `GOD force-reboots your persona --` }));
+        }
+        return bill.lines;
+    }
+    /** The owner of the thing learns something went wrong. */
+    wakeOwner(t, made) {
+        const actor = this.actor;
+        actor.sneaking = false;
+        const host = t.kind === 'device' ? t.host : t.kind === 'camera' ? t.master : undefined;
+        if (host) {
+            host.hostAlert = true;
+            if (made)
+                host.hostMarksOn.set(actor.name, Math.min(MAX_MARKS, (host.hostMarksOn.get(actor.name) ?? 0) + 1));
+        }
+        if (t.kind === 'gun' && made) {
+            actor.panMarksBy.set(t.owner.name, Math.min(MAX_MARKS, (actor.panMarksBy.get(t.owner.name) ?? 0) + 1));
+            t.owner.performAction('notices a Matrix probe', 'their link flashing an intrusion warning');
+        }
+        this.scene.updateStatus();
+    }
+    // ------------------------------------------------------ Control Device --
+    controlDevice(t) {
+        const actor = this.actor;
+        const name = this.nameOf(t);
+        const marks = this.marksOn(t);
+        if (marks < MARKS_TO_CONTROL) {
+            const how = t.kind === 'device' ? `"hack ${t.device.name}"` : t.kind === 'camera' ? `"hack ${t.master ? hostLabel(t.master) : 'the host'}"` : `"hack ${t.owner.name}"`;
+            return `${name} takes orders from ${MARKS_TO_CONTROL} marks and you hold ${marks} (Control Device, p.238: a Simple device action wants two).${hint(` (${how} places them; or "brick" it -- no marks, but loud, and a bricked lock stays locked.)`)}`;
+        }
+        const burned = actor.burnedAttributeRefusal('sleaze');
+        if (burned)
+            return burned;
+        // ELECTRONIC WARFARE + INTUITION [SLEAZE] v. Intuition + Firewall
+        // (p.238), the no-test device action's test. Unskilled at -1 (p.130).
+        const ew = actor.skillRating('electronic-warfare');
+        const grid = gridActionModifier(actor.currentGrid, !!actor.hostInside, t.kind === 'device' ? t.host?.host?.grid : t.kind === 'camera' ? t.master?.host?.grid : undefined);
+        const pool = Math.max(1, actor.intuition + (ew > 0 ? ew : -1) + actor.bonus('hacking') + actor.bonus('matrix-sleaze')
+            + actor.matrixActionPenalty + actor.woundModifier - actor.sustainingPenalty + grid.total);
+        const limit = actor.matrixAttribute('sleaze');
+        const roll = rollPool(pool, limit, { gremlins: actor.deckGremlins });
+        const defence = this.defence(t);
+        const defenceRoll = rollPool(defence.pool);
+        const net = roll.hits - defenceRoll.hits;
+        actor.performAction('takes control of a device', name);
+        if (this.scene.isHumanControlled(actor)) {
+            this.logger.meta(`Control Device (Electronic Warfare + Intuition [Sleaze])${gridNote(grid)}: ${formatRoll(roll)}`);
+            this.logger.meta(`${defence.label}: ${formatRoll(defenceRoll)} -- net ${net >= 0 ? '+' : ''}${net}`);
+        }
+        const godLines = this.godBill(defenceRoll.hits, 'Control Device (sleaze)');
+        if (net <= 0) {
+            // A blown Sleaze is noticed (p.236): the owner marks you and the
+            // host it hangs off is awake.
+            this.wakeOwner(t, true);
+            const who = t.kind === 'gun' ? `${t.owner.name}'s firewall holds a MARK on your persona now` : `whoever owns it has your icon on file now`;
+            return [`${name} refuses the order and SAYS SO -- ${who}.`, ...godLines].join('\n');
+        }
+        const lines = [];
+        if (t.kind === 'device') {
+            // THE ORDER: it opens. Same aftermath as a key or a forced door
+            // (utilities/devices.ts) -- the exit unseals in the meat.
+            const opened = t.device.force(true);
+            lines.push(`${t.device.name} takes the order as its owner's: ${opened.message}`);
+            lines.push(...applyDeviceOpened(this.scene, actor, t.room, t.device, 'disable'));
+        }
+        else if (t.kind === 'camera') {
+            t.room.camerasLooped = true;
+            lines.push(`The cluster on ${t.room.name} takes the order: every lens loops on an empty hallway. Security sees NOTHING there now.${hint(` ("snoop ${t.room.name}" rides the real feed.)`)}`);
+            this.scene.addWorldEvent(`An unseen hand looped the cameras on ${t.room.name}.`);
+        }
+        else {
+            t.gun.jammed = true;
+            lines.push(`${t.owner.name}'s ${t.gun.name} takes the order: the smartlink seizes and the clip drops -- LOCKED until they reboot.`);
+            t.owner.performAction('suffers a PAN crack', `their ${t.gun.name} locking up in their hand`);
+            this.scene.addWorldEvent(`An unseen hand seized ${t.owner.name}'s ${t.gun.name}.`);
+        }
+        this.scene.updateStatus();
+        return [...lines, ...godLines].join('\n');
+    }
+    // ----------------------------------------------------------- Data Spike --
+    dataSpike(t) {
+        const actor = this.actor;
+        const name = this.nameOf(t);
+        const burned = actor.burnedAttributeRefusal('attack');
+        if (burned)
+            return burned;
+        if (t.kind === 'device' && t.device.isBricked)
+            return `${t.device.name} is already bricked -- dead boards, nothing left to spike.`;
+        if (t.kind === 'camera' && t.room.camerasBricked)
+            return `The cluster on ${t.room.name} is already dead glass.`;
+        if (t.kind === 'gun' && t.gun.bricked)
+            return `${t.owner.name}'s ${t.gun.name} is already bricked.`;
+        // CYBERCOMBAT + LOGIC [ATTACK] v. Intuition + Firewall (p.239).
+        const grid = gridActionModifier(actor.currentGrid, !!actor.hostInside, t.kind === 'device' ? t.host?.host?.grid : t.kind === 'camera' ? t.master?.host?.grid : undefined);
+        const pool = Math.max(1, actor.getAttackPool() + actor.matrixActionPenalty + actor.bonus('matrix-attack') + grid.total);
+        const limit = actor.matrixAttribute('attack');
+        const roll = rollPool(pool, limit, { gremlins: actor.deckGremlins });
+        const defence = this.defence(t);
+        const defenceRoll = rollPool(defence.pool);
+        const net = roll.hits - defenceRoll.hits;
+        actor.performAction('throws a Data Spike', name);
+        if (this.scene.isHumanControlled(actor)) {
+            this.logger.meta(`Data Spike (Cybercombat + Logic [Attack ${limit}])${gridNote(grid)}: ${formatRoll(roll)}`);
+            this.logger.meta(`${defence.label}: ${formatRoll(defenceRoll)} -- net ${net >= 0 ? '+' : ''}${net}`);
+        }
+        const godLines = this.godBill(defenceRoll.hits, 'Data Spike (attack)');
+        if (net <= 0) {
+            // A failed Attack action is never noticed (p.236), but the
+            // target's software rejects the code and sends it back: one
+            // unresistable box per net hit the defender got (Data Trails p.181).
+            const rebound = Math.max(0, -net);
+            const lines = [`${name} shrugs the spike off${rebound > 0 ? ' -- and sends it back' : ''}.`];
+            if (rebound > 0) {
+                if (actor.isTechnomancer()) {
+                    actor.takeStun(rebound);
+                    lines.push(`  Rejected code burns back through your living persona -- ${rebound} stun: ${actor.stunSummary()}`);
+                }
+                else {
+                    actor.takeMatrixDamage(rebound);
+                    lines.push(`  Rejected code burns back into your deck -- ${rebound} box${rebound === 1 ? '' : 'es'}, unresisted: ${actor.matrixSummary()}`);
+                    if (actor.matrixCrashed)
+                        lines.push(...leaveMatrix(this.scene, actor, { forced: true, reason: `Your own spike bricks the deck under you.` }));
+                }
+            }
+            lines.push(`  Nobody upstairs noticed -- a spike that doesn't land leaves no trace.`);
+            return [...lines, ...godLines].join('\n');
+        }
+        // DV = Attack + net hits, +2 per mark held (p.239); resisted with
+        // Device Rating + Firewall (p.228).
+        const marks = this.marksOn(t);
+        const dv = limit + net + 2 * marks;
+        const soak = rollPool(this.defence(t).pool);
+        const dealt = Math.max(0, dv - soak.hits);
+        if (this.scene.isHumanControlled(actor)) {
+            this.logger.meta(`Data Spike -- ${dv} DV (Attack ${limit} +${net} net${marks > 0 ? ` +${2 * marks} for ${marks} mark${marks === 1 ? '' : 's'}` : ''}) v. ${defence.label}: ${formatRoll(soak)} -> ${dealt}`);
+        }
+        // An Attack action is never subtle: the owner knows.
+        this.wakeOwner(t, false);
+        const lines = [];
+        if (dealt <= 0) {
+            lines.push(`${name} takes the spike and its firewall holds -- barely. It knows it was hit.`);
+            return [...lines, ...godLines].join('\n');
+        }
+        if (t.kind === 'device') {
+            t.device.takeMatrixDamage(dealt);
+            lines.push(`The spike lands on ${t.device.name} -- ${dealt} box${dealt === 1 ? '' : 'es'} (${t.device.matrixSummary()}).`);
+            if (t.device.isBricked) {
+                lines.push(t.device.kind === 'lock'
+                    ? `  ${t.device.name} BRICKS -- sparks, a pop, a smell of hot plastic. And the lock STAYS LOCKED (p.228): a dead maglock holds like a bolt.${hint(` (Marks and "disable" would have opened it; now it is "pick" or "breach".)`)}`
+                    : `  ${t.device.name} BRICKS -- sparks, a pop, dead electronics. Whatever it was doing, it has stopped.`);
+                this.scene.addWorldEvent(`${actor.name} bricked ${t.device.name} in ${t.room.name} with a Data Spike.`);
+            }
+        }
+        else if (t.kind === 'camera') {
+            // The cluster has no Device of its own to hold a monitor; a hit
+            // that lands past the firewall kills it. Engine ruling.
+            t.room.camerasBricked = true;
+            lines.push(`The spike lands on the cluster -- ${dealt} box${dealt === 1 ? '' : 'es'} -- and every lens on ${t.room.name} goes to static and stays there. Dead glass.`);
+            this.scene.addWorldEvent(`${actor.name} bricked the cameras on ${t.room.name} with a Data Spike.`);
+        }
+        else {
+            // A gun is a Rating 2 device with a monitor of 9 (p.228, the
+            // book's own smartgun example): a spike that lands past its
+            // firewall for that much bricks it outright.
+            const monitor = 8 + 1;
+            if (dealt >= monitor) {
+                t.gun.bricked = true;
+                lines.push(`The spike lands on ${t.owner.name}'s ${t.gun.name} -- it sparks, crackles and smokes in their hand. BRICKED: it will not fire again until somebody's bench work.`);
+                t.owner.performAction('suffers a PAN crack', `their ${t.gun.name} smoking in their hand`);
+            }
+            else {
+                t.gun.jammed = true;
+                lines.push(`The spike lands on ${t.owner.name}'s ${t.gun.name} -- ${dealt} box${dealt === 1 ? '' : 'es'}: the smartlink seizes and LOCKS. It boots again on a reboot; another spike like that bricks it.`);
+                t.owner.performAction('suffers a PAN crack', `their ${t.gun.name} locking up in their hand`);
+            }
+            this.scene.addWorldEvent(`${actor.name} spiked ${t.owner.name}'s ${t.gun.name}.`);
+        }
+        this.scene.updateStatus();
+        return [...lines, ...godLines].join('\n');
+    }
+}
+/** `brick <icon>`: the Data Spike, by its street name. */
+export class BrickCommand extends DisableCommand {
+    static verb = 'brick';
+    static description = 'Data Spike (SR5 p.239): Cybercombat + Logic [Attack] v. Device Rating + Firewall, no marks needed, never subtle. Fill a device\'s Matrix condition monitor (8 + DR/2, p.228) and it BRICKS -- a camera goes dead, a smartgun sparks and dies; a lock stays locked. A miss burns your own deck.';
+    way(args) {
+        const rest = [...args];
+        if (rest[0]?.toLowerCase() === 'loud')
+            rest.shift();
+        return { way: 'spike', rest };
+    }
+}
+//# sourceMappingURL=disable.js.map

package/bundle/typescript/src/commands/game/sideQuest/commands/enter-host.js

@@ -3,6 +3,7 @@ import { movePersonaWith } from '../utilities/matrix-roster.js';
 import { resolveHostInReach, hostsInReach, gridVicinity, hostOver } from '../utilities/grid-reach.js';
 import { hint } from '../utilities/hints.js';
 import { hostLabel } from '../utilities/grid-names.js';
+import { billAction } from '../utilities/action-cost.js';
 /**
  * ENTER/EXIT HOST (SR5 p.239, Complex Action).
  *
@@ -67,6 +68,12 @@ export class EnterHostCommand extends Command {
                 hint(`A host opens to anyone holding a MARK on it (p.239) -- "mark ${target.name}" softens it, or "hack" takes one by force.`),
             ].join('\n');
         }
+        // A Complex Action (p.239) -- billed only inside a Combat Turn.
+        const bill = billAction(this.scene, actor, 'complex', 'Enter Host');
+        if (bill)
+            return bill;
+        // Crossing the wall leaves whatever fight was on this side of it.
+        this.scene.encounterFor?.(actor)?.leave(actor);
         // THE PERSONA CROSSES, THE BODY STAYS (increment 2): position becomes
         // the host, remembering the grid it came from (p.239: exit returns
         // you there). currentLocation is never written -- it is the body's.
@@ -130,6 +137,13 @@ export class ExitHostCommand extends Command {
             const by = [...actor.linkLockedBy].join(', ');
             return `{red-fg}You reach for the door and it isn't there. LINK-LOCKED by ${by}: the connection is held open and Enter/Exit Host is closed to you (p.229). "jack out" still works -- it just costs you dumpshock.{/red-fg}`;
         }
+        // A Complex Action (p.239), and the way out of the host's fight
+        // (utilities/host-combat.ts): a persona back on the grid is beyond
+        // the ice, which "does not operate out on the grid".
+        const bill = billAction(this.scene, actor, 'complex', 'Exit Host');
+        if (bill)
+            return bill;
+        this.scene.encounterFor?.(actor)?.leave(actor);
         const host = actor.insideHost;
         const from = actor.matrixPosition?.kind === 'host' ? actor.matrixPosition.from : undefined;
         actor.matrixPosition = { kind: 'grid', grid: from };

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

@@ -12,6 +12,7 @@ import { matchesCameraName, hostLabel } from '../utilities/grid-names.js';
 import { TapCommand } from './tap.js';
 import { sameHostSide } from '../models/player.js';
 import { MAX_MARKS } from '../utilities/marks.js';
+import { billAction } from '../utilities/action-cost.js';
 import { declarationPenalty, parseMarkDeclaration, hostDefensePool, wanDefensePool, freeMatrixPerceptionHits, bruteForceMatrixDv, overwatchFromDefense, GO_BIG_QUALITY, deviceDefensePool } from '../utilities/matrix-intrusion.js';
 /**
  * MARKS A PAN INTRUSION MUST ALREADY HOLD before it can command the
@@ -74,6 +75,12 @@ export class HackCommand extends BypassCommand {
         // here so a declaration never lands in a target name, the same way
         // the mode words are.
         const { marks: declaredMarks, rest } = parseMarkDeclaration(afterMode);
+        // BRUTE FORCE and HACK ON THE FLY are Complex Actions (p.238, p.240)
+        // -- billed only inside a Combat Turn, where one intrusion is the
+        // whole Action Phase.
+        const bill = billAction(this.scene, this.actor, 'complex', mode === 'sleaze' ? 'Hack on the Fly' : 'Brute Force');
+        if (bill)
+            return bill;
         // PAN warfare: "hack <name>" cracks a meat actor's personal area
         // network -- from inside the Matrix, or right here in AR with a
         // working deck in hand (which is also how enemy deckers get YOU).
@@ -601,16 +608,16 @@ export class HackCommand extends BypassCommand {
             if (perception > 0)
                 lines.push(`  {cyan-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what it guards (p.240).{/cyan-fg}`);
         }
-        // ONE MARK COMMANDS IT. Opening a door is a Free action, and p.238
-        // puts a Free action at one mark -- so the key IS the door, and
-        // there is no second roll to make.
-        if (now >= 1 && !device.isOpen()) {
-            // NAME ONLY A VERB THAT DISPATCHES. An earlier draft offered
-            // "control <device>", which is not a command this game has --
-            // caught by advertised-verbs-structured.test.ts, which exists for
-            // exactly that. `open` is the real one, and it is a MEAT verb: the
-            // key is placed from in here, the door swings out there.
-            lines.push(`  That is enough to work it: ${device.opensExit ? `the ${device.opensExit} way` : device.name} answers to you now.${hint(` ("open ${device.opensExit ?? device.name}" once your body is back in the room.)`)}`);
+        // TWO MARKS COMMAND IT (p.238 Control Device: 1 mark for a Free
+        // action, 2 for a Simple, 3 for a Complex -- and unlocking a maglock
+        // is the book's own example of the no-test device action, a Simple
+        // "Use Simple Device", p.165). The verb is `disable`
+        // (commands/disable.ts): the key is turned from in here, the door
+        // swings out there. One mark short says so.
+        if (!device.isOpen()) {
+            lines.push(now >= 2
+                ? `  That is enough to command it: ${hint(`"disable ${device.name}" (Control Device, p.238) ${device.opensExit ? `opens the ${device.opensExit} way` : `works it`} from right here.`)}`
+                : `  One more mark and it takes orders.${hint(` ("hack ${device.name}" again, then "disable ${device.name}" -- Control Device wants 2 marks for a Simple device action, p.238.)`)}`);
         }
         this.scene.updateStatus();
         return [...lines, ...godLines].join('\n');

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

@@ -3,6 +3,7 @@ import { gridVicinity } from '../utilities/grid-reach.js';
 import { enterMatrix, leaveMatrix } from '../utilities/planes.js';
 import { hint } from '../utilities/hints.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
+import { billAction } from '../utilities/action-cost.js';
 /**
  * The Matrix door, both directions: "jack in [hot|cold]" and "jack out".
  * Needs a working CYBERDECK carried (a commlink is calls and AR only) --
@@ -97,6 +98,11 @@ export class JackCommand extends Command {
             if (actor.inExchange) {
                 return `The ice has your persona locked in the exchange -- survive it first, then jack out in the lull.`;
             }
+            // JACK OUT is a Simple Action (p.240) -- billed inside a Combat
+            // Turn; leaving the Matrix then leaves the fight (planes.ts).
+            const bill = billAction(this.scene, actor, 'simple', 'Jack Out');
+            if (bill)
+                return bill;
             // LINK-LOCKED: leaving stops being a decision and becomes a test
             // (p.229/p.240). Everything below is the Jack Out action.
             if (actor.linkLockedBy.size > 0) {

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

@@ -17,6 +17,7 @@ import { BULLET } from '../utilities/log-style.js';
 import { spotsActive, whoIsWhereLine, highlightSpots, highlightActors, canReach, sealedRouteTo } from '../utilities/spots.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { findCatalogItem, describeEffect } from '../utilities/catalog.js';
+import { billAction } from '../utilities/action-cost.js';
 export class LookCommand extends Command {
     static verb = 'look';
     static description = 'Examine your surroundings';
@@ -301,6 +302,11 @@ export class LookCommand extends Command {
      * match the grid map: ● host, ◆ persona, ▣ PAN, ◇ data.
      */
     gridLook(room) {
+        // MATRIX PERCEPTION is a Complex Action (p.241) -- billed only inside
+        // a Combat Turn, where a look at the room costs the phase.
+        const bill = billAction(this.scene, this.actor, 'complex', 'Matrix Perception');
+        if (bill)
+            return bill;
         // NO MEAT PROSE AT ALL (player ruling 2026-08-26: "looking in the
         // matrix shouldn't show the meatworld"). The room's own description
         // used to open this view "for orientation" -- but that description

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

@@ -163,6 +163,19 @@ export class RestCommand extends Command {
             lines.push(`  Bench work on the ${deck.name}: ${formatRoll(repairRoll)}`);
             lines.push(`  ${repaired} box${repaired === 1 ? '' : 'es'} repaired: ${deck.deckSummary()}${wasBricked && !deck.isBricked ? ' -- it boots again.' : ''}`);
         }
+        // BRICKED GEAR (p.228 Repairing Matrix Damage): an hour with a
+        // toolkit and Hardware + Logic -- the rest is the hour, and every
+        // hit either clears boxes or halves the time, so by the end of a
+        // night's rest a bricked smartgun boots again. A reboot never does
+        // this; that is the difference between bricked and jammed.
+        const brickedGear = [
+            ...actor.inventory.getAllItems(),
+            actor.equipment.rightHand?.weapon, actor.equipment.leftHand?.weapon,
+        ].filter((i) => !!i && i.bricked);
+        for (const gear of new Set(brickedGear)) {
+            gear.bricked = false;
+            lines.push(`  Bench work on the ${gear.name}: the burnt boards come out, and it powers up again.`);
+        }
         for (const drone of damagedDrones) {
             const wasWrecked = drone.isWrecked;
             const repairRoll = rollPool(actor.logic + actor.skillRating('hardware') + actor.bonus('piloting'));