@maka/maka-cli 5.169.0 → 5.171.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.169.0",
+  "version": "5.171.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/factories/scene-chunks.js

@@ -157,6 +157,10 @@ Tailoring rules:
 - Never gate FINISHING the run behind a capability they lack: no matrix-plane winCondition
   item unless they can already jack in (deck or resonance) or a findable Cyberdeck is placed
   in a reachable room; no ward/"spell"-bypass-only route for someone who can't cast.
+- The mirror of that rule: if they CAN jack in and the winCondition item is a Datachip or
+  Document, it is PAYDATA -- "plane": "matrix", in a hasNode room, with an ice NPC stationed
+  there. A hacker's file is never lying on a desk in the meat world; the host IS the job.
+  (A physical objective -- a person, a prototype, a briefcase -- stays physical.)
 - Don't hand them loot they can't use as a puzzle rewardItem or the winCondition rewardItem
   (spellcasting gear for an adept, a second cyberdeck or drone for someone who already has
   one). Useless-to-them gear may still exist as ordinary world dressing or valuables.
@@ -500,7 +504,9 @@ Hard structural rules (validated mechanically -- a violation is rejected):
   skill can still take the shortcut -- pick the lock, hack the panel -- but the found way
   must exist for a runner who has neither.
 - The winCondition item must not be heldBy winCondition.toNpc. If a matrix-plane item is the
-  winCondition item, its room has hasNode true AND a "matrix"-plane NPC stationed there.
+  winCondition item, its room has hasNode true AND a "matrix"-plane NPC stationed there. If
+  the runner can jack in, a Datachip/Document winCondition item MUST be that matrix-plane
+  item -- data for a hacker lives on a host, never on a desk.
 - ${isContinuation
         ? 'ZERO "starting"-role items -- the runner arrives with everything they own. 4-6'
         : '3-5 "starting"-role items (basics the runner doesn\'t already own -- see the dossier), 4-6'}
@@ -763,6 +769,14 @@ export function partyCanDispel(player) {
 export function partyCanDeck(player) {
     return !!player && (player.isTechnomancer() || !!player.getCyberdeck());
 }
+/** The item categories that ARE data: the only shapes paydata takes
+ *  (schema: "matrix" = paydata, category Datachip/Document). A win item
+ *  in one of these, for a runner who can deck, belongs on a host --
+ *  see the rule in validateSkeleton (jfjjTmJ7NYwDaFiyB). */
+export const DATA_ITEM_CATEGORIES = ['datachip', 'document'];
+export function isDataShaped(category) {
+    return !!category && DATA_ITEM_CATEGORIES.includes(category.trim().toLowerCase());
+}
 /**
  * WHAT KIND OF JOB IS ON THE TABLE.
  *
@@ -990,6 +1004,44 @@ export function validateSkeleton(skeleton, player, crew) {
         fail(`winCondition.item "${skeleton.winCondition.item}" is not in items.`);
     if (!npcNames.has(skeleton.winCondition.toNpc))
         fail(`winCondition.toNpc "${skeleton.winCondition.toNpc}" is not in npcs.`);
+    // A HACKER'S DATA LIVES ON A HOST (jfjjTmJ7NYwDaFiyB, Ted: "the
+    // encrypted data chip was just laying there in the meat world...
+    // hardly a fun run for a decker that never needs to attack a host,
+    // get the data, download it, and get out"). The data-run brief only
+    // fires on the DATA_RUN_SHARE roll; the other seven jobs in ten are
+    // standard runs, and a standard run was free to make its objective a
+    // Datachip on a desk -- for a runner whose whole toolkit is the
+    // Matrix. So: whenever the runner CAN jack in and the objective is
+    // data-shaped, it is paydata, and paydata sits inside a host with ice
+    // on it. A runner who cannot deck keeps the chip on the desk (the
+    // "never gate finishing" rule outranks this one), and a physical
+    // objective -- a person, a prototype, a briefcase -- is untouched.
+    //
+    // Checked HERE, at the skeleton, and not left to validateMatrixDefense
+    // (scene-seed-generator.ts): that one runs after the detail passes and
+    // its wording routes to the items chunk through classifyRepair, which
+    // cannot add a hasNode flag or an ice NPC -- the skeleton owns both.
+    // Worded to route to 'skeleton' (no "items[", no "Win condition item").
+    const winItem = skeleton.items.find(i => i.name === skeleton.winCondition.item);
+    if (winItem && isDataShaped(winItem.category) && winItem.plane !== 'matrix' && partyCanDeck(player)) {
+        fail(`the winCondition item "${winItem.name}" is a ${winItem.category} on the meat plane, and this runner can jack in -- for a decker or technomancer, data is PAYDATA: give it "plane": "matrix", place it in a hasNode room (not heldBy anyone), and station a "matrix"-plane NPC (ice) there. A chip lying on a desk is no job for a hacker.`);
+    }
+    // The other half of the same rule, for ANY matrix-plane objective: the
+    // schema says its room has hasNode and an ice NPC stationed there, and
+    // until now nothing at the skeleton checked it.
+    if (winItem?.plane === 'matrix') {
+        if (!winItem.room) {
+            fail(`the winCondition item "${winItem.name}" is matrix-plane paydata but has no "room" -- data lives on a host, never in a pocket. Place it in a hasNode room.`);
+        }
+        const vault = skeleton.rooms.find(r => r.name === winItem.room);
+        if (!vault?.hasNode) {
+            fail(`the winCondition item "${winItem.name}" is matrix-plane paydata in "${winItem.room}", which has no "hasNode": true -- a matrix file can only exist on a host. Mark that room hasNode.`);
+        }
+        const ice = skeleton.npcs.some(n => n.plane === 'matrix' && n.startLocation === winItem.room);
+        if (!ice) {
+            fail(`the winCondition item "${winItem.name}" is matrix-plane paydata in hasNode room "${winItem.room}" with no ice guarding it -- station a "matrix"-plane NPC there. An undefended vault is a free win.`);
+        }
+    }
     // Lock-and-key reachability. CRITICAL: edges are BIDIRECTIONAL -- the
     // engine mirrors every declared exit into a shared two-way Door
     // (room.addExit writes both sides), so a one-sided skeleton exit still

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/package.json

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