@maka/maka-cli 5.182.0 → 5.183.0

package/bundle/typescript/package.json

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

@@ -218,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.`;
         }

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

@@ -608,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/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'));

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

@@ -2,7 +2,9 @@ import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { planeTintItemName, emphasizeFind, objectiveMark, fileReach } from '../utilities/planes.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
-import { perceptionTest } from '../utilities/perception.js';
+import { perceptionTest, matrixSearchTest, matrixSearchSeconds, MATRIX_SEARCH } from '../utilities/perception.js';
+import { gridVicinity } from '../utilities/grid-reach.js';
+import { hostLabel } from '../utilities/grid-names.js';
 import { canReach, exitSpot, spotsActive, revealWithPerception, theSpot, sealedRouteTo, } from '../utilities/spots.js';
 import { placeName } from '../utilities/log-style.js';
 import { billAction, encounterOf } from '../utilities/action-cost.js';
@@ -135,6 +137,73 @@ ${coach}`;
 export class SearchCommand extends Command {
     static verb = 'search';
     static description = 'Search for items in your area';
+    /**
+     * MATRIX SEARCH (SR5 p.241, player ruling 2026-09-13: "a true matrix
+     * search, not perception, revealing what is inside a host if it's
+     * cracked open").
+     *
+     * A Special action: Computer + Intuition [Data Processing] against a
+     * threshold from the Matrix Search Table, and it takes TIME -- one
+     * minute inside a host whatever the information, net hits over the
+     * threshold dividing it, a miss spending it all, a Browse program
+     * halving it (utilities/perception.ts). The time is real: it moves
+     * the persona's Overwatch clock back, so a slow search inside a host
+     * is what GOD bills for (utilities/overwatch.ts billTime, +2d6 per
+     * 15 minutes).
+     *
+     * WHAT IT FINDS. Inside a host, the host's archive: from then on the
+     * interior lists its files for this persona (Host.searchedBy,
+     * grid-view.ts). A CRACKED host spills them without the roll -- the
+     * seal is broken, there is nothing to find. Out on the grid it is the
+     * public-knowledge row: the loose data icons in reach.
+     */
+    matrixSearch() {
+        const actor = this.actor;
+        const host = actor.hostInside;
+        const where = host ? host.over : gridVicinity(actor);
+        const row = host ? MATRIX_SEARCH.inHost : MATRIX_SEARCH.public;
+        const browse = actor.activeDeck?.hasProgram('browse') ?? false;
+        const { pool, limit } = matrixSearchTest(actor);
+        const roll = rollPool(pool, limit);
+        const seconds = matrixSearchSeconds(row.seconds, roll.hits, row.threshold, browse);
+        const isPlayer = this.scene.isHumanControlled(actor);
+        if (isPlayer) {
+            this.logger.meta(`Matrix Search (Computer + Intuition [Data Processing], threshold ${row.threshold}${browse ? ', Browse' : ''}): ${formatRoll(roll)} -- ${seconds}s`);
+        }
+        // THE MINUTES ARE GOD'S (p.231-232): Overwatch bills time on the
+        // grid, and a search is time. Winding the last tick back by the
+        // seconds spent is what makes the next illegal action pay for them.
+        if (actor.overwatchLastTick > 0)
+            actor.overwatchLastTick -= seconds * 1000;
+        actor.performAction('runs a Matrix Search', host ? `inside ${hostLabel(where)}` : `across ${where.name}'s grid`);
+        const files = where.offlineServer ? [] : where.inventory.getAllItems().filter(i => i.plane === 'matrix');
+        const clock = `(${seconds}s of Matrix time${browse ? ', Browse cutting it' : ''})`;
+        if (roll.hits < row.threshold) {
+            return host
+                ? `You dig through ${hostLabel(where)}'s archive and the index keeps folding away from you -- nothing this pass. ${clock}${hint(` Try again; the host is not going anywhere.`)}`
+                : `You sweep ${where.name}'s grid for loose data and turn up nothing this pass. ${clock}`;
+        }
+        if (host) {
+            host.searchedBy.add(actor.name);
+            where.searchedBy.add(actor.name);
+            if (files.length === 0) {
+                return `The archive is indexed and EMPTY -- ${hostLabel(where)} keeps nothing worth the trip. ${clock}`;
+            }
+            const list = files.map(i => `${objectiveMark(this.scene, i.name)}${emphasizeFind(planeTintItemName(i, actor.plane))}`).join(', ');
+            const seal = where.hostCracked
+                ? hint(` ("take" them -- the seal is already broken.)`)
+                : hint(` (sealed in the host's data vault: "hack" the node to break the seal, then "take".)`);
+            return `The index gives up ${hostLabel(where)}'s archive: ${list}. ${clock}${seal}`;
+        }
+        where.searchedBy.add(actor.name);
+        const loose = where.hasNode ? [] : files;
+        if (loose.length === 0) {
+            const sealedElsewhere = files.length > 0 && where.hasNode;
+            return `Nothing loose on ${where.name}'s grid. ${clock}${sealedElsewhere ? hint(` (${hostLabel(where)} keeps its files INSIDE -- "enter" it and search from in there.)`) : ''}`;
+        }
+        const list = loose.map(i => `${objectiveMark(this.scene, i.name)}${emphasizeFind(planeTintItemName(i, actor.plane))}`).join(', ');
+        return `Loose on ${where.name}'s grid: ${list}. ${clock}${hint(` ("take" rides them out on your deck.)`)}`;
+    }
     async execute(_args) {
         const room = this.actor.currentLocation;
         // A MATRIX SEARCH IS MEASURED IN MINUTES (p.241: base time one
@@ -144,6 +213,8 @@ export class SearchCommand extends Command {
         if (this.actor.plane === 'matrix' && encounterOf(this.scene, this.actor)) {
             return `Not with the ice on you -- a Matrix Search takes minutes (p.241), and a Combat Turn is three seconds. Crash the ice or get out first.`;
         }
+        if (this.actor.plane === 'matrix')
+            return this.matrixSearch();
         // OBSERVE IN DETAIL (SR5 p.165): the Perception Test below is the
         // Simple Action the book names, inside a Combat Turn.
         const bill = billAction(this.scene, this.actor, 'simple', 'Observe in Detail');
@@ -155,17 +226,14 @@ export class SearchCommand extends Command {
         // room stays uncased ("take all" stays gated). Barriers (puzzles) are
         // in plain sight and show regardless -- you can't fail to notice the
         // maglock you're staring at.
-        // On the GRID a search is Matrix Search (canon: Computer, Logic) --
-        // best-of with perception so pre-computer deckers lose nothing.
-        // A loaded Browse program is purpose-built for Matrix Search: +2.
-        const browse = this.actor.plane === 'matrix' && this.actor.activeDeck?.hasProgram('browse') ? 2 : 0;
         // ACTIVE: this is the deliberate hunt, so it carries p.135-136's +3
         // for "perceiver is specifically looking for it" -- the modifier
         // that makes `search` mechanically different from `look` rather
         // than only differently named (FNgptvRhbA5yMunbB). The pool and the
         // bracket both live in utilities/perception.ts; look.ts rolls the
-        // same test without the +3.
-        const { pool, limit } = perceptionTest(this.actor, { active: true, browse });
+        // same test without the +3. The grid never comes through here: a
+        // persona's search is matrixSearch() above.
+        const { pool, limit } = perceptionTest(this.actor, { active: true });
         const roll = rollPool(pool, limit);
         // Roll anatomy to the Mechanics ticker for the player; an NPC's
         // return string is its AI history, so IT keeps the roll inline
@@ -234,28 +302,7 @@ export class SearchCommand extends Command {
         if (spotted.length > 0) {
             description += `\n{yellow-fg}You pick ${spotted.map(a => a.name).join(', ')} out of the shadows -- ${spotted.length === 1 ? 'they were' : 'they were'} there the whole time.{/yellow-fg}`;
         }
-        // Data is LOOT -- say so while the persona is standing on it, with the
-        // vault state attached: sealed files need the host cracked first. A
-        // real session's decker found the paydata jacked-in, didn't realize it
-        // was takeable from the grid, and went hunting for it in the meat.
-        if (this.actor.plane === 'matrix' && found.some(i => i.plane === 'matrix')) {
-            description += room.hasNode && !room.offlineServer && !room.hostCracked
-                ? `\n{cyan-fg}(the files sit sealed in the host's data vault -- "hack" the node to unseal them){/cyan-fg}`
-                : hint(`\n{cyan-fg}(data files are loot -- "take" them right here on the grid; they ride out on your deck){/cyan-fg}`);
-        }
-        // A persona sweeping the grid OUTSIDE a host: the files exist and
-        // this sweep cannot reach them. Say why, rather than reading empty
-        // -- a silent nothing is what made the old air-gap case feel broken.
-        if (this.actor.plane === 'matrix' && !filesInReach
-            && room.inventory.getAllItems().some(i => i.plane === 'matrix')) {
-            if (room.offlineServer) {
-                description += `\n{cyan-fg}There is a ${room.offlineServer} in this room and it is NOT on the Matrix -- nothing you can do from out here touches it.${hint(` Walk in and cable into it in the flesh.`)}{/cyan-fg}`;
-            }
-            else {
-                const marked = (room.hostMarksBy.get(this.actor.name) ?? 0) > 0 || room.hostCracked;
-                description += `\n{cyan-fg}This sweep only covers the open grid. Whatever the host holds is INSIDE it, behind its wall (p.246).${hint(marked ? ` "enter" and search again.` : ` A mark is the door -- "mark" the host, then "enter".`)}{/cyan-fg}`;
-            }
-        }
+        // The grid never reaches here: a persona's search is matrixSearch().
         // The mirror hint: a meat-side search can't see matrix files, but it
         // shouldn't pretend the room is empty when the good stuff is one
         // "jack in" away.

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

@@ -109,6 +109,7 @@ import { EndCallCommand } from './commands/end-call.js';
 import { fuzzyPickName, guessVerb } from './utilities/fuzzy-match.js';
 import { PickCommand } from './commands/pick.js';
 import { HackCommand } from './commands/hack.js';
+import { DisableCommand, BrickCommand } from './commands/disable.js';
 import { CastCommand } from './commands/cast.js';
 import { StanceCommand } from './commands/stance.js';
 import { FollowCommand, UnfollowCommand } from './commands/follow.js';
@@ -2596,6 +2597,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('end-call', EndCallCommand);
         CommandFactory.registerCommand('pick', PickCommand);
         CommandFactory.registerCommand('hack', HackCommand);
+        CommandFactory.registerCommand('disable', DisableCommand);
+        CommandFactory.registerCommand('brick', BrickCommand);
         CommandFactory.registerCommand('cast', CastCommand);
         CommandFactory.registerCommand('stance', StanceCommand);
         CommandFactory.registerCommand('surrender', SurrenderCommand);
@@ -6275,7 +6278,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // players" / "crew street"); the bare verb still answers quietly.
         { title: 'party', entries: [['crew', 'party'], ['hire'], ['dismiss'], ['train'], ['order'], ['lead'], ['command'], ['deploy'], ['recall'], ['stow']] },
         { title: 'magic', entries: [['spells'], ['cast'], ['summon', 'conjure'], ['project', 'astral'], ['return'], ['assense'], ['counterspell']] },
-        { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['mark'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
+        { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['mark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
         // The Emerged get their own shelf (player request: "there MUST be
         // resonance" -- matrix is the place, Resonance is the talent).
         // `sustain` shelves here and not under magic: the command is

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

@@ -126,6 +126,16 @@ export class Device {
     structure;
     armor;
     _barrierDamage = 0;
+    /**
+     * THE MATRIX CONDITION MONITOR (p.228): 8 + (Device Rating / 2)
+     * boxes, resisted with Device Rating + Firewall, filled by a Data
+     * Spike (commands/disable.ts, "brick"). Full = BRICKED: "the device
+     * ceases functioning" -- a camera records nothing, a smartgun sparks
+     * and dies -- but "a lock stays locked" (p.228): bricking is never a
+     * way through a maglock. Repaired on the bench (rest.ts), never by a
+     * reboot. A ward is not electronics and has no monitor at all.
+     */
+    _matrixDamage = 0;
     /**
      * THE LOCKSMITH EXTENDED TEST IN PROGRESS (p.48, p.359-360): picking a
      * maglock by hand accumulates hits toward Rating x 2 across attempts,
@@ -207,6 +217,33 @@ export class Device {
      * exact fault this codebase keeps having to close (see the gun in
      * aroTags, AKfemBJJWJP99nx8K).
      */
+    // ---- The Matrix condition monitor (commands/disable.ts) ----
+    /** p.228: 8 + (Device Rating / 2), rounded up as the deck's is. 0 for
+     *  a thing with no rating (a ward): nothing there to brick. */
+    get matrixMonitor() {
+        return this.rating > 0 ? 8 + Math.ceil(this.rating / 2) : 0;
+    }
+    get matrixDamage() {
+        return this._matrixDamage;
+    }
+    /** Returns boxes actually taken. */
+    takeMatrixDamage(boxes) {
+        if (this.matrixMonitor <= 0)
+            return 0;
+        const taken = Math.max(0, Math.floor(boxes));
+        this._matrixDamage = Math.min(this.matrixMonitor, this._matrixDamage + taken);
+        return taken;
+    }
+    get isBricked() {
+        return this.matrixMonitor > 0 && this._matrixDamage >= this.matrixMonitor;
+    }
+    /** Bench work (rest.ts): the whole monitor, at once. */
+    repairMatrix() {
+        this._matrixDamage = 0;
+    }
+    matrixSummary() {
+        return this.matrixMonitor > 0 ? `${this._matrixDamage}/${this.matrixMonitor} boxes` : '';
+    }
     broadcastsAro() {
         return this.wireless && this.rating > 0;
     }
@@ -328,11 +365,13 @@ export class Device {
         const text = hint(AFFORDANCE_FLAVOR[this.kind].hint);
         return text.length > 0 ? text : undefined;
     }
-    /** Persistence-only: one flag in, nothing out. */
+    /** Persistence-only: flags in, nothing out. */
     restoreState(state) {
         this.open = state.open;
         if (state.damage !== undefined)
             this._barrierDamage = Math.max(0, Math.min(this.structure, Math.floor(state.damage)));
+        if (state.bricked !== undefined)
+            this._matrixDamage = state.bricked ? this.matrixMonitor : 0;
     }
 }
 //# sourceMappingURL=device.js.map

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

@@ -41,6 +41,10 @@ export class Host {
     marksBy = new Map();
     /** player name -> marks the host holds on that player. */
     marksOn = new Map();
+    /** Personas whose Matrix Search (p.241, commands/search.ts) turned up
+     *  this host's files: the archive is listed for them from then on. A
+     *  cracked host lists it for everyone. Session-only. */
+    searchedBy = new Set();
     /** Walls up: the host holds a mark on an intruder and its ice is hunting. */
     alert = false;
     /** IC running now, by kind name. Names, not actors -- until increment 5. */

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

@@ -43,6 +43,12 @@ export class Item extends AbstractItem {
     // A jammed firearm can't fire (fists until cleared); "reboot" clears
     // every jammed device you carry, in the lull.
     jammed = false;
+    // BRICKED (p.228, commands/disable.ts "brick"): a Data Spike filled the
+    // device's Matrix condition monitor. Dead electronics -- a smartgun
+    // "sparks, crackles, and smokes" and will not fire -- until bench
+    // work (rest.ts). A reboot does NOT clear it; that is the whole
+    // difference from `jammed`.
+    bricked = false;
     _transferable;
     // New currency-related fields
     _currencyAmount = 0;

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

@@ -469,6 +469,12 @@ export class Room extends AbstractRoom {
     warded = false;
     // See IRoomConstructorConfig.watched (utilities/surveillance.ts).
     watched = false;
+    /** The cluster is LOOPED by Control Device (commands/disable.ts): the
+     *  house sees empty hallways until the run ends. Session-only. */
+    camerasLooped = false;
+    /** The cluster is BRICKED by a Data Spike (p.228): dead lenses, until
+     *  somebody's bench work nobody in this run is doing. Session-only. */
+    camerasBricked = false;
     /**
      * THE HOST STANDING OVER THIS ROOM, as an object (models/host.ts) --
      * increment 1 of the Matrix position model. Every host field this class

package/bundle/typescript/src/commands/game/sideQuest/utilities/grid-view.js

@@ -16,6 +16,25 @@ import { isWatched, camerasLive, canSnoopFeeds } from './surveillance.js';
  * ▣ PAN, ▲ dangerous device, ◇ data. (There is no air-gapped-host glyph
  * any more -- see hhSWzLSXECFtfoAGa and canReachHost.)
  */
+/**
+ * A DEVICE ICON, AND WHAT WORKS IT (commands/disable.ts, 2026-09-13).
+ * Control Device (p.238) needs 2 marks on the device -- "disable" -- and
+ * a Data Spike (p.239) needs none -- "brick". A bricked lock stays
+ * locked (p.228), so its line says so rather than offering a way in.
+ */
+export function deviceIconLine(device, actor) {
+    const dr = `{bold}[DR ${device.rating}]{/bold}`;
+    if (device.isOpen())
+        return `▤ ${device.name} ${dr} -- its icon standing open, nothing left to hold.`;
+    if (device.isBricked) {
+        return `▤ ${device.name} ${dr} -- BRICKED, dead electronics${device.kind === 'lock' ? '; the lock stays locked (p.228)' : ''}.`;
+    }
+    const marks = device.marksBy.get(actor.name) ?? 0;
+    const way = marks >= 2
+        ? `"disable ${device.name}" (Control Device, ${marks} marks held)`
+        : `"hack ${device.name}" for marks (${marks}/2 to command it), or "brick ${device.name}"`;
+    return `▤ ${device.name} ${dr} -- a device icon shaped like the thing itself, shut. (${way})`;
+}
 export function gridIcons(scene, actor, room) {
     // INSIDE A HOST IS A DIFFERENT PLACE (SR5 p.246, and Deditri's
     // eJANPpm7qCaCAJBJw). "The virtual space inside a host is separate
@@ -202,9 +221,7 @@ export function gridIcons(scene, actor, room) {
     for (const device of room.devices) {
         if (!device.broadcastsAro())
             continue;
-        icons.push(device.isOpen()
-            ? `▤ ${device.name} {bold}[DR ${device.rating}]{/bold} -- its icon standing open, nothing left to hold.`
-            : `▤ ${device.name} {bold}[DR ${device.rating}]{/bold} -- a device icon shaped like the thing itself, shut. ("hack ${device.name}")`);
+        icons.push(deviceIconLine(device, actor));
     }
     // The cameras, as a THING (surveillance.ts): live for security, looped,
     // or yours to ride.
@@ -306,7 +323,16 @@ function hostInteriorIcons(scene, actor, room) {
     const data = room.offlineServer
         ? []
         : room.inventory.getAllItems().filter(i => i.plane === 'matrix');
-    for (const item of data) {
+    // THE ARCHIVE IS NOT A GLANCE (p.241, player ruling 2026-09-13): a
+    // persona sees the host's files after a Matrix Search turns them up
+    // (commands/search.ts, Host.searchedBy), or when the host is cracked
+    // and they spill open. Until then a look says only that there is an
+    // archive to search.
+    const found = room.hostCracked || (room.host?.searchedBy.has(actor.name) ?? false);
+    if (data.length > 0 && !found) {
+        icons.push(`◇ The host's archive -- files in here somewhere, and a glance does not read an archive. ("search" runs a Matrix Search, p.241)`);
+    }
+    for (const item of found ? data : []) {
         icons.push(room.hostCracked
             ? `◇ ${item.name} [data] -- unsealed, sitting open in the host's archive. ("take" it)`
             : `◇ ${item.name} [data] -- SEALED in the host's archive. ("hack" the host to break the seal)`);

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

@@ -39,36 +39,65 @@ import { mentalLimit } from './limits.js';
  *  an active search mechanically different from a passive glance. */
 export const ACTIVELY_LOOKING = 3;
 /**
- * ON THE GRID IT IS A DIFFERENT TEST WITH A DIFFERENT BRACKET. Matrix
- * Search is Computer + Logic [Data Processing], so the Mental limit does
- * NOT apply out there -- capping a decker's sweep by their Willpower
- * would be a fresh deviation dressed as a fix. The engine takes the
- * best of Perception and Computer so pre-Computer deckers lose nothing
- * (a standing allowance, older than this function).
+ * THE MEAT PERCEPTION TEST. The Matrix used to ride through here as a
+ * "different test with a different bracket" -- Logic + the better of
+ * Perception and Computer [Data Processing] -- which was neither Matrix
+ * Perception nor Matrix Search. It is matrixSearchTest now, below; the
+ * grid never comes through this door.
+ */
+export function perceptionTest(actor, opts = {}) {
+    const skill = actor.skillRating('perception');
+    // Unskilled defaults at -1 (p.130), exactly as both callers already did.
+    const pool = Math.max(1, actor.intuition
+        + (skill > 0 ? skill : -1)
+        + (opts.active ? ACTIVELY_LOOKING : 0)
+        + actor.bonus('perception')
+        + actor.woundModifier
+        - actor.sustainingPenalty);
+    return { pool, limit: mentalLimit(actor) };
+}
+/**
+ * MATRIX SEARCH (SR5 p.241, RAG-checked 2026-09-13): a Special action,
+ * "Computer + Intuition [Data Processing]" -- INTUITION, not Logic; the
+ * old grid branch above rolled Logic and called it canon. The threshold
+ * and the base time come from what is being looked for (the Matrix
+ * Search Table: public 1 / 1 minute, limited 3 / 30 minutes; inside a
+ * host the base time is one minute whatever the information), net hits
+ * over the threshold divide the time, and a failure still spends all
+ * of it. A Browse program "cuts the base time in half" (Splintered
+ * State p.54) -- time, not dice. Running silent costs its -2 like every
+ * Matrix action (p.235-236).
  *
  * Data Processing reads 0 for an actor with no deck at all; that is a
  * caller's missing gate rather than a real limit, so it degrades to
  * unlimited here instead of handing rollPool a zero it would reject.
  */
-export function perceptionTest(actor, opts = {}) {
-    const onGrid = actor.plane === 'matrix';
-    const skill = onGrid
-        ? Math.max(actor.skillRating('perception'), actor.skillRating('computer'))
-        : actor.skillRating('perception');
-    const attribute = onGrid ? actor.logic : actor.intuition;
-    // Unskilled defaults at -1 (p.130), exactly as both callers already did.
-    const pool = Math.max(1, attribute
+export function matrixSearchTest(actor) {
+    const skill = actor.skillRating('computer');
+    const pool = Math.max(1, actor.intuition
         + (skill > 0 ? skill : -1)
-        + (opts.browse ?? 0)
-        + (opts.active ? ACTIVELY_LOOKING : 0)
         + actor.bonus('perception')
+        + (typeof actor.matrixActionPenalty === 'number' ? actor.matrixActionPenalty : 0)
         + actor.woundModifier
         - actor.sustainingPenalty);
-    const dataProcessing = onGrid ? actor.matrixAttribute('dataProcessing') : 0;
-    const limit = onGrid
-        ? (dataProcessing > 0 ? dataProcessing : undefined)
-        : mentalLimit(actor);
-    return { pool, limit };
+    const dataProcessing = actor.matrixAttribute('dataProcessing');
+    return { pool, limit: dataProcessing > 0 ? dataProcessing : undefined };
+}
+/** The Matrix Search Table (p.241-242): threshold and base time in
+ *  seconds. Inside a host the base time is one minute regardless. */
+export const MATRIX_SEARCH = {
+    public: { threshold: 1, seconds: 60 },
+    inHost: { threshold: 3, seconds: 60 },
+};
+/** How long a search takes once rolled: the base time divided by the
+ *  net hits over the threshold, never under one Combat Turn (3s); a
+ *  failure spends the whole base time. Browse halves the base. */
+export function matrixSearchSeconds(baseSeconds, hits, threshold, browse) {
+    const base = browse ? Math.ceil(baseSeconds / 2) : baseSeconds;
+    if (hits < threshold)
+        return base;
+    const net = hits - threshold;
+    return net > 0 ? Math.max(3, Math.ceil(base / net)) : base;
 }
 /**
  * PERCEPTION THRESHOLDS (p.136). Named because the numbers appear in

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

@@ -164,6 +164,8 @@ export function serializeItem(item) {
         out.loadedAmmo = item.loadedAmmo;
     if (item.jammed)
         out.jammed = true;
+    if (item.bricked)
+        out.bricked = true;
     if (item.deckDamage > 0)
         out.deckDamage = item.deckDamage;
     if (item.droneDamage > 0)
@@ -219,6 +221,8 @@ export function restoreItem(json) {
         item.loadedAmmo = json.loadedAmmo;
     if (json.jammed)
         item.jammed = true;
+    if (json.bricked)
+        item.bricked = true;
     if (json.deckDamage)
         item.takeDeckDamage(json.deckDamage);
     if (json.droneDamage)
@@ -663,7 +667,7 @@ export function captureHubOverlay(scene, hubSeed, player, homeRoom) {
         .map(n => n.player.name)
         .filter(name => !scene.getActor(name));
     const devices = [...collectDevices(scene).entries()]
-        .map(([name, d]) => ({ name, open: d.isOpen(), ...(d.barrierDamage > 0 ? { damage: d.barrierDamage } : {}) }));
+        .map(([name, d]) => ({ name, open: d.isOpen(), ...(d.barrierDamage > 0 ? { damage: d.barrierDamage } : {}), ...(d.isBricked ? { bricked: true } : {}) }));
     // THE TOMBSTONE (see ISavedHub.puzzles): always [], never read here.
     // Omitting it crashes v5.64.0's unguarded for-of on resume, and
     // saves move between builds via the cloud mirror.
@@ -824,7 +828,7 @@ export function applyHubOverlay(scene, saved, player, homeRoom) {
     for (const d of saved.devices ?? []) {
         const live = liveDevices.get(d.name);
         if (live)
-            live.restoreState({ open: d.open, damage: d.damage });
+            live.restoreState({ open: d.open, damage: d.damage, bricked: d.bricked });
     }
     // A SAVE WRITTEN BEFORE DEVICES EXISTED has no `devices` key at all,
     // so every device would read shut -- while the door it holds stays

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

@@ -85,6 +85,10 @@ export function directConnectionBlocker(actor, room) {
 export function camerasLive(rooms, room) {
     if (!isWatched(room))
         return false;
+    // Looped by Control Device or bricked by a Data Spike (commands/
+    // disable.ts): the house sees nothing from this cluster either way.
+    if (room.camerasLooped || room.camerasBricked)
+        return false;
     if (room.hasNode)
         return !room.hostCracked;
     const hosts = Object.values(rooms).filter(r => r.hasNode);

package/package.json

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