@maka/maka-cli 5.196.0 → 5.198.0

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

@@ -1,6 +1,7 @@
 import { hostConcealedFrom } from './jackpoint.js';
-import { matchesHostName, hostLabel } from './grid-names.js';
-import { fuzzyPickName } from './fuzzy-match.js';
+import { matchesHostName, hostLabel, hostAliases } from './grid-names.js';
+import { fuzzyPickName, normalizeLoose } from './fuzzy-match.js';
+import { MAX_MARKS } from './marks.js';
 /**
  * THE GRID HAS NO STREETS (user canon check 2026-09-02; SR5 pp.217-218,
  * p.246). Jacked in and outside a host, a persona is on its grid: "a
@@ -88,6 +89,64 @@ export function resolveHostInReach(rooms, actor, query) {
     const picked = fuzzyPickName(bare, hosts.map(r => r.name));
     return picked ? hosts.find(r => r.name === picked) : undefined;
 }
+/**
+ * DOES THIS QUERY NAME A HOST OUTRIGHT -- no fuzz, no guessing.
+ *
+ * resolveHostInReach ends in a fuzzy fallback, which is right for it:
+ * once a player has committed to meaning a host, a near miss should
+ * still find one. This is the other question, and it exists because
+ * `hack`/`mark` resolve PANs FIRST (WTLfRHxJEnPmN2ht9: "this keeps
+ * matching on Torque's PAN even though I gave it exactly the host
+ * name"). The PAN pass runs fuzzyPickName over the names of every body
+ * in reach, and that matcher's tier 2 is substring containment in
+ * either direction -- so a runner standing near anyone whose name is
+ * contained in the host's could never reach the host by typing its
+ * name, because the PAN pass answered before the host pass was asked.
+ *
+ * So the caller asks this first: an EXACT alias hit (grid-names.ts's
+ * hostAliases, loosely normalized -- case, punctuation and a trailing
+ * "host"/"node" all forgiven) means the player named a host and the PAN
+ * pass must not get to reinterpret it. Anything less falls through and
+ * the old order stands, so a genuinely ambiguous word still reaches the
+ * PAN it always did.
+ *
+ * The bare aliases ("host", "the host", "node", "ice") resolve to the
+ * host over the vicinity, exactly as resolveHostInReach resolves them
+ * -- one query, one answer, whichever door asks.
+ */
+export function namesHostExactly(rooms, actor, query) {
+    const q = query.trim().toLowerCase();
+    if (q === '')
+        return undefined;
+    if (q === 'host' || q === 'the host')
+        return hostOver(gridVicinity(actor));
+    const near = hostOver(gridVicinity(actor));
+    if (near && hostNamed(near, q))
+        return near;
+    return hostsInReach(rooms, actor).find(r => hostNamed(r, q));
+}
+/**
+ * THE APOSTROPHE, which a player does not type and the matcher insisted
+ * on. normalizeLoose SPLITS punctuation rather than dropping it -- right,
+ * and load-bearing, because "Mr.Krow" has to become "mr krow" and not
+ * "mrkrow". The side effect is that "Torque's Garage" normalizes to
+ * "torque s garage", so a player typing the name they READ, minus the
+ * apostrophe they did not bother with, missed every alias.
+ *
+ * So the comparison is tried twice: matchesHostName first (the shared
+ * rule, unchanged and still the authority), then again with whitespace
+ * squashed out of both sides, which forgives exactly the punctuation the
+ * player dropped and nothing else. "torques garage" reaches the host;
+ * "torque" -- a whole word shorter -- still does not, which is the line
+ * that keeps this from stealing the PAN pass.
+ */
+function hostNamed(room, q) {
+    if (matchesHostName(q, room))
+        return true;
+    const squash = (s) => normalizeLoose(s).replace(/\s+/g, '');
+    const squashed = squash(q);
+    return squashed.length > 0 && hostAliases(room).some(a => squash(a) === squashed);
+}
 /** Noise between the persona and a room's icons: 0 for the vicinity (and inside a host), -DISTRICT_NOISE dice elsewhere. */
 export function noiseFor(actor, room) {
     if (actor.insideHost)
@@ -113,9 +172,20 @@ export function noiseNote(noise) {
 export function hostLine(room, actor) {
     const inside = actor.insideHost === room;
     const marks = room.hostMarksBy.get(actor.name) ?? 0;
+    // STANDING IS TWO FACTS, NOT ONE (spcebZTKN24GYRHXW: "it's saying
+    // I've already cracked open (hold 3 marks) but I don't").
+    //
+    // "cracked open" is the SITE's state -- somebody took this node to
+    // three marks and its vault has been hanging open ever since. The
+    // marks count is YOUR state, and canon wipes it on every reboot
+    // (p.236). The two used to be one string with the crack winning, so a
+    // rebooted persona holding nothing read a line that says the place is
+    // yours -- while every device on it refused them for want of marks.
+    // Print both whenever they disagree.
+    const held = `${marks}/${MAX_MARKS} marks`;
     const standing = room.hostSanctioned ? 'haven'
-        : room.hostCracked ? 'cracked open'
-            : marks > 0 ? `${marks}/3 marks`
+        : room.hostCracked ? (marks >= MAX_MARKS ? 'cracked open' : `cracked open, but you hold ${held}`)
+            : marks > 0 ? held
                 : 'sealed';
     const alert = room.hostAlert && !room.hostSanctioned ? ', walls UP' : '';
     const over = hostOver(gridVicinity(actor)) === room ? ', over you' : '';
@@ -133,9 +203,16 @@ export function hostLine(room, actor) {
 export function hostDockLine(room, actor, width) {
     const inside = actor.insideHost === room;
     const marks = room.hostMarksBy.get(actor.name) ?? 0;
-    const tag = room.hostCracked ? ' open' : marks > 0 ? ` ${marks}/3` : '';
+    // Same split as hostLine, cut to the dock's width: "open" alone is the
+    // site's state and was reading as the persona's. A crack you no longer
+    // hold marks on shows the marks, because that is the number every
+    // device on this node is about to check (spcebZTKN24GYRHXW).
+    const tag = room.hostCracked && marks >= MAX_MARKS ? ' open'
+        : room.hostCracked ? ` open ${marks}/${MAX_MARKS}`
+            : marks > 0 ? ` ${marks}/${MAX_MARKS}`
+                : '';
     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/bundle/typescript/src/commands/game/sideQuest/utilities/shared-run.js

@@ -1253,6 +1253,14 @@ export class SharedRunSession {
                     catch { /* the name is a courtesy; the warning stands without it */ }
                     return `The dispatcher picks up -- and you hesitate. You never settled with ${who}: ${owed}¥ still on the table. ("call taxi" again to leave it and go.)`;
                 }
+                // MID-FIGHT (hHvR2kxrqAKuuXwED). This shortcut skips the engine's
+                // CallCommand exactly as the unclaimed-pay case above does, so
+                // the server carries the refusal and this renders it in the
+                // engine's own words. It arms NOTHING: unlike `unsettled`, no
+                // second call gets you a cab.
+                if (e.error === 'in-combat') {
+                    return `Mid-fight is no time to hail a cab. Finish this, then call.`;
+                }
                 if (e.error === 'bad-status' || e.error === 'interrupted') {
                     await this.homecoming();
                     return '';

package/package.json

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