@maka/maka-cli 5.199.0 → 5.201.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/mechanics-audience.js

@@ -0,0 +1,71 @@
+/**
+ * WHO IS WATCHING THE DICE (wjFBY3zgyWzJP9adw, Deditri: "the sprite put a
+ * mark on the target but there was no output about the rolls in the
+ * logs").
+ *
+ * The sprite's dice WERE rolled. `order <sprite> mark <lock>` runs the
+ * real verb with the sprite as actor -- commands/order.ts hands the
+ * string to NPC.tryRunCommand, commands/mark.ts re-dispatches into
+ * HackCommand, and hack.ts rolls Hack on the Fly against the device
+ * exactly as it would for a decker. The roll was then thrown away at the
+ * REPORTING layer, by a guard that has been copied into ~30 commands:
+ *
+ *     if (this.scene.isHumanControlled(actor)) this.logger.meta(...)
+ *
+ * That asks "is the ROLLER a human". The question the Mechanics panel
+ * actually wants is "is a HUMAN WATCHING" -- and the codebase already
+ * answers it correctly two files over, in CombatExchange.playerWitnesses
+ * (utilities/combat-exchange.ts), which is precisely why a sprite's
+ * COMBAT rolls have always shown up while the same sprite's ordered
+ * mark went silent. One question, asked two ways, in one engine.
+ *
+ * WHY OWNERSHIP AND NOT PROXIMITY. playerWitnesses is a bystander test:
+ * same place, perceivable plane. That is right for a fight, which is an
+ * event in a room. It is wrong for an ORDER, which is a thing the player
+ * deliberately did: a rigger whose drone is sweeping the floor above,
+ * or a technomancer whose sprite is working a host their body is nowhere
+ * near, typed that command and is owed its dice. So a companion's rolls
+ * are shown to its master wherever it is standing. Anything that is
+ * NOT a companion -- IC, a guard, a passer-by -- keeps the old silence
+ * and reports through the channels it already had (utilities/ic.ts
+ * accumulates into IICTurn.meta; a fight goes through announce).
+ *
+ * THE FORK MUST STAY EXCLUSIVE. Several commands route the roll to
+ * EITHER the Mechanics panel (player) OR their own return string, which
+ * for an NPC is its AI history:
+ *
+ *     const isPlayer = scene.isHumanControlled(actor);
+ *     if (isPlayer) this.logger.meta(`Perception: ${formatRoll(roll)}`);
+ *     const rollPrefix = isPlayer ? '' : `Perception: ${formatRoll(roll)}\n`;
+ *
+ * Both halves must read the SAME predicate or an ordered companion
+ * prints its dice twice. Callers swapping to showsMechanics must swap
+ * both.
+ */
+/** The companion ledger entry for this actor, if it is somebody's. */
+function companionEntryFor(scene, actor) {
+    return scene.ownerGame?.companions?.find(c => c.npc === actor);
+}
+/**
+ * Should this actor's dice anatomy go to the Mechanics panel?
+ *
+ * True for a human-controlled actor (the old rule, unchanged), and for a
+ * companion a human is running -- a sprite, spirit, agent or drone whose
+ * master typed the order that got here.
+ */
+export function showsMechanics(scene, actor) {
+    if (scene.isHumanControlled?.(actor) === true)
+        return true;
+    return companionEntryFor(scene, actor) !== undefined;
+}
+/**
+ * The name to hang on a Mechanics line when the roller is not the player
+ * -- "Crack Sprite -- Hack on the Fly (sleaze) on Hatch Maglock: ...".
+ * Empty for the player's own rolls, which stay exactly as they read
+ * today: a panel that started prefixing the player's own name on every
+ * line would be noisier for the common case to serve the rare one.
+ */
+export function mechanicsActorPrefix(scene, actor) {
+    return scene.isHumanControlled?.(actor) === true ? '' : `${actor.name} -- `;
+}
+//# sourceMappingURL=mechanics-audience.js.map

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

@@ -601,6 +601,9 @@ function serializeRoomOverlay(room, player) {
             inventory: b.inventory.getAllItems().map(serializeItem),
         })),
         searchedBy: [...room.searchedBy],
+        // A SANCTIONED HOST KEEPS NO INDEX EITHER, for the same reason it
+        // forgets a crack: a haven is not a target you cased.
+        hostSearchedBy: room.hostSanctioned ? [] : [...(room.host?.searchedBy ?? [])],
         visitedBy: [...room.visitedBy],
         // A SANCTIONED HOST NEVER REMEMBERS A CRACK (Room.hostSanctioned).
         // The overlay rule is right for run content -- you broke that
@@ -771,6 +774,10 @@ export function applyHubOverlay(scene, saved, player, homeRoom) {
             return { name: b.name, cell: { ...b.cell }, inventory: held };
         });
         room.searchedBy = new Set(overlay.searchedBy);
+        // Only onto a room that HAS a host -- a seed that dropped its node
+        // between saves must not grow one back through the overlay.
+        if (room.host)
+            room.host.searchedBy = new Set(overlay.hostSearchedBy ?? []);
         room.visitedBy = new Set(overlay.visitedBy);
         // Both ends, so an OLD save written before hostSanctioned existed
         // cannot restore a cracked haven either.

package/bundle/typescript/src/commands/game/sideQuest/utilities/presence-gate.js

@@ -17,12 +17,37 @@
  * Game, a hub, or a socket. It is deliberately the WHOLE gate: a caller
  * that reimplements part of it inline is the bug this file exists to
  * prevent coming back.
+ *
+ * THE ACCOUNT HALF MOVED IN HERE (TLKZKLQ4rJBCnDjrw, 2026-09-15). It was
+ * living in Game.startPresenceHeartbeat, guarding only the process that
+ * ARMS the timer -- and `returnToHub` beats once directly at every
+ * homecoming, past that guard. So a hosted hub, a repro bench and the
+ * jest suite alike all dialed www.maka-cli.com on the way home with
+ * whatever token the BOX happened to be logged in as. In the suite that
+ * is the developer's own account: `loose-ends.test.ts` boots a fixture
+ * runner named Vex over the "Legacy Hub Fixture" seed, goes home, and
+ * overwrote the developer's real presence row -- so their web sheet read
+ * "You are on the street as Vex", a runner belonging to somebody else's
+ * account entirely. Two halves of one rule, in two places, is how that
+ * happened; both halves live here now.
+ */
+/**
+ * IS THIS PROCESS ON THE STREET AT ALL? The account half of the gate --
+ * the half that asks whether the credentials on this box belong to the
+ * runner in memory. A `false` here means no beat ever, from any caller,
+ * at any moment; nothing downstream can re-enable it.
  */
-export function presenceBeatAllowed(atHub, holdsLiveSeat) {
+export function presenceProcessOnTheStreet(f) {
+    return !f.anonymous && !f.bench && !f.hostedHub;
+}
+/** The WHOLE gate: the account half, then the position half. */
+export function presenceBeatAllowed(f) {
+    if (!presenceProcessOnTheStreet(f))
+        return false;
     // A solo run stays private, exactly as before. Only a LIVE SEAT keeps
     // the beat alive off-hub -- the narrowest change that fixes the cut,
     // and at that point other real players are sitting at the table, so
     // "the run is nobody's business" no longer describes the situation.
-    return atHub || holdsLiveSeat;
+    return f.atHub || f.holdsLiveSeat;
 }
 //# sourceMappingURL=presence-gate.js.map

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

@@ -14,7 +14,13 @@
  */
 export const PROGRAMS = [
     // ---- Common programs (p.245; pricing canon-approximate) ----
-    { key: 'browse', name: 'Browse', kind: 'common', cost: 80, availability: 2, effect: '+2 dice on Matrix Search while jacked in.' },
+    // BROWSE BUYS TIME, NOT DICE (Splintered State p.54: it "cuts the base
+    // time in half"). The catalogue advertised "+2 dice on Matrix Search"
+    // and no code ever added them -- utilities/perception.ts has always
+    // halved the clock, which is the half that is right. A program whose
+    // shop blurb promises a bonus it does not grant is a lie the player
+    // pays 80 nuyen for.
+    { key: 'browse', name: 'Browse', kind: 'common', cost: 80, availability: 2, effect: 'Halves the base time of a Matrix Search (p.241).' },
     { key: 'toolbox', name: 'Toolbox', kind: 'common', cost: 80, availability: 2, effect: '+1 Data Processing.' },
     { key: 'encryption', name: 'Encryption', kind: 'common', cost: 80, availability: 2, effect: '+1 Firewall.' },
     { key: 'signal-scrub', name: 'Signal Scrub', kind: 'common', cost: 80, availability: 2, effect: 'Cleans your noise floor: +1 die defending your PAN.' },

package/bundle/typescript/src/commands/game/sideQuest/utilities/sprite-power-actions.js

@@ -0,0 +1,270 @@
+import { rollPool, formatRoll } from './dice.js';
+import { hint } from './hints.js';
+import { hostLabel } from './grid-names.js';
+import { spriteMatrix, spritePower, powersForSprite } from '../sprite-powers.js';
+const refuse = (text) => ({ text, meta: [], spent: false });
+/** Every persona sharing this sprite's place on the grid or in a host. */
+function personasNear(ctx) {
+    const here = ctx.sprite.hostInside;
+    return ctx.scene.allActors.filter((a) => a !== ctx.sprite && a.plane === 'matrix'
+        && (here ? a.hostInside === here : a.currentGrid === ctx.sprite.currentGrid));
+}
+/** The host this sprite is standing inside, if any. */
+function hostOf(ctx) {
+    return ctx.sprite.hostInside?.over;
+}
+/** The sprite's pool for a skill, its Level standing in for the attribute
+ *  the book pairs it with (p.254: a sprite's ratings are all Level-derived). */
+function spritePool(ctx, skill) {
+    const rating = ctx.sprite.skillRating(skill);
+    return Math.max(1, (rating > 0 ? rating : -1) + ctx.level);
+}
+// ===================== THE FOUR ROLLED POWERS =====================
+/** COOKIE (p.256-257): Hacking + Resonance [Sleaze] v. Intuition + Firewall. */
+function cookie(ctx, targetName) {
+    const near = personasNear(ctx);
+    const target = near.find(p => p.name.toLowerCase() === targetName.toLowerCase())
+        ?? near.find(p => p.name.toLowerCase().includes(targetName.toLowerCase()));
+    if (!target) {
+        return refuse(`${ctx.sprite.name} finds no persona called "${targetName}" to tag.${near.length > 0 ? hint(` (Here: ${near.map(p => p.name).join(', ')}.)`) : ''}`);
+    }
+    const m = spriteMatrix(ctx.spriteKey, ctx.level);
+    const attack = rollPool(spritePool(ctx, 'hacking') + m.resonance, m.sleaze);
+    const defence = rollPool(Math.max(1, target.intuition + target.matrixAttribute('firewall')));
+    const net = attack.hits - defence.hits;
+    const meta = [
+        `${ctx.sprite.name} -- Cookie (Hacking + Resonance [Sleaze ${m.sleaze}]): ${formatRoll(attack)}`,
+        `  ${target.name} resists (Intuition + Firewall): ${formatRoll(defence)} -- net ${net >= 0 ? '+' : ''}${net}`,
+    ];
+    if (net <= 0) {
+        return { text: `The tag slides off ${target.name}'s icon and dissolves. Nothing stuck.`, meta, spent: true };
+    }
+    // Net hits set the DEPTH the report will carry (p.257: one hit a bare
+    // outline, four or more a detailed report).
+    target.cookiedBy.set(ctx.sprite.name, net);
+    const depth = net >= 4 ? 'a detailed report' : net >= 2 ? 'more than an outline' : 'a bare outline';
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} writes a silent file into ${target.name}'s persona, rated ${ctx.level} and running quiet. It is logging -- ${depth} when it ships home.{/light-blue-fg}${hint(` (${target.name} is carrying it and does not know. A Matrix Perception on them finds it.)`)}`,
+        meta,
+        spent: true,
+    };
+}
+/** DIAGNOSTICS (p.257): a Teamwork Test, Hardware + Level [Data Processing].
+ *  Any hits give +1 limit; each hit adds a die. */
+function diagnostics(ctx, targetName) {
+    const room = ctx.master.currentLocation;
+    const device = deviceNamed(room, targetName) ?? ctx.master.inventory.getAllItems()
+        .find(i => i.name.toLowerCase().includes(targetName.toLowerCase()));
+    if (!targetName || !device) {
+        return refuse(`${ctx.sprite.name} needs a device to read. "order ${ctx.sprite.name} diagnostics <device>".`);
+    }
+    const m = spriteMatrix(ctx.spriteKey, ctx.level);
+    const roll = rollPool(spritePool(ctx, 'hardware'), m.dataProcessing);
+    const meta = [`${ctx.sprite.name} -- Diagnostics (Hardware + Level [Data Processing ${m.dataProcessing}]): ${formatRoll(roll)}`];
+    if (roll.hits === 0) {
+        return { text: `${ctx.sprite.name} reads the ${name(device)} down to its seams and finds nothing useful to say.`, meta, spent: true };
+    }
+    // It takes the sprite's whole attention: one target at a time, and the
+    // bonus lasts until the sprite does anything else (dropped by the
+    // caller when the next power is used).
+    ctx.master.spriteAssist = { sprite: ctx.sprite.name, device: name(device), dice: roll.hits, limit: 1 };
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} folds itself around the ${name(device)} and starts narrating -- tolerances, wear, the one screw somebody cross-threaded. +${roll.hits} dice and +1 limit while you work it.{/light-blue-fg}${hint(` (It holds this until you give ${ctx.sprite.name} another order.)`)}`,
+        meta,
+        spent: true,
+    };
+}
+/** ELECTRON STORM (p.257): Cybercombat + Resonance [Attack] v. Intuition +
+ *  Firewall, sustained, (Resonance) DV Matrix damage and 2 noise. */
+function electronStorm(ctx, targetName) {
+    const near = personasNear(ctx);
+    const target = near.find(p => p.name.toLowerCase().includes(targetName.toLowerCase()));
+    if (!target) {
+        return refuse(`${ctx.sprite.name} finds no persona called "${targetName}" out here.${near.length > 0 ? hint(` (Here: ${near.map(p => p.name).join(', ')}.)`) : ''}`);
+    }
+    const m = spriteMatrix(ctx.spriteKey, ctx.level);
+    const attack = rollPool(spritePool(ctx, 'cybercombat') + m.resonance, m.attack);
+    const defence = rollPool(Math.max(1, target.intuition + target.matrixAttribute('firewall')));
+    const net = attack.hits - defence.hits;
+    const meta = [
+        `${ctx.sprite.name} -- Electron Storm (Cybercombat + Resonance [Attack ${m.attack}]): ${formatRoll(attack)}`,
+        `  ${target.name} resists (Intuition + Firewall): ${formatRoll(defence)} -- net ${net >= 0 ? '+' : ''}${net}`,
+    ];
+    if (net <= 0) {
+        return { text: `The datastorm breaks over ${target.name} and washes past. Nothing sticks to them.`, meta, spent: true };
+    }
+    const dv = m.resonance;
+    const soak = rollPool(Math.max(1, target.matrixAttribute('firewall') + target.logic));
+    const dealt = Math.max(0, dv - soak.hits);
+    meta.push(`  ${dv} DV Matrix, soaked (Firewall + Logic): ${formatRoll(soak)} -> ${dealt}`);
+    if (dealt > 0)
+        target.takeMatrixDamage(dealt);
+    // Sustained: it keeps burning until the sprite is hurt or redirected.
+    ctx.sprite.sustainedStorm = target.name;
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} tears open and ${target.name}'s icon is inside it -- corrupting datastreams sheeting off them, ${dealt} Matrix damage and their signal fraying (noise +2). It is holding the storm open.{/light-blue-fg}${hint(` (It burns again every action it sustains this -- and ends the moment ${ctx.sprite.name} takes Matrix damage of its own.)`)}`,
+        meta,
+        spent: true,
+    };
+}
+/** GREMLINS (p.257): Hardware + Level [Attack] v. Device Rating + Firewall.
+ *  Success is a glitch; 4+ net hits is a critical one. */
+function gremlins(ctx, targetName) {
+    const room = ctx.master.currentLocation;
+    const device = deviceNamed(room, targetName);
+    if (!device) {
+        return refuse(`${ctx.sprite.name} finds no device called "${targetName}" to sour.`);
+    }
+    const m = spriteMatrix(ctx.spriteKey, ctx.level);
+    const attack = rollPool(spritePool(ctx, 'hardware'), m.attack);
+    const defence = rollPool(Math.max(1, device.rating * 2));
+    const net = attack.hits - defence.hits;
+    const meta = [
+        `${ctx.sprite.name} -- Gremlins (Hardware + Level [Attack ${m.attack}]): ${formatRoll(attack)}`,
+        `  ${device.name} resists (Device Rating + Firewall): ${formatRoll(defence)} -- net ${net >= 0 ? '+' : ''}${net}`,
+    ];
+    if (net <= 0) {
+        return { text: `The ${device.name} hiccups once and carries on. Whatever ${ctx.sprite.name} whispered into it did not take.`, meta, spent: true };
+    }
+    // WHAT A GLITCH IS, ON A DEVICE -- an engine ruling, labelled. The book
+    // says "the GM chooses an appropriate malfunction" and at 4+ net hits
+    // "the device crashes, burns out, or jolts its user". This engine has
+    // exactly one model of a device that has stopped behaving: its Matrix
+    // condition monitor (Device.takeMatrixDamage, which is what Data Spike
+    // fills). So a glitch is damage scaled by how badly it landed, and a
+    // critical glitch fills the track -- the device is dead, which is the
+    // book's "crashes, burns out" in the vocabulary the engine already
+    // speaks. Inventing a separate "soured" flag would mean a state
+    // nothing else in the engine reads.
+    const critical = net >= 4;
+    const boxes = critical ? device.matrixMonitor : Math.max(1, Math.ceil(net / 2));
+    device.takeMatrixDamage(boxes);
+    meta.push(`  ${critical ? 'CRITICAL glitch' : 'glitch'}: ${boxes} Matrix damage to ${device.name}`);
+    return {
+        text: critical
+            ? `{light-blue-fg}${ctx.sprite.name} gets INTO the ${device.name} and something lets go -- a bang, a smell of hot resin, and the panel goes dark for good.{/light-blue-fg}`
+            : `{light-blue-fg}The ${device.name} starts lying. Readings drift, a control sticks, a signal loops back on itself -- ${ctx.sprite.name} has soured it.{/light-blue-fg}`,
+        meta,
+        spent: true,
+    };
+}
+// ===================== THE STATE POWERS =====================
+/** CAMOUFLAGE (p.256): hides a file inside another file, invisible to
+ *  Matrix searches -- only a Perception specifically hunting it finds it. */
+function camouflage(ctx, targetName) {
+    const room = hostOf(ctx);
+    const file = room && fileNamed(room, targetName);
+    if (!room || !file) {
+        return refuse(`${ctx.sprite.name} has no file called "${targetName}" to hide. It works inside a host, on what the archive holds.`);
+    }
+    file.concealedBy = ctx.sprite.name;
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} folds ${file.name} into the body of another file -- same checksum, same size, nothing out of place. A Matrix Search will walk straight past it now.{/light-blue-fg}${hint(` (Only a Matrix Perception hunting this file finds it -- ${ctx.sprite.name} included.)`)}`,
+        meta: [],
+        spent: true,
+    };
+}
+/** HASH (p.257): seals a file with a Resonance algorithm only this sprite
+ *  can undo, for up to (Level x 10) Combat Turns. */
+function hash(ctx, targetName) {
+    const room = hostOf(ctx);
+    const file = room && fileNamed(room, targetName);
+    if (!room || !file) {
+        return refuse(`${ctx.sprite.name} has no file called "${targetName}" to seal.`);
+    }
+    file.hashedBy = ctx.sprite.name;
+    file.hashTurns = ctx.level * 10;
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} wraps ${file.name} in an algorithm nothing else in the Matrix can read, and carries it. ${ctx.level * 10} Combat Turns.{/light-blue-fg}${hint(` (Nobody else edits or deletes it while the hash holds -- but kill ${ctx.sprite.name} while it carries this and the file is corrupted for good.)`)}`,
+        meta: [],
+        spent: true,
+    };
+}
+/** SUPPRESSION (p.257): a sprite in a host delays launched IC by
+ *  (Level / 2) Combat Turns; delayed IC can neither act nor be targeted. */
+function suppression(ctx) {
+    const room = hostOf(ctx);
+    if (!room?.host) {
+        return refuse(`Suppression baffles a HOST, and ${ctx.sprite.name} is not inside one.`);
+    }
+    const turns = Math.max(1, Math.floor(ctx.level / 2));
+    room.host.icLaunchDelay = turns;
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} spreads itself thin across ${hostLabel(room)}'s launch paths and starts arguing with them. Anything it tries to bring up comes up ${turns} Combat Turn${turns === 1 ? '' : 's'} late -- and comes up unable to act or be touched while it waits.{/light-blue-fg}`,
+        meta: [],
+        spent: true,
+    };
+}
+/** WATERMARK (p.257): an invisible tag only Resonance-driven things read. */
+function watermark(ctx, rest) {
+    const room = hostOf(ctx);
+    // LONGEST FILE NAME FIRST, then the rest is the message. Splitting on
+    // the first space would read "Client Ledger they know" as a file called
+    // "Client" -- and every file in this game has a two-word name.
+    const words = rest.split(/\s+/).filter(w => w.length > 0);
+    let file;
+    let note = '';
+    for (let i = words.length; i >= 1 && !file; i--) {
+        const candidate = room && fileNamed(room, words.slice(0, i).join(' '));
+        if (candidate) {
+            file = candidate;
+            note = words.slice(i).join(' ').trim();
+        }
+    }
+    if (!room || !file) {
+        return refuse(`${ctx.sprite.name} has no icon called "${words[0] ?? ''}" to mark. "order ${ctx.sprite.name} watermark <file> <message>".`);
+    }
+    file.watermark = { by: ctx.sprite.name, note: note || 'no message, just the mark' };
+    return {
+        text: `{light-blue-fg}${ctx.sprite.name} writes into ${file.name} something no eye and no program will ever render${note ? `: "${note}"` : ''}. It overwrites whatever was there before, and it lasts as long as the icon does.{/light-blue-fg}${hint(` (Only Resonance reads it -- a technomancer or another sprite.)`)}`,
+        meta: [],
+        spent: true,
+    };
+}
+// ===================== DISPATCH =====================
+function name(x) { return x.name; }
+function deviceNamed(room, query) {
+    if (!query)
+        return undefined;
+    const q = query.toLowerCase();
+    return room.allDevices().find(d => d.name.toLowerCase() === q)
+        ?? room.allDevices().find(d => d.name.toLowerCase().includes(q));
+}
+function fileNamed(room, query) {
+    if (!query)
+        return undefined;
+    const q = query.toLowerCase();
+    const files = room.inventory.getAllItems().filter(i => i.plane === 'matrix');
+    return files.find(f => f.name.toLowerCase() === q) ?? files.find(f => f.name.toLowerCase().includes(q));
+}
+/**
+ * Run one power. The caller has already established that this actor IS a
+ * sprite and has the power; this resolves it and reports whether a task
+ * was actually spent.
+ */
+export function runSpritePower(key, ctx, rest) {
+    const power = spritePower(key);
+    if (!power)
+        return refuse(`No such sprite power.`);
+    if (!power.runnable) {
+        // Said plainly rather than failing silently -- the catalogue's own
+        // rule (a wrong ability is worse than a missing one).
+        return refuse(`${power.name} (${power.page}) is canon this engine lists but does not yet resolve -- it wants the glitch contract changed in one place first. "sprites" says which powers are moves.`);
+    }
+    if (!powersForSprite(ctx.spriteKey).some(p => p.key === key)) {
+        return refuse(`A ${ctx.spriteKey} sprite has no ${power.name} (p.259). ${ctx.sprite.name} can do: ${powersForSprite(ctx.spriteKey).map(p => p.name).join(', ')}.`);
+    }
+    const target = rest.trim();
+    switch (key) {
+        case 'cookie': return cookie(ctx, target);
+        case 'diagnostics': return diagnostics(ctx, target);
+        case 'electron-storm': return electronStorm(ctx, target);
+        case 'gremlins': return gremlins(ctx, target);
+        case 'camouflage': return camouflage(ctx, target);
+        case 'hash': return hash(ctx, target);
+        case 'suppression': return suppression(ctx);
+        case 'watermark': return watermark(ctx, target);
+        default: return refuse(`${power.name} is not resolved here.`);
+    }
+}
+//# sourceMappingURL=sprite-power-actions.js.map

package/package.json

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