@maka/maka-cli 5.137.0 → 5.139.0

package/bundle/typescript/package.json

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

@@ -0,0 +1,88 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { NUDGES_TO_SKIP } from '../utilities/combat-turn.js';
+/**
+ * NUDGE -- the table's answer to a runner who is holding the Action
+ * Phase and has gone quiet (project owner, 2026-09-07: "three nudges
+ * skips the player being nudged").
+ *
+ * Since the Combat Turn (utilities/combat-turn.ts) a human's phase
+ * waits for "end turn", and since the autopilot went (v5.136.0)
+ * nothing plays a phase for anyone. On a shared run that leaves one
+ * hole: a human who walks away mid-phase stalls the whole table. There
+ * is deliberately no clock -- a timer skips the player who was reading
+ * the rules -- so the escape is the table's: every nudge tells the
+ * nudged runner, in their own log, that people are waiting; the third
+ * nudge on one phase ends it for them, whatever they had left forfeit,
+ * exactly as "end turn" with nothing spent (SR5 p.158-159; the book
+ * gives no refund). The count is the phase's (CombatEncounter.noteNudge)
+ * and starts over the next time they act.
+ *
+ * Off the phase, or out of a fight, a nudge is a tap on the shoulder
+ * only the nudged runner sees. Human-only: an NPC acts by rule on its
+ * own phase and must never be able to skip a human's.
+ */
+export class NudgeCommand extends Command {
+    static verb = 'nudge';
+    static humanOnly = true;
+    static description = 'Prod another runner on a shared run: "nudge <name>". If they are holding the Action Phase, that tells them the table is waiting -- the third nudge on one phase ends it for them, whatever is unspent forfeit, the same as "end turn" with nothing spent. Off the phase, or out of a fight, it is a tap on the shoulder only they see. "initiative" names who is holding the phase.';
+    /** The scene's other humans -- the only legal targets. */
+    others() {
+        return this.scene.getPlayers().filter(p => p !== this.actor);
+    }
+    async execute(args = []) {
+        if (!this.scene.isHumanControlled(this.actor))
+            return '';
+        const me = this.actor;
+        const query = (args ?? []).join(' ').trim();
+        const others = this.others();
+        if (others.length === 0) {
+            return `You're running this one alone -- there's nobody to nudge.${hint(` (Seat a table with "crew hire"; "nudge" is for a shared run.)`)}`;
+        }
+        if (!query) {
+            return `Nudge who? ${others.map(p => p.name).join(', ')}.  Usage: "nudge <runner>".`;
+        }
+        if (query.toLowerCase() === me.name.toLowerCase()) {
+            return `Nudging yourself moves nothing. If it's your phase, act -- or "end turn".`;
+        }
+        const picked = fuzzyPickName(query, others.map(p => p.name));
+        const target = picked ? others.find(p => p.name === picked) : undefined;
+        if (!target) {
+            return `No runner on this job answers to "${query}". Out here with you: ${others.map(p => p.name).join(', ')}. (An NPC acts by rule on its own phase -- nothing to nudge there.)`;
+        }
+        if (this.scene.getKnockout?.(target.name)) {
+            return `${target.name} is out cold -- no nudge reaches them.`;
+        }
+        const enc = this.scene.encounterFor?.(target);
+        const count = enc?.noteNudge(target);
+        if (count === undefined) {
+            // A TAP ON THE SHOULDER, seen by them alone -- the same per-human
+            // scope beginPhase uses for the cyan "your Action Phase" line.
+            this.logger.log(`{yellow-fg}${me.name} nudges you.{/yellow-fg}`, { actor: target.name });
+            this.logger.write(`${me.name} nudged ${target.name} (no phase to count against).`);
+            const holder = enc?.phaseActor;
+            const aside = enc && holder && holder !== target
+                ? ` It isn't ${target.name}'s Action Phase -- ${holder === me ? `it's yours` : `${holder.name} is holding it`}.`
+                : '';
+            return `You nudge ${target.name}.${aside}`;
+        }
+        const room = target.currentLocation;
+        if (count >= NUDGES_TO_SKIP) {
+            // THE SKIP. Logged, not returned: the phases that follow announce
+            // themselves while this command is still running (end-turn.ts has
+            // the same note), and a return value would land under them.
+            this.logger.log(`{yellow-fg}${target.name}'s Action Phase is skipped -- nudged ${NUDGES_TO_SKIP} times; whatever they had left is forfeit.{/yellow-fg}`, { room: room.name });
+            this.logger.write(`${me.name}'s nudge #${count} skips ${target.name}'s Action Phase.`);
+            await enc.endPhase(target);
+            return '';
+        }
+        this.logger.log(`{yellow-fg}${me.name} nudges you -- the table is waiting on your Action Phase (${count}/${NUDGES_TO_SKIP}; ${NUDGES_TO_SKIP} and it is skipped). "end turn" when you're done.{/yellow-fg}`, { actor: target.name });
+        this.logger.log(`${me.name} nudges ${target.name} (${count}/${NUDGES_TO_SKIP}).`, { room: room.name });
+        this.logger.write(`${me.name} nudged ${target.name} (${count}/${NUDGES_TO_SKIP}).`);
+        // The room line above already reached the nudger when they share the
+        // room; from elsewhere they get the summary instead.
+        return me.currentLocation === room ? '' : `You nudge ${target.name} (${count}/${NUDGES_TO_SKIP}).`;
+    }
+}
+//# sourceMappingURL=nudge.js.map

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

@@ -384,5 +384,9 @@
 //   arrival. During a live encounter the ephemeral governor, open-floor
 //   re-seating and doorway yielding are frozen: nobody moves off the
 //   player's keystrokes. bluff/persuade wins clear the hostile flag.
-export const ENGINE_VERSION = '1.42.0';
+// 1.43.0 (2026-09-07): NUDGE. New verb in shared scenes: "nudge <runner>"
+//   tells a human holding the Action Phase that the table is waiting; the
+//   third nudge on one phase ends it for them (forfeit, as "end turn" with
+//   nothing spent). Off the phase it is a private tap on the shoulder.
+export const ENGINE_VERSION = '1.43.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -80,6 +80,7 @@ import { InitiativeCommand } from './commands/initiative.js';
 import { AimCommand } from './commands/aim.js';
 import { DefendCommand } from './commands/defend.js';
 import { DelayCommand } from './commands/delay.js';
+import { NudgeCommand } from './commands/nudge.js';
 import { SpellsCommand } from './commands/spells.js';
 import { InventoryCommand } from './commands/inv.js';
 import { EquipmentCommand } from './commands/equipment.js';
@@ -2341,7 +2342,17 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
     static HOME_DIRECTION_PRIORITY = [
         Direction.DOWN, Direction.UP, Direction.SOUTH, Direction.NORTH, Direction.EAST, Direction.WEST,
     ];
-    constructor(player, sceneSeed) {
+    /**
+     * IN-PROCESS CONDITION REPORTING (2026-09-07): a site-hosted headless
+     * session hands this in so `onConditionChanged` below can skip HubLink
+     * entirely -- see condition-report.ts's `ConditionSink` doc comment for
+     * why this lives on the instance rather than as module state. Absent
+     * for the interactive CLI, which keeps today's HubLink/DDP behavior
+     * unchanged.
+     */
+    _conditionSink;
+    constructor(player, sceneSeed, conditionSink) {
+        this._conditionSink = conditionSink;
         this.player = player;
         this.sceneSeed = sceneSeed;
         this.initialized = false;
@@ -2356,11 +2367,12 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 return;
             // Checked HERE too, before the import -- a dynamic import after a
             // Jest file's teardown is itself the failure, so the gate cannot
-            // live only on the far side of one.
-            if (process.env.MAKA_NO_DDP === '1')
+            // live only on the far side of one. Irrelevant when a conditionSink
+            // is wired (no DDP hop for that path to silence).
+            if (!this._conditionSink && process.env.MAKA_NO_DDP === '1')
                 return;
             void import('./utilities/condition-report.js')
-                .then(m => m.reportConditionSoon(this.player))
+                .then(m => m.reportConditionSoon(this.player, this._conditionSink))
                 .catch(() => undefined);
         };
         // A ROOM CHANGE IS A SAVE BEAT (player request 2026-09-02): where you
@@ -2542,6 +2554,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('aim', AimCommand);
         CommandFactory.registerCommand('defend', DefendCommand);
         CommandFactory.registerCommand('delay', DelayCommand);
+        CommandFactory.registerCommand('nudge', NudgeCommand);
         // 'train' used to alias advance; it belongs to crew instruction now
         // (commands/crew.ts) -- self-training is "advance".
         CommandFactory.registerCommand('advance', AdvanceCommand);
@@ -6029,7 +6042,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
     static HELP_CATEGORIES = [
         { title: 'moving', entries: [['look'], ['go'], ['move', 'walk', 'approach'], ['run'], ['sprint'], ['climb', 'mantle', 'scale', 'clamber'], ['descend'], ['sit', 'kneel'], ['lie', 'prone'], ['stand'], ['follow'], ['unfollow'], ['map', 'exits'], ['search'], ['sneak']] },
         { title: 'gear', entries: [['inv', 'inventory'], ['equipment', 'eq'], ['take'], ['loot'], ['drop'], ['give'], ['store'], ['open'], ['close'], ['put'], ['equip'], ['unequip'], ['fit'], ['unfit'], ['brandish', 'draw'], ['holster'], ['reload'], ['use'], ['read']] },
-        { title: 'combat', entries: [['attack'], ['kill'], ['subdue'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['stance'], ['surrender'], ['edge'], ['rest'], ['heal', 'firstaid', 'bandage', 'patch']] },
+        { title: 'combat', entries: [['attack'], ['kill'], ['subdue'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['nudge'], ['stance'], ['surrender'], ['edge'], ['rest'], ['heal', 'firstaid', 'bandage', 'patch']] },
         // The party layer: everyone who walks (or flies, or manifests) at
         // your side answers to these.
         // "players" folded back under crew after playtesting ("crew

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

@@ -18,6 +18,7 @@ import { currentSession, runInSession } from './utilities/session-context.js';
 import { restorePlayer, serializePlayer } from './utilities/persistence.js';
 import { renderMapViewport, mapCaption } from './utilities/map-view.js';
 import { renderRoomLayoutCompact, crewOfTable, roomCaption } from './utilities/room-view.js';
+import { serializeRoomGrid } from './utilities/room-grid.js';
 import { entrySpotFor, spotOf } from './utilities/spots.js';
 import { equipIntoEmptySlots } from './archetypes.js';
 /**
@@ -191,7 +192,7 @@ export async function createHeadlessSession(opts) {
     const ctx = { sessionId: opts.sessionId, logger };
     return runInSession(ctx, async () => {
         const primary = buildPlayerFromSave(opts.players[0]);
-        const game = new Game(primary, opts.seed);
+        const game = new Game(primary, opts.seed, opts.conditionSink);
         // The run's tier, stated rather than defaulted -- see
         // HeadlessOptions.tier and Game.tier.
         if (typeof opts.tier === 'number')
@@ -325,7 +326,21 @@ export async function createHeadlessSession(opts) {
                     if (roomLines.length > 0) {
                         roomLines.push(mapCaption(roomCaption(here, p)));
                     }
-                    logger.system(roomLines.join('\n'), { actor: p.name }, 'room');
+                    // STRUCTURED ROOM GEOMETRY, ADDITIVE (2026-09-07): the ASCII
+                    // above stays the log-adjacent text every consumer already
+                    // reads; a browser client wanting the site's real SVG DotMap
+                    // instead reads `data.grid` off this SAME event -- no new
+                    // event kind, no publication change (GameEvent.data already
+                    // round-trips end to end). ensureGrid() always synthesizes now
+                    // ("EVERY ROOM IS MATRIXED", room.ts:357-370, the 2026-08-25
+                    // ruling that retired the spotless-room compat gap) -- the
+                    // `undefined` in its return type is a vestige, kept guarded
+                    // here anyway rather than asserted, since a decoration must
+                    // never take down the room push (same reasoning as the
+                    // try/catch this sits inside).
+                    const grid = here.ensureGrid();
+                    const data = grid ? { grid: serializeRoomGrid(grid, here.name) } : undefined;
+                    logger.system(roomLines.join('\n'), { actor: p.name }, 'room', data);
                 }
                 catch (err) {
                     logger.write(`Room overlay render failed for ${p.name} in ${here.name}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);

package/bundle/typescript/src/commands/game/sideQuest/utilities/combat-turn.js

@@ -1,6 +1,71 @@
 import { rollInitiativeScore, formatInitiative, INITIATIVE_PASS_DROP, rollPool, formatRoll } from './dice.js';
 import { ActionBudget } from './action-budget.js';
 import { runNpcActionPhase } from './npc-combat-brain.js';
+/**
+ * THE COMBAT TURN (SR5 p.158-161, RAG-checked 2026-09-06).
+ *
+ * This engine used to resolve a fight as EXCHANGES: one typed "attack"
+ * rolled a two-actor initiative, both sides struck, and a >10 gap bought
+ * one extra strike. That was the closest thing it had to the book's
+ * turn, and combat-exchange.ts said so. What it could never express was
+ * the thing the book is built on -- a sequence of Action Phases in
+ * which every participant spends a budget of actions, in an order the
+ * dice decided, until nobody has Initiative Score left.
+ *
+ * The sequence, as the book gives it:
+ *   1. ROLL INITIATIVE: Initiative attribute + Initiative Dice, summed
+ *      (p.159). Highest acts first; ties break Edge, Reaction,
+ *      Intuition, coin (p.159 "ERIC").
+ *   2-4. INITIATIVE PASS: each participant, highest score first, takes
+ *      an ACTION PHASE -- two Simple Actions or one Complex, plus one
+ *      Free (p.158). When everyone has acted, EVERY score drops by 10
+ *      (p.159), and anyone still above zero goes again.
+ *   5. When nobody is above zero the Combat Turn ends and a new one
+ *      begins at step 1 (p.159).
+ *
+ * Also carried here because the score lives here:
+ *   - INTERRUPT ACTIONS (p.167-168) spend Initiative Score: Full
+ *     Defense -10 for the Combat Turn, Block/Dodge/Parry -5 each for
+ *     one test. Only affordable "if he has enough Initiative Score
+ *     left" -- a score already at or below zero buys nothing (the p.191
+ *     worked example).
+ *   - WOUND MODIFIERS CHANGE THE SCORE AS THEY LAND (p.160 Changing
+ *     Initiative): the difference is applied immediately, and it can
+ *     reorder the pass. It never grants an extra action.
+ *   - ENTERING LATE (p.160): roll as normal, then subtract 10 for every
+ *     pass already gone.
+ *   - DELAYING (p.161): an actor may hold their Action Phase and take
+ *     it later in the same pass. Modelled as "act after everyone else
+ *     this pass, keeping your score"; the pass-end -10 still applies.
+ *   - SURPRISE (p.192): a fight opened on the unaware makes every other
+ *     participant roll Reaction + Intuition (3); failure is -10 and no
+ *     defense against, nor action against, the surprising side until
+ *     their next Action Phase. +3 for anyone already alert.
+ *   - MOVEMENT is a WHOLE-TURN total (p.161-162, Player.movedMetersThisTurn)
+ *     and comes back at step 5, not per pass.
+ *
+ * SCOPE: one encounter per ROOM, on the physical planes (meat and a
+ * jumped-in drone). The Matrix keeps its own initiative structure
+ * (utilities/ic.ts maps IC to Combat Turns per player action) and
+ * astral combat still rides the exchange engine -- both are noted as
+ * gaps rather than folded in half-right.
+ *
+ * WHO DRIVES IT: a human's Action Phase waits for them to type actions
+ * and then "end turn" (commands/end-turn.ts). An NPC's phase is played
+ * by a deterministic brain (utilities/npc-combat-brain.ts) -- the LLM
+ * reflect chain is suspended for participants while the encounter runs,
+ * because a model answering "what next?" in a second or two cannot be
+ * sequenced against a dice-ordered pass, and was the reason NPCs used
+ * to shoot from between the beats of the player's own exchange.
+ */
+/**
+ * Nudges on one Action Phase before the table ends it for the holder
+ * (commands/nudge.ts, owner ruling 2026-09-07). A ruling, not canon --
+ * the book has no idle player -- kept as a count rather than a clock so
+ * that a runner reading the rules is never skipped by a timer, only by
+ * three people saying so.
+ */
+export const NUDGES_TO_SKIP = 3;
 export class CombatEncounter {
     scene;
     logger;
@@ -317,6 +382,7 @@ export class CombatEncounter {
         this.budget = new ActionBudget();
         p.surprised = false;
         p.delayed = false;
+        p.nudges = 0;
         p.actor.clearAim();
         // Recoil resets the moment an Action Phase passes without firing --
         // tracked by the phase, settled by attack.ts (p.175-176).
@@ -342,6 +408,19 @@ export class CombatEncounter {
         const walkLeft = Math.max(0, actor.walkRateMeters - actor.movedMetersThisTurn);
         return `${left} m of movement left this turn (${walkLeft} m at a walk)`;
     }
+    /**
+     * Another human nudged the phase holder (commands/nudge.ts): the
+     * running count for this phase, or undefined when `target` is not
+     * the one holding it. Bookkeeping only -- the verb owns the wording
+     * and calls endPhase() itself at NUDGES_TO_SKIP.
+     */
+    noteNudge(target) {
+        const p = this.participantOf(target);
+        if (!p || this.ended || this.phaseActor !== target)
+            return undefined;
+        p.nudges = (p.nudges ?? 0) + 1;
+        return p.nudges;
+    }
     /** The human typed "end turn" (or lost the phase -- fled, dropped). */
     async endPhase(actor) {
         const p = this.participantOf(actor);

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

@@ -18,7 +18,24 @@ import { hostLabel } from './grid-names.js';
  * storm into a single report of where the monitors LANDED.
  */
 const COALESCE_MS = 250;
-let pending;
+/**
+ * KEYED PER PLAYER, NOT A SINGLE SLOT (fixed 2026-09-07 alongside the
+ * ConditionSink work above). A lone real terminal process only ever
+ * calls this for its own primary, so a single `pending` variable never
+ * showed a problem: every arm captured the SAME player object, and
+ * reading its state at fire time was always correct regardless of which
+ * call armed the timer. That stops being true the moment more than one
+ * `Game` can be reporting condition in the same process -- exactly what
+ * ConditionSink exists for. With one shared slot, a second session's
+ * mutation arriving while the first session's beat is still gathering
+ * hit `if (pending) return` and vanished silently: not delayed, not
+ * coalesced into the wrong report -- simply never sent, for that
+ * session, for that beat. Keying the map on the Player instance gives
+ * each session (each primary Player is a distinct object) its own
+ * independent 250ms coalescing window, with no change to the
+ * single-session behavior this always had.
+ */
+const pendingByPlayer = new WeakMap();
 /** The method name is the server's -- co-owned; do not rename alone. */
 export const REPORT_METHOD = 'characterSheet.reportCondition';
 /**
@@ -215,21 +232,21 @@ function noteRefusal(why) {
         catch { /* no session */ }
     }
 }
-export function reportConditionSoon(player) {
+export function reportConditionSoon(player, sink) {
     // Before the TIMER, not just before the call: a scheduled beat firing
     // after a Jest file finished lazy-imported into a torn-down
     // environment and failed CI with every test green (2026-09-01). Under
     // MAKA_NO_DDP nothing is armed at all -- the same switch the whole
-    // live layer honors.
-    if (process.env.MAKA_NO_DDP === '1')
+    // live layer honors. Irrelevant to a caller-supplied sink: there is no
+    // DDP hop to silence when reporting stays in-process.
+    if (!sink && process.env.MAKA_NO_DDP === '1')
         return;
-    if (pending)
-        return; // a beat is already gathering
-    pending = setTimeout(() => {
-        pending = undefined;
+    if (pendingByPlayer.has(player))
+        return; // a beat is already gathering for THIS player
+    const timer = setTimeout(() => {
+        pendingByPlayer.delete(player);
         void (async () => {
-            const [{ HubLink }, { saveSlug }, { arSightUp }] = await Promise.all([
-                import('./shared-run.js'),
+            const [{ saveSlug }, { arSightUp }] = await Promise.all([
                 import('./persistence.js'),
                 import('./ar.js'),
             ]);
@@ -244,6 +261,14 @@ export function reportConditionSoon(player) {
             // beat fires next. All read at FIRE time, like position.
             const report = buildConditionReport(player, { saveSlug, arSightUp });
             noteRoster(report);
+            if (sink) {
+                // IN-PROCESS: no HubLink, no MAKA_NO_DDP gate, no version-skew
+                // retry -- the engine module and its caller are always the same
+                // deployed version here (see ConditionSink's doc comment).
+                await sink(report);
+                return;
+            }
+            const { HubLink } = await import('./shared-run.js');
             try {
                 await HubLink.call(REPORT_METHOD, report);
             }
@@ -270,10 +295,11 @@ export function reportConditionSoon(player) {
             noteRefusal(err instanceof Error ? err.message : String(err));
         });
     }, COALESCE_MS);
-    pending.unref?.();
+    pendingByPlayer.set(player, timer);
+    timer.unref?.();
 }
-/** Test seam: is a beat currently gathering? */
-export function conditionReportPending() {
-    return pending !== undefined;
+/** Test seam: is a beat currently gathering for this player? */
+export function conditionReportPending(player) {
+    return pendingByPlayer.has(player);
 }
 //# sourceMappingURL=condition-report.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/room-grid.js

@@ -800,6 +800,37 @@ export function synthesizeGrid(input) {
 // the module doc); Room.ensureGrid queries this cell by that same
 // string. A rename on either side must update both.
 export const OPEN_FLOOR_NAME = 'open floor';
+/** Flattens a live IRoomGrid's Maps into ISerializedRoomGrid. Spots ship
+ *  UNFILTERED (the caller resolves actor positions against the full
+ *  list, open floor included -- see room-view.ts's seatingIn); only the
+ *  DRAWN footprints skip the open-floor anchor, matching the site's own
+ *  filter. */
+export function serializeRoomGrid(grid, roomName) {
+    const spots = [...grid.spotCells.entries()].map(([name, c]) => ({
+        name, x: c.x, y: c.y, z: c.z,
+    }));
+    const doors = [...grid.exitCells.entries()].map(([dir, c]) => ({
+        dir: String(dir), x: c.x, y: c.y, z: c.z,
+    }));
+    const footprints = [...grid.spotFootprints.entries()]
+        .filter(([name]) => name !== OPEN_FLOOR_NAME)
+        .map(([name, cells]) => ({
+        name,
+        cells: cells.map(c => ({ x: c.x, y: c.y, z: c.z })),
+    }));
+    const vertical = [...grid.vertical.entries()].map(([cellKey, link]) => {
+        const [x, y, z] = cellKey.split(',').map(Number);
+        return { kind: link.kind, x, y, z };
+    });
+    return {
+        name: roomName,
+        dims: { x: grid.dims.x, y: grid.dims.y, z: grid.dims.z },
+        spots,
+        doors,
+        footprints,
+        vertical,
+    };
+}
 function clamp(n, lo, hi) { return Math.max(lo, Math.min(hi, n)); }
 function jitter(rng) { return Math.floor(rng() * 3) - 1; }
 function chebyshev(a, b) { return Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y)); }

package/package.json

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