@maka/maka-cli 5.167.0 → 5.170.0

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

@@ -2394,6 +2394,16 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // never report; the anonymous/bench gate is evaluated at fire time
         // because _anonymous is decided after construction.
         this.player.onConditionChanged = () => {
+            // THE TERMINAL'S ROOM PANE RIDES THE SAME SIGNAL (q6tBaFn5EDmGMoJFh):
+            // the room now reports every occupant's move to the humans in it
+            // (Room.noteOccupancyChanged), and this is the one hook a human's
+            // report fires -- so a body stepping across the room while the
+            // player watches repaints here at once, not on the next keystroke
+            // or the 2-second map heartbeat. Same call a typed move makes;
+            // updateExits is a no-op without a screen, and combat repaints
+            // itself blow by blow (see mapHeartbeatTick).
+            if (this._mapBox && !this.player.inExchange)
+                this.updateExits(this.player.currentLocation);
             if (this._anonymous || this._bench)
                 return;
             // Checked HERE too, before the import -- a dynamic import after a

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

@@ -391,10 +391,14 @@ export async function createHeadlessSession(opts) {
                 // THE WEB MAP FOLLOWS THE ROOM, NOT JUST YOUR OWN BODY
                 // (oHhjxjqKuptDGMHLD: a looted body stayed on the map "until I
                 // move"; 9aEMA4APbB6rYtWnT: a killed NPC's dot never changed).
-                // The condition beat is what the browser draws actors from, and
-                // it fires only on the primary's OWN mutations -- a kill or a
-                // loot mutates the room, not the killer, so nothing fired until
-                // their next step. One nudge per command; the beat coalesces.
+                // The condition beat is what the browser draws actors from. A
+                // kill or a loot mutates the room, not the killer, so this
+                // nudge -- one per command, coalesced -- still covers those.
+                // MOVEMENT NO LONGER WAITS FOR IT (q6tBaFn5EDmGMoJFh): the room
+                // publishes every occupant's position change to the humans in
+                // it the moment it happens (Room.noteOccupancyChanged), so an
+                // NPC stepping on its own reflect chain between commands
+                // reaches the browser without anyone typing.
                 game.player.noteConditionChanged();
                 return res;
             })),

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

@@ -2258,7 +2258,10 @@ export class Player extends AbstractPlayer {
     // gets no cover) -- the compat default for everything un-migrated.
     // Accessor (live-sheet, 2026-09-01, user: "let's get that streaming
     // in too"): in-room movement walks the sheet's dot map, so the write
-    // fires the report hook on CHANGE. Source-compatible; NPCs no-op.
+    // fires the report hook on CHANGE. Source-compatible; an NPC's own
+    // hook is a no-op -- which is why the ROOM is told as well
+    // (Room.noteOccupancyChanged, q6tBaFn5EDmGMoJFh): the humans standing
+    // in it are the ones whose maps draw this body, and they report.
     _atSpot;
     get atSpot() { return this._atSpot; }
     set atSpot(v) {
@@ -2266,6 +2269,7 @@ export class Player extends AbstractPlayer {
             return;
         this._atSpot = v;
         this.noteConditionChanged();
+        this._currentLocation?.noteOccupancyChanged(this);
     }
     /**
      * WHICH PAPER YOU CARRY (player request 2026-08-25, twice: "I should
@@ -2310,6 +2314,8 @@ export class Player extends AbstractPlayer {
             return;
         this._atCell = v;
         this.noteConditionChanged();
+        // The witnesses' maps move too -- see the atSpot accessor above.
+        this._currentLocation?.noteOccupancyChanged(this);
     }
     /** The spot this actor was SEEDED at -- i.e. the fixture they work
      *  (a bartender's bar, a shopkeeper's counter). Seating puts them on

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

@@ -619,6 +619,7 @@ Keep it concise and dramatic.`;
                     this.logger.write(`${other.name} will observe ${actor.name}`);
                 }
             }
+            this.noteOccupancyChanged(actor);
         }
     }
     removeActor(actor) {
@@ -633,6 +634,39 @@ Keep it concise and dramatic.`;
                 actor.off('action', other._onSeenAction);
             }
         }
+        this.noteOccupancyChanged(actor);
+    }
+    /**
+     * THE ROOM PUBLISHES ITS OWN OCCUPANCY (q6tBaFn5EDmGMoJFh, 2026-09-11:
+     * "I still can't see the NPCs moving unless I move").
+     *
+     * The browser draws every dot on the room map from a human's condition
+     * report (condition-report.ts buildConditionReport reads THIS room's
+     * actors at fire time), and that report is fired by
+     * Player.noteConditionChanged -- which every position setter calls on
+     * the actor that MOVED. An NPC has no reporter of its own (game.ts sets
+     * the hook on the primary human only, on purpose), so an NPC stepping
+     * across the room on its own reflect chain, a companion answering the
+     * pursuit heartbeat, or a hostile taking its Action Phase changed the
+     * room's truth and told nobody. The only thing that ever refreshed the
+     * dots was the once-per-command nudge in headless.ts -- which is
+     * exactly "they move when I move".
+     *
+     * So the room tells everyone standing in it. NPCs and crew shells
+     * no-op (no hook); each human present fires its own report, and the
+     * report layer coalesces a burst (pendingByPlayer, 250 ms) so a mob of
+     * four stepping at once is one beat per watching human. DDP carries it
+     * from there -- no timer, no polling, no beat of its own (user ruling:
+     * "this is a pub/sub mechanic that doesn't need beats").
+     *
+     * `cause` is left out: the mover already reported itself through its
+     * own setter, and a second report for the same change is just noise.
+     */
+    noteOccupancyChanged(cause) {
+        for (const other of this.actors) {
+            if (other !== cause)
+                other.noteConditionChanged();
+        }
     }
     getActors() {
         return Array.from(this.actors);

package/bundle/typescript/src/commands/game/sideQuest/utilities/climb-state.js

@@ -0,0 +1,51 @@
+import { hint } from './hints.js';
+import { spotOf, spotClimbSteps } from './spots.js';
+import { METERS_PER_LEVEL } from './room-grid.js';
+export function onTheWall(actor) {
+    const progress = actor.climbProgress;
+    if (!progress)
+        return undefined;
+    const room = actor.currentLocation;
+    const grid = room.ensureGrid();
+    const from = spotOf(actor);
+    if (!grid || from === undefined)
+        return undefined;
+    const fromZ = grid.spotCells.get(from)?.z;
+    const targetZ = grid.spotCells.get(progress.target)?.z;
+    // A bank toward a spot this grid cannot place, or one on the actor's
+    // own level, is stale -- it is not a wall anyone is on.
+    if (fromZ === undefined || targetZ === undefined || targetZ === fromZ)
+        return undefined;
+    const steps = spotClimbSteps(room, from, progress.target) ?? Math.abs(targetZ - fromZ);
+    const wallHeight = Math.max(steps, 1) * METERS_PER_LEVEL;
+    const travelled = Math.min(progress.meters, wallHeight);
+    const up = targetZ > fromZ;
+    return {
+        target: progress.target, from, travelled, wallHeight, up,
+        // Climbing UP, what you have travelled is your height. Climbing
+        // DOWN, travel is measured from the top, so height is what is left.
+        height: up ? travelled : wallHeight - travelled,
+    };
+}
+/** "about 1m" / "about a body length" -- the same rounding the climb
+ *  ticker and the elevation bar use, so no two readouts disagree. */
+export function heightPhrase(meters) {
+    return meters < 1 ? 'about a body length' : `about ${Math.round(meters)}m`;
+}
+/**
+ * The refusal every horizontal verb gives a runner who is part-way up
+ * a wall. Not a rule -- canon says nothing about acting mid-climb, and
+ * this invents nothing -- but a fact about where the body is: you do
+ * not cross a floor you are not standing on. Names both ways off the
+ * wall, because "you can't" with no way out is the false-impression
+ * shape this whole family of reports has been about.
+ */
+export function midClimbRefusal(actor) {
+    const wall = onTheWall(actor);
+    if (!wall)
+        return undefined;
+    return wall.up
+        ? `You're partway up the wall toward the ${wall.target}, ${heightPhrase(wall.height)} off the ground -- not going anywhere sideways from here.${hint(` ("climb" keeps going; "descend" gets you back down to the ${wall.from} first.)`)}`
+        : `You're partway down the wall from the ${wall.from}, ${heightPhrase(wall.height)} above the ${wall.target} -- not going anywhere sideways from here.${hint(` ("descend" keeps going; "climb" gets you back up onto the ${wall.from} first.)`)}`;
+}
+//# sourceMappingURL=climb-state.js.map

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

@@ -92,6 +92,22 @@ export function parseMarkDeclaration(words) {
 export function deviceDefensePool(device) {
     return { label: 'Device Rating + Firewall', pool: Math.max(0, device.rating * 2) };
 }
+/**
+ * A SLAVE ATTACKED THROUGH ITS MASTER (SR5 p.233, PANs and WANs):
+ * "Whenever a slaved device is called on to make a defense test, it
+ * uses either its own or its master's rating for each rating in the
+ * test ... whichever is higher in each instance." Per rating, not
+ * wholesale: the device's own Rating against the host's Rating, its
+ * own Firewall (which this engine reads as its rating, see above)
+ * against the host's Firewall. Only from the grid -- inside the host
+ * you are directly connected and the slave stands alone (p.233; Data
+ * Trails p.87-88), which is deviceDefensePool.
+ */
+export function wanDefensePool(device, host) {
+    const rating = Math.max(device.rating, host.rating);
+    const firewall = Math.max(device.rating, host.attributes().firewall);
+    return { label: "Device Rating + Firewall (the master's where higher, p.233)", pool: Math.max(0, rating + firewall) };
+}
 /**
  * A HOST'S OWN DEFENCE IS AN ENGINE RULING, NOT A CITATION, and this
  * comment is the label on it. Asked directly (2026-09-03), the rulebooks

package/bundle/typescript/src/commands/game/sideQuest/utilities/npc-combat-brain.js

@@ -1,5 +1,5 @@
 import { Category } from '../types/shared/item-enum.js';
-import { spotOf, canReach, isInCover, coverAvailableFor, actorDistanceMeters } from './spots.js';
+import { inMeleeReach, isInCover, coverAvailableFor, actorDistanceMeters } from './spots.js';
 import { Logger } from './logger.js';
 /**
  * AN NPC'S ACTION PHASE, PLAYED BY RULE (SR5 p.163-167).
@@ -82,11 +82,15 @@ export async function runNpcActionPhase(enc, npc) {
         }
         const melee = !firearm || dry || weapon.jammed;
         if (melee) {
-            const targetSpot = spotOf(target);
-            if (!canReach(npc, targetSpot)) {
-                const r = await npc.actInCombat(`move to ${targetSpot}`);
-                logger.write(`Brain: ${npc.name} move to ${targetSpot} -> ${r}`);
-                if (!canReach(npc, targetSpot)) {
+            // ARM'S REACH, NOT SPOT NAME (HBssKNQahWxGR95wB: "Ellis is able to
+            // attack me, however his position is several squares away"). The
+            // open floor is one spot across most of a room, so canReach said
+            // yes from five squares off and the swing landed. inMeleeReach asks
+            // the cells; "move to <person>" is the walk that closes them.
+            if (!inMeleeReach(npc, target)) {
+                const r = await npc.actInCombat(`move to ${target.name}`);
+                logger.write(`Brain: ${npc.name} move to ${target.name} -> ${r}`);
+                if (!inMeleeReach(npc, target)) {
                     // Couldn't close this turn: get behind something and wait.
                     tell(`${npc.name} closes on ${target.name} but can't cover the ground this turn.`);
                     if (!isInCover(npc) && coverAvailableFor(npc) && (enc.budgetOf(npc)?.simple ?? 0) > 0) {

package/bundle/typescript/src/commands/game/sideQuest/utilities/pregen-worksheet.js

@@ -1,6 +1,7 @@
 import { archetypeGearDefs } from '../archetypes.js';
 import { siteRequest } from './cloud-saves.js';
 import { getAspect, ASPECTED_PRIORITY, MAGICAL_GROUP_SKILLS } from '../aspects.js';
+import { skillsInGroup } from '../skill-groups.js';
 /**
  * A PREGEN GOES TO THE WEB TO BE BOUND (user, 2026-09-03): "if they choose
  * to bind the pre-gen character, I'd like the chargen sheet to open the
@@ -11,16 +12,25 @@ import { getAspect, ASPECTED_PRIORITY, MAGICAL_GROUP_SKILLS } from '../aspects.j
  * So binding a pregen no longer writes a bound save. The CLI creates a
  * chargen WORKSHEET through the site's own API (the same collection the
  * Forge wizard edits), fills it from the archetype -- attributes as spend
- * over the human minimums, the skills, the qualities, the chrome at
- * standard grade, the catalog slugs as gear lines, the spellbook and
- * powers, the name and gender -- and opens the wizard on it at Review.
- * The runner is born when the player finalizes there, exactly as a
- * web-built one is, and launch sources her from the cloud afterwards.
+ * over the human minimums, the skills and skill groups, the qualities
+ * with their ratings and picks, the chrome at standard grade, the catalog
+ * slugs as gear lines, the spellbook and powers, the name and gender --
+ * and opens the wizard on it at Review. The runner is born when the
+ * player finalizes there, exactly as a web-built one is, and launch
+ * sources her from the cloud afterwards.
  *
- * A pregen's spread is a spread, not a priority build, so the validator
- * will have things to say on arrival. That is the feature: the player
- * sees the ledger and settles it in the UI instead of the engine quietly
- * accepting a sheet no worksheet could produce.
+ * A PREGEN ARRIVES COMPLETE (user, 2026-09-11: "when a user chooses a
+ * premade archetype, they shouldn't need to figure out what's wrong
+ * with it -- it should just work"). Every archetype is a priority build
+ * (IArchetype.priorities) with every pool spent to the column and
+ * nothing the validator refuses; archetype-priorities.test.ts holds the
+ * CLI half of that contract and the site's chargen-archetypes suite runs
+ * the real validator over every one. Review is where the player may
+ * ADJUST, not where they finish someone else's homework. Until this
+ * date the patch dropped three fields the wizard reads -- `picks`,
+ * `qualityRatings`, `skillGroups` -- so the Decker arrived with an
+ * unanswered Codeslinger, every rated quality priced at rating 1, and
+ * no archetype could spend a single group point.
  *
  * The URL shape and the `open` query are CO-OWNED with the web side
  * (cli-login.tsx allowedNext, character-generator.tsx open(id)) -- do not
@@ -133,6 +143,24 @@ export function pregenWorksheetPatch(archetype, name, gender) {
         for (const member of MAGICAL_GROUP_SKILLS[aspect.group] ?? [])
             delete skills[member];
     }
+    /**
+     * BOUGHT GROUPS, THE SAME WAY (SR5 p.88, the skills column's second
+     * pool): a group the archetype declares is sent as a group, and its
+     * members come OUT of `skills` -- a group cannot be broken by rating a
+     * member individually on top, and the validator refuses exactly that
+     * ("covered by the X group"). The archetype's `combat.skills` keeps the
+     * expanded per-skill ratings for the local engine; the group is what
+     * the worksheet says about how they were paid for. Membership is read
+     * from skill-groups.ts itself, never copied here.
+     */
+    const skillGroups = {};
+    for (const [group, rating] of Object.entries(archetype.skillGroups ?? {})) {
+        if (!(rating > 0))
+            continue;
+        skillGroups[group] = rating;
+        for (const member of skillsInGroup(group))
+            delete skills[member];
+    }
     const gearSeen = new Set();
     const gear = [];
     for (const slug of archetype.gearSlugs ?? []) {
@@ -156,7 +184,10 @@ export function pregenWorksheetPatch(archetype, name, gender) {
         attributeSpend,
         specialSpend: { edge: spend(c.edge, HUMAN_EDGE_MIN), magic: magicPath === 'technomancer' || magicPath === 'mundane' ? 0 : Math.max(0, (c.magic ?? 0) - magicOffer), resonance: magicPath === 'technomancer' ? Math.max(0, (c.resonance ?? 0) - magicOffer) : 0 },
         skills,
+        ...(Object.keys(skillGroups).length ? { skillGroups } : {}),
         qualities: [...(archetype.qualities ?? [])],
+        ...(archetype.qualityRatings && Object.keys(archetype.qualityRatings).length ? { qualityRatings: { ...archetype.qualityRatings } } : {}),
+        ...(archetype.qualityPicks && Object.keys(archetype.qualityPicks).length ? { picks: { ...archetype.qualityPicks } } : {}),
         augmentations: (archetype.augs ?? []).map(key => ({ key, grade: 'standard' })),
         gear,
         lifestyle: 'Street',
@@ -203,7 +234,7 @@ export function pregenHandoffLines(url, name) {
     return {
         notice: `${name}'s sheet is waiting in the character generator: ${url}`,
         lines: [
-            `Look it over there -- the ledger will say what a pregen leaves unsettled, and you can adjust before you finalize.`,
+            `It arrives complete and legal -- look it over there, adjust anything you like, then finalize.`,
             `When she is born, run "maka play" and she will be in your runners.`,
         ],
     };

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

@@ -803,6 +803,37 @@ export function actorCell(room, actor, seats) {
  * words for the test are "next to me in the room map".
  */
 export const ADJACENT_METERS = METERS_PER_CELL * 1.5;
+/**
+ * WITHIN ARM'S REACH -- the melee question, asked of CELLS and not of
+ * spots (HBssKNQahWxGR95wB: "Ellis is able to attack me, however his
+ * position is several squares away from me, not in melee range").
+ *
+ * canReach answers by SPOT NAME, and that was right until bodies got
+ * their own cells (seatingIn, 2026-08-25): the open floor is one spot
+ * that covers most of a room, so two people "on the open floor" can
+ * be five squares apart and canReach still says yes. Every melee gate
+ * -- the player's attack, the NPC brain's "can I swing this phase" --
+ * read that yes and let the blow land across the room. The map drew
+ * the truth and the dice ignored it.
+ *
+ * Reach here is the engine's own atom: one cell, orthogonal or diagonal
+ * (ADJACENT_METERS -- see the note above on why that is not dressed as
+ * a canon number). Falls back to canReach wherever there is no cell to
+ * measure from, so a spotless or ungridded room keeps the compat rule.
+ */
+export function inMeleeReach(actor, target) {
+    if (!canReach(actor, spotOf(target)))
+        return false;
+    const room = actor.currentLocation;
+    if (!room.ensureGrid() || target.currentLocation !== room)
+        return true;
+    const seats = seatingIn(room);
+    const a = actorCell(room, actor, seats);
+    const t = actorCell(room, target, seats);
+    if (!a || !t)
+        return true;
+    return distanceMeters(a, t) <= ADJACENT_METERS;
+}
 /** Everything you have to walk AROUND rather than through: other
  *  people's bodies and the furniture itself. findPath treats these as a
  *  soft block (see its pass order) so they steer a route without ever

package/package.json

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