@maka/maka-cli 5.197.0 → 5.198.0

package/bundle/typescript/package.json

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

@@ -64,14 +64,14 @@ export class ArCommand extends Command {
             return `Overlay back on -- over nothing. No commlink, no deck, no AR: you're reading the street with your eyes like it's 2050.`;
         }
         const tags = aroTags(this.scene, actor, actor.currentLocation);
-        const head = `{lightblue-fg}The overlay blinks back in.{/lightblue-fg}`;
+        const head = `{light-blue-fg}The overlay blinks back in.{/light-blue-fg}`;
         // Turning AR back on while silent is the other moment the question
         // lands -- you have just done the thing you were unsure was allowed.
         const note = silentAndSeeingNote(actor);
         if (tags.length === 0) {
-            return [head, `{lightblue-fg}Nothing here is talking -- a dead patch of street.{/lightblue-fg}`, note].filter(Boolean).join('\n');
+            return [head, `{light-blue-fg}Nothing here is talking -- a dead patch of street.{/light-blue-fg}`, note].filter(Boolean).join('\n');
         }
-        return [head, ...tags.map(t => `  {lightblue-fg}${t}{/lightblue-fg}`), note].filter(Boolean).join('\n');
+        return [head, ...tags.map(t => `  {light-blue-fg}${t}{/light-blue-fg}`), note].filter(Boolean).join('\n');
     }
 }
 /**
@@ -105,11 +105,11 @@ export class ArosCommand extends Command {
         const note = silentAndSeeingNote(actor);
         const tags = aroTags(this.scene, actor, actor.currentLocation);
         if (tags.length === 0) {
-            return [`{lightblue-fg}Nothing here is talking -- a dead patch of street.{/lightblue-fg}`, note].filter(Boolean).join('\n');
+            return [`{light-blue-fg}Nothing here is talking -- a dead patch of street.{/light-blue-fg}`, note].filter(Boolean).join('\n');
         }
         return [
-            `{lightblue-fg}AR OVERLAY:{/lightblue-fg}`,
-            ...tags.map(t => `  {lightblue-fg}${t}{/lightblue-fg}`),
+            `{light-blue-fg}AR OVERLAY:{/light-blue-fg}`,
+            ...tags.map(t => `  {light-blue-fg}${t}{/light-blue-fg}`),
             note,
         ].filter(Boolean).join('\n');
     }

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

@@ -92,7 +92,7 @@ export class DownloadCommand extends Command {
         // is that nobody could find the file should say what it can see.
         const query = args.join(' ').trim();
         if (query.length === 0) {
-            const lines = [`{lightblue-fg}Within reach to pull down:{/lightblue-fg}`];
+            const lines = [`{light-blue-fg}Within reach to pull down:{/light-blue-fg}`];
             for (const i of loose)
                 lines.push(`  ${planeTintItemName(i, actor.plane)} -- loose on the grid here`);
             for (const c of carried)
@@ -140,11 +140,11 @@ export class DownloadCommand extends Command {
         this.scene.updateStatus();
         return fromSprite
             ? [
-                `{lightblue-fg}${fromSprite.npc.name} opens its hands and the data pours out of them.{/lightblue-fg}`,
+                `{light-blue-fg}${fromSprite.npc.name} opens its hands and the data pours out of them.{/light-blue-fg}`,
                 `You pull {bold}{underline}${item.name}{/underline}{/bold} down onto a chip -- meat-world cargo now.${hint(` (You can "give ${item.name}" to somebody standing in front of you.)`)}`,
             ].join('\n')
             : [
-                `{lightblue-fg}You pull {bold}{underline}${item.name}{/underline}{/bold} down off the grid -- written to a chip.{/lightblue-fg}`,
+                `{light-blue-fg}You pull {bold}{underline}${item.name}{/underline}{/bold} down off the grid -- written to a chip.{/light-blue-fg}`,
                 hint(`(Meat-world cargo now: carry it, stash it, or "give" it to somebody.)`),
             ].join('\n');
     }

package/bundle/typescript/src/commands/game/sideQuest/commands/edit-file.js

@@ -115,7 +115,7 @@ export class EditFileCommand extends Command {
         const banner = this.scene.checkErased?.(file.name, actor.name);
         this.scene.updateStatus();
         return [
-            `{lightblue-fg}${file.name} comes apart under your hand -- sectors zeroed, index entry gone, the host's own checksum rewritten to agree. ${hostLabel(room, { capital: true })} no longer has it.{/lightblue-fg}`,
+            `{light-blue-fg}${file.name} comes apart under your hand -- sectors zeroed, index entry gone, the host's own checksum rewritten to agree. ${hostLabel(room, { capital: true })} no longer has it.{/light-blue-fg}`,
             ...(banner ? [banner] : []),
         ].join('\n');
     }

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

@@ -64,7 +64,7 @@ export class EnterHostCommand extends Command {
         const marks = target.hostMarksBy.get(actor.name) ?? 0;
         if (marks < 1 && !target.hostCracked && !target.hostSanctioned) {
             return [
-                `{lightblue-fg}${hostLabel(target, { capital: true })} doesn't know you. Its architecture has no door shaped like your icon.{/lightblue-fg}`,
+                `{light-blue-fg}${hostLabel(target, { capital: true })} doesn't know you. Its architecture has no door shaped like your icon.{/light-blue-fg}`,
                 hint(`A host opens to anyone holding a MARK on it (p.239) -- "mark ${target.name}" softens it, or "hack" takes one by force.`),
             ].join('\n');
         }
@@ -85,7 +85,7 @@ export class EnterHostCommand extends Command {
         // ONE LINE (2026-09-13, "too much text"): the crossing, and the
         // coaching behind the hints toggle.
         return [
-            `{lightblue-fg}You cross into ${hostLabel(target, { capital: false })} -- the outside grid folds shut behind you.{/lightblue-fg}`,
+            `{light-blue-fg}You cross into ${hostLabel(target, { capital: false })} -- the outside grid folds shut behind you.{/light-blue-fg}`,
             hint(`(In here there is only what the host keeps. "look" reads it; "exit" puts you back on the grid.)`),
         ].filter(Boolean).join('\n');
     }
@@ -110,14 +110,14 @@ export class EnterHostCommand extends Command {
             const over = hostOver(gridVicinity(this.actor)) ?? hostOver(here);
             if (over)
                 return over;
-            return `{lightblue-fg}Thin grid here -- no host stands over ${gridVicinity(this.actor).name}.{/lightblue-fg} ${hint(`Overhead: ${roster} -- "enter <name>" crosses into any of them from here.`)}`;
+            return `{light-blue-fg}Thin grid here -- no host stands over ${gridVicinity(this.actor).name}.{/light-blue-fg} ${hint(`Overhead: ${roster} -- "enter <name>" crosses into any of them from here.`)}`;
         }
         const host = resolveHostInReach(rooms, this.actor, named);
         if (host)
             return host;
         const street = Object.values(rooms).find(r => r.name.toLowerCase() === named.toLowerCase());
         if (street)
-            return `{lightblue-fg}${street.name} has no host over it -- nothing to enter. Overhead: ${roster}.{/lightblue-fg}`;
+            return `{light-blue-fg}${street.name} has no host over it -- nothing to enter. Overhead: ${roster}.{/light-blue-fg}`;
         return `No host called "${named}" overhead. ${hint(`Overhead: ${roster}.`)}`;
     }
 }
@@ -152,7 +152,7 @@ export class ExitHostCommand extends Command {
         actor.performAction('exits a host', `icon surfacing out of ${host.name}'s architecture`, { quiet: this.scene.isHumanControlled(actor) });
         this.logger.write(`${actor.name} exited the host at ${host.name}.`);
         this.scene.updateStatus();
-        return `{lightblue-fg}You step back out of ${hostLabel(host, { capital: false })} onto the grid; the host seals behind you. Your body still sits in ${actor.currentLocation.name}.{/lightblue-fg}`;
+        return `{light-blue-fg}You step back out of ${hostLabel(host, { capital: false })} onto the grid; the host seals behind you. Your body still sits in ${actor.currentLocation.name}.{/light-blue-fg}`;
     }
 }
 //# sourceMappingURL=enter-host.js.map

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

@@ -317,7 +317,7 @@ export class HackCommand extends BypassCommand {
                 if (marksNow >= 1)
                     lines.push(`  One mark is the door: "enter" walks your persona inside (p.239).`);
                 if (perception > 0)
-                    lines.push(`  {lightblue-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what this node is (p.240).{/lightblue-fg}`);
+                    lines.push(`  {light-blue-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what this node is (p.240).{/light-blue-fg}`);
                 if (forcedDv > 0)
                     lines.push(`  The forcing burns ${forcedDv} DV into the architecture -- a host has no boards to brick, so it only announces you louder.`);
                 lines.push(`  ${MAX_MARKS - marksNow} more and its architecture stops asking who you are.${hint(` ("hack for ${MAX_MARKS - marksNow}" reaches for the rest at once -- ${declarationPenalty(MAX_MARKS - marksNow, this.actor.hasQuality(GO_BIG_QUALITY))} dice.)`)}`);
@@ -388,13 +388,13 @@ export class HackCommand extends BypassCommand {
                 lines.push(`  ${iconLocks.length} ${iconLocks.length === 1 ? 'lock hangs' : 'locks hang'} off it, still sealed -- each its own icon behind its own rating: ${iconLocks.map(d => d.name).join(', ')}.${hint(` ("hack <lock>" from in here keys one; the host's key is not the door's.)`)}`);
             }
             if (vaultedFiles.length > 0) {
-                lines.push(`  {lightblue-fg}The data vault unseals -- ${vaultedFiles.map(i => i.name).join(', ')} spill${vaultedFiles.length === 1 ? 's' : ''} into the open.${hint(` Yours to "take".`)}{/lightblue-fg}`);
+                lines.push(`  {light-blue-fg}The data vault unseals -- ${vaultedFiles.map(i => i.name).join(', ')} spill${vaultedFiles.length === 1 ? 's' : ''} into the open.${hint(` Yours to "take".`)}{/light-blue-fg}`);
             }
             // AND WHAT THE CRACK DID NOT REACH: a wired site's data sits on an
             // air-gapped box the host never held (p.233) -- say so, or the next
             // "take" reads as a contradiction.
             if (room.offlineServer && room.inventory.getAllItems().some(i => i.plane === 'matrix')) {
-                lines.push(`  {lightblue-fg}Nothing on the grid side of the vault -- whatever this place keeps sits on the ${room.offlineServer}, an air-gapped box with no Matrix presence. Your BODY has to be in ${room.name} to cable in (p.233).{/lightblue-fg}`);
+                lines.push(`  {light-blue-fg}Nothing on the grid side of the vault -- whatever this place keeps sits on the ${room.offlineServer}, an air-gapped box with no Matrix presence. Your BODY has to be in ${room.name} to cable in (p.233).{/light-blue-fg}`);
             }
             // THE FEEDS ARE A REAL GAIN AND WERE NEVER MENTIONED
             // (BpR5cjhYuvgCyDSZc, 7aNWnDSHeZMYmS2De: "what have I gained?").
@@ -683,7 +683,7 @@ export class HackCommand extends BypassCommand {
         else {
             const perception = freeMatrixPerceptionHits(netHits);
             if (perception > 0)
-                lines.push(`  {lightblue-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what it guards (p.240).{/lightblue-fg}`);
+                lines.push(`  {light-blue-fg}And you read it on the way past -- ${perception} Matrix Perception hit${perception === 1 ? '' : 's'} of what it guards (p.240).{/light-blue-fg}`);
         }
         // 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

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

@@ -101,7 +101,7 @@ export class HideCommand extends Command {
         this.scene.addWorldEvent(`${host.name}'s ice lost ${actor.name} in the traffic.`);
         this.scene.updateStatus();
         return [
-            `{lightblue-fg}You drop into the host's own traffic and become one more packet in a million. ${hostLabel(room, { capital: true })} loses you.{/lightblue-fg}`,
+            `{light-blue-fg}You drop into the host's own traffic and become one more packet in a million. ${hostLabel(room, { capital: true })} loses you.{/light-blue-fg}`,
             `  Its ice has nothing to swing at -- but the host is still awake, and Patrol is looking every action now.${hint(` ("silent" keeps a sweep from seeing you for free; "search" is possible while it looks.)`)}`,
             ...god.lines,
         ].join('\n');

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

@@ -71,7 +71,7 @@ export class HopCommand extends Command {
             actor.performAction('hops grids', `persona blinking across to ${target.name}`);
             this.logger.write(`${actor.name} hopped to ${target.key} (legal, ${tier}).`);
             this.scene.updateStatus();
-            return `{lightblue-fg}The sky changes texture and you're on ${target.name}.{/lightblue-fg}${target.userPenalty ? ` ${hint(`Public grid: -2 on everything you do out here.`)}` : ''}${await land()}`;
+            return `{light-blue-fg}The sky changes texture and you're on ${target.name}.{/light-blue-fg}${target.userPenalty ? ` ${hint(`Public grid: -2 on everything you do out here.`)}` : ''}${await land()}`;
         }
         // ILLEGAL HOP (p.240): Hack on the Fly against the grid itself.
         const burned = actor.burnedAttributeRefusal('sleaze');
@@ -105,7 +105,7 @@ export class HopCommand extends Command {
         this.logger.write(`${actor.name} hopped to ${target.key} (illegal, ${attempt.hits} v ${defence.hits}).`);
         this.scene.updateStatus();
         return [
-            `{lightblue-fg}You slip through a seam nobody sold you and come up on ${target.name}.{/lightblue-fg}`,
+            `{light-blue-fg}You slip through a seam nobody sold you and come up on ${target.name}.{/light-blue-fg}`,
             ...bill.lines,
             ...(isLooseEnd ? [await land()] : []),
         ].join('\n');

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

@@ -387,7 +387,7 @@ export class LookCommand extends Command {
                 const dim = this.scene.getActorsInRoom(far)
                     .find(a => a !== this.actor && a.name.toLowerCase() === target.toLowerCase() && this.actor.canPerceive(a));
                 if (dim)
-                    return `${this.inspectPersona(dim)}\n{lightblue-fg}  -- a far icon, ${far.name}${noiseNote(noise)}{/lightblue-fg}`;
+                    return `${this.inspectPersona(dim)}\n{light-blue-fg}  -- a far icon, ${far.name}${noiseNote(noise)}{/light-blue-fg}`;
             }
         }
         // 3. THE HOST, as a thing you can name. gridIcons already renders it
@@ -404,8 +404,8 @@ export class LookCommand extends Command {
                 // `deck` reads out your own array.
                 const a = namedHost.hostAttributes();
                 return [
-                    `{lightblue-fg}${hostIcon}{/lightblue-fg}`,
-                    `{lightblue-fg}  Attack ${a.attack}  Sleaze ${a.sleaze}  Data Processing ${a.dataProcessing}  Firewall ${a.firewall}{/lightblue-fg}`,
+                    `{light-blue-fg}${hostIcon}{/light-blue-fg}`,
+                    `{light-blue-fg}  Attack ${a.attack}  Sleaze ${a.sleaze}  Data Processing ${a.dataProcessing}  Firewall ${a.firewall}{/light-blue-fg}`,
                 ].join('\n');
             }
         }
@@ -417,7 +417,7 @@ export class LookCommand extends Command {
         if (matchesCameraName(target)) {
             const eye = gridIcons(this.scene, this.actor, room).find(i => i.startsWith('◎'));
             if (eye)
-                return `{lightblue-fg}${eye}{/lightblue-fg}`;
+                return `{light-blue-fg}${eye}{/light-blue-fg}`;
             // Named correctly, and there is simply nothing here to name.
             // Worth its own line: the old answer said the WORDS were wrong,
             // which sent the player hunting for a synonym that never
@@ -533,7 +533,7 @@ export class LookCommand extends Command {
      * there's a deck anywhere in the shape of it.
      */
     inspectPersona(target) {
-        const lines = [`{lightblue-fg}◆ ${target.name} -- a persona on this grid.{/lightblue-fg}`];
+        const lines = [`{light-blue-fg}◆ ${target.name} -- a persona on this grid.{/light-blue-fg}`];
         const companion = this.scene.ownerGame?.companions.find(c => c.npc === target);
         if (companion) {
             lines.push(`Yours -- it goes where you go, and it answers when you speak.`);

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

@@ -93,7 +93,7 @@ export class MapCommand extends Command {
             actor.insideHost
                 ? `THE GRID -- INSIDE ${hostLabel(actor.insideHost, { capital: true }).toUpperCase()}`
                 : `THE GRID -- ${actor.currentGrid ? `on ${actor.currentGrid.name}, ` : ''}jacked in from ${body.name}`,
-            `{lightblue-fg}Black flatland under a black sky. No streets out here -- only icons. The hosts hang overhead; ${actor.insideHost ? '"exit" puts you back under them' : '"go <host>" (or "go <number>") crosses into one you hold a mark on, from anywhere'}.{/lightblue-fg}`,
+            `{light-blue-fg}Black flatland under a black sky. No streets out here -- only icons. The hosts hang overhead; ${actor.insideHost ? '"exit" puts you back under them' : '"go <host>" (or "go <number>") crosses into one you hold a mark on, from anywhere'}.{/light-blue-fg}`,
         ];
         if (hosts.length === 0) {
             lines.push('  Nothing overhead -- no host stands over this district.');

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

@@ -51,7 +51,7 @@ export class MarkCommand extends Command {
             screen: this.screen,
             game: this.game,
         }).execute(args);
-        return `{lightblue-fg}Placing a mark IS ${action} -- running it (p.238/p.240).{/lightblue-fg}\n${result}`;
+        return `{light-blue-fg}Placing a mark IS ${action} -- running it (p.238/p.240).{/light-blue-fg}\n${result}`;
     }
 }
 //# sourceMappingURL=mark.js.map

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

@@ -87,6 +87,7 @@ export class SayCommand extends Command {
         }
         const message = args?.join(' ');
         const currentPlayer = this.actor;
+        let farOff = "";
         const scene = this.context.scene;
         // Speaking out loud ends a sneak (see sneak.ts).
         currentPlayer.sneaking = false;
@@ -245,8 +246,23 @@ export class SayCommand extends Command {
             // (matrix-roster.ts); a body's reach the room, as always.
             if (currentPlayer.plane === 'matrix')
                 speakOnTheGrid(this.scene, currentPlayer, message);
-            else
-                currentPlayer.currentLocation.say(currentPlayer, message);
+            else {
+                const heard = currentPlayer.currentLocation.say(currentPlayer, message);
+                // NOBODY CLOSE ENOUGH is now a thing that can happen, and has to
+                // be said (en3p6eCpiRuqsTSKm). Speech used to escalate to a
+                // room-wide shout the moment nobody shared your spot, so this
+                // case did not exist; with `say` bounded by each listener's
+                // hearing range it does, and a player whose words reached nobody
+                // would otherwise see their own echo and assume they landed.
+                //
+                // Only when there was somebody TO miss: an empty room is not a
+                // failure to be heard, it is an empty room, and nagging about it
+                // every time a runner mutters to themselves would be noise.
+                const others = currentPlayer.currentLocation.getActors().filter(a => a !== currentPlayer);
+                if ((heard ?? []).length === 0 && others.length > 0 && !(this.actor instanceof NPC)) {
+                    farOff = `\n  Nobody's close enough to catch that.${hint(` ("shout" carries the whole room; "move to <place>" gets you near someone.)`)}`;
+                }
+            }
             // Talking in the CLIENT's presence is the meet (a real session
             // walked up to Ms. Veil, spoke with plain "say", and the advance
             // never triggered -- only talk-to/call/give were hooked). The
@@ -294,7 +310,7 @@ export class SayCommand extends Command {
                 ? `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.)`;
         }
-        return "";
+        return farOff;
     }
     /**
      * "say private" -- the answer to "can anyone hear me right now",

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

@@ -313,8 +313,8 @@ export class SearchCommand extends Command {
             // tells a player standing next to an offline server that it is
             // there and what it wants from them.
             description += room.offlineServer
-                ? `\n{lightblue-fg}A ${room.offlineServer} sits here, dark and off the network -- no aerial, no marquee, nothing broadcasting. Whatever it holds comes out through a cable and no other way.${hint(` "jack in" RIGHT HERE to touch its files.`)}{/lightblue-fg}`
-                : `\n{lightblue-fg}The node here hums with locked files -- whatever's worth taking lives on the grid, inside the host.${hint(` "jack in", then "enter" the host.`)}{/lightblue-fg}`;
+                ? `\n{light-blue-fg}A ${room.offlineServer} sits here, dark and off the network -- no aerial, no marquee, nothing broadcasting. Whatever it holds comes out through a cable and no other way.${hint(` "jack in" RIGHT HERE to touch its files.`)}{/light-blue-fg}`
+                : `\n{light-blue-fg}The node here hums with locked files -- whatever's worth taking lives on the grid, inside the host.${hint(` "jack in", then "enter" the host.`)}{/light-blue-fg}`;
         }
         description += describeContainers(room, this.actor);
         description += describeBarriers(room, this.actor);

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

@@ -0,0 +1,69 @@
+import { Command } from './command.js';
+import { NPC } from '../models/npc.js';
+import { hint } from '../utilities/hints.js';
+import { SHOUT_METERS } from '../utilities/earshot.js';
+import { speakOnTheGrid } from '../utilities/matrix-roster.js';
+/**
+ * SHOUTING IS A VERB NOW (en3p6eCpiRuqsTSKm: "add 'shout' can be heard
+ * by anyone within a reasonable distance, 50m?").
+ *
+ * It used to be something that HAPPENED TO YOU. Room.say escalated to a
+ * room-wide shout whenever nobody shared your spot, so a runner standing
+ * on their own could not say anything quietly, and a runner at a crowded
+ * table could not deliberately call across the room. Both halves of the
+ * volume decision belonged to the furniture rather than to the player.
+ *
+ * Now `say` carries to whoever is close enough to hear it (earshot.ts)
+ * and this is how you reach everyone else. The range is this engine's
+ * number, not the book's -- see SHOUT_METERS -- and in practice it is
+ * room-wide, because the largest room the generator builds is tens of
+ * metres across.
+ *
+ * WHAT IT COSTS, and why that is not nothing: every hostile in the room
+ * hears you, and shouting is not sneaking. `sneaking` is dropped here
+ * the same way `say` drops it -- talking on comms is not a quiet
+ * activity, and bellowing across a warehouse is less so.
+ */
+export class ShoutCommand extends Command {
+    static verb = 'shout';
+    static description = `Raise your voice so the whole place hears it (~${SHOUT_METERS}m), instead of just whoever is standing close. "say" is ordinary speech and only carries as far as a listener's ears reach -- roughly 5m, further for someone with the chrome for it. Shouting reaches everyone in the room, hostiles included, and drops any sneaking.`;
+    context;
+    constructor(context) {
+        super(context);
+        this.context = context;
+    }
+    async execute(args) {
+        if (!args || args.length === 0) {
+            return `What do you want to shout?${hint(` ("shout <message>" -- "say" keeps it between you and whoever is close.)`)}`;
+        }
+        const message = args.join(' ');
+        const actor = this.actor;
+        // THE PLANES, worded as say.ts words them -- one mechanic, one set
+        // of sentences. An astral voice never reaches meat ears and a
+        // persona's never leaves the grid, and volume changes neither: a
+        // louder voice on the wrong plane is still no voice at all.
+        if (actor.plane === 'astral') {
+            return `You can shout all you like -- the meat world hears nothing. Spirits and projections do.`;
+        }
+        // Talking is not sneaking (sneak.ts); shouting least of all.
+        actor.sneaking = false;
+        if (actor.plane === 'matrix') {
+            // ON THE GRID THERE IS NO DISTANCE (grid-reach.ts): personas hear
+            // 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.`;
+        }
+        const heard = actor.currentLocation.shout(actor, message);
+        if (!(this.actor instanceof NPC)) {
+            this.actor.performAction('shouts', actor.currentLocation.name, { quiet: true });
+        }
+        return heard.length > 0
+            ? `You raise your voice: "${message}"`
+            : `You raise your voice: "${message}"\n  Nothing answers -- there's nobody here to hear it.`;
+    }
+}
+//# sourceMappingURL=shout.js.map

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

@@ -49,7 +49,7 @@ export class SnoopCommand extends Command {
         this.logger.write(`Snoop: ${actor.name} watching ${target.name} via camera feed.`);
         const lines = [`CAMERA FEED: ${target.name.toUpperCase()}`];
         if (!camerasLive(allRooms, target)) {
-            lines.push(`{lightblue-fg}(Security sees a loop of empty hallways -- these eyes answer only to you now.){/lightblue-fg}`);
+            lines.push(`{light-blue-fg}(Security sees a loop of empty hallways -- these eyes answer only to you now.){/light-blue-fg}`);
         }
         const seen = this.scene.getActorsInRoom(target)
             .filter(a => a !== actor && a.plane === 'meat' && !a.sneaking);

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

@@ -73,7 +73,7 @@ export class SpritesCommand extends Command {
             const name = type?.name ?? set.spriteKey;
             const isMine = mineType === set.spriteKey;
             const powers = powersForSprite(set.spriteKey);
-            lines.push(`${name.toUpperCase()} SPRITE${isMine ? ' {lightblue-fg}(yours){/lightblue-fg}' : ''}${type ? ` -- ${type.blurb}` : ''}`);
+            lines.push(`${name.toUpperCase()} SPRITE${isMine ? ' {light-blue-fg}(yours){/light-blue-fg}' : ''}${type ? ` -- ${type.blurb}` : ''}`);
             lines.push(`  Skills: ${skillsForSprite(set.spriteKey).join(', ')}${hint(`  (${set.page})`)}`);
             if (!detailed) {
                 // The names alone, which is the comparison view.

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

@@ -79,8 +79,8 @@ export function resolveSpokenTarget(parsedArgs, names) {
     return undefined;
 }
 export class TalkCommand extends Command {
-    static verb = "talk-to";
-    static description = "Speak privately to a person in the room.";
+    static verb = "tell";
+    static description = "Speak privately to ONE person standing with you -- only they hear it, however loud the room is. \"tell <name> <message>\". (\"talk-to\" is the old spelling and still works.) Compare \"say\", which carries to whoever is close enough to hear, and \"shout\", which reaches the whole place.";
     context;
     constructor(context) {
         super(context);

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

@@ -164,9 +164,9 @@ export class TapCommand extends Command {
         }
         this.logger.write(`${actor.name} now holds ${now} mark(s) on ${host.name} via the ${room.name} cameras.`);
         const lines = [
-            `{lightblue-fg}The filament finds the connector and the camera stops being a camera -- it's a device, and it's talking to you.{/lightblue-fg}`,
-            `  {lightblue-fg}It never gets to hide behind ${hostLabel(host)}: a cable doesn't ask the network for permission, so the lens has to defend itself with what a lens has. It doesn't have much.{/lightblue-fg}`,
-            `  {lightblue-fg}MARK PLACED -- and it lands on the host too. The camera answers to ${host.name}, and anything ${host.name} trusts to speak for it just handed you a key. [${now}/${MAX_MARKS}]{/lightblue-fg}`,
+            `{light-blue-fg}The filament finds the connector and the camera stops being a camera -- it's a device, and it's talking to you.{/light-blue-fg}`,
+            `  {light-blue-fg}It never gets to hide behind ${hostLabel(host)}: a cable doesn't ask the network for permission, so the lens has to defend itself with what a lens has. It doesn't have much.{/light-blue-fg}`,
+            `  {light-blue-fg}MARK PLACED -- and it lands on the host too. The camera answers to ${host.name}, and anything ${host.name} trusts to speak for it just handed you a key. [${now}/${MAX_MARKS}]{/light-blue-fg}`,
         ];
         if (mode === 'attack') {
             lines.push(`  The housing is visibly forced -- the host FELT that one, even if nothing saw your face.`);
@@ -175,15 +175,15 @@ export class TapCommand extends Command {
             lines.push(`  Nothing logged, nothing flagged. You were never here.`);
         }
         if (host === room) {
-            lines.push(`  {lightblue-fg}${now >= MAX_MARKS
+            lines.push(`  {light-blue-fg}${now >= MAX_MARKS
                 ? `The host thinks you belong now -- "hack" walks straight in.`
-                : `${hostLabel(host, { capital: true })} cracks easier with every key you hold${hint(` -- "jack in" and "hack", or come back for another lens`)}.`}{/lightblue-fg}`);
+                : `${hostLabel(host, { capital: true })} cracks easier with every key you hold${hint(` -- "jack in" and "hack", or come back for another lens`)}.`}{/light-blue-fg}`);
         }
         else {
-            lines.push(`  {lightblue-fg}These lenses ride the site network, so the key fits ${hostLabel(host)}${hint(` -- "jack in", "go ${host.name}", "hack"`)}.{/lightblue-fg}`);
+            lines.push(`  {light-blue-fg}These lenses ride the site network, so the key fits ${hostLabel(host)}${hint(` -- "jack in", "go ${host.name}", "hack"`)}.{/light-blue-fg}`);
         }
         // A mark is all canSnoopFeeds ever wanted (surveillance.ts).
-        lines.push(`  {lightblue-fg}And the eyes are half yours already${hint(` -- jacked in, "snoop <room>" rides any feed on this network`)}.{/lightblue-fg}`);
+        lines.push(`  {light-blue-fg}And the eyes are half yours already${hint(` -- jacked in, "snoop <room>" rides any feed on this network`)}.{/light-blue-fg}`);
         lines.push(...godLines);
         this.scene.updateStatus();
         return lines.join('\n');

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

@@ -67,7 +67,7 @@ export class ThreadCommand extends Command {
             const lines = [`COMPLEX FORMS (thread <form> <level>)`];
             for (const f of FORMS) {
                 const held = actor.sustainedForms.some(s => s.key === f.key);
-                lines.push(`  ${f.name.padEnd(16)} ${f.kind === 'sustained' ? '[sustained]' : '[instant]  '} ${f.blurb}${held ? ' {lightblue-fg}(HELD){/lightblue-fg}' : ''}`);
+                lines.push(`  ${f.name.padEnd(16)} ${f.kind === 'sustained' ? '[sustained]' : '[instant]  '} ${f.blurb}${held ? ' {light-blue-fg}(HELD){/light-blue-fg}' : ''}`);
             }
             if (actor.sustainedForms.length > 0) {
                 lines.push('', `  Holding ${actor.sustainedForms.length} form${actor.sustainedForms.length === 1 ? '' : 's'} (${sustainTotal(actor.sustainedLedger().filter(w => w.kind === 'form'))}).${hint(` ("thread drop <form>" releases.)`)}`);

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

@@ -503,5 +503,28 @@
 //     to refuse sideQuest.settle -- on a shared run the cab is intercepted
 //     before the engine ever sees it, so the server is the only place
 //     that path can be stopped.
-export const ENGINE_VERSION = '1.56.0';
+// 1.57.0 (2026-09-15): A VOICE CARRIES AS FAR AS THE EAR, and two
+//   spellings change with it.
+//   - `say` was resolved by SPOT NAME -- whoever shared your spot, plus
+//     anyone CIRCULATING, because "no position" was read as "every
+//     position". A patrol officer walking through a back room answered a
+//     question put to a Johnson at a table. It also ESCALATED on its own:
+//     alone at a spot, a murmur became a room-wide shout nobody asked
+//     for. Now `say` reaches whoever is inside their OWN hearing range
+//     (utilities/earshot.ts canHearSpeech; range is 5 m plus the
+//     listener's perception dice) and never escalates. Canon gives no
+//     distance for speech -- it is dice and limits, p.445/p.453-454 --
+//     so the metres are this engine's and are labelled as such.
+//   - NEW VERB `shout` (~50 m, in practice room-wide) is the old
+//     escalation, now deliberate.
+//   - `talk-to` is spelled `tell`. Command semantics in shared scenes:
+//     the old spelling stays registered as an alias, so nothing that
+//     learned it breaks.
+//   - COLOUR TAGS: the run-together "lightblue" spelling never parsed
+//     in blessed (its tag parser wants "light blue fg", hyphens turned
+//     to spaces) and was printed to CLI players as literal braces for
+//     months, while the web client rendered it perfectly. 134 tags are
+//     now {light-blue-fg}. The site's render-tags.ts maps that back
+//     to a real CSS keyword, so the pin must carry both halves.
+export const ENGINE_VERSION = '1.57.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -73,6 +73,7 @@ import { LockCommand } from './commands/lock.js';
 import { SearchCommand } from './commands/search.js';
 import { SayCommand } from './commands/say.js';
 import { TalkCommand } from './commands/talk.js';
+import { ShoutCommand } from './commands/shout.js';
 import { StoreCommand } from './commands/store.js';
 import { OpenCommand, CloseCommand, PutCommand } from './commands/container-verbs.js';
 import { GiveCommand } from './commands/give.js';
@@ -708,7 +709,7 @@ export default class Game {
         Logger.getInstance().write(`Loose end "${c.id}" left: ${erased ? 'ERASED' : 'still open'}; hub is the scene again.`);
         this.requestSave('cleanup');
         return [erased
-                ? `\n{lightblue-fg}The grid closes behind you. ${le?.site ?? 'The site'}'s feeds run clean -- whatever they had of you is gone.{/lightblue-fg}`
+                ? `\n{light-blue-fg}The grid closes behind you. ${le?.site ?? 'The site'}'s feeds run clean -- whatever they had of you is gone.{/light-blue-fg}`
                 : `\n{yellow-fg}The grid closes behind you. The footage is still up there.{/yellow-fg}${hint(` (Jack in and "hop" again while the desk hasn't reviewed it.)`)}`];
     }
     /** The HUD's read on the district (bands, never the number). */
@@ -2692,7 +2693,14 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('open', OpenCommand);
         CommandFactory.registerCommand('close', CloseCommand);
         CommandFactory.registerCommand('put', PutCommand);
+        // TELL IS THE VERB (en3p6eCpiRuqsTSKm: "let's adjust 'talk-to' to
+        // 'tell' to be more concise"). `talk-to` stays registered as an
+        // alias rather than being deleted: it is the spelling in every
+        // transcript, every NPC brief and every backlog item written before
+        // today, and a player who learned it should not be told it is gone.
+        CommandFactory.registerCommand('tell', TalkCommand);
         CommandFactory.registerCommand('talk-to', TalkCommand);
+        CommandFactory.registerCommand('shout', ShoutCommand);
         CommandFactory.registerCommand('give', GiveCommand);
         CommandFactory.registerCommand('read', ReadCommand);
         CommandFactory.registerCommand('kill', KillCommand);
@@ -5955,7 +5963,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // works the grid while you're back in the meat (the AR-drop exit).
         const remoteAgent = this.companions.find(c => c.kind === 'agent');
         if (remoteAgent && player.plane !== 'matrix') {
-            lines.push(`{lightblue-fg}▣ DECK IN AR -- ${remoteAgent.npc.name} on the grid${remoteAgent.npc.objective ? ', working its directive' : ''}${hint(' ("jack in" to rejoin it, "recall" to fold it home)')}{/lightblue-fg}`);
+            lines.push(`{light-blue-fg}▣ DECK IN AR -- ${remoteAgent.npc.name} on the grid${remoteAgent.npc.objective ? ', working its directive' : ''}${hint(' ("jack in" to rejoin it, "recall" to fold it home)')}{/light-blue-fg}`);
         }
         // Off-plane context: which reality you're in, your persona's Matrix
         // track (cold-sim damage lands there), and where your empty body lies.
@@ -5974,7 +5982,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             const track = jackedDeck
                 ? `  Deck A${jackedDeck.attack} S${jackedDeck.sleaze} D${jackedDeck.dataProcessing} F${jackedDeck.firewall} ${jackedDeck.deckSummary()}${player.simMode === 'hot' ? ' +biofeedback' : ''}${pgms}`
                 : `  (living persona -- damage is REAL stun)`;
-            lines.push(`{lightblue-fg}▣ MATRIX ${(player.simMode ?? 'cold').toUpperCase()}-SIM${track} -- body at ${player.bodyRoom?.name ?? '???'}{/lightblue-fg}`);
+            lines.push(`{light-blue-fg}▣ MATRIX ${(player.simMode ?? 'cold').toUpperCase()}-SIM${track} -- body at ${player.bodyRoom?.name ?? '???'}{/light-blue-fg}`);
         }
         else if (player.plane === 'astral') {
             lines.push(`{magenta-fg}✧ ASTRAL -- ${player.astralTicks} move${player.astralTicks === 1 ? '' : 's'} out -- body at ${player.bodyRoom?.name ?? '???'}{/magenta-fg}`);
@@ -6066,7 +6074,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             const dockW = mapWidth ?? 15;
             const lines = hosts.length > 0
                 ? hosts.map(h => hostDockLine(h, this.player, dockW))
-                : ['{lightblue-fg}nothing overhead{/lightblue-fg}'];
+                : ['{light-blue-fg}nothing overhead{/light-blue-fg}'];
             lines.push(caption(this.player.insideHost ? `inside ${this.player.insideHost.name}` : `on the grid from ${gridVicinity(this.player).name}`, mapWidth));
             this.setMapOverlay(lines);
             if (onTheGrid) {
@@ -6575,7 +6583,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // technomancer-gated (a sprite task, SR5 p.256) and refuses anyone
         // else, so the Emerged shelf is where its audience looks.
         { title: 'resonance', entries: [['compile'], ['decompile'], ['thread'], ['unravel'], ['register'], ['standby'], ['sustain'], ['sprites']] },
-        { title: 'social', entries: [['say'], ['emote', 'me'], ['talk-to'], ['call'], ['message'], ['end-call', 'end', 'hangup'], ['accept'], ['decline', 'deny', 'refuse'], ['haggle', 'negotiate'], ['persuade', 'convince'], ['ask'], ['contacts']] },
+        { title: 'social', entries: [['say'], ['shout'], ['emote', 'me'], ['tell', 'talk-to'], ['call'], ['message'], ['end-call', 'end', 'hangup'], ['accept'], ['decline', 'deny', 'refuse'], ['haggle', 'negotiate'], ['persuade', 'convince'], ['ask'], ['contacts']] },
         { title: 'street', entries: [['abandon'], ['browse', 'buy'], ['sell'], ['catalog'], ['source', 'procure'], ['work', 'gig'], ['jobs'], ['journal'], ['perform'], ['palm'], ['docwagon'], ['treat'], ['eat'], ['drink'], ['lifestyle'], ['garage'], ['pay']] },
         { title: 'barriers', entries: [['pick'], ['breach'], ['dispel', 'dispell'], ['bluff'], ['unlock'], ['lock']] },
         { title: 'character', entries: [['sheet', 'stats'], ['advance'], ['qualities', 'quality'], ['sin', 'sins', 'papers'], ['initiate', 'submerge'], ['install', 'chrome']] },

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

@@ -9,7 +9,8 @@ import * as fuzzyMatch from '../utilities/fuzzy-match.js';
 import { sameHostSide } from './player.js';
 import { AI } from '../../../../tools/ai/ai.class.js';
 import { AbstractRoom } from '../types/shared/abstracts.js';
-import { spotOf, spotsActive, actorDistanceMeters, voiceBandFor, voiceTag, doorwayKindOf, exitDoorwayKind } from '../utilities/spots.js';
+import { spotsActive, actorDistanceMeters, voiceBandFor, voiceTag, doorwayKindOf, exitDoorwayKind } from '../utilities/spots.js';
+import { canHearSpeech } from '../utilities/earshot.js';
 import { synthesizeGrid, } from '../utilities/room-grid.js';
 export class Room extends AbstractRoom {
     logger = Logger.getInstance();
@@ -724,16 +725,37 @@ Keep it concise and dramatic.`;
         const others = mouths - 1;
         return ` [System note: ${others} other ${others === 1 ? 'person' : 'people'} in earshot heard this too, and each is answering in the same moment as you -- none of you can see what the others are about to say. Say YOUR piece, in your own voice, but not the same piece: if the obvious reply is one anyone here would give, make yours specific to you instead. Two people reporting one event reads as a joke.]`;
     }
+    /**
+     * ORDINARY SPEECH, which now carries as far as the LISTENER can hear
+     * and no further (en3p6eCpiRuqsTSKm: "'say' should only be perceived
+     * by anyone within 3-5m un-augmented. Really, it's the audible
+     * perception range of the listener").
+     *
+     * WHAT THIS REPLACES, and why the old shape produced the report.
+     * Speech used to be resolved by SPOT NAME: whoever shared your spot
+     * heard you, plus anyone CIRCULATING -- and if nobody shared your
+     * spot, the words escalated to a room-wide shout automatically. Two
+     * consequences, both reported in one session:
+     *
+     *  - A circulating actor heard everything, because "no spot" was read
+     *    as "everywhere". That is how Patrol Officer Kessler, `moving
+     *    through` the back room, answered a question put to Ms. Quill at
+     *    a table (CugfYsH8DWH8FcfgS).
+     *  - Standing anywhere on your own turned every murmur into a shout
+     *    without you asking for one, so there was no way to say something
+     *    quietly and no verb that meant "I want the room to hear this".
+     *
+     * Now: earshot.ts owns the rule (canHearSpeech), distance is real
+     * metres between cells, and the range belongs to each listener's ears.
+     * The escalation is gone -- SHOUTING IS A VERB NOW (commands/shout.ts,
+     * Room.shout below). Saying something nobody is close enough to catch
+     * is a thing that can happen, and say.ts tells you so.
+     *
+     * Returns who actually heard it, so the caller can say "nobody did"
+     * without asking the same question a second way and risking a
+     * different answer.
+     */
     say(actor, message) {
-        // "At" spots: speech is LOCAL (player decision: speech local, sight
-        // room-wide -- walking into the bar had every NPC in the room
-        // engaging at once). Same-spot and circulating listeners hear
-        // normally. When NOBODY shares the speaker's spot but others are in
-        // the room, the words carry as a SHOUT -- delivered room-wide with
-        // a tag so an NPC AI reacts to being called across the room, not to
-        // bar-side murmur. When same-spot listeners exist, cross-spot
-        // actors hear nothing (v1: the murmur doesn't carry).
-        const speakerSpot = spotOf(actor);
         // THE HOST WALL IS ALSO A WALL FOR VOICES (FhXadizkMCxAdMaJx).
         //
         // Every verb that PICKS a target honours sameHostSide -- that is what
@@ -748,66 +770,67 @@ Keep it concise and dramatic.`;
         // have insideHost undefined, so they compare equal and nothing about
         // ordinary speech changes.
         const listeners = [...this.actors].filter(r => r !== actor && sameHostSide(actor, r));
+        const audience = listeners.filter(r => canHearSpeech(actor, r));
         // broadcast: true -- room speech is overheard, not addressed. A
         // companion shell at heel uses that distinction to stay quiet (see
-        // NPC.hear); targeted channels (talk/order/ask...) never set it.
-        if (speakerSpot === undefined) {
-            const crowd = this.crowdNote(listeners);
-            // CAUGHT, like every other hear() fan-out in the game (say.ts,
-            // planes.ts, game.ts heartbeat). These three were the only bare
-            // ones left: a bare `void` on a rejecting promise is an
-            // unhandledRejection, and ui.ts fatal handler kills the session
-            // on one -- which is exactly how a 502 from the AI relay ended a
-            // live game twice on 2026-08-29. Belt AND braces: NPC.hear now
-            // swallows its own reaction failures too, so this is redundant
-            // for NPCs on purpose -- it still guards any other Player
-            // subclass that grows an async hear().
-            for (const recipient of listeners) {
-                void Promise.resolve(recipient.hear(actor, recipient instanceof NPC ? `${message}${crowd}` : message, { broadcast: true })).catch(err => {
-                    this.logger.error(`${recipient.name} failed to hear ${actor.name}: ${err}`);
-                });
-            }
-            return;
-        }
-        const local = listeners.filter(r => {
-            const rs = spotOf(r);
-            return rs === undefined || rs === speakerSpot;
-        });
-        if (local.length > 0) {
-            const crowd = this.crowdNote(local);
-            for (const recipient of local) {
-                void Promise.resolve(recipient.hear(actor, recipient instanceof NPC ? `${message}${crowd}` : message, { broadcast: true })).catch(err => {
-                    this.logger.error(`${recipient.name} failed to hear ${actor.name}: ${err}`);
-                });
-            }
-            return;
+        // NPC.hear); targeted channels (tell/order/ask...) never set it.
+        const crowd = this.crowdNote(audience);
+        // CAUGHT, like every other hear() fan-out in the game (say.ts,
+        // planes.ts, game.ts heartbeat). These were the only bare ones
+        // left: a bare `void` on a rejecting promise is an
+        // unhandledRejection, and ui.ts fatal handler kills the session on
+        // one -- which is exactly how a 502 from the AI relay ended a live
+        // game twice on 2026-08-29. Belt AND braces: NPC.hear now swallows
+        // its own reaction failures too, so this is redundant for NPCs on
+        // purpose -- it still guards any other Player subclass that grows
+        // an async hear().
+        //
+        // NO VOICE TAG. Everyone here is inside their own hearing range by
+        // construction, which is what voiceBandFor calls 'conversation' --
+        // the band that has always rendered as no tag at all.
+        for (const recipient of audience) {
+            void Promise.resolve(recipient.hear(actor, recipient instanceof NPC ? `${message}${crowd}` : message, { broadcast: true })).catch(err => {
+                this.logger.error(`${recipient.name} failed to hear ${actor.name}: ${err}`);
+            });
         }
-        // VOICE RANGE (spatial pass 2026-08-25): how hard you have to work
-        // to be heard scales with the actual gap, not a flat "another spot"
-        // -- since the room resize, a stallholder answering across a 32 m
-        // market was tagged the same as a neighbour two tables over
-        // (playtest: "he's basically screaming"). See spots.ts voiceBandFor.
-        // The shout channel: a lone-at-spot PLAYER calling out reaches the
-        // whole room. A lone-at-spot NPC reaches only the PLAYER -- the
-        // camera, not the cast: when every NPC's murmur went room-wide, two
-        // barflies at opposite ends conducted a shouted conversation about
-        // the player's drink order (real session: Patch and Old Cray,
-        // volleying "(calling across the room)" lines through each other's
-        // AI). Same-spot NPC chat is untouched -- that's the local branch.
+        return audience;
+    }
+    /**
+     * SHOUTING, which used to happen to you and is now something you do
+     * (en3p6eCpiRuqsTSKm: "add 'shout' can be heard by anyone within a
+     * reasonable distance, 50m?").
+     *
+     * Reaches the whole room -- see earshot.ts SHOUT_METERS for why 50 m
+     * is in practice room-wide and why the number is this engine's rather
+     * than the book's. Each listener is told how far the words travelled
+     * (voiceTag), so an NPC's AI answers someone calling across a bar
+     * differently from someone at its elbow.
+     *
+     * THE NPC RESTRAINT IS KEPT from the old auto-escalation, because the
+     * reason for it has not changed: when every NPC's raised voice went
+     * room-wide, two barflies at opposite ends held a shouted conversation
+     * about the player's drink order through each other's AI (a real
+     * session -- Patch and Old Cray). An NPC shout reaches the PLAYER, the
+     * camera rather than the cast. A PLAYER's shout reaches everyone,
+     * which is the whole point of typing it.
+     */
+    shout(actor, message) {
+        const listeners = [...this.actors].filter(r => r !== actor && sameHostSide(actor, r));
         const player = [...this.actors].find(a => !(a instanceof NPC));
-        const shoutTargets = actor instanceof NPC
+        const targets = actor instanceof NPC
             ? listeners.filter(r => r === player)
             : listeners;
-        const shoutCrowd = this.crowdNote(shoutTargets);
-        for (const recipient of shoutTargets) {
+        const crowd = this.crowdNote(targets);
+        for (const recipient of targets) {
             const band = voiceBandFor(actorDistanceMeters(this, actor, recipient));
             // The crowd note goes LAST, after the voice tag: both are system
             // dressing, and the tag describes the words while the note
             // describes the room.
-            void Promise.resolve(recipient.hear(actor, `${message}${voiceTag(band)}${recipient instanceof NPC ? shoutCrowd : ''}`, { broadcast: true })).catch(err => {
+            void Promise.resolve(recipient.hear(actor, `${message}${voiceTag(band)}${recipient instanceof NPC ? crowd : ''}`, { broadcast: true })).catch(err => {
                 this.logger.error(`${recipient.name} failed to hear ${actor.name} shout: ${err}`);
             });
         }
+        return targets;
     }
     addExit(direction, targetRoom, keyItemOrSolution) {
         let door = this.findExistingDoor(targetRoom);

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

@@ -256,7 +256,7 @@ export function aroBlock(scene, actor, room) {
     const tags = aroTags(scene, actor, room);
     if (tags.length === 0)
         return '';
-    return `{lightblue-fg}AR OVERLAY:{/lightblue-fg}\n${tags.map(t => `  {lightblue-fg}${t}{/lightblue-fg}`).join('\n')}`;
+    return `{light-blue-fg}AR OVERLAY:{/light-blue-fg}\n${tags.map(t => `  {light-blue-fg}${t}{/light-blue-fg}`).join('\n')}`;
 }
 /** Gear that talks to the grid on its own, lying LOOSE in the room.
  *  Weapons are absent here because a carried one is handled above, as

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

@@ -1,4 +1,4 @@
-import { sameSpot, spotOf, spotsActive, OPEN_FLOOR } from './spots.js';
+import { sameSpot, spotOf, spotsActive, OPEN_FLOOR, IMMEDIATE_VICINITY_M, actorDistanceMeters } from './spots.js';
 /**
  * WHO CAN OVERHEAR A MURMUR (playtest, Deditri: "a private place for
  * calls"). A call is audible to the room, and that is correct and
@@ -17,17 +17,25 @@ import { sameSpot, spotOf, spotsActive, OPEN_FLOOR } from './spots.js';
  * Market's "shadowed edge". Nothing new is invented here; the call path
  * just respects the position everyone else already respects.
  *
- * THE RULE, and why it is not Room.say's rule: room speech that finds
- * nobody at your spot escalates to a SHOUT and carries room-wide -- that
- * is how you call across a bar. A commlink held to your face never
- * escalates; talking quietly into it is the whole point of it. So a
- * murmur reaches your spot and stops there.
+ * THE RULE, and why it is STILL not Room.say's rule. A murmur into a
+ * commlink reaches your spot and stops there, full stop -- talking
+ * quietly into a phone is the whole point of a phone, and it never
+ * escalates however alone you are standing.
  *
- * WHAT DOES NOT BUY PRIVACY, deliberately:
+ * Room speech used to share that shape and no longer does. `say` is now
+ * bounded by each LISTENER's hearing range in real metres
+ * (canHearSpeech below, en3p6eCpiRuqsTSKm) and never escalates on its
+ * own; shouting is a verb you type (commands/shout.ts). The two rules
+ * live in one file so they can be read against each other, which is the
+ * lesson of the drift that produced this module in the first place.
+ *
+ * WHAT DOES NOT BUY PRIVACY ON A CALL, deliberately:
  *  - CIRCULATING (no atSpot) is the compat state and means "anywhere in
- *    the room" -- it both reaches and is reached by everything. It is
- *    also the common case, and it stays exactly as loud as it has always
- *    been.
+ *    the room" -- your half of a CALL still reaches and is reached by
+ *    everything, because there is no spot for it to stop at. Note this
+ *    is the opposite of what circulating now means for ordinary speech,
+ *    and the asymmetry is argued at canHearSpeech: a murmur has a place
+ *    it comes from and a phone call does not.
  *  - THE OPEN FLOOR is a real position but it is bare ground in the
  *    middle of the room, no cover, always visible (see spots.ts). Being
  *    apart from people is not the same as being out of earshot, and a
@@ -40,6 +48,104 @@ import { sameSpot, spotOf, spotsActive, OPEN_FLOOR } from './spots.js';
  * Nothing here caches, stores, or derives a second notion of where
  * anybody is.
  */
+/**
+ * HOW FAR ORDINARY SPEECH CARRIES, and how far one listener can hear it
+ * (en3p6eCpiRuqsTSKm: "'say' should only be perceived by anyone within
+ * 3-5m un-augmented. Really, it's the audible perception range of the
+ * listener").
+ *
+ * CANON IS SILENT ON THE DISTANCE, checked rather than assumed. SR5
+ * handles hearing as dice and limits, never as a range table: an audio
+ * enhancement "adds its Rating to your limit in audio Perception Tests"
+ * (p.445), cyberears give "hearing with normal ranges" (p.453-454), and
+ * the only metre figures anywhere near it belong to the directional and
+ * laser microphones (p.445, 100 m). There is no rule for how far a
+ * sentence travels, so THESE NUMBERS ARE THIS ENGINE'S, said out loud
+ * rather than dressed as the book's.
+ *
+ * What is defensible about them:
+ *  - 5 m is already this engine's word for conversational range
+ *    (spots.ts IMMEDIATE_VICINITY_M, and voiceBandFor calls anything
+ *    inside it 'conversation'). Speech reaching exactly as far as the
+ *    engine already says a conversation reaches is one number, not two.
+ *  - The listener's perception dice extend it. Canon gives audio gear a
+ *    DICE/LIMIT bonus and this engine models speech by DISTANCE, so the
+ *    conversion is ours; a metre per die is the smallest unit that can
+ *    express "you hear better than they do" in a model made of 2 m
+ *    cells. Cyberears (+1) hear a metre further. That is an
+ *    extrapolation of a canon bonus, not a canon rule.
+ */
+export const SPEECH_METERS = IMMEDIATE_VICINITY_M;
+/**
+ * A SHOUT (commands/shout.ts) -- "anyone within a reasonable distance,
+ * 50m?" Also this engine's number and not the book's. In practice it is
+ * room-wide: the largest room this generator builds is tens of metres
+ * across, so the figure is a ceiling that says "the whole place hears
+ * you" rather than a boundary anyone will stand outside.
+ */
+export const SHOUT_METERS = 50;
+/**
+ * How far THIS listener can hear, in metres. The report's own framing:
+ * range is a property of the ear, not of the mouth.
+ *
+ * Reads the same `perception` pool a Perception test reads, so a piece
+ * of chrome and a quality that both say "+1 perception" extend hearing
+ * identically and neither needs a line here. Never below the base -- a
+ * perception PENALTY should make you miss things you roll for, not
+ * shrink the room to nothing.
+ */
+export function hearingRangeMeters(listener) {
+    const bonus = listener.augBonus('perception') + listener.qualityBonus('perception');
+    return Math.max(SPEECH_METERS, SPEECH_METERS + bonus);
+}
+/**
+ * CAN THIS LISTENER HEAR ORDINARY SPEECH FROM THERE -- the whole of the
+ * `say` rule, in one place so the verb, the NPC fan-out and any future
+ * reader cannot drift apart the way Room.say and murmurAudience once did.
+ *
+ * THE CIRCULATING ASYMMETRY, which is the actual defect this item was
+ * filed about. "Circulating" (no atSpot) is the compat state meaning
+ * "somewhere in this room, unfixed", and the old rule read it as "at
+ * every spot at once" -- so a circulating listener heard everything.
+ * That is how a patrol officer walking through the back room answered a
+ * question put to a Johnson at a table (CugfYsH8DWH8FcfgS, same
+ * session): Kessler was `moving through`, so he was nowhere, so he was
+ * everywhere.
+ *
+ * ASK spotOf, NEVER actorCell. A circulating body IS given a cell by
+ * seatingIn -- its "drift seat" -- and that cell is deliberately not a
+ * position: spots.ts says so in as many words ("a place to DRAW
+ * someone, never a position they hold"), and sameSpot and canReach both
+ * short-circuit on atSpot before any of it is consulted. A distance
+ * check written against the drift seat would have put Kessler a
+ * plausible two metres from the table and let him hear after all --
+ * correct-looking arithmetic over a number that means nothing.
+ *
+ * A LISTENER with no position is therefore NOT in earshot of a murmur:
+ * someone crossing the room is not standing at your table. A SPEAKER
+ * with no position still reaches the room, and that is deliberate rather
+ * than an oversight -- they are moving among everybody, there is no
+ * "here" for the words to fall short of, and refusing to let a
+ * circulating player be heard at all would make the game's main verb
+ * fail for the commonest position in it.
+ *
+ * A room that declares NO spots keeps the old room-wide behaviour
+ * outright. There is no geometry in such a room to be near or far in,
+ * and inventing one would refuse speech in the small abstract rooms
+ * where `say` is all there is.
+ */
+export function canHearSpeech(speaker, listener) {
+    const room = speaker.currentLocation;
+    if (!spotsActive(room))
+        return true;
+    // The speaker is unplaced: they are moving among everyone.
+    if (spotOf(speaker) === undefined)
+        return true;
+    // The listener is unplaced: they are passing through, not standing here.
+    if (spotOf(listener) === undefined)
+        return false;
+    return actorDistanceMeters(room, speaker, listener) <= hearingRangeMeters(listener);
+}
 /**
  * Everyone in the speaker's room close enough to catch a murmur.
  * From a named spot: whoever shares it, plus anyone circulating.

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

@@ -213,6 +213,6 @@ export function hostDockLine(room, actor, width) {
                 : '';
     const raw = `${inside ? '▣' : '●'} ${room.name} HR${room.hostRating}${tag}`;
     const cut = [...raw].slice(0, Math.max(4, width)).join('');
-    return `{lightblue-fg}${cut}{/lightblue-fg}`;
+    return `{light-blue-fg}${cut}{/light-blue-fg}`;
 }
 //# sourceMappingURL=grid-reach.js.map

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

@@ -460,20 +460,20 @@ export function gridSculpt(actor, room) {
         const purpose = room.host?.purpose;
         const sculpt = room.host?.sculpt;
         return [
-            `{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}`,
+            `{light-blue-fg}INSIDE :: ${hostLabel(room, { capital: true }).toUpperCase()} [HR ${room.hostRating}]${purpose ? ` -- ${purpose}` : ''}{/light-blue-fg}`,
+            `{light-blue-fg}${sculpt ?? 'Architecture all the way around -- the outside grid is a wall away and might as well be weather.'}{/light-blue-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 = `{lightblue-fg}THE GRID :: jacked in from ${body.name.toUpperCase()}{/lightblue-fg}`;
+    const header = `{light-blue-fg}THE GRID :: jacked in from ${body.name.toUpperCase()}{/light-blue-fg}`;
     const grid = actor.currentGrid;
-    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}`;
+    const flat = `{light-blue-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)' : ''}.` : ''}{/light-blue-fg}`;
     if (!room.hasNode)
         return `${header}\n${flat}`;
-    return `${header}\n${flat}\n{lightblue-fg}${hostLabel(room, { capital: true })} hangs directly overhead, sealed. What it holds is inside it.{/lightblue-fg}`;
+    return `${header}\n${flat}\n{light-blue-fg}${hostLabel(room, { capital: true })} hangs directly overhead, sealed. What it holds is inside it.{/light-blue-fg}`;
 }
 /**
  * The icons rendered as the standard cyan block, or the thin-grid line.
@@ -502,19 +502,19 @@ export function gridIconBlock(scene, actor, room, rooms) {
     if (actor.insideHost || !rooms) {
         const icons = gridIcons(scene, actor, room);
         if (icons.length === 0) {
-            return `{lightblue-fg}Thin grid out here -- background noise, nothing worth cracking.{/lightblue-fg}`;
+            return `{light-blue-fg}Thin grid out here -- background noise, nothing worth cracking.{/light-blue-fg}`;
         }
-        return `{lightblue-fg}ICONS IN REACH:{/lightblue-fg}\n${icons.map(i => `  {lightblue-fg}${i}{/lightblue-fg}`).join('\n')}`;
+        return `{light-blue-fg}ICONS IN REACH:{/light-blue-fg}\n${icons.map(i => `  {light-blue-fg}${i}{/light-blue-fg}`).join('\n')}`;
     }
     const out = [];
     const hosts = hostsInReach(rooms, actor);
     out.push(hosts.length > 0
-        ? `{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}`);
+        ? `{light-blue-fg}HOSTS OVERHEAD:{/light-blue-fg}\n${hosts.map(h => `  {light-blue-fg}${hostLine(h, actor)}{/light-blue-fg}`).join('\n')}`
+        : `{light-blue-fg}Nothing overhead -- no host stands over this district.{/light-blue-fg}`);
     const near = gridIcons(scene, actor, gridVicinity(actor)).filter(i => !isHostLine(i));
     out.push(near.length > 0
-        ? `{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}`);
+        ? `{light-blue-fg}ICONS IN REACH:{/light-blue-fg}\n${near.map(i => `  {light-blue-fg}${i}{/light-blue-fg}`).join('\n')}`
+        : `{light-blue-fg}Nothing near -- background noise around your signal.{/light-blue-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
@@ -539,9 +539,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]) => `  {lightblue-fg}· dim, noise -${noise}: ${names.join(', ')}{/lightblue-fg}`);
+        .map(([noise, names]) => `  {light-blue-fg}· dim, noise -${noise}: ${names.join(', ')}{/light-blue-fg}`);
     if (far.length > 0)
-        out.push(`{lightblue-fg}FARTHER OUT -- dimmer with distance:{/lightblue-fg}\n${far.join('\n')}`);
+        out.push(`{light-blue-fg}FARTHER OUT -- dimmer with distance:{/light-blue-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');
@@ -556,7 +556,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) => `{lightblue-fg}${[...raw].slice(0, Math.max(4, cols)).join('')}{/lightblue-fg}`;
+    const cut = (raw) => `{light-blue-fg}${[...raw].slice(0, Math.max(4, cols)).join('')}{/light-blue-fg}`;
     const lines = [];
     lines.push(cut(`INSIDE ${host.name}`));
     if (host.purpose)

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

@@ -1,4 +1,4 @@
-export const MATRIX_COLOR = 'lightblue';
+export const MATRIX_COLOR = 'light-blue';
 export const FEED_COLOR = 'white';
 export const TURN_COLOR = 'yellow';
 /** Matrix-plane prose, tagged. */

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: [`{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 };
+        return { lines: [`{light-blue-fg}The grid RIPPLES -- hard, close, and looking. Something vast has nearly found the thread you're hanging by. ("reboot" is a clean slate.){/light-blue-fg}`], converged: false };
     }
     if (before < 20 && actor.overwatchScore >= 20) {
-        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: [`{light-blue-fg}A ripple crosses the grid -- subtle, wrong, deliberate. Somewhere above, an eye has started counting your fingerprints.{/light-blue-fg}`], converged: false };
     }
     return { lines: [], converged: false };
 }

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

@@ -454,7 +454,7 @@ export function fileReach(actor, room) {
  */
 export function planeTintItemName(item, viewerPlane) {
     if (item.plane === 'matrix') {
-        return `{lightblue-fg}${item.name} [data]{/lightblue-fg}`;
+        return `{light-blue-fg}${item.name} [data]{/light-blue-fg}`;
     }
     if (item.plane === 'astral') {
         return `{magenta-fg}${item.name} [astral]{/magenta-fg}`;

package/package.json

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