@maka/maka-cli 5.219.0 → 5.221.0

package/bundle/typescript/package.json

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

@@ -72,7 +72,7 @@ export class DisableCommand extends Command {
         // 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)
+        const matching = (room) => room.openableDevices().filter(d => d.rating > 0).filter(d => d.hasIconFor(actor.name)).filter(d => d.name.toLowerCase().includes(raw)
             || (d.opensExit ?? '').toLowerCase() === raw
             || d.description.toLowerCase().includes(raw));
         const inside = actor.insideHost;

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

@@ -569,7 +569,7 @@ export class HackCommand extends BypassCommand {
         if (!named)
             return null;
         const raw = named.toLowerCase();
-        const matching = (room) => room.openableDevices().filter(d => d.rating > 0).filter(d => d.name.toLowerCase().includes(raw)
+        const matching = (room) => room.openableDevices().filter(d => d.rating > 0).filter(d => d.hasIconFor(actor.name)).filter(d => d.name.toLowerCase().includes(raw)
             || (d.opensExit ?? '').toLowerCase() === raw
             || d.description.toLowerCase().includes(raw));
         // INSIDE THE HOST you are directly connected to every device on

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

@@ -19,6 +19,7 @@ import { rollPool, formatRoll } from '../utilities/dice.js';
 import { findCatalogItem, describeEffect } from '../utilities/catalog.js';
 import { billAction } from '../utilities/action-cost.js';
 import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
+import { spotHiddenIcons, spotLine, spotMechanics } from '../utilities/silent-icons.js';
 export class LookCommand extends Command {
     static verb = 'look';
     static description = 'Examine your surroundings';
@@ -322,8 +323,25 @@ export class LookCommand extends Command {
         // IS the meat world: the furniture, the smells, the people leaning
         // on it. gridSculpt (grid-view.ts) orients on what a persona
         // actually stands in: the room's name and the density of its grid.
+        // SWEEP FOR WHAT IS HIDING, BEFORE DRAWING THE LIST (p.217: "some
+        // icons are deliberately hidden from view, such as locks and other
+        // security devices ... and of course people who prefer not to be
+        // seen"; p.235-236, p.241 for the test). `look` on the grid IS
+        // Matrix Perception and is already billed as one above, so the
+        // sweep costs exactly what canon charges and a second look is a
+        // second action. Run FIRST so anything this sweep turns up appears
+        // in the icon block below rather than one look later.
+        const swept = spotHiddenIcons(this.scene, this.actor, this.actor.insideHost === room ? room : gridVicinity(this.actor));
         const lines = [gridSculpt(this.actor, room)];
         lines.push(gridIconBlock(this.scene, this.actor, room, this.rooms));
+        if (swept) {
+            lines.push(spotLine(swept));
+            if (showsMechanics(this.scene, this.actor)) {
+                for (const m of spotMechanics(swept)) {
+                    this.logger.meta(`${mechanicsActorPrefix(this.scene, this.actor)}${m}`);
+                }
+            }
+        }
         // THE COACHING HAS TO MATCH THE ROOM YOU ARE IN. Inside a host,
         // `go` is refused (go.ts checkHostBoundary) and `map` draws the
         // outside grid you cannot reach -- so offering both is the same

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

@@ -313,10 +313,28 @@ export class SayCommand extends Command {
         // presence on the grid and is not -- "call" is still the verb that
         // reaches a body.
         if (currentPlayer.plane === 'matrix' && !(this.actor instanceof NPC)) {
-            const heard = speakOnTheGrid(this.scene, currentPlayer, '').map(a => a.name);
-            return heard.length > 0
-                ? `Your persona speaks and the grid carries it: ${heard.join(', ')} ${heard.length === 1 ? 'is' : 'are'} on this side of the architecture and hears you. Bodies in the room hear nothing -- you have no voice out there.`
-                : `Your words go out over the grid and find no persona to land on. Anyone here in the FLESH hears nothing -- a PAN icon is a commlink in somebody's pocket, not a person you can talk to. ("call <name>" reaches a body.)`;
+            const { personas, links } = speakOnTheGrid(this.scene, currentPlayer, '');
+            const iconNames = personas.map(a => a.name);
+            const linkNames = links.map(a => a.name);
+            const lines = [];
+            if (iconNames.length > 0) {
+                lines.push(`Your persona speaks and the grid carries it: ${iconNames.join(', ')} ${iconNames.length === 1 ? 'is' : 'are'} on this side of the architecture and hears you.`);
+            }
+            // A COMMLINK IS FOR TALKING (FhXadizkMCxAdMaJx). This used to be
+            // the refusal -- "a PAN icon is a commlink in somebody's pocket,
+            // not a person you can talk to" -- which had the fact right and
+            // drew the wrong conclusion. It IS a commlink in their pocket, and
+            // that is precisely a thing you can speak out of.
+            if (linkNames.length > 0) {
+                lines.push(`It comes out of ${linkNames.join(', ')}'s commlink where ${linkNames.length === 1 ? 'they stand' : 'they stand'} in the flesh -- your voice out of ${linkNames.length === 1 ? 'their' : 'their'} pocket, not out of the air.`);
+            }
+            if (lines.length === 0) {
+                return `Your words go out over the grid and land on nothing. No persona on this side of the architecture, and nobody near your body is carrying a live commlink for them to come out of. ("call <name>" reaches somebody further off.)`;
+            }
+            if (linkNames.length === 0) {
+                lines.push(`Bodies in the room hear nothing -- nobody there is carrying a live link.`);
+            }
+            return lines.join('\n');
         }
         return farOff;
     }

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

@@ -52,10 +52,21 @@ export class ShoutCommand extends Command {
             // each other or they do not, and no amount of volume crosses a
             // host wall. So this routes to the same fan-out `say` uses rather
             // than inventing a louder one.
-            const heard = speakOnTheGrid(this.scene, actor, message).map(a => a.name);
-            return heard.length > 0
-                ? `You push it out across the grid: "${message}"\n  Heard by ${heard.join(', ')}.`
-                : `You push it out across the grid -- nothing out here is listening.`;
+            // Both halves of the fan-out, named apart: a persona beside you and
+            // a commlink in somebody's pocket are two different places for your
+            // voice to come out of, and only one of them is standing in the
+            // same room as your body (FhXadizkMCxAdMaJx).
+            const { personas, links } = speakOnTheGrid(this.scene, actor, message);
+            const heard = personas.map(a => a.name);
+            const onLink = links.map(a => a.name);
+            if (heard.length === 0 && onLink.length === 0) {
+                return `You push it out across the grid -- nothing out here is listening.`;
+            }
+            const who = [
+                ...(heard.length > 0 ? [`Heard by ${heard.join(', ')}.`] : []),
+                ...(onLink.length > 0 ? [`Out of ${onLink.join(', ')}'s commlink, where they stand in the flesh.`] : []),
+            ];
+            return `You push it out across the grid: "${message}"\n  ${who.join('\n  ')}`;
         }
         const heard = actor.currentLocation.shout(actor, message);
         if (!(this.actor instanceof NPC)) {

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

@@ -1205,5 +1205,79 @@
 //   other at all. The meat case is pinned in the same test file, because
 //   a fix that traded this report for the older one it was built from
 //   would be no fix.
-export const ENGINE_VERSION = '1.78.0';
+// 1.79.0 (2026-09-16): A COMMLINK IS FOR TALKING (FhXadizkMCxAdMaJx,
+//   Maka, rejecting the first fix: "this looks like it's backwards. If I
+//   jack in, and Grunt's icon is in reach, he SHOULD hear me through his
+//   icon when I do a 'say'"). He is right and the books agree. p.246
+//   names this as the exception to the host wall itself -- from outside
+//   a host "you can't interact directly with icons inside it, ALTHOUGH
+//   you can still send messages, make commcalls, and that sort of thing"
+//   -- and nothing anywhere requires the person on the other end to be
+//   jacked in. The old answer, "a PAN icon is a commlink in somebody's
+//   pocket, not a person you can talk to", had the fact right and drew
+//   the wrong conclusion from it: a commlink in somebody's pocket is
+//   exactly a thing a voice can come out of.
+//   - `say` and `shout` from the grid now reach the PERSONAS beside you
+//     (as always) AND the live commlinks of people standing around your
+//     BODY, delivered with hear()'s existing viaLink so the NPC knows it
+//     came out of their pocket rather than from a mouth in the room.
+//   - SCOPED TO THE VICINITY, not the district. Canon would let a
+//     persona call a commlink anywhere on the grid -- distance is noise,
+//     not range -- but a `say` that rang every commlink in the barrens
+//     is a broadcast nobody asked for. "In reach" means what it means in
+//     the icon list the reporter was reading: the room the body is in.
+//     `call <name>` still reaches further.
+//   - isLinked is the test, the same predicate that decides whether a
+//     body is a ▣ icon at all, so the icon list and the voice agree: no
+//     link, no icon, no pocket for the words to come out of -- and the
+//     refusal says which of the two reasons it was.
+//   The old test asserted the right refusal for the WRONG REASON: its
+//   comment claimed "Krow is HERE, in the flesh, with a PAN icon on the
+//   grid" while its fixture gave him no commlink at all, so there was
+//   never a PAN icon in it. Pinned properly now, both ways.
+// 1.80.0 (2026-09-16): SECURITY ICONS ARE DELIBERATELY HIDDEN
+//   (eJANPpm7qCaCAJBJw). The reporter rejected the last pass with "double
+//   check canon again", then quoted p.217 in full, and the full sentence
+//   is the whole design:
+//     "some icons are deliberately hidden from view, such as locks and
+//      other security devices, baby monitors, maintenance monitors, and
+//      of course PEOPLE WHO PREFER NOT TO BE SEEN."
+//   Two things fall out of that list. It is ONE list -- the maglock and
+//   the runner who went dark in the same breath -- and the last clause
+//   identifies the mechanic: "people who prefer not to be seen" is
+//   RUNNING SILENT (p.235-236), the only hiding the rules define. So
+//   nothing here is invented; the sentence points at a rule that existed.
+//   - Device.silent, true by default for the security kinds ('lock',
+//     'panel' -- the maglock, the keypad, the safe). A ward is the Art
+//     and has no wireless mode to hide in.
+//   - CAMERAS TOO, which p.217 names FIRST. The cluster is not a Device
+//     (it is derived from the room), so it hides on Room.camerasSpottedBy
+//     and resists with its master host's rating -- a site's lenses are as
+//     quiet as the security that runs them.
+//   - AND PEOPLE. Going dark used to make an icon simply unfindable:
+//     isLinked answers false and nothing anywhere rolled to beat it, so
+//     the book's own example of a hidden icon was the one case with no
+//     way through. Player.matrixSpottedBy closes it.
+//   - THE SWEEP is utilities/silent-icons.ts, fired by `look` on the grid
+//     -- because `look` there IS Matrix Perception (p.241) and is already
+//     billed as the Complex Action it is. A second look is a second
+//     action, which is what makes a dark room cost something. Ties go to
+//     the hider (p.236). Per viewer: one decker spotting an icon does not
+//     hand it to the team.
+//   - A MISS STILL REPORTS SOMETHING IS THERE, which is step one of the
+//     canon two-step: a hit buys "there are icons running silent in the
+//     vicinity" (p.235-236). A failed sweep is not silence -- it is the
+//     difference between a hidden lock and a door with no lock on it.
+//   - THE ICON HIDES; THE OBJECT DOES NOT. This is a Matrix fact and
+//     nothing else. The maglock is still screwed to the door, still
+//     described by a meat-world look, still picked, breached, shot and
+//     keyed exactly as before. Only the grid view, the AR overlay,
+//     Matrix-side Tab and Matrix-side targeting ask the question -- and
+//     the AR overlay matters: hide the icon on the grid alone and the
+//     street overlay quietly becomes a free Matrix Perception.
+//   NOT INVENTED, deliberately: the -2 a silent icon pays is left on what
+//   it DOES (p.235-236, already charged to players through
+//   matrixActionPenalty) rather than added to its hide roll. Spending it
+//   twice would be a house rule wearing a citation.
+export const ENGINE_VERSION = '1.80.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -16,6 +16,15 @@ export const DEFAULT_DEVICE_RATING = {
     lock: 2,
     panel: 2,
 };
+/**
+ * WHICH KINDS ARE BORN DARK (p.217-218: "some icons are deliberately
+ * hidden from view, such as locks and other security devices"; user
+ * ruling 2026-09-16 on what that covers -- "cameras, locks, sensors
+ * etc"). In this engine a 'lock' and a 'panel' ARE the security
+ * furniture: the maglock, the keypad, the safe. A 'ward' is the Art and
+ * has no wireless mode to hide in.
+ */
+export const SILENT_BY_DEFAULT = new Set(['lock', 'panel']);
 /**
  * THE BOOK'S BARRIER TIERS (p.197 Barrier Ratings, RAG-checked 2026-09-03):
  * Structure / Armor. Fragile is standard glass; Reinforced is a security
@@ -116,6 +125,56 @@ export class Device {
      */
     rating;
     wireless;
+    /**
+     * RUNNING SILENT (p.235-236), and why a maglock is born that way
+     * (eJANPpm7qCaCAJBJw; user ruling 2026-09-16: security devices means
+     * "cameras, locks, sensors etc").
+     *
+     * p.217-218: "some icons are deliberately hidden from view, such as
+     * locks and other security devices." The books do not give that
+     * sentence a mechanic of its own, and RUNNING SILENT is the only
+     * hiding the rules define -- a state an owner CHOOSES, which is
+     * exactly what a site does with its own security. Splintered State
+     * p.47-50 runs the same play with a whole host ("the entire Security
+     * Host is running silent... a character must succeed a Matrix
+     * Perception test... the Security Host receives a -2 dice pool penalty
+     * to all actions due to running silent"), so this is published
+     * practice rather than an invention.
+     *
+     * IT IS A TRADE, NOT A WALL. Silent costs the device -2 on everything
+     * it does (see deviceDefensePool), so a lock that is hard to FIND is
+     * easier to crack once found. That is the whole bargain, and it is why
+     * this is not simply "security devices are invisible".
+     *
+     * THE ICON HIDES; THE OBJECT DOES NOT. This is a Matrix fact and
+     * nothing else. The maglock is still screwed to the door, still
+     * described by a meat-world `look`, still picked, breached, shot and
+     * opened with a key exactly as before -- bypass-command.ts and the
+     * spot system never ask this question. Only the grid view, the AR
+     * overlay and Matrix-side targeting do.
+     */
+    silent;
+    /**
+     * WHO HAS SPOTTED IT, by name -- the other half of running silent.
+     *
+     * Session-scoped and per VIEWER, the same shape as Room.revealedBy and
+     * Host.spotted, and for the same reason: one decker beating the
+     * opposed test does not hand the icon to everybody on the team. Once
+     * found, it stays found -- a silent icon you have already pinned does
+     * not go missing again between looks.
+     */
+    spottedBy = new Set();
+    /** Is this icon on the grid for this viewer? Wireless and rated (the
+     *  old broadcastsAro question), and either loud or already spotted. */
+    hasIconFor(viewerName) {
+        if (!this.broadcastsAro())
+            return false;
+        return !this.silent || this.spottedBy.has(viewerName);
+    }
+    /** Hidden from this viewer, and therefore worth rolling against. */
+    isHiddenFrom(viewerName) {
+        return this.broadcastsAro() && this.silent && !this.spottedBy.has(viewerName);
+    }
     /**
      * WHAT IT IS MADE OF (p.197-198): Structure is the condition monitor
      * shooting it fills, Armor is what it soaks with. Reaching Structure
@@ -166,6 +225,12 @@ export class Device {
         // because a seeded keypad nobody thought about is a keypad on the
         // grid -- which is the state the report says the game should model.
         this.wireless = config.kind === 'ward' ? false : (config.wireless ?? true);
+        // SECURITY IS SILENT BY DEFAULT (p.217-218: "locks and other
+        // security devices"). In this engine a 'lock' and a 'panel' ARE the
+        // security furniture -- the maglock, the keypad, the safe -- so both
+        // are born dark unless a seed says otherwise. A 'ward' has no
+        // wireless mode to hide in the first place.
+        this.silent = config.kind === 'ward' ? false : (config.silent ?? SILENT_BY_DEFAULT.has(config.kind));
     }
     isOpen() {
         return this.open;

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

@@ -150,6 +150,22 @@ export class Player extends AbstractPlayer {
     // but stops broadcasting -- no calls out, and nobody can raise this
     // actor (call.ts checks both ends). Toggling it drops any active call.
     runningSilent = false;
+    /**
+     * WHO HAS PICKED THIS ICON OUT OF THE NOISE, by name.
+     *
+     * The other half of running silent, and the half that was missing:
+     * going dark used to make an icon simply unfindable, because isLinked
+     * answers false and nothing anywhere rolled to beat it. p.217 lists
+     * "people who prefer not to be seen" beside the locks and the
+     * maintenance monitors, and p.236 gives the way through all of them --
+     * an Opposed Computer + Intuition [Data Processing] v. Logic + Sleaze.
+     * utilities/silent-icons.ts rolls it; this remembers who won.
+     *
+     * Session-scoped and per VIEWER, the same shape as Device.spottedBy,
+     * Room.revealedBy and Host.spotted: one decker beating the test does
+     * not hand the icon to the whole team.
+     */
+    matrixSpottedBy = new Set();
     // Whoever this actor most recently traded combat exchanges with, and
     // when -- set for BOTH sides by CombatExchange.beginExchange(). Walking
     // out on a live, recent opponent invites a parting shot (see go.ts);

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

@@ -59,6 +59,21 @@ export class Room extends AbstractRoom {
     // searchedBy/visitedBy (fresh Rooms per scene), and per-VIEWER: one
     // runner spotting the sniper doesn't hand them to everyone.
     revealedBy = new Map();
+    /**
+     * WHO HAS SPOTTED THE CAMERAS, by name (eJANPpm7qCaCAJBJw; p.217 names
+     * cameras first in its list of icons "deliberately hidden from view").
+     *
+     * The camera cluster is not a Device -- it is derived from the room
+     * itself (utilities/surveillance.ts isWatched), so it cannot carry
+     * Device.spottedBy and needs its own set. Same contract as that one:
+     * session-scoped, per VIEWER, and once found it stays found.
+     *
+     * The LENSES are not hidden, only their icon. A body in the room still
+     * sees cameras on the wall with its eyes and can still "tap" one in
+     * the flesh; what takes a Matrix Perception is picking their icon out
+     * of the grid.
+     */
+    camerasSpottedBy = new Set();
     /**
      * THE FALLEN (player ruling 2026-08-25). A killed actor leaves a BODY
      * where they dropped, holding everything they carried, instead of

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

@@ -140,7 +140,9 @@ export function aroTags(scene, actor, room) {
     }
     // THE EYES. Whether they are looped is knowledge you had to take from
     // the host, so it shows only to whoever owns the feeds.
-    if (isWatched(room)) {
+    // Same gate as the grid: this overlay draws ICONS, and a camera icon
+    // is the first thing p.217 lists as deliberately hidden until spotted.
+    if (isWatched(room) && room.camerasSpottedBy.has(actor.name)) {
         const rooms = scene.getRooms();
         // The verb rides the tag: standing in the room IS the requirement
         // for a direct connection (commands/tap.ts), so this is the one
@@ -165,7 +167,12 @@ export function aroTags(scene, actor, room) {
     // The RATING RIDES THE TAG for the same reason the host's [HR] does --
     // it is the number you decide against before touching anything.
     for (const device of room.devices) {
-        if (!device.broadcastsAro())
+        // The same gate as the grid view. This overlay draws ICONS, and an
+        // icon running silent is not one of them until it has been spotted
+        // (p.217, p.235-236). The OBJECT is untouched: the maglock is still
+        // screwed to the door, still described by a meat-world `look`, and
+        // still picked, breached, shot and keyed exactly as before.
+        if (!device.hasIconFor(actor.name))
             continue;
         tags.push(`▤ ${device.name} -- wireless, {bold}[DR ${device.rating}]{/bold}${device.isOpen() ? ', standing open' : `.${hint(` ("${device.verbs()[0]} ${device.name}")`)}`}`);
     }

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

@@ -256,13 +256,23 @@ export function gridIcons(scene, actor, room) {
     // device has an icon, it looks like the object, and it carries a
     // Device Rating (p.219, p.234).
     for (const device of room.devices) {
-        if (!device.broadcastsAro())
+        // HIDDEN ICONS ARE HIDDEN (p.217, eJANPpm7qCaCAJBJw). A silent lock
+        // is not on the grid until THIS viewer has beaten it in an opposed
+        // Matrix Perception (utilities/silent-icons.ts) -- per viewer,
+        // because one decker spotting it does not hand it to the team.
+        if (!device.hasIconFor(actor.name))
             continue;
         icons.push(deviceIconLine(device, actor));
     }
     // The cameras, as a THING (surveillance.ts): live for security, looped,
     // or yours to ride.
-    if (isWatched(room)) {
+    //
+    // p.217 NAMES CAMERAS FIRST among the icons "deliberately hidden from
+    // view" (eJANPpm7qCaCAJBJw). The lenses are still bolted to the wall,
+    // still described in the meat, and a body still "tap"s one in the
+    // flesh -- it is the ICON that takes a Matrix Perception to pick out
+    // of the noise (utilities/silent-icons.ts).
+    if (isWatched(room) && room.camerasSpottedBy.has(actor.name)) {
         const rooms = scene.getRooms();
         if (!camerasLive(rooms, room)) {
             icons.push(`◎ Camera cluster -- looped on empty hallways. Security sees NOTHING here.${canSnoopFeeds(rooms, room, actor) ? ` ("snoop" rides the feeds you own)` : ''}`);

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

@@ -1,5 +1,6 @@
 import { roomsInReach } from './grid-reach.js';
 import { NPC } from '../models/npc.js';
+import { isLinked } from './comm-style.js';
 /**
  * WHO A PERSONA CAN REACH (increment 2 of the Matrix position model,
  * 2026-09-02). The persona's position is `Player.matrixPosition` -- on a
@@ -35,13 +36,62 @@ export function cybercombatCandidates(scene, actor) {
 export function speechAudience(scene, actor) {
     return personasOnMySide(scene, actor);
 }
-/** Delivers a persona's words to its audience, the way Room.say delivers a body's. */
+/**
+ * THE COMMLINKS IN EARSHOT OF YOUR BODY (FhXadizkMCxAdMaJx, Maka: "this
+ * looks like it's backwards. If I jack in, and Grunt's icon is in reach,
+ * he SHOULD hear me through his icon when I do a 'say'").
+ *
+ * He is right, and the books agree. A commlink is a COMMUNICATION
+ * device: p.246 says that even across a host wall "you can still send
+ * messages, make commcalls, and that sort of thing", and nothing
+ * anywhere requires the person on the other end to be jacked in -- a
+ * commcall rings a commlink in somebody's pocket, which is what a
+ * commlink is for. The engine's old answer, "a PAN icon is a commlink in
+ * somebody's pocket, not a person you can talk to", had the fact right
+ * and drew the wrong conclusion from it.
+ *
+ * SCOPED TO THE VICINITY, not the district. Canon would let a persona
+ * call a commlink anywhere on the grid -- distance is noise, not range
+ * -- but `say` is the verb for speaking to the people around you, and a
+ * `say` that rang every commlink in the barrens would be a broadcast
+ * nobody asked for. The room your body is slumped in is what "in reach"
+ * means in the icon list the reporter was reading, so it is what it
+ * means here. `call <name>` is still the verb for reaching somebody
+ * further off, and it still works.
+ *
+ * A PAN IS THE TEST, not a pulse: isLinked is the same predicate that
+ * decides whether a body shows up as a ▣ icon at all. Somebody with no
+ * commlink, or running silent, has nothing for your voice to come out
+ * of -- and does not appear in the icon list either, so the two answers
+ * agree.
+ */
+export function panAudience(scene, actor) {
+    const here = actor.bodyRoom ?? actor.currentLocation;
+    if (!here)
+        return [];
+    return scene.allActors.filter(a => a !== actor
+        && a.plane === 'meat'
+        && (a.bodyRoom ?? a.currentLocation) === here
+        && isLinked(a));
+}
+/**
+ * Delivers a persona's words to its audience, the way Room.say delivers
+ * a body's -- to the personas beside it, and out of the commlinks of the
+ * people standing around its body.
+ */
 export function speakOnTheGrid(scene, actor, message) {
-    const audience = speechAudience(scene, actor);
-    for (const recipient of audience) {
+    const personas = speechAudience(scene, actor);
+    for (const recipient of personas) {
         void Promise.resolve(recipient.hear(actor, message, { broadcast: true })).catch(() => undefined);
     }
-    return audience;
+    // viaLink, so the NPC knows this arrived out of their commlink rather
+    // than from a mouth in the room -- which is the whole difference, and
+    // the thing their reply has to be able to react to.
+    const links = panAudience(scene, actor);
+    for (const recipient of links) {
+        void Promise.resolve(recipient.hear(actor, message, { broadcast: true, viaLink: true })).catch(() => undefined);
+    }
+    return { personas, links };
 }
 /**
  * The combat exchange's "same place": on the matrix plane it is the

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

@@ -36,6 +36,11 @@ function matrixNameables(scene, actor, rooms) {
             push(out, seen, { glyph: '▣', name: body.name, what: 'a body in reach -- its PAN' });
         }
         for (const device of room.openableDevices()) {
+            // Tab must not hand you the name of an icon you have not spotted
+            // (p.217) -- that is the same "Tab is a free search" defect
+            // yaw2btNX8aNEEF9D3 fixed for meat-world loot, one plane over.
+            if (!device.hasIconFor(actor.name))
+                continue;
             push(out, seen, { glyph: '▤', name: device.name, what: `device, rating ${device.rating}` });
         }
     }

package/bundle/typescript/src/commands/game/sideQuest/utilities/silent-icons.js

@@ -0,0 +1,137 @@
+import { rollPool, formatRoll } from './dice.js';
+import { deviceDefensePool } from './matrix-intrusion.js';
+import { isWatched, cameraMasterHost } from './surveillance.js';
+import { DEFAULT_DEVICE_RATING } from '../models/device.js';
+function hiddenDevice(device) {
+    return {
+        name: device.name,
+        // Its rating stands in for the Mental attribute it has not got
+        // (p.237-238) -- the same pool it defends an intrusion with.
+        hide: { pool: deviceDefensePool(device).pool, label: 'Device Rating (no Logic to hide behind)' },
+        reveal: (viewer) => { device.spottedBy.add(viewer); },
+    };
+}
+function hiddenPersona(actor) {
+    return {
+        name: actor.name,
+        // p.236/p.241, verbatim: "the target defending with Logic + Sleaze".
+        hide: { pool: Math.max(0, actor.logic + actor.matrixAttribute('sleaze')), label: 'Logic + Sleaze' },
+        reveal: (viewer) => { actor.matrixSpottedBy.add(viewer); },
+    };
+}
+/**
+ * Everything running silent within reach of this viewer that they have
+ * not already pinned.
+ *
+ * DEVICES come from the room the sweep is aimed at. PEOPLE come from the
+ * scene, because a runner who went dark is still standing somewhere, and
+ * the icon you are looking for is their PAN -- which sits where their
+ * body does.
+ */
+export function hiddenIconsIn(scene, room, viewer) {
+    const out = room.devices
+        .filter(d => d.isHiddenFrom(viewer.name))
+        .map(hiddenDevice);
+    // THE CAMERAS, which p.217 names FIRST. They are not a Device -- the
+    // cluster is derived from the room (surveillance.ts isWatched) -- so
+    // they hide on the room's own set and resist with their master host's
+    // rating where there is one: a site's lenses are as quiet as the
+    // security that runs them, and a slave borrows its master's numbers
+    // (p.233). Without a host they fall back to the door-lock rating
+    // canon prices ordinary fixtures at (p.356).
+    if (isWatched(room) && !room.camerasSpottedBy.has(viewer.name)) {
+        const master = scene ? cameraMasterHost(scene.getRooms(), room) : undefined;
+        const rating = master?.hostRating ?? DEFAULT_DEVICE_RATING.lock ?? 2;
+        out.push({
+            name: 'Camera cluster',
+            hide: { pool: Math.max(0, rating * 2), label: master ? 'its host\'s rating' : 'Device Rating' },
+            reveal: (v) => { room.camerasSpottedBy.add(v); },
+        });
+    }
+    for (const a of scene?.allActors ?? []) {
+        if (a === viewer)
+            continue;
+        if (!a.runningSilent)
+            continue;
+        if (a.matrixSpottedBy.has(viewer.name))
+            continue;
+        // Where the BODY is, because that is where the commlink is.
+        if ((a.bodyRoom ?? a.currentLocation) !== room)
+            continue;
+        out.push(hiddenPersona(a));
+    }
+    return out;
+}
+/**
+ * ONE MATRIX PERCEPTION, AGAINST EVERYTHING HIDING IN THE ROOM.
+ *
+ * Canon resolves one icon per action. This rolls the sweeper's pool ONCE
+ * and compares it against each hider's own resistance, which is a
+ * deliberate simplification worth naming: rolling a fresh attacker pool
+ * per icon would make a room with six locks six times as easy to sweep
+ * for the same single action, and asking a player to NAME an icon they
+ * cannot see yet is not a question anybody can answer. One action, one
+ * roll; the icons differ by what they hide behind.
+ *
+ * `look` is where it fires, because `look` on the grid IS Matrix
+ * Perception (p.241) and is already billed as the Complex Action it is.
+ * A second look is a second action, which is what makes a dark room
+ * cost something.
+ */
+export function spotHiddenIcons(scene, actor, room) {
+    const hidden = hiddenIconsIn(scene, room, actor);
+    if (hidden.length === 0)
+        return undefined;
+    // Computer + Intuition [Data Processing] (p.241), carrying the
+    // sweeper's own silence, wounds and sustaining the way every other
+    // Matrix action in this engine does.
+    const computer = actor.skillRating('computer');
+    const pool = Math.max(1, actor.intuition + (computer > 0 ? computer : -1)
+        + actor.matrixActionPenalty + actor.woundModifier - actor.sustainingPenalty);
+    const roll = rollPool(pool, actor.matrixAttribute('dataProcessing'), { gremlins: actor.deckGremlins });
+    const found = [];
+    const missed = [];
+    const against = [];
+    for (const icon of hidden) {
+        const resist = rollPool(icon.hide.pool);
+        against.push({ name: icon.name, label: icon.hide.label, roll: resist });
+        // Ties go to the hider: "on a tie or more hits by the defender, it
+        // stays hidden and out of reach" (p.236).
+        if (roll.hits > resist.hits) {
+            icon.reveal(actor.name);
+            found.push(icon.name);
+        }
+        else {
+            missed.push(icon.name);
+        }
+    }
+    return { found, missed, roll, against };
+}
+/** The mechanics lines for a sweep, for a screen that shows them. */
+export function spotMechanics(outcome) {
+    return [
+        `Matrix Perception, silent icons (Computer + Intuition [Data Processing]): ${formatRoll(outcome.roll)}`,
+        ...outcome.against.map(a => `  ${a.name} hides (${a.label}): ${formatRoll(a.roll)}`),
+    ];
+}
+/**
+ * What the runner is TOLD, which is never nothing.
+ *
+ * A miss still reports that something is there -- that is step 1 above,
+ * the hit that buys "there are icons running silent in the vicinity",
+ * and it is the whole reason a hidden lock reads differently from a door
+ * with no lock on it.
+ */
+export function spotLine(outcome) {
+    const lines = [];
+    if (outcome.found.length > 0) {
+        lines.push(`You pick ${outcome.found.length === 1 ? 'an icon' : `${outcome.found.length} icons`} out of the noise -- ${outcome.found.join(', ')}, running silent and not quiet enough.`);
+    }
+    if (outcome.missed.length > 0) {
+        lines.push(outcome.missed.length === 1
+            ? `Something else here is running silent and you cannot pin it -- a shape in the static that stops when you look at it. (Look again; each sweep is its own Matrix Perception, p.241.)`
+            : `${outcome.missed.length} more icons are running silent here, and none of them will hold still. (Look again; each sweep is its own Matrix Perception, p.241.)`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=silent-icons.js.map

package/package.json

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