@maka/maka-cli 5.211.0 → 5.213.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.211.0",
+  "version": "5.213.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/bypass-command.js

@@ -89,6 +89,15 @@ export class BypassCommand extends Command {
         }
         return { error: `There's nothing here called "${raw}".` };
     }
+    /**
+     * THE ACTION PHASE COST OF ONE ATTEMPT, charged at the moment the
+     * attempt becomes real (see execute()). Free by default; a subclass
+     * whose verb IS a canon Matrix or combat action overrides it and
+     * returns the refusal when the phase cannot pay.
+     */
+    billForAttempt() {
+        return undefined;
+    }
     async execute(args) {
         const room = this.actor.currentLocation;
         const all = room?.openableDevices() ?? [];
@@ -164,6 +173,19 @@ export class BypassCommand extends Command {
         if (reach.refusal)
             return reach.refusal;
         const crossNote = reach.line ? `${reach.line}\n` : '';
+        // THE LAST POINT BEFORE THE ATTEMPT IS REAL -- the target resolved,
+        // the verb allowed, the runner standing where the mechanism is. A
+        // subclass with an Action Phase cost pays it HERE and nowhere
+        // earlier, so every refusal above is free (GoEyGG9PSRM4mpXzG: "I
+        // shouldn't be hit on a simple/complex action if the command is
+        // rejected").
+        //
+        // Default is free: most verbs on this base (pick, breach, use) have
+        // never billed an action and this is not the change that gives them
+        // one. Only HackCommand overrides it today.
+        const billed = this.billForAttempt();
+        if (billed)
+            return billed;
         const outcome = await this.determineOutcome(device);
         if (outcome === 'progress') {
             this.logger.write(`${this.actor.name} keeps working "${device.name}" (${this.verbName}, in progress)`);

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

@@ -1,4 +1,5 @@
 import { Command } from './command.js';
+import { billAction } from '../utilities/action-cost.js';
 import { roomsInReach, gridVicinity } from '../utilities/grid-reach.js';
 import { hint } from '../utilities/hints.js';
 import { Category } from '../types/shared/item-enum.js';
@@ -38,11 +39,15 @@ import { fileReach, planeTintItemName } from '../utilities/planes.js';
  * else's sprite is not a shelf you may take from -- that is a hack, and
  * hack.ts owns it.
  *
- * DELIBERATELY NOT A TEST. Pulling a file you already have reach on is
- * not an opposed action in this engine -- `take` does not roll for it
- * either, and getting past whatever GUARDED the file is what the host
- * crack and the mark already charged for. Adding dice here would price
- * the same obstacle twice.
+ * DELIBERATELY NOT A TEST -- BUT IT IS AN ACTION. Pulling a file you
+ * already have reach on is not an opposed action in this engine --
+ * `take` does not roll for it either, and getting past whatever GUARDED
+ * the file is what the host crack and the mark already charged for.
+ * Adding dice here would price the same obstacle twice.
+ *
+ * The TIME is a separate bill, and it was going unpaid: copying a file
+ * is Edit File, a COMPLEX ACTION (p.239). See the billAction call in
+ * execute() for what that was costing in a fight.
  */
 export class DownloadCommand extends Command {
     static verb = 'download';
@@ -116,6 +121,27 @@ export class DownloadCommand extends Command {
         if (wc?.type === 'erase' && wc.item.toLowerCase() === item.name.toLowerCase()) {
             return `Pulling ${item.name} down changes nothing -- the desk keeps its own. ${hint(`"erase ${item.name}" is what makes it go away (Edit File, p.239).`)}`;
         }
+        // COPYING A FILE IS EDIT FILE, AND EDIT FILE IS A COMPLEX ACTION
+        // (p.239: "Edit File allows you to create, change, COPY, delete, or
+        // protect any kind of file"). The no-dice ruling above stands -- the
+        // host crack already charged for the obstacle -- but "not a test"
+        // was silently read as "not an action", and in a Combat Turn that is
+        // a different claim entirely. Found in jfjjTmJ7NYwDaFiyB's own
+        // bench: walking into a rating-3 host wakes Patrol IC, `search` is
+        // correctly refused ("a Matrix Search takes minutes ... a Combat
+        // Turn is three seconds") and `download` then emptied the archive
+        // for FREE with the ice mid-turn on the runner. That makes the fight
+        // the report asked for optional -- stroll in, take the paydata, and
+        // the ice never mattered.
+        //
+        // billAction is a no-op outside an encounter, so the quiet case --
+        // an empty host, a file loose on the grid -- is untouched: still one
+        // verb, no roll, no friction. It bills only where an action economy
+        // exists to bill against, and a refusal returns BEFORE the item
+        // moves, so a runner out of actions keeps both the file and the turn.
+        const bill = billAction(this.scene, actor, 'complex', 'Edit File (copy)');
+        if (bill)
+            return bill;
         // THE CONVERSION, identical to take.ts's. Same two fields, because a
         // file that came down by one verb and a file that came down by the
         // other must be the same object afterwards -- a chip you can `give`.

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

@@ -13,7 +13,7 @@ import { TapCommand } from './tap.js';
 import { nameableNames } from '../utilities/nameables.js';
 import { sameHostSide } from '../models/player.js';
 import { MAX_MARKS } from '../utilities/marks.js';
-import { billAction } from '../utilities/action-cost.js';
+import { actionRefusal, billAction } from '../utilities/action-cost.js';
 import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 import { declarationPenalty, parseMarkDeclaration, hostDefensePool, wanDefensePool, freeMatrixPerceptionHits, bruteForceMatrixDv, overwatchFromDefense, GO_BIG_QUALITY, deviceDefensePool } from '../utilities/matrix-intrusion.js';
 /**
@@ -54,6 +54,23 @@ export class HackCommand extends BypassCommand {
     actionName() {
         return this.mode() === 'attack' ? 'Brute Force' : 'Hack on the Fly';
     }
+    /**
+     * THE SPEND, at the moment the verb commits -- see the long note in
+     * execute() for why it is not at the top any more
+     * (GoEyGG9PSRM4mpXzG). Called immediately before a roll, or before
+     * handing off to a command that does the work. Returns the refusal
+     * when the phase cannot pay, undefined when it just did.
+     */
+    bill() {
+        return billAction(this.scene, this.actor, 'complex', this.actionName());
+    }
+    /** The meat-world barrier route (super.execute) pays at the same
+     *  moment every other route does -- once the device is resolved and
+     *  the attempt is about to happen, never for a name that matched
+     *  nothing. */
+    billForAttempt() {
+        return this.bill();
+    }
     async execute(args = []) {
         const mode = this.mode();
         const afterMode = [...(args ?? [])];
@@ -66,9 +83,26 @@ export class HackCommand extends BypassCommand {
         // BRUTE FORCE and HACK ON THE FLY are Complex Actions (p.238, p.240)
         // -- billed only inside a Combat Turn, where one intrusion is the
         // whole Action Phase.
-        const bill = billAction(this.scene, this.actor, 'complex', this.actionName());
-        if (bill)
-            return bill;
+        //
+        // ASKED HERE, PAID LATER (GoEyGG9PSRM4mpXzG, Maka: "I shouldn't be
+        // hit on a simple/complex action if the command is rejected").
+        // This used to be the spend, at the top, before a single line of
+        // target resolution had run -- so "hack camera" in a room with no
+        // camera printed "Nothing on the grid answers to 'camera'" AND ate
+        // the whole Action Phase. The player was charged an intrusion for a
+        // word the parser did not recognise.
+        //
+        // The affordability question still belongs up here: a runner with
+        // nothing left this phase should hear it before the game goes
+        // hunting through PANs, devices and hosts on their behalf. What
+        // moved is the SPEND -- down to `bill()` below, called at each point
+        // the verb actually commits: immediately before a roll, or before
+        // handing off to a command that does the work (TapCommand, the
+        // barrier bypass in super.execute). Every refusal between here and
+        // there costs nothing, which is the report.
+        const unaffordable = actionRefusal(this.scene, this.actor, 'complex');
+        if (unaffordable)
+            return unaffordable;
         // PAN warfare: "hack <name>" cracks a meat actor's personal area
         // network -- from inside the Matrix, or right here in AR with a
         // working deck in hand (which is also how enemy deckers get YOU).
@@ -99,6 +133,11 @@ export class HackCommand extends BypassCommand {
         // puzzle that happens to be named for one still falls through to
         // the bypass path below, untouched.
         if (rest.length > 0 && matchesCameraName(rest.join(' ')) && isWatched(this.actor.currentLocation)) {
+            // NOT BILLED HERE. TapCommand has its own refusals past this point
+            // -- a direct connection is a cable and wants your BODY in the
+            // room -- so it pays at its own commit point instead. Billing
+            // before the handoff charged a Complex Action for being told the
+            // route was not available (GoEyGG9PSRM4mpXzG, one layer down).
             return new TapCommand({
                 actor: this.actor,
                 scene: this.scene,
@@ -208,6 +247,12 @@ export class HackCommand extends BypassCommand {
             const burned = this.actor.burnedAttributeRefusal(mode === 'attack' ? 'attack' : 'sleaze');
             if (burned)
                 return burned;
+            // Committed: a real host, resolved by name, with marks left to
+            // take and a bracket to take them with. Every refusal above this
+            // line is free.
+            const billedHost = this.bill();
+            if (billedHost)
+                return billedHost;
             this.actor.performAction('hacks the host', room.name, { quiet: this.scene.isHumanControlled(this.actor) });
             const attempt = await this.hostIntrusionRoll(mode, declared, room);
             const success = attempt.success;
@@ -592,6 +637,13 @@ export class HackCommand extends BypassCommand {
         const burned = actor.burnedAttributeRefusal(mode === 'attack' ? 'attack' : 'sleaze');
         if (burned)
             return burned;
+        // Committed: a real slaved icon, named and reachable. Note that
+        // every `return null` above is a FALL-THROUGH, not a refusal -- it
+        // hands the query on to the host or PAN route, which pays for
+        // itself if it commits. Billing before those would charge twice.
+        const billedDevice = this.bill();
+        if (billedDevice)
+            return billedDevice;
         const declared = Math.min(declaredMarks, MAX_MARKS - held);
         const declarePenalty = declarationPenalty(declared, actor.hasQuality(GO_BIG_QUALITY));
         const silence = actor.matrixActionPenalty;
@@ -845,6 +897,10 @@ export class HackCommand extends BypassCommand {
         const burnedPan = actor.burnedAttributeRefusal(mode === 'attack' ? 'attack' : 'sleaze');
         if (burnedPan)
             return burnedPan;
+        // Committed: a real person, in reach, running a PAN worth cracking.
+        const billedPan = this.bill();
+        if (billedPan)
+            return billedPan;
         const limit = actor.matrixAttribute(mode === 'attack' ? 'attack' : 'sleaze');
         // Logic + the better of HACKING and ELECTRONIC WARFARE + gear (canon:
         // EW is the jamming-and-signals half of PAN warfare; best-of keeps

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

@@ -1,4 +1,5 @@
 import { Command } from './command.js';
+import { billAction } from '../utilities/action-cost.js';
 import { hostLabel } from '../utilities/grid-names.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
 import { accrueOverwatch } from '../utilities/overwatch.js';
@@ -113,6 +114,21 @@ export class TapCommand extends Command {
             return burned;
         const limit = actor.matrixAttribute(mode === 'attack' ? 'attack' : 'sleaze');
         const pool = Math.max(1, actor.logic + actor.skillRating('hacking') + actor.bonus('hacking') + silence + actor.woundModifier - actor.sustainingPenalty);
+        // THE SPEND, HERE AND NOT EARLIER (GoEyGG9PSRM4mpXzG). A direct
+        // connection does not change WHICH action you are taking -- it is
+        // still Hack on the Fly or Brute Force (p.240/p.238), and both are
+        // Complex Actions -- but every refusal above this line is a reason
+        // the attempt never happened: no cameras, no cable, no host on the
+        // other end, the host already open, the ring already full, a bracket
+        // eaten to zero. None of those is an action taken.
+        //
+        // It matters twice, because hack.ts routes "hack camera" here. That
+        // route USED to bill before delegating, which meant a decker out on
+        // the grid typing "hack camera" paid a Complex Action to be told a
+        // direct connection is a CABLE and needs their body in the room.
+        const billed = billAction(this.scene, actor, 'complex', mode === 'attack' ? 'Brute Force' : 'Hack on the Fly');
+        if (billed)
+            return billed;
         actor.performAction('cables into the cameras', `${room.name} -- a hand on the housing, a filament out of their deck`);
         const roll = rollPool(pool, limit);
         if (showsMechanics(this.scene, actor)) {

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

@@ -984,5 +984,66 @@
 //     that reads like an icon you could act on. It is dropped when it
 //     lands first. (1.69.0 fixed the same heading leaking into the
 //     distance bands; this is the other half.)
-export const ENGINE_VERSION = '1.71.0';
+// 1.72.0 (2026-09-16): COPYING A FILE IS AN ACTION, NOT JUST A VERB
+//   (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 generation half of that report shipped in 5.171.0 -- a
+//   data-shaped objective for a runner who can jack in is paydata on a
+//   host, refused at the skeleton. Building this item's bench on top of
+//   it is what exposed the rest: walk into a rating-3 host, Patrol IC
+//   opens a Combat Turn, "search" refuses itself correctly ("a Matrix
+//   Search takes minutes (p.241), and a Combat Turn is three seconds")
+//   -- and "download" then emptied the archive for FREE with the ice
+//   mid-turn on the runner. The fight the report asked for was
+//   optional: stroll in, take the paydata, the ice never mattered.
+//   Copying a file IS Edit File, and Edit File IS a Complex Action
+//   (p.239, RAG-checked: "Edit File allows you to create, change, COPY,
+//   delete, or protect any kind of file"). download.ts now bills one.
+//   The deliberate no-dice ruling it was built with stands untouched --
+//   the host crack already charged for the obstacle, and dice here would
+//   price it twice -- but "not a test" had been read as "not an action",
+//   and in a Combat Turn those are different claims. billAction is a
+//   no-op outside an encounter, so the quiet case (an empty host, a file
+//   loose on the grid) is exactly as it was: one verb, no roll, no
+//   friction. The refusal returns before the item moves, so a runner out
+//   of actions keeps both the file and the turn, and listing what is in
+//   reach ("download" bare) still costs nothing.
+// 1.73.0 (2026-09-16): A REJECTED COMMAND IS FREE (GoEyGG9PSRM4mpXzG,
+//   Maka: "I shouldn't be hit on a simple/complex action if the command
+//   is rejected: 'Nothing on the grid answers to \"camera\" -- no host by
+//   that name, no PAN, no camera ...' should not count as a complex
+//   action"). hack.ts billed its Complex Action at the TOP of execute(),
+//   before one line of target resolution had run, so a name the grid
+//   does not answer to cost exactly what an intrusion costs: the player
+//   was told nothing matched and their Action Phase was gone. Canon
+//   charges for an action TAKEN (p.163-167); a sentence the parser
+//   refused is not one.
+//   - The AFFORDABILITY question stays at the top, where it belongs: a
+//     runner with nothing left this phase should hear that before the
+//     game goes hunting through PANs, devices and hosts on their behalf.
+//     That is the new actionRefusal() in utilities/action-cost.ts --
+//     billAction's question without billAction's spend, same budget,
+//     same wording, so the player cannot tell which one spoke.
+//   - The SPEND moved down to each route's commit point: immediately
+//     before the host intrusion roll, the slaved-device roll and the PAN
+//     roll, and (for the meat-world barrier route) at the new
+//     billForAttempt() hook in bypass-command.ts, which fires once the
+//     device is resolved, the verb allowed and the runner standing where
+//     the mechanism is. The hook is free by default -- pick, breach and
+//     use have never billed an action and this is not the change that
+//     gives them one.
+//   - THE SAME DEFECT WAS ONE LAYER DOWN, found by the test rather than
+//     by reading: "hack camera" RESOLVES in a watched room and hands off
+//     to TapCommand, which then refuses because a direct connection is a
+//     cable and wants your BODY in the room. Billing before the handoff
+//     charged a Complex Action for that refusal. tap.ts now pays at its
+//     own commit point, which also gives the `tap` verb the cost it
+//     always owed -- a direct connection does not change WHICH action
+//     you are taking (p.233), and both halves are Complex (p.238/p.240).
+//   Note the shape, because it is easy to write again: a verb that bills
+//   at the top of execute() has charged for the phase before it knows
+//   whether it has a target, and a verb that bills before delegating has
+//   charged for a refusal it cannot see.
+export const ENGINE_VERSION = '1.73.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -76,6 +76,41 @@ export function billAction(scene, actor, kind, label, opts = {}) {
     scene.updateStatus?.();
     return undefined;
 }
+/**
+ * THE SAME QUESTION, ASKED WITHOUT PAYING -- "could I afford this?"
+ *
+ * GoEyGG9PSRM4mpXzG (Maka): "I shouldn't be hit on a simple/complex
+ * action if the command is rejected: 'Nothing on the grid answers to
+ * "camera" -- no host by that name, no PAN, no camera' ... should not
+ * count as a complex action."
+ *
+ * Exactly right, and the shape of the bug is worth naming because it is
+ * easy to write again: a verb that bills at the TOP of execute() has
+ * charged for the Action Phase before it knows whether it has a target.
+ * Typing a name the grid does not answer to then costs the same as an
+ * intrusion -- the player is told "nothing answers to that" and their
+ * turn is gone. Canon charges for an action TAKEN (p.163-167); a
+ * sentence the game refused to parse is not one.
+ *
+ * But a verb still wants to say "you have nothing left this phase"
+ * BEFORE it goes hunting for a target, or the player gets a page of
+ * resolution and a refusal at the end of it. So: ask with this at the
+ * top, spend with billAction at the point the action actually commits
+ * -- after every refusal, immediately before the roll or the delegation.
+ * The pair reads the same budget and returns the same wording, so the
+ * player cannot tell which one spoke.
+ */
+export function actionRefusal(scene, actor, kind, opts = {}) {
+    const enc = encounterOf(scene, actor);
+    if (!enc || enc.ended)
+        return undefined;
+    if (!enc.isPhaseOf(actor))
+        return notYourPhase(enc, actor);
+    const budget = enc.budgetOf(actor);
+    if (!budget)
+        return notYourPhase(enc, actor);
+    return budget.refusalFor(kind, opts.attack === true);
+}
 /**
  * A verb that is refused outright mid-fight unless it is your phase --
  * for things that are not actions at all but still cannot happen while

package/package.json

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