@maka/maka-cli 5.182.0 → 5.184.0

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)`);
@@ -414,20 +440,20 @@ export function gridSculpt(actor, room) {
         const purpose = room.host?.purpose;
         const sculpt = room.host?.sculpt;
         return [
-            `{cyan-fg}INSIDE :: ${hostLabel(room, { capital: true }).toUpperCase()} [HR ${room.hostRating}]${purpose ? ` -- ${purpose}` : ''}{/cyan-fg}`,
-            `{cyan-fg}${sculpt ?? 'Architecture all the way around -- the outside grid is a wall away and might as well be weather.'}{/cyan-fg}`,
+            `{lightblue-fg}INSIDE :: ${hostLabel(room, { capital: true }).toUpperCase()} [HR ${room.hostRating}]${purpose ? ` -- ${purpose}` : ''}{/lightblue-fg}`,
+            `{lightblue-fg}${sculpt ?? 'Architecture all the way around -- the outside grid is a wall away and might as well be weather.'}{/lightblue-fg}`,
         ].join('\n');
     }
     // ON THE GRID (SR5 pp.217-218): no street under the persona -- a black
     // flatland, the body's room named only because that is where the
     // signal comes from. A host directly overhead gets a line of its own.
     const body = actor.bodyRoom ?? room;
-    const header = `{cyan-fg}THE GRID :: jacked in from ${body.name.toUpperCase()}{/cyan-fg}`;
+    const header = `{lightblue-fg}THE GRID :: jacked in from ${body.name.toUpperCase()}{/lightblue-fg}`;
     const grid = actor.currentGrid;
-    const flat = `{cyan-fg}Black flatland under a black sky -- the icons are the only things out here.${grid ? ` Riding ${grid.name}${grid.userPenalty ? ' (-2 on everything you do, p.233)' : ''}.` : ''}{/cyan-fg}`;
+    const flat = `{lightblue-fg}Black flatland under a black sky -- the icons are the only things out here.${grid ? ` Riding ${grid.name}${grid.userPenalty ? ' (-2 on everything you do, p.233)' : ''}.` : ''}{/lightblue-fg}`;
     if (!room.hasNode)
         return `${header}\n${flat}`;
-    return `${header}\n${flat}\n{cyan-fg}${hostLabel(room, { capital: true })} hangs directly overhead, sealed. What it holds is inside it.{/cyan-fg}`;
+    return `${header}\n${flat}\n{lightblue-fg}${hostLabel(room, { capital: true })} hangs directly overhead, sealed. What it holds is inside it.{/lightblue-fg}`;
 }
 /**
  * The icons rendered as the standard cyan block, or the thin-grid line.
@@ -456,19 +482,19 @@ export function gridIconBlock(scene, actor, room, rooms) {
     if (actor.insideHost || !rooms) {
         const icons = gridIcons(scene, actor, room);
         if (icons.length === 0) {
-            return `{cyan-fg}Thin grid out here -- background noise, nothing worth cracking.{/cyan-fg}`;
+            return `{lightblue-fg}Thin grid out here -- background noise, nothing worth cracking.{/lightblue-fg}`;
         }
-        return `{cyan-fg}ICONS IN REACH:{/cyan-fg}\n${icons.map(i => `  {cyan-fg}${i}{/cyan-fg}`).join('\n')}`;
+        return `{lightblue-fg}ICONS IN REACH:{/lightblue-fg}\n${icons.map(i => `  {lightblue-fg}${i}{/lightblue-fg}`).join('\n')}`;
     }
     const out = [];
     const hosts = hostsInReach(rooms, actor);
     out.push(hosts.length > 0
-        ? `{cyan-fg}HOSTS OVERHEAD:{/cyan-fg}\n${hosts.map(h => `  {cyan-fg}${hostLine(h, actor)}{/cyan-fg}`).join('\n')}`
-        : `{cyan-fg}Nothing overhead -- no host stands over this district.{/cyan-fg}`);
+        ? `{lightblue-fg}HOSTS OVERHEAD:{/lightblue-fg}\n${hosts.map(h => `  {lightblue-fg}${hostLine(h, actor)}{/lightblue-fg}`).join('\n')}`
+        : `{lightblue-fg}Nothing overhead -- no host stands over this district.{/lightblue-fg}`);
     const near = gridIcons(scene, actor, gridVicinity(actor)).filter(i => !isHostLine(i));
     out.push(near.length > 0
-        ? `{cyan-fg}ICONS IN REACH:{/cyan-fg}\n${near.map(i => `  {cyan-fg}${i}{/cyan-fg}`).join('\n')}`
-        : `{cyan-fg}Nothing near -- background noise around your signal.{/cyan-fg}`);
+        ? `{lightblue-fg}ICONS IN REACH:{/lightblue-fg}\n${near.map(i => `  {lightblue-fg}${i}{/lightblue-fg}`).join('\n')}`
+        : `{lightblue-fg}Nothing near -- background noise around your signal.{/lightblue-fg}`);
     // FARTHER OUT, WITHOUT AN ADDRESS (SR5 p.235, p.243): Matrix Perception
     // never tells you where a device physically sits -- that is Trace Icon,
     // two marks and an opposed test. So far icons are listed by the noise
@@ -493,9 +519,9 @@ export function gridIconBlock(scene, actor, room, rooms) {
         byBand.set(noise, list);
     }
     const far = [...byBand.entries()].sort((a, b) => a[0] - b[0])
-        .map(([noise, names]) => `  {cyan-fg}· dim, noise -${noise}: ${names.join(', ')}{/cyan-fg}`);
+        .map(([noise, names]) => `  {lightblue-fg}· dim, noise -${noise}: ${names.join(', ')}{/lightblue-fg}`);
     if (far.length > 0)
-        out.push(`{cyan-fg}FARTHER OUT -- dimmer with distance:{/cyan-fg}\n${far.join('\n')}`);
+        out.push(`{lightblue-fg}FARTHER OUT -- dimmer with distance:{/lightblue-fg}\n${far.join('\n')}`);
     // A blank line between the distance bands (user, 2026-09-02): three
     // sections read as three when they do not touch.
     return out.join('\n\n');
@@ -510,7 +536,7 @@ export function gridIconBlock(scene, actor, room, rooms) {
  * the other personas, and the files. Cut to the dock's rows and columns.
  */
 export function hostInteriorPanel(scene, actor, host, rows, cols) {
-    const cut = (raw) => `{cyan-fg}${[...raw].slice(0, Math.max(4, cols)).join('')}{/cyan-fg}`;
+    const cut = (raw) => `{lightblue-fg}${[...raw].slice(0, Math.max(4, cols)).join('')}{/lightblue-fg}`;
     const lines = [];
     lines.push(cut(`INSIDE ${host.name}`));
     if (host.purpose)

package/bundle/typescript/src/commands/game/sideQuest/utilities/matrix-style.js

@@ -0,0 +1,8 @@
+export const MATRIX_COLOR = 'lightblue';
+export const FEED_COLOR = 'white';
+export const TURN_COLOR = 'yellow';
+/** Matrix-plane prose, tagged. */
+export function mx(text) {
+    return `{${MATRIX_COLOR}-fg}${text}{/${MATRIX_COLOR}-fg}`;
+}
+//# sourceMappingURL=matrix-style.js.map

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

@@ -58,10 +58,10 @@ export function accrueOverwatch(scene, actor, defenseHits, why) {
     // The grid's built-in warning system (p.221): subtle ripples, once
     // per band -- the only free hint the player ever gets.
     if (before < 30 && actor.overwatchScore >= 30) {
-        return { lines: [`{cyan-fg}The grid RIPPLES -- hard, close, and looking. Something vast has nearly found the thread you're hanging by. ("reboot" is a clean slate.){/cyan-fg}`], converged: false };
+        return { lines: [`{lightblue-fg}The grid RIPPLES -- hard, close, and looking. Something vast has nearly found the thread you're hanging by. ("reboot" is a clean slate.){/lightblue-fg}`], converged: false };
     }
     if (before < 20 && actor.overwatchScore >= 20) {
-        return { lines: [`{cyan-fg}A ripple crosses the grid -- subtle, wrong, deliberate. Somewhere above, an eye has started counting your fingerprints.{/cyan-fg}`], converged: false };
+        return { lines: [`{lightblue-fg}A ripple crosses the grid -- subtle, wrong, deliberate. Somewhere above, an eye has started counting your fingerprints.{/lightblue-fg}`], converged: false };
     }
     return { lines: [], converged: false };
 }

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

@@ -107,7 +107,7 @@ export function enterMatrix(scene, actor, mode) {
     // half-done, which would be a fresh canon violation wearing a
     // feature's clothes. See the PR for CgJ6uTfEvTd8JXdDN.
     actor.activeDeck = actor.isTechnomancer() ? undefined : actor.getCyberdeck();
-    actor.performAction('jacks in', `slumping where they stand, eyes flickering (${mode}-sim)`);
+    actor.performAction('jacks in', `slumping where they stand, eyes flickering (${mode}-sim)`, { quiet: scene.isHumanControlled?.(actor) ?? false });
     scene.addWorldEvent(`${actor.name} jacked into the Matrix in ${actor.bodyRoom.name}.`);
     Logger.getInstance().write(`${actor.name} entered the Matrix (${mode}-sim, ${actor.activeDeck?.name ?? (actor.isTechnomancer() ? 'living persona' : 'no deck?!')}) from ${actor.bodyRoom.name}.`);
     const hotWarning = mode === 'hot'
@@ -267,7 +267,7 @@ export function leaveMatrix(scene, actor, opts) {
         actor.bodyRoom = undefined;
         lines.push(`You're back in your body in ${body.name}.`);
     }
-    actor.performAction('jacks out', 'stirring awake');
+    actor.performAction('jacks out', 'stirring awake', { quiet: scene.isHumanControlled?.(actor) ?? false });
     scene.addWorldEvent(`${actor.name} jacked out of the Matrix.`);
     scene.updateStatus();
     return lines;
@@ -449,7 +449,7 @@ export function fileReach(actor, room) {
  */
 export function planeTintItemName(item, viewerPlane) {
     if (item.plane === 'matrix') {
-        return `{cyan-fg}${item.name} [data]{/cyan-fg}`;
+        return `{lightblue-fg}${item.name} [data]{/lightblue-fg}`;
     }
     if (item.plane === 'astral') {
         return `{magenta-fg}${item.name} [astral]{/magenta-fg}`;

package/bundle/typescript/src/commands/game/sideQuest/utilities/shared-run.js

@@ -24,6 +24,7 @@ import { join, dirname } from 'node:path';
 import { Logger } from './logger.js';
 import { hint } from './hints.js';
 import { CALL_ICON, CALL_COLOR, END_CALL_SENTINEL } from './comm-style.js';
+import { FEED_COLOR } from './matrix-style.js';
 import { ENGINE_VERSION } from '../engine-version.js';
 import { authToken, fetchSave } from './cloud-saves.js';
 import { saveSlug, restorePlayer, writeSaveAtomic } from './persistence.js';
@@ -1143,7 +1144,7 @@ export class SharedRunSession {
                     break;
                 }
                 for (const line of ev.text.split('\n'))
-                    g.logBox?.pushLine(`{cyan-fg}${line}{/cyan-fg}`);
+                    g.logBox?.pushLine(`{${FEED_COLOR}-fg}${line}{/${FEED_COLOR}-fg}`);
                 Logger.getInstance().transcript(ev.text);
                 g.followLog?.();
                 if (ev.kind === 'death' && ev.data?.player === g.player.name) {

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.184.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.",