@maka/maka-cli 5.166.0 → 5.169.0

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/shared-run.js

@@ -1204,6 +1204,11 @@ export class SharedRunSession {
                     sessionID: this.sessionID,
                     query: inviteMatch[1].trim(),
                 });
+                // A mid-run seat needs the runner REACHABLE now (site ruling
+                // 2026-09-11: a CLI alive on the account, or a browser logged
+                // in); the server refuses with `offline` otherwise, so `online`
+                // is always true past this point. The aside stays for a server
+                // older than the rule.
                 return `Invite sent to ${res.memberRunner} -- a seat at this table, mid-job.${res.online ? '' : ` (They're off the street -- it'll wait on their link.)`}`;
             }
             catch (err) {
@@ -1290,10 +1295,21 @@ export class SharedRunSession {
         return `You pull out of the run. The crew's voices fade off the link.`;
     }
     /** Quit-as-pause (ruling 2026-08-24): the seat survives, the run
-     *  keeps rolling server-side, and the server marks us disconnected
-     *  the moment this process's link closes. No leave call, no
-     *  forfeiture -- "call taxi" rides back in. */
+     *  keeps rolling server-side, and the server marks us disconnected.
+     *  No leave call, no forfeiture -- "call taxi" rides back in.
+     *
+     *  SAID OUT LOUD (2026-09-11): the server used to learn of this only
+     *  when the process's socket closed -- and this process does not
+     *  close it; the hub link stays up for invites and pages. So a runner
+     *  who stepped away sat `joined` on the doc with nobody at the
+     *  keyboard, and the site's sheet could not tell "at the table" from
+     *  "stepped away". sideQuest.stepAway is that one word; best effort,
+     *  and the socket-close path still stands behind it. */
     async stepAway() {
+        try {
+            await HubLink.call('sideQuest.stepAway', { sessionID: this.sessionID }, { timeoutMs: 5000 });
+        }
+        catch { /* the seat stays warm either way; the socket close says the same later */ }
         this.finish('');
         // THE OTHER HALF OF blankRunPanels. Entering a run clears the hub's
         // maps so the server's paint cannot be confused with them; stepping

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.166.0",
+  "version": "5.169.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.",