@maka/maka-cli 5.196.0 → 5.197.0

package/bundle/typescript/package.json

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

@@ -2,6 +2,7 @@ import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { SKILL_NAMES } from '../models/player.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { inLiveCombat } from '../utilities/action-cost.js';
 /**
  * Karma spending: "advance" lists every skill AND attribute with its
  * current rating and the cost to raise it; "advance <name>" pays and
@@ -27,7 +28,11 @@ export class AdvanceCommand extends Command {
     ];
     async execute(args = []) {
         const actor = this.actor;
-        if (actor.inExchange) {
+        // THE WHOLE FIGHT, not one exchange (hHvR2kxrqAKuuXwED). See
+        // inLiveCombat: `inExchange` is a re-entrancy lock that is false for
+        // most of a Combat Turn, so this refusal said "firefight" and meant
+        // "for the half-second one trade of fire is resolving".
+        if (inLiveCombat(this.scene, actor)) {
             return `Mid-exchange is no time for training montages.`;
         }
         if (actor.currentLocation?.roomType !== 'Residence') {

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

@@ -4,6 +4,7 @@ import { priceOf, vendorsInRoom, waresOf, shelfNote } from '../utilities/commerc
 import { findCatalogItem, ROLE_DOMAINS } from '../utilities/catalog.js';
 import { optionMark } from '../utilities/log-style.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { inLiveCombat } from '../utilities/action-cost.js';
 /**
  * Diegetic shopping: "browse" (or bare "buy") in a vendor's room reads
  * their shelves with live prices; "buy <item>" slides the nuyen across
@@ -20,7 +21,11 @@ export class BuyCommand extends Command {
         if (actor.plane !== 'meat') {
             return `Commerce is a meat-world ritual -- come back to your body first.`;
         }
-        if (actor.inExchange) {
+        // THE WHOLE FIGHT, not one exchange (hHvR2kxrqAKuuXwED). See
+        // inLiveCombat: `inExchange` is a re-entrancy lock that is false for
+        // most of a Combat Turn, so this refusal said "firefight" and meant
+        // "for the half-second one trade of fire is resolving".
+        if (inLiveCombat(this.scene, actor)) {
             return `Nobody rings up a sale in a firefight.`;
         }
         const room = actor.currentLocation;

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

@@ -12,6 +12,7 @@ import { meetLocationFor } from '../utilities/meet-location.js';
 import { asksForDataWork, noDeckForDataWork } from '../utilities/data-work.js';
 import { partyCanDeck } from '../factories/scene-chunks.js';
 import { RecallCommand } from './companions.js';
+import { inLiveCombat } from '../utilities/action-cost.js';
 export class CallCommand extends Command {
     static verb = 'call';
     static description = 'Call someone remotely over a commlink (no need to be in the same room; commlink must be equipped).';
@@ -86,8 +87,13 @@ export class CallCommand extends Command {
                     ? `Cabs take bodies, not personas -- "jack out" first.`
                     : `Cabs take bodies, not ghosts -- "return" first.`;
             }
-            if (this.actor.inExchange) {
-                return `Mid-fight is no time to hail a cab.`;
+            // THE WHOLE FIGHT, not one exchange (hHvR2kxrqAKuuXwED -- a cab
+            // hailed mid-firefight from the web client, with Initiative rolled
+            // and a Halloweener swinging). See inLiveCombat: `inExchange`
+            // alone let this through for every beat of a Combat Turn that was
+            // not a trade of fire resolving right that instant.
+            if (inLiveCombat(this.scene, this.actor)) {
+                return `Mid-fight is no time to hail a cab. Finish this, then call.`;
             }
             // THE FARE COMES FIRST (playtest 2026-08-26: "I was able to call a
             // taxi before calling Mr. Krow. I shouldn't be able to until I get

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

@@ -1,6 +1,6 @@
 import { BypassCommand } from './bypass-command.js';
 import { gridActionModifier, gridNote } from '../utilities/grids.js';
-import { resolveHostInReach, hostsInReach, hostOver, gridVicinity, roomsInReach, noiseNote } from '../utilities/grid-reach.js';
+import { resolveHostInReach, hostsInReach, hostOver, gridVicinity, roomsInReach, noiseNote, namesHostExactly } from '../utilities/grid-reach.js';
 import { accrueOverwatch } from '../utilities/overwatch.js';
 import { hint } from '../utilities/hints.js';
 import { dropActiveCall } from '../utilities/comm-style.js';
@@ -86,7 +86,20 @@ export class HackCommand extends BypassCommand {
         // working deck in hand (which is also how enemy deckers get YOU).
         // Tried first so a name never falls through to the barrier-bypass
         // path; misses fall through untouched.
-        if (rest && rest.length > 0) {
+        // ...UNLESS THE PLAYER NAMED A HOST OUTRIGHT (WTLfRHxJEnPmN2ht9:
+        // "this keeps matching on Torque's PAN even though I gave it exactly
+        // the host name"). tryPanHack resolves with fuzzyPickName over every
+        // body in reach, whose tier 2 is substring containment in EITHER
+        // direction -- so any runner whose name is contained in the host's
+        // (or contains a word of it) swallowed the query before the host
+        // pass below ever ran, and no spelling of the host's name could get
+        // past them. An exact alias hit settles it here instead; anything
+        // less falls through and the old order stands, so a genuinely
+        // ambiguous word still reaches the PAN it always did.
+        const namedHost = rest.length > 0
+            ? namesHostExactly(this.rooms ?? this.scene.getRooms(), this.actor, rest.join(' '))
+            : undefined;
+        if (rest && rest.length > 0 && !namedHost) {
             const panResult = await this.tryPanHack(rest, mode);
             if (panResult)
                 return panResult;
@@ -145,9 +158,34 @@ export class HackCommand extends BypassCommand {
             // before allowing the crack would leave an unmarked decker with no
             // legal move against a host at all. That is a playability ruling
             // this engine owns, not something SR5 says.
-            if (room.hostCracked) {
-                return `This host is already cracked open -- its security hangs in shreds. Whatever it guarded is yours to take.`;
-            }
+            // A CRACKED HOST IS NOT A HOST YOU STILL HOLD MARKS ON
+            // (spcebZTKN24GYRHXW). What stood here was a blanket refusal --
+            // "already cracked open, whatever it guarded is yours to take" --
+            // keyed on the room-global crack flag and nothing else. That is
+            // wrong twice over.
+            //
+            // Canon first: marks are per-persona and "only last a single
+            // Matrix session ... deleted when you reboot" (p.236, Recognition
+            // Keys; p.242, Reboot Device erases them in both directions). A
+            // decker who takes a host to three marks and then reboots holds
+            // NOTHING on it -- "if they want access again, they must re-place
+            // the marks" via Brute Force or Hack on the Fly. The host is never
+            // permanently keyed to them.
+            //
+            // Playability second, and this is what the report actually hit: a
+            // reboot mid-run left the persona on 0 marks with the flag still
+            // up, so `mark`/`hack` refused, and every mark-gated device action
+            // on that node then refused for the opposite reason ("takes orders
+            // from 2 marks and you hold 0", Control Device p.238). No verb in
+            // the game could hand the marks back. The node was dead to that
+            // runner for the rest of the run.
+            //
+            // The crack's WORLD consequences stay permanent and stay here --
+            // maglocks released, vault unsealed, archive listed. Those are
+            // facts about the site, not about whose keys are in the lattice.
+            // Only the standing is per-persona, and the guard for that is the
+            // MAX_MARKS check below, which already says the right thing.
+            const alreadyCracked = room.hostCracked;
             // What the host masters, through the room it stands over (models/host.ts).
             const lockedDoors = room.host.maglocks();
             // MARKS ARE THE CURRENCY, AND THIS IS AN OPPOSED TEST NOW
@@ -314,7 +352,14 @@ export class HackCommand extends BypassCommand {
             // its feeds over. Computed AFTER hostCracked is set, so this is
             // the state the player is now standing in, not the one they left.
             const feedsNow = canSnoopFeeds(this.rooms ?? {}, room, this.actor);
-            const lines = [`You're in. The host's sculpted security folds back layer by layer --`];
+            const lines = [alreadyCracked
+                    // RE-KEYING A NODE THAT IS ALREADY IN SHREDS. Everything below
+                    // still runs -- a door the last crack released is already
+                    // unlocked, a file already spilled is already listed -- so the
+                    // only thing that changes is the sentence that would otherwise
+                    // claim you just broke in somewhere you had broken before.
+                    ? `You're back in. The wreckage of the last break-in is still hanging where you left it, and your keys are in the lattice again --`
+                    : `You're in. The host's sculpted security folds back layer by layer --`];
             // WHICH DOORS ARE ICONS, AND WHICH ARE JUST THE HOST'S OWN WALLS.
             //
             // A door held by a DEVICE has that device's back-reference on it
@@ -365,9 +410,13 @@ export class HackCommand extends BypassCommand {
             if (lockedDoors.length === 0 && vaultedFiles.length === 0 && !feedsNow) {
                 lines.push(`  This node guarded nothing -- no maglocks, no vault, no eyes.`);
             }
-            // The crack PERSISTS, which nothing told the player either: they
-            // could not know whether they had bought a moment or a state.
-            lines.push(`  The host stays open from here -- no cracking it twice.`);
+            // WHAT PERSISTS AND WHAT DOES NOT, said in one breath because the
+            // old line here said only the first half ("the host stays open
+            // from here -- no cracking it twice") and a player who then
+            // rebooted had been told, in as many words, that they would not
+            // need to do this again. They did. See the alreadyCracked comment
+            // above: the damage is permanent, the keys are not (p.236).
+            lines.push(`  The damage stays done -- the vault does not re-seal behind you. Your MARKS do not last: reboot or jack out and the lattice forgets your keys (p.236), and you key back in from scratch.`);
             if (mode === 'attack') {
                 // Brute-force success is ANNOUNCED (canon: the target knows it's
                 // under attack and screams to its owner -- it just can't see

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

@@ -2,6 +2,7 @@ import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { catalogMetamagics } from '../utilities/catalog.js';
+import { inLiveCombat } from '../utilities/action-cost.js';
 // THE PICKS ARE CATALOG ROWS (kind 'metamagic' on maka-cli.com), read
 // through catalogMetamagics(); the shape is ../metamagics.ts. The four
 // metamagics whose rule is not expressible as dice (overclocking, the
@@ -15,7 +16,11 @@ export class InitiateCommand extends Command {
     static description = 'Initiation/submersion at your hideout (10 + grade x3 karma): each grade lifts Magic/Resonance past 6 and grants a metamagic (or echo). "initiate" lists; "initiate <pick>" pays.';
     async execute(args = []) {
         const actor = this.actor;
-        if (actor.inExchange) {
+        // THE WHOLE FIGHT, not one exchange (hHvR2kxrqAKuuXwED). See
+        // inLiveCombat: `inExchange` is a re-entrancy lock that is false for
+        // most of a Combat Turn, so this refusal said "firefight" and meant
+        // "for the half-second one trade of fire is resolving".
+        if (inLiveCombat(this.scene, actor)) {
             return `Transcendence waits for the shooting to stop.`;
         }
         if (actor.currentLocation?.roomType !== 'Residence') {

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

@@ -4,6 +4,7 @@ import { WARE_GRADES, getGrade, gradedAug, STANDARD_GRADE, formatEssence, } from
 import { catalogAugmentations, findAug } from '../utilities/catalog.js';
 import { venueSinCheck, venueBustResponse } from '../utilities/sin.js';
 import { Category } from '../types/shared/item-enum.js';
+import { inLiveCombat } from '../utilities/action-cost.js';
 /**
  * The chrome shop: "install" at a street clinic lists the augmentation
  * catalog against your essence and nuyen; "install <name>" pays, goes
@@ -21,7 +22,11 @@ export class InstallCommand extends Command {
         if (actor.plane !== 'meat') {
             return `Chrome goes into meat. Come back to your body first.`;
         }
-        if (actor.inExchange) {
+        // THE WHOLE FIGHT, not one exchange (hHvR2kxrqAKuuXwED). See
+        // inLiveCombat: `inExchange` is a re-entrancy lock that is false for
+        // most of a Combat Turn, so this refusal said "firefight" and meant
+        // "for the half-second one trade of fire is resolving".
+        if (inLiveCombat(this.scene, actor)) {
             return `Nobody operates in a firefight.`;
         }
         if (!InstallCommand.isClinic(actor.currentLocation)) {

package/bundle/typescript/src/commands/game/sideQuest/commands/quality-trade.js

@@ -2,6 +2,7 @@ import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { catalogQualities } from '../utilities/catalog.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { inLiveCombat } from '../utilities/action-cost.js';
 /** The qualities on sale: every row that is not retired (a retired one
  *  is dormant on its holder's sheet, never on the board). */
 const onSale = () => catalogQualities().filter(q => !q.retired);
@@ -22,7 +23,11 @@ export class QualityTradeCommand extends Command {
     static description = 'Trade qualities with karma at your hideout (SR5e x2 rates): "qualities" lists, "qualities <name>" buys a positive or buys off a negative; "qualities <name> <rating>" buys or raises a rated one.';
     async execute(args = []) {
         const actor = this.actor;
-        if (actor.inExchange) {
+        // THE WHOLE FIGHT, not one exchange (hHvR2kxrqAKuuXwED). See
+        // inLiveCombat: `inExchange` is a re-entrancy lock that is false for
+        // most of a Combat Turn, so this refusal said "firefight" and meant
+        // "for the half-second one trade of fire is resolving".
+        if (inLiveCombat(this.scene, actor)) {
             return `Reinventing yourself mid-firefight is called dying.`;
         }
         if (actor.currentLocation?.roomType !== 'Residence') {

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

@@ -1,6 +1,7 @@
 import { Command } from './command.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { hint } from '../utilities/hints.js';
+import { inLiveCombat } from '../utilities/action-cost.js';
 /**
  * Registering (SR5e p.254-256, engine-adapted): make a compiled sprite
  * PERMANENT. An opposed Resonance + REGISTERING test against TWICE the
@@ -45,7 +46,11 @@ export class RegisterCommand extends Command {
             }
             return `No sprite rides with you -- "compile" one first.`;
         }
-        if (actor.inExchange) {
+        // THE WHOLE FIGHT, not one exchange (hHvR2kxrqAKuuXwED). See
+        // inLiveCombat: `inExchange` is a re-entrancy lock that is false for
+        // most of a Combat Turn, so this refusal said "firefight" and meant
+        // "for the half-second one trade of fire is resolving".
+        if (inLiveCombat(this.scene, actor)) {
             return `Registering takes more focus than the fight will give you.`;
         }
         // THE LOGIC CEILING (p.254-256): "You can register a number of

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

@@ -2,6 +2,7 @@ import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { priceOf, fenceValueOf, isSellable, isFence } from '../utilities/commerce.js';
 import { sameSpot, spotOf, spotRefusal } from '../utilities/spots.js';
+import { inLiveCombat } from '../utilities/action-cost.js';
 /**
  * Fencing loot: "sell <item>" in front of a fence (Whisper's pawnshop, or
  * any generated NPC/room in the trade -- see commerce.isFence) quotes 40%
@@ -18,7 +19,11 @@ export class SellCommand extends Command {
         if (actor.plane !== 'meat') {
             return `The fence deals in things a hand can pass over a counter. Come back to your body.`;
         }
-        if (actor.inExchange) {
+        // THE WHOLE FIGHT, not one exchange (hHvR2kxrqAKuuXwED). See
+        // inLiveCombat: `inExchange` is a re-entrancy lock that is false for
+        // most of a Combat Turn, so this refusal said "firefight" and meant
+        // "for the half-second one trade of fire is resolving".
+        if (inLiveCombat(this.scene, actor)) {
             return `Mid-firefight is a seller's market for exactly nothing.`;
         }
         const fence = this.scene.getActorsInRoom(actor.currentLocation)

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

@@ -482,5 +482,26 @@
 //   hub, characterSheet.hydrate -- silently ATE the lifestyle point of a
 //   runner who left fed and slept. The tier is on the save; it is read
 //   there now (commerce.lifestyleTierFor, Squatter when unnamed).
-export const ENGINE_VERSION = '1.55.1';
+// 1.56.0 (2026-09-15): TWO FLAGS THAT WERE STANDING IN FOR STATE THEY
+//   DO NOT HOLD.
+//   - A CRACKED HOST IS NOT A HOST YOU HOLD MARKS ON
+//     (spcebZTKN24GYRHXW). `hack`/`mark` refused outright on the
+//     room-global hostCracked, so a persona that rebooted mid-run -- which
+//     canon wipes marks on (p.236, p.242) -- could never re-place one,
+//     while every device on the node went on refusing them for want of
+//     marks. Command semantics in shared scenes: the refusal is gone, the
+//     standing guard is 3 marks held, a repeat break-in is worded as one,
+//     and the host line prints the site's state and the persona's marks
+//     apart. The crack's world consequences stay permanent.
+//   - NO CAB MID-FIGHT (hHvR2kxrqAKuuXwED). The downtime verbs (buy,
+//     sell, install, register, initiate, quality-trade, advance, call
+//     taxi) gated on Player.inExchange, a re-entrancy lock that is false
+//     for most of a Combat Turn, so each refused for the half-second an
+//     exchange resolved and permitted itself the rest of the fight. They
+//     ask inLiveCombat (action-cost.ts) now. NEW EMBEDDER SURFACE:
+//     Scene.anyLiveEncounter(), which the site reads off the live handle
+//     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';
 //# sourceMappingURL=engine-version.js.map

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

@@ -185,6 +185,30 @@ export class Scene extends AbstractScene {
         const enc = this.encounterAt(arenaOf(actor));
         return enc?.has(actor) ? enc : undefined;
     }
+    /**
+     * IS ANYBODY AT THIS TABLE IN A FIGHT, asked across every arena.
+     *
+     * For the EMBEDDER, not for a verb (hHvR2kxrqAKuuXwED: "I was able to
+     * call a taxi in the middle of a fight"). On a shared run the ride
+     * home is not an engine verb at all -- both the CLI
+     * (utilities/shared-run.ts) and the browser (the site's run-exit.ts)
+     * intercept "call taxi" before it reaches the table and call
+     * sideQuest.settle, which ends the run for EVERYONE. So the engine's
+     * own gate in commands/call.ts, correct as it is, never ran on the
+     * path the report came in on, and the site had no way to ask this
+     * question without reaching into `encounters`.
+     *
+     * Every arena, not just the leader's: settling the table yanks the
+     * whole party home, so a decker in a host trading with ice is reason
+     * enough to refuse even if the leader is standing in an empty street.
+     */
+    anyLiveEncounter() {
+        for (const enc of this.encounters.values()) {
+            if (!enc.ended)
+                return true;
+        }
+        return false;
+    }
     /**
      * Who is in the fight when `aggressor` opens on `target`: the two of
      * them, every human and bound shell in the room (the party fights as

package/bundle/typescript/src/commands/game/sideQuest/utilities/action-cost.js

@@ -3,6 +3,42 @@ import { hint } from './hints.js';
 export function encounterOf(scene, actor) {
     return scene.encounterFor?.(actor);
 }
+/**
+ * IS THERE A FIGHT ON, for a verb that simply cannot happen during one.
+ *
+ * `Player.inExchange` is NOT this question, and a family of verbs was
+ * asking it as though it were (hHvR2kxrqAKuuXwED: "I was able to call a
+ * taxi in the middle of a fight"). That flag is a re-entrancy lock --
+ * true only while one exchange is mid-RESOLUTION, set by
+ * CombatExchange.beginExchange and cleared by finishExchange -- so it is
+ * false for almost all of a Combat Turn, including the whole of your own
+ * Action Phase. Every verb that gated on it alone was therefore refusing
+ * during the narration beats of a single trade of fire and permitting
+ * itself freely the rest of the fight, while its refusal line said
+ * "firefight".
+ *
+ * The Combat Turn (utilities/combat-turn.ts) is what actually knows a
+ * fight is on: an encounter exists for the actor's arena and has not
+ * ended. That is the primary test here. The two exchange checks stay
+ * underneath it because an exchange can resolve outside an encounter
+ * (an NPC AI loop, a scene with no Combat Turn running), and because
+ * NPCs have no encounter phase of their own to consult.
+ *
+ * This is the "no" answer, not the "not yet" answer. Use requirePhase
+ * for something that IS legal in a fight but only on your own phase
+ * (walking out of the room); use this for something that is not a combat
+ * action at all and has no phase that could pay for it -- hailing a cab,
+ * ringing up a sale, a training montage.
+ */
+export function inLiveCombat(scene, actor) {
+    const enc = encounterOf(scene, actor);
+    if (enc && !enc.ended)
+        return true;
+    if (actor.inExchange)
+        return true;
+    return scene.isHumanControlled?.(actor) === true
+        && scene.isPlayerExchangeActive?.(actor.name) === true;
+}
 /**
  * The refusal when it is not this actor's Action Phase -- the wording
  * every verb shares, so a player learns one sentence.

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,7 +203,14 @@ 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}`;

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