@maka/maka-cli 5.159.0 → 5.161.0

package/bundle/typescript/package.json

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

@@ -125,7 +125,7 @@ export class EquipCommand extends Command {
             // hear which wetware that is (user, 2026-09-02).
             const dni = actor.dniSource();
             const link = dni?.kind === 'datajack' ? `It cables straight into your datajack -- VR ready.`
-                : dni?.kind === 'trodes' ? `It rides your ${dni.item?.name ?? 'trode net'}${dni.worn ? '' : ' (in the bag -- "equip" it to wear it)'} -- VR ready.`
+                : dni?.kind === 'trodes' ? `It rides your ${dni.item?.name ?? 'trode net'}${dni.host ? ` built into your ${dni.host.name}${dni.worn ? '' : ' (in the bag -- "equip" the helmet to wear it)'}` : dni.worn ? '' : ' (in the bag -- "equip" it to wear it)'} -- VR ready.`
                     : dni?.kind === 'technomancer' ? `Your living persona is the interface.`
                         : `No direct neural interface yet: AR only until you wear a trode net or install a datajack.`;
             return `The ${name} doesn't wear -- it's a slab of hardware in your kit. ${link} "jack in" when you're ready to ride it${hint(`, "pan" to see your network`)}.`;

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

@@ -75,7 +75,7 @@ export class EquipmentCommand extends Command {
                 ? `none -- AR only${hint(' (a trode net from any electronics shelf, or a datajack at the clinic)')}`
                 : dni.kind === 'technomancer' ? 'living persona -- VR ready'
                     : dni.kind === 'datajack' ? 'datajack (implanted) -- VR ready'
-                        : `${dni.item?.name ?? 'trode net'} (${dni.worn ? 'worn' : 'in the bag'}) -- VR ready`;
+                        : `${dni.item?.name ?? 'trode net'} (${dni.host ? `built into your ${dni.host.name}${dni.worn ? '' : ', in the bag'}` : dni.worn ? 'worn' : 'in the bag'}) -- VR ready`;
             lines.push(`  Interface: ${dniLine}`);
             if (link) {
                 lines.push(`  Commlink:  ${link.name}${actor.runningSilent ? ' -- running silent' : ''}`);

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

@@ -5,6 +5,8 @@ import { matchesHostName, matchesCameraName, hostLabel } from '../utilities/grid
 import { Door } from '../models/door.js';
 import { Item } from '../models/item.js';
 import { NPC } from '../models/npc.js';
+import { Player } from '../models/player.js';
+import { readDetails } from '../utilities/clue-reading.js';
 import { Category } from '../types/shared/item-enum.js';
 import { Command } from './command.js';
 import { shellsInRoom, planeTintItemName, emphasizeFind, fileReach } from '../utilities/planes.js';
@@ -579,7 +581,16 @@ export class LookCommand extends Command {
         if (!item) {
             return `You don't see any ${itemName} here.`;
         }
-        const prose = item.details || item.description || `It's just a regular ${itemName}.`;
+        // A CODE ON THE PAGE IS A PERCEPTION TEST (Xxbwtgffkyq8uCHfR): a
+        // scrap of paper with a combination on it is read here, not by
+        // "read" (which is the Book verb), so it takes the same test -- one
+        // gate for one credential, whichever verb reaches it.
+        const details = readDetails(this.scene, item, {
+            reader: this.actor instanceof Player ? this.actor : undefined,
+            logger: this.logger,
+            isPlayer: this.scene.isHumanControlled(this.actor),
+        });
+        const prose = details || item.description || `It's just a regular ${itemName}.`;
         if (item.category == Category.Book) {
             // A book's payload IS its detail -- "read" is the verb that opens
             // it, and saying so beats a stat block on a paperback.

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

@@ -1,5 +1,7 @@
 import { Command } from './command.js';
 import { Category } from '../types/shared/item-enum.js';
+import { Player } from '../models/player.js';
+import { readDetails } from '../utilities/clue-reading.js';
 export class ReadCommand extends Command {
     static verb = 'read';
     static description = 'Read a book from your surroundings.';
@@ -21,7 +23,16 @@ export class ReadCommand extends Command {
         // "details" is where clue/note content is meant to live, but "description"
         // is a reasonable fallback if a scene ever puts it there instead -- better
         // to show something real than a dead "blank pages" non-answer.
-        return item.details || item.description || `You flip through "${item.name}" but it's mostly blank pages.`;
+        //
+        // A CODE ON THE PAGE IS A PERCEPTION TEST (Xxbwtgffkyq8uCHfR):
+        // utilities/clue-reading.ts rolls it, and hands back the prose with
+        // the credential in or out of it.
+        const details = readDetails(this.scene, item, {
+            reader: this.actor instanceof Player ? this.actor : undefined,
+            logger: this.logger,
+            isPlayer: this.scene.isHumanControlled(this.actor),
+        });
+        return details || item.description || `You flip through "${item.name}" but it's mostly blank pages.`;
     }
 }
 //# sourceMappingURL=read.js.map

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-chunks.js

@@ -419,7 +419,9 @@ ${JSON_ONLY}
                           // exit's "guard"; people are got past socially, not picked.
     "grantsItem"?: string // an items[].name with role "reward" -- what opening it hands
                            // over. Omit for a device that holds a door: the open way IS
-                           // the reward.
+                           // the reward. REQUIRED for a device on no exit (a safe, a
+                           // lockbox, a cabinet): a device is a promise of something
+                           // behind it, and a safe that opens onto nothing is refused.
   }],
   "items": [{
     "name": string,
@@ -929,6 +931,20 @@ export function validateSkeleton(skeleton, player, crew) {
         // record -- and which looked like random flakiness precisely
         // because it varied with the character.
         const kind = device.kind ?? 'panel';
+        // A DEVICE IS A PROMISE OF SOMETHING BEHIND IT (bPiyyWu9TQ4pBfGbM,
+        // Jynx: "it looks like the safe is open, but it never dropped
+        // anything"). The Blood Ledger's skeleton declared a floor safe as
+        // a bare "lock" in the back office -- on no exit, granting no item
+        // -- while the prize sat in another room and the details pass,
+        // taking the safe at its word, wrote a combination clue for it.
+        // Every rule below checks that a device's way THROUGH is findable;
+        // none checked that there was anything on the other side. A safe
+        // that opens onto nothing is not a puzzle, it is a lie the room
+        // description tells, and the only honest fix is to refuse the
+        // skeleton before four detail passes build on it.
+        if (refs === 0 && !device.grantsItem) {
+            fail(`device "${device.name}" holds no door and grants nothing -- a device is a promise of something behind it. Declare an exit from "${device.room}" with "device": "${device.name}", or give it "grantsItem" naming a "reward"-role item.`);
+        }
         if (kind === 'panel') {
             const clue = skeleton.items.find(i => i.role === 'clue' && i.forDevice === device.name);
             if (!clue) {
@@ -955,8 +971,12 @@ export function validateSkeleton(skeleton, player, crew) {
             const holdsDoor = refs > 0;
             const keyed = skeleton.rooms.some(r => (r.exits ?? []).some(e => e.device === device.name && e.keyRequired));
             const looseKey = skeleton.items.some(i => i.role === 'key');
-            if (holdsDoor && !keyed && !looseKey) {
-                fail(`lock "${device.name}" holds a door with no "keyRequired" and the scene has no "key"-role item -- a runner without locksmith has no way through it. Add a key.`);
+            // The same floor for a lock that holds a PRIZE rather than a
+            // door (a safe): its findable way in is a key, and "holdsDoor"
+            // used to exempt it -- so a keyless safe passed here and then
+            // stood in play with only breach options (bPiyyWu9TQ4pBfGbM).
+            if (!keyed && !looseKey) {
+                fail(`lock "${device.name}" ${holdsDoor ? 'holds a door with no "keyRequired"' : 'holds a prize'} and the scene has no "key"-role item -- a runner without locksmith has no way through it. Add a key.`);
             }
         }
         // A WARD is the exception no clue can rescue: there is no findable

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

@@ -16,6 +16,7 @@ import { Player, Room } from './models/_index.js';
 import { Logger } from './utilities/logger.js';
 import { currentSession, runInSession } from './utilities/session-context.js';
 import { restorePlayer, serializePlayer } from './utilities/persistence.js';
+import { runWithAuthToken } from './utilities/cloud-saves.js';
 import { renderMapViewport, mapCaption } from './utilities/map-view.js';
 import { hostileByStance, enemyInFight, renderRoomLayoutCompact, crewOfTable, roomCaption } from './utilities/room-view.js';
 import { serializeRoomGrid } from './utilities/room-grid.js';
@@ -352,12 +353,12 @@ export async function createHeadlessSession(opts) {
         const session = {
             game,
             logger,
-            command: (actorName, input) => runInSession(ctx, async () => {
+            command: (actorName, input, opts) => runInSession(ctx, () => runWithAuthToken(opts?.authToken, async () => {
                 const res = await game.handleInputAs(actorName, input);
                 session.pushStatus();
                 pushMap();
                 return res;
-            }),
+            })),
             addPlayer: (save) => runInSession(ctx, async () => {
                 // REJOIN IS NOT A JOIN (playtest 2026-08-27, Sherry: "got an
                 // internal server error"). A dropped DDP connection -- a

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

@@ -867,6 +867,9 @@ export class Item extends AbstractItem {
     papers = [];
     /** On a license: the name of the fake SIN it was bought for. */
     linkedSin;
+    /** Who has already found the credential written in this item's
+     *  details (utilities/clue-reading.ts): a found code stays found. */
+    revealedTo = [];
     isPaper() {
         return this.category === Category.FakeSIN || this.category === Category.License || this.category === Category.SIN;
     }

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

@@ -703,9 +703,17 @@ export class Player extends AbstractPlayer {
             return true;
         return this.dniSource() !== null;
     }
+    /** Failed reads of a clue, by item name, for p.49's Trying Again
+     *  (-2 per retry). In memory only: a save and reload is the "break"
+     *  the rule says clears it. See utilities/clue-reading.ts. */
+    readAttempts = new Map();
     /** True for the one Electronics item that is a trode net (p.439-440). */
     static isTrodeNet(item) {
-        if (item.hasCapability('dni'))
+        // The item's OWN row, not Item.effects: that getter folds fitted
+        // mods in, so a helmet with a net built into it would read as a
+        // trode net itself and be named as the interface instead of the
+        // net inside it (dniSource reports the net, and the helmet as host).
+        if ((item.row?.effects ?? []).some(e => e.type === 'flag' && e.property === 'dni' && e.value > 0))
             return true;
         if (item.row)
             return false;
@@ -726,8 +734,33 @@ export class Player extends AbstractPlayer {
         const worn = this._equipment.head?.trodes;
         if (worn)
             return { kind: 'trodes', worn: true, item: worn };
-        const bagged = this._inventory.getAllItems().find(i => Player.isTrodeNet(i));
-        return bagged ? { kind: 'trodes', worn: false, item: bagged } : null;
+        // TRODES BUILT INTO HEADGEAR (koz9FKuH8Q685ogcy: "I see my helmet
+        // can hold trodes, this should be where my interface to the
+        // commlink is, right?"). Right: "Adding this to headgear takes two
+        // slots of Capacity" (p.439-440), and the helmet row has advertised
+        // a trodes slot all along -- so a net fitted into a WORN helmet is
+        // a worn net, and reads here as one. Any worn slot is searched, not
+        // just the skull: what the catalog lets hold trodes is the
+        // catalog's business.
+        for (const group of Object.values(this._equipment)) {
+            if (!group)
+                continue;
+            for (const host of Object.values(group)) {
+                if (!host)
+                    continue;
+                const built = host.fitted.find(m => Player.isTrodeNet(m));
+                if (built)
+                    return { kind: 'trodes', worn: true, item: built, host };
+            }
+        }
+        for (const carried of this._inventory.getAllItems()) {
+            if (Player.isTrodeNet(carried))
+                return { kind: 'trodes', worn: false, item: carried };
+            const built = carried.fitted.find(m => Player.isTrodeNet(m));
+            if (built)
+                return { kind: 'trodes', worn: false, item: built, host: carried };
+        }
+        return null;
     }
     /**
      * THE PRICE OF SILENCE (canon p.235-236 "Running Silent",
@@ -1237,7 +1270,18 @@ export class Player extends AbstractPlayer {
     // Edge is a per-job pool: spend a point (see commands/edge.ts) to arm a
     // boost that supercharges your next strike. Refreshed to `edge` on every
     // new job (see Game.continueToNextScene).
-    edgeRemaining = 0;
+    // AN ACCESSOR, like weaponDrawn (ZpgTTPgX4Hn7qL5M7, 2026-09-10): the
+    // play page's HUD header shows edge remaining, and a browser run has
+    // no mid-run save to carry a spend -- only the beat can. Source-
+    // compatible: every `edgeRemaining =` still works; it now reports.
+    _edgeRemaining = 0;
+    get edgeRemaining() { return this._edgeRemaining; }
+    set edgeRemaining(v) {
+        if (this._edgeRemaining === v)
+            return;
+        this._edgeRemaining = v;
+        this.noteConditionChanged();
+    }
     edgeBoostArmed = false;
     // Physical condition monitor, straight from SR5: 8 + (Body / 2, rounded
     // up) boxes. Damage fills boxes; a full track is death.
@@ -2075,7 +2119,17 @@ export class Player extends AbstractPlayer {
     // Karma: the advancement currency, earned per completed job (see
     // Scene.checkWinCondition) and spent in the hideout via "advance" --
     // gear stops being the only progression axis.
-    karma = 0;
+    // AN ACCESSOR (2026-09-10, same reason as edgeRemaining): the web's
+    // HUD header follows a karma award through the beat, since a browser
+    // run's save summary never moves mid-job. `karma +=` still works.
+    _karma = 0;
+    get karma() { return this._karma; }
+    set karma(v) {
+        if (this._karma === v)
+            return;
+        this._karma = v;
+        this.noteConditionChanged();
+    }
     /**
      * The effective rating for a skill: explicit rating if set; otherwise
      * combat skills fall back to the legacy `combatSkill` attribute (which
@@ -4189,6 +4243,10 @@ export class Player extends AbstractPlayer {
                 break;
         }
         this._currency += remaining;
+        // The wallet moved: the web's HUD header reads nuyen off the beat
+        // (2026-09-10) -- a payout, a fare, a purchase all land here.
+        if (delta !== 0)
+            this.noteConditionChanged();
     }
 }
 //# sourceMappingURL=player.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/cloud-saves.js

@@ -3,6 +3,7 @@ import * as os from 'os';
 import * as path from 'path';
 import * as http from 'http';
 import * as https from 'https';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { Logger } from './logger.js';
 import { saveSlug, readSave, writeSaveAtomic, tombstonePathFor } from './persistence.js';
 /**
@@ -90,7 +91,29 @@ export function siteRequest(method, apiPath, token, body) {
     return request(method, apiPath, token, body);
 }
 const GLOBAL_CONFIG_PATH = path.join(os.homedir(), '.meteor', '.maka', 'global-config.json');
+/**
+ * A LOGIN SCOPED TO ONE ASYNC FLOW, for the site's in-process engine
+ * (user 2026-09-10: "I can't record to the backlog while in the web
+ * client -- I AM logged in", answered with "Your login's expired").
+ *
+ * authToken() reads the machine's `maka login` -- right on a terminal,
+ * wrong on www.maka-cli.com, where one Node process hosts every
+ * browser table and the box's own global config holds whichever stale
+ * token last ran `maka` there. The site knows who typed the command;
+ * it hands that user's token to HeadlessSession.command, which runs
+ * the verb inside this store, and every transport that asks
+ * authToken() -- backlog, social, telemetry -- answers as THEM for the
+ * length of that one command. No token, no store: a terminal's
+ * behavior is byte-for-byte what it was.
+ */
+const scopedToken = new AsyncLocalStorage();
+export function runWithAuthToken(token, fn) {
+    return token ? scopedToken.run(token, fn) : fn();
+}
 export function authToken() {
+    const scoped = scopedToken.getStore();
+    if (scoped)
+        return scoped;
     try {
         const cfg = JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, 'utf8'));
         const token = cfg?.token?.authToken;

package/bundle/typescript/src/commands/game/sideQuest/utilities/clue-reading.js

@@ -0,0 +1,84 @@
+import { perceptionTest, PERCEPTION_THRESHOLD } from './perception.js';
+import { rollPool, formatRoll } from './dice.js';
+import { hint } from './hints.js';
+/**
+ * READING A CLUE IS A PERCEPTION TEST (Xxbwtgffkyq8uCHfR, Maka:
+ * 'reading codes on "books" should use a perception check to get
+ * critical information').
+ *
+ * A clue's body is plain prose anyone can read; the CREDENTIAL in it
+ * -- a maglock code in a margin, a combination on a folded page -- is
+ * the detail that "isn't obvious", and p.135 says that is exactly what
+ * a Perception Test is for: Perception + Intuition [Mental], threshold
+ * 2 for something Normal ("street sign, conversation", p.136). Hits at
+ * the threshold and the page gives up the code; short of it the reader
+ * gets the prose and not the number.
+ *
+ * TRYING AGAIN (p.49): a re-read is allowed at a cumulative -2 per
+ * retry, tracked on the reader for the session. A found code stays
+ * found (Item.revealedTo, saved with the item) -- nobody re-rolls for a
+ * number they have already read out loud.
+ *
+ * WHAT COUNTS AS A CODE: the scene's own device codes, matched
+ * verbatim against the item's details -- the same fact ensureClueDetails
+ * guarantees is written there (scene-chunks.ts). No code on the page
+ * means no test: a diary is just a diary.
+ */
+/** The p.49 penalty per failed retry. */
+export const TRYING_AGAIN_PENALTY = 2;
+/** Every device code the scene knows that this item's details spell out. */
+export function codesOnPage(scene, item) {
+    const text = (item.details ?? '').toLowerCase();
+    if (!text)
+        return [];
+    const codes = new Set();
+    for (const room of Object.values(scene.getRooms())) {
+        for (const device of room.devices) {
+            const code = (device.code ?? '').trim();
+            if (code && text.includes(code.toLowerCase()))
+                codes.add(code);
+        }
+    }
+    return [...codes];
+}
+/** The details with every sentence that spells a code taken out. */
+export function redactCodes(details, codes) {
+    const lower = codes.map(c => c.toLowerCase());
+    const kept = details
+        .split(/(?<=[.!?]["'\u201d\u2019)]?)\s+/)
+        .filter(sentence => !lower.some(c => sentence.toLowerCase().includes(c)));
+    return kept.join(' ').trim();
+}
+/**
+ * The text a reader gets from an item's details: everything, when the
+ * page holds no code or the reader already found it; otherwise the
+ * Perception Test decides whether the credential is on the page.
+ */
+export function readDetails(scene, item, opts = {}) {
+    const details = item.details ?? '';
+    const reader = opts.reader;
+    if (!details || !reader)
+        return details;
+    const codes = codesOnPage(scene, item);
+    if (codes.length === 0)
+        return details;
+    if (item.revealedTo.includes(reader.name))
+        return details;
+    const attempts = reader.readAttempts.get(item.name) ?? 0;
+    const { pool, limit } = perceptionTest(reader);
+    const penalty = attempts * TRYING_AGAIN_PENALTY;
+    const roll = rollPool(Math.max(1, pool - penalty), limit);
+    const rollLine = `Perception: ${formatRoll(roll)} (threshold ${PERCEPTION_THRESHOLD.normal}${penalty ? `, trying again -${penalty}` : ''})`;
+    if (opts.isPlayer)
+        opts.logger?.meta(rollLine);
+    const prefix = opts.isPlayer ? '' : `${rollLine}\n`;
+    if (roll.hits >= PERCEPTION_THRESHOLD.normal) {
+        item.revealedTo.push(reader.name);
+        reader.readAttempts.delete(item.name);
+        return `${prefix}${details}`;
+    }
+    reader.readAttempts.set(item.name, attempts + 1);
+    const body = redactCodes(details, codes) || item.description || `You go through "${item.name}" page by page.`;
+    return `${prefix}${body}\nSomething in it is written to be missed -- you have the sense you skimmed past it.${hint(` (read it again: -${TRYING_AGAIN_PENALTY} dice per retry, p.49)`)}`;
+}
+//# sourceMappingURL=clue-reading.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/condition-report.js

@@ -166,6 +166,15 @@ export function buildConditionReport(player, deps) {
         // The ONE honest AR answer (2026-09-01): muted, cut, and no-rig
         // all collapse into arSightUp, computed at fire time.
         ar: arSightUp(player),
+        // THE HEADER'S NUMBERS (contract 2026-09-10, web accepted first;
+        // ZpgTTPgX4Hn7qL5M7: the play page's HUD shows the sheet header). A
+        // browser run writes no mid-run save and its roster summary is
+        // frozen for the whole job, so an edge spend, a payout, or a karma
+        // award reaches the web only through the beat. The engine's own
+        // fields, verbatim; edge is BOTH halves or neither on the web side.
+        karma: player.karma,
+        nuyen: player.currency,
+        edge: { remaining: player.edgeRemaining, max: player.edge },
         // THE ROOM'S OTHER DOTS (user: the map becomes a tactical
         // readout). Current room only, read at fire time; spot-seated
         // actors carry `spot` and the web places them on the grid it
@@ -218,6 +227,7 @@ function noteRoster(report) {
 const ADDITIVE_FIELDS = [
     'ar', 'actors', 'deckLine', 'deckDamage', 'astralPerceiving', 'bodyRoom', 'sustainingPenalty',
     'matrix', 'panMarks', 'hostMarksOnYou', 'marksPlaced', 'marksOnYou', 'deckStored', 'droneDamage', 'companions', 'pools', 'initiative',
+    'karma', 'nuyen', 'edge',
 ];
 /** Refusal reasons already written to the session log -- one line each. */
 const announcedRefusals = new Map();

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

@@ -178,6 +178,8 @@ export function serializeItem(item) {
         out.linkedSin = item.linkedSin;
     if (item.fitted.length > 0)
         out.fitted = item.fitted.map(serializeItem);
+    if (item.revealedTo.length > 0)
+        out.revealedTo = [...item.revealedTo];
     if (item.isCyberdeck() && item.deckOrder.join() !== '0,1,2,3')
         out.deckOrder = item.deckOrder;
     return out;
@@ -231,6 +233,8 @@ export function restoreItem(json) {
         item.linkedSin = json.linkedSin;
     if (json.fitted)
         item.fitted = json.fitted.map(restoreItem);
+    if (json.revealedTo)
+        item.revealedTo = [...json.revealedTo];
     // A running program is in storage by definition -- saves from before
     // storage existed carried only the running set.
     for (const k of item.loadedPrograms)

package/package.json

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