@maka/maka-cli 5.212.0 → 5.213.0

package/bundle/typescript/package.json

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

@@ -1009,5 +1009,41 @@
 //   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.
-export const ENGINE_VERSION = '1.72.0';
+// 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.212.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.",