@maka/maka-cli 5.215.0 → 5.217.0

package/bundle/typescript/package.json

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

@@ -1,5 +1,6 @@
 import { Command } from './command.js';
 import { nameablesFor, whereAmI } from '../utilities/nameables.js';
+import { playerVerbs, verbShelf, helpCategories } from '../utilities/verb-index.js';
 import { normalizeLoose } from '../utilities/fuzzy-match.js';
 /**
  * TAB COMPLETION, ANSWERED BY THE ENGINE (f79LLqTerep4nKWcA: "How do I
@@ -71,6 +72,40 @@ export class CompleteCommand extends Command {
         // long one out loud.
         return all.filter(n => normalizeLoose(n.name).includes(want));
     }
+    /**
+     * THE FIRST WORD IS A VERB, NOT A NAME (yaw2btNX8aNEEF9D3, Maka: "If
+     * someone presses 'tab' with nothing in the input box, the first list
+     * to reference is the 'command' list").
+     *
+     * Tab used to answer with NAMEABLES whatever was in the box, so an
+     * empty box dumped every icon and body in reach into the Mechanics
+     * panel -- the reporter's first sentence -- and a half-typed verb
+     * matched names by accident or nothing at all. But a command line has
+     * two halves and they have different vocabularies: before the first
+     * space you are choosing a VERB, after it you are naming a TARGET.
+     *
+     * The test is the space, not the emptiness: "ha" and "" are both the
+     * verb slot, "hack " and "hack ca" are both the target slot. That is
+     * also why `head` is what it is -- with no space there is no head, so
+     * a completed verb replaces the whole box.
+     */
+    verbSlot(raw) {
+        return !raw.includes(' ');
+    }
+    /** The verb list, shaped like nameables so one renderer prints both. */
+    verbs() {
+        return playerVerbs().map(v => {
+            const shelf = verbShelf(v);
+            const primary = shelf?.primary;
+            return {
+                glyph: '›',
+                name: v,
+                what: shelf
+                    ? `${shelf.category}${primary && primary !== v ? ` -- same as "${primary}"` : ''}`
+                    : 'a command',
+            };
+        });
+    }
     async execute(args = []) {
         const actor = this.actor;
         // The client sends the box VERBATIM, so the words rebuild it exactly;
@@ -80,7 +115,20 @@ export class CompleteCommand extends Command {
         // A VERB ALONE IS NOT A NAME. With nothing typed after the verb the
         // player wants the roster, which is the `fragment === ''` case below
         // and handled by matches() returning everything.
-        const all = nameablesFor(this.scene, actor, this.rooms);
+        const onVerb = this.verbSlot(raw);
+        // AN EMPTY BOX IS NOT A QUERY, it is "what can I even do?", and the
+        // answer is not 180 verbs truncated at 12 -- that is the dump the
+        // report is about, wearing different clothes. The SHELVES are the
+        // command list at the altitude a person can read: a dozen lines,
+        // each one a place to look, and `help <shelf>` opens it.
+        if (onVerb && fragment.length === 0) {
+            const shelves = helpCategories();
+            return [
+                `Type a verb, or a letter or two and Tab again. The shelves:`,
+                ...shelves.map(c => `  › ${c.title} -- ${c.entries.length} commands ("help ${c.title}")`),
+            ].join('\n');
+        }
+        const all = onVerb ? this.verbs() : nameablesFor(this.scene, actor, this.rooms);
         if (all.length === 0) {
             return `Nothing to name from ${whereAmI(actor)}.`;
         }
@@ -90,6 +138,17 @@ export class CompleteCommand extends Command {
             return `${COMPLETE_MARKER}${head}${only.name}`;
         }
         if (hits.length === 0) {
+            // The two slots miss for different reasons and the line has to say
+            // which: a verb that does not exist is a different problem from a
+            // name that is not HERE, and telling somebody "nothing at the
+            // Night Market answers to 'inevntory'" sends them looking round
+            // the room for their own pack.
+            if (onVerb) {
+                return [
+                    `No command starts with "${fragment}". Try a shelf:`,
+                    ...helpCategories().map(c => `  › ${c.title} ("help ${c.title}")`),
+                ].join('\n');
+            }
             return [
                 `Nothing at ${whereAmI(actor)} answers to "${fragment}". You could name:`,
                 ...all.slice(0, 12).map(n => `  ${n.glyph} ${n.name} -- ${n.what}`),

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

@@ -1103,5 +1103,65 @@
 //   accident. The distinction is the rule itself: a character may SAY
 //   what they know; they may not have it NARRATED at a player who cannot
 //   hear it.
-export const ENGINE_VERSION = '1.74.1';
+// 1.75.0 (2026-09-16): TAB COMPLETES A VERB BEFORE THE SPACE AND A
+//   TARGET AFTER IT (yaw2btNX8aNEEF9D3, Maka: "the 'tab' key shouldn't
+//   SHOW all the things in the room in the Mechanics panel ... If
+//   someone presses 'tab' with nothing in the input box, the first list
+//   to reference is the 'command' list. Then, tab can cycle through
+//   entities. Be careful though, if I can't percieve the thing, it
+//   shouldn't be on the tab list."). Four asks, four changes.
+//   - THE SPACE IS THE BOUNDARY. `complete` answered with NAMEABLES
+//     whatever was in the box, so an empty box dumped every icon and
+//     body in reach into the panel and a half-typed verb matched entity
+//     names by accident. A command line has two halves with two
+//     vocabularies; before the first space you are choosing a verb.
+//   - AN EMPTY BOX GETS THE SHELVES, not 180 verbs truncated at 12 --
+//     that is the same dump wearing different clothes. A dozen lines,
+//     each a place to look, each with its "help <shelf>".
+//   - THE VERB TABLE MOVED OUT OF game.ts to utilities/verb-index.ts, so
+//     Tab and the help screen read ONE list. A second hand-maintained
+//     copy of ~180 verbs is a copy that drifts. Aliases complete too:
+//     somebody typing "inventor" is reaching for `inventory`, and it is
+//     an alias of `inv`. Role-aware, so Tab never offers a play-tester
+//     verb to an account the server will 403.
+//   - TAB WAS A FREE SEARCH. nameablesFor read the room's WHOLE
+//     inventory, so it offered loot nobody had found -- while `look` and
+//     `take` filter the same set and would then refuse to show or hand
+//     over the very name Tab had just typed for you. It now uses take.ts's
+//     gate exactly: cased the room, or the thing arrived in the open in
+//     front of you. Off-plane items go too, for take.ts's reason.
+//   - AND TAB AGAIN WALKS THE LIST (utilities/tab-cycle.ts, CLI only for
+//     now -- cycling is a property of an input box and only the CLI has
+//     one). Pure model, so a test can press Tab four times without a
+//     terminal. Continuation is an EXACT match on what the last press
+//     wrote: one typed letter ends the walk and asks the engine again,
+//     because that is what narrowing means. One candidate is not a
+//     cycle -- a key that rewrites the box to what it already holds
+//     looks broken.
+// 1.76.0 (2026-09-16): THE WAN IS DRAWN AS A TREE (RXBaewsjGDZqqW8ba,
+//   Maka: "the heiarchy is confusing when using 'look' in the matrix.
+//   What 'host' does camera cluster attach to? it says 'live, feeding
+//   the site's host'. If we're allowed to know which host it's attached
+//   to, then let's make this a 'tree' view"). The list was flat: a host
+//   in one section, the devices hanging off it in another, nothing
+//   joining them, and the only clue a phrase that named no host. The
+//   structure was in the model all along and only the rendering hid it.
+//   - HOSTS OVERHEAD now indents a host's slaves beneath it with box
+//     drawing, and ICONS IN REACH holds only what answers to nobody.
+//   - The camera line NAMES its master, from the same cameraMasterHost
+//     tap.ts uses to decide what is on the other end of the cable.
+//   - WHAT COUNTS AS A SLAVE is p.233's rule, not "everything nearby":
+//     "the slaves must be devices and the master must be a host". So the
+//     room's devices and its camera cluster branch off the host; a
+//     person's commlink is THEIR PAN and a persona is nobody's slave,
+//     and both stay at top level.
+//   - "IF WE'RE ALLOWED TO KNOW" IS THE REPORTER'S OWN CONDITIONAL, and
+//     it was RAG-checked rather than assumed. Matrix Perception does NOT
+//     list a device's master among what a hit buys you (p.235), so this
+//     must not become a way to learn one -- and it is not. The engine
+//     already disclosed that these icons answered to "the site's host",
+//     and a room with a node has exactly one; the tree says the same
+//     thing in a shape that can be read. A watched room with NO node
+//     still names no master, pinned as a test.
+export const ENGINE_VERSION = '1.76.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -60,7 +60,8 @@ import { NoteCommand } from './commands/note.js';
 import { BacklogCommand } from './commands/backlog.js';
 // Whether this account may actually USE the backlog -- gates what the
 // help index offers, never what the verb accepts (item D).
-import { isPlaytester, probePlaytesterStanding } from './utilities/playtester.js';
+import { probePlaytesterStanding } from './utilities/playtester.js';
+import { HELP_CATEGORIES, HIDDEN_VERBS, PLAYTESTER_VERBS, helpCategories } from './utilities/verb-index.js';
 import { RolesCommand } from './commands/roles.js';
 import { ReviewCommand } from './commands/review.js';
 import { SinCommand } from './commands/sin.js';
@@ -6747,46 +6748,13 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      * the renderer is ENTITLED to make -- the table was what lied.
      * help-taxonomy.test.ts now holds that line for the whole table.
      */
-    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', 'stun', 'knock'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['nudge'], ['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
-        // players" / "crew street"); the bare verb still answers quietly.
-        { title: 'party', entries: [['crew', 'party'], ['hire'], ['dismiss'], ['train'], ['order'], ['lead'], ['command'], ['deploy'], ['recall'], ['stow']] },
-        { title: 'magic', entries: [['spells'], ['cast'], ['summon', 'conjure'], ['project', 'astral'], ['return'], ['assense'], ['counterspell']] },
-        { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['force', 'brute', 'smash'], ['mark', 'marks'], ['unmark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
-        // The Emerged get their own shelf (player request: "there MUST be
-        // resonance" -- matrix is the place, Resonance is the talent).
-        // `sustain` shelves here and not under magic: the command is
-        // technomancer-gated (a sprite task, SR5 p.256) and refuses anyone
-        // else, so the Emerged shelf is where its audience looks.
-        { title: 'resonance', entries: [['compile'], ['decompile'], ['thread'], ['unravel'], ['register'], ['standby'], ['sustain'], ['sprites']] },
-        { title: 'social', entries: [['say'], ['shout'], ['emote', 'me'], ['tell', 'talk-to'], ['call'], ['message'], ['end-call', 'end', 'hangup'], ['accept'], ['decline', 'deny', 'refuse'], ['haggle', 'negotiate'], ['persuade', 'convince'], ['ask'], ['contacts']] },
-        { title: 'street', entries: [['abandon'], ['browse', 'buy'], ['sell'], ['catalog'], ['source', 'procure'], ['work', 'gig'], ['jobs'], ['journal'], ['perform'], ['palm'], ['docwagon'], ['treat'], ['eat'], ['drink'], ['lifestyle'], ['garage'], ['pay']] },
-        { title: 'barriers', entries: [['pick'], ['breach'], ['dispel', 'dispell'], ['bluff'], ['unlock'], ['lock']] },
-        { title: 'character', entries: [['sheet', 'stats'], ['advance'], ['qualities', 'quality'], ['sin', 'sins', 'papers'], ['initiate', 'submerge'], ['install', 'chrome']] },
-        { title: 'session', entries: [['help'], ['hints'], ['time', 'clock'], ['note'], ['backlog'], ['review'], ['roles'], ['clear'], ['quit', 'exit']] },
-    ];
-    /** Registered but deliberately UNLISTED: reachable as subcommands or
-     *  muscle-memory ("players" folded back under crew after playtesting
-     *  -- "crew players" is the advertised path; the bare verb still
-     *  answers). Without this, the uncategorized sweep resurrects them
-     *  in an "other" bucket. */
-    // 'first' and 'apply' exist ONLY to catch the two-word phrasings
-    // ("first aid", "apply first aid") that used to die at the parser. As
-    // bare words they mean nothing, so they are claimed but not advertised
-    // -- `heal` is the verb the help screen teaches.
-    // `complete` is what Tab sends (commands/complete.ts) -- a question the
-    // input box asks, not a verb anyone types, so it stays out of help.
-    static HIDDEN_VERBS = ['players', 'first', 'apply', 'complete'];
-    /** Session verbs that only a play-tester (or admin) can actually use
-     *  -- the server role-gates both and 403s everyone else. Listed in
-     *  help ONLY for a confirmed play-tester; see helpCategories. `roles`
-     *  rides along because it is admin-only, a strictly narrower group. */
-    static PLAYTESTER_VERBS = new Set(['backlog', 'review', 'roles']);
+    // THE VERB TABLES MOVED TO utilities/verb-index.ts. Tab needs the
+    // same list the help screen prints (yaw2btNX8aNEEF9D3), and two
+    // hand-maintained copies of ~180 verbs is a copy that drifts. These
+    // aliases keep every call site below reading as it did.
+    static HELP_CATEGORIES = HELP_CATEGORIES;
+    static HIDDEN_VERBS = HIDDEN_VERBS;
+    static PLAYTESTER_VERBS = PLAYTESTER_VERBS;
     /** Descriptions for the verbs handled inline in handleInput() rather than registered. */
     static BUILTIN_DESCRIPTIONS = {
         help: 'This overview. "help <category>" for one group with full descriptions; "help <command>" for one command.',
@@ -6810,12 +6778,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      * and why the verb itself stays registered and usable regardless.
      */
     helpCategories() {
-        if (isPlaytester())
-            return Game.HELP_CATEGORIES;
-        return Game.HELP_CATEGORIES.map(c => c.title !== 'session' ? c : {
-            ...c,
-            entries: c.entries.filter(e => !Game.PLAYTESTER_VERBS.has(e[0])),
-        });
+        return helpCategories();
     }
     getHelpMessage(args = []) {
         const registered = Object.keys(CommandFactory.getAllRegisteredCommands());

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

@@ -8,6 +8,7 @@ import { getArchetype, outfitArchetype } from './archetypes.js';
 import { attachLineEditor, attachArrowMovement } from './utilities/line-editor.js';
 import { attachInputHistory } from './utilities/input-history.js';
 import { COMPLETE_MARKER } from './commands/complete.js';
+import { startCycle, advance, continues } from './utilities/tab-cycle.js';
 import { TERMINAL_RESET_SEQUENCE } from './utilities/terminal-reset.js';
 import { readSave } from './utilities/persistence.js';
 import { requireCatalog, CatalogUnavailableError } from './utilities/catalog.js';
@@ -328,6 +329,10 @@ export async function main(playerName, sceneSeed, options) {
         // asked for in its place is a way to know which icon you are about
         // to hit. Bound on the input box because that's where focus lives
         // during play.
+        // The walk the previous Tab set up, if any. Lives out here so it
+        // survives between presses and nowhere else, which is the whole of
+        // its scope: no cycle outlives the input box it belongs to.
+        let tabCycle;
         game.inputBox.key(['tab'], () => {
             // Blessed's textarea reader appends the literal '\t' to the box
             // value on this same keypress (listener order isn't guaranteed
@@ -355,9 +360,26 @@ export async function main(playerName, sceneSeed, options) {
             // So: send the box, let the engine answer, on both run shapes.
             void (async () => {
                 const box = game.inputBox.getValue().replace(/\t/g, '');
+                // TAB AGAIN TAKES THE NEXT ONE (yaw2btNX8aNEEF9D3, Maka: "Then,
+                // tab can cycle through entities"). No round trip and no second
+                // copy of the list in the panel: the names from the previous
+                // press are still good, and walking them is a property of this
+                // input box rather than a question for the engine. The model is
+                // in utilities/tab-cycle.ts, pure, so a test can press Tab four
+                // times without a terminal. `continues` is an exact match on
+                // what the last press wrote, so one typed letter ends the walk
+                // and asks the engine again -- which is what narrowing means.
+                if (continues(tabCycle, box)) {
+                    const { box: filled, next } = advance(tabCycle);
+                    tabCycle = next;
+                    game.inputBox.setValue(filled);
+                    screen.render();
+                    return;
+                }
                 const res = await game.handleInput(`complete ${box}`);
                 if (!res)
                     return;
+                tabCycle = startCycle(box, res);
                 const lines = res.split('\n');
                 // THE MARKER LINE refills the box (see commands/complete.ts).
                 // Everything else is the candidate list, and goes to the ticker
@@ -365,12 +387,19 @@ export async function main(playerName, sceneSeed, options) {
                 if (lines[0]?.startsWith(COMPLETE_MARKER)) {
                     const filled = lines[0].slice(COMPLETE_MARKER.length);
                     game.inputBox.setValue(filled);
+                    // The engine may have grown the box to the common head; the
+                    // cycle has to compare against what is ACTUALLY there or the
+                    // next press would look like a player keystroke.
+                    if (tabCycle)
+                        tabCycle = { ...tabCycle, box: filled };
                     lines.shift();
                 }
                 for (const l of lines) {
                     if (l.trim().length > 0)
                         gameLog.meta(l, 'white');
                 }
+                if (tabCycle)
+                    gameLog.meta(`  (Tab again walks these.)`, 'white');
                 screen.render();
             })();
         });

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

@@ -4,7 +4,7 @@ import { hostsInReach, hostLine, roomsInReach, gridVicinity } from './grid-reach
 import { NPC } from '../models/npc.js';
 import { hostLabel, hostPurposeFor } from './grid-names.js';
 import { isLinked } from './comm-style.js';
-import { isWatched, camerasLive, canSnoopFeeds } from './surveillance.js';
+import { isWatched, camerasLive, canSnoopFeeds, cameraMasterHost } from './surveillance.js';
 /**
  * The grid's icon inventory for one room -- everything a persona can
  * ACT on, each with its verb (player rulings 2026-08-23/24: "it's hard
@@ -277,7 +277,16 @@ export function gridIcons(scene, actor, room) {
             // catch is that a persona cannot hold a cable -- so this reads as
             // something your BODY could do, which is the price the rule
             // charges. See commands/tap.ts.
-            icons.push(`◎ Camera cluster -- live, feeding the site's host. Loud acts here travel. (own the host to loop them -- or walk in and "tap" a lens in the flesh: slaved to the host means a key to the host)`);
+            // NAME THE MASTER (RXBaewsjGDZqqW8ba, Maka: "What 'host' does
+            // camera cluster attach to? it says 'live, feeding the site's
+            // host'"). Nothing new is disclosed -- the line already said these
+            // lenses answer to a host, and cameraMasterHost is the same
+            // function tap.ts uses to decide what is on the other end of the
+            // cable. It simply refused to say WHICH, in a district that has
+            // exactly one, so the reader was left to guess at a fact the
+            // engine had already handed them.
+            const owner = cameraMasterHost(scene.getRooms(), room);
+            icons.push(`◎ Camera cluster -- live, feeding ${owner ? hostLabel(owner) : `the site's host`}. Loud acts here travel. (own the host to loop them -- or walk in and "tap" a lens in the flesh: slaved to the host means a key to the host)`);
         }
     }
     // THE DIVIDER (eJANPpm7qCaCAJBJw). Only when there is a host to be
@@ -562,9 +571,6 @@ export function gridIconBlock(scene, actor, room, rooms) {
     }
     const out = [];
     const hosts = hostsInReach(rooms, actor);
-    out.push(hosts.length > 0
-        ? `{light-blue-fg}HOSTS OVERHEAD:{/light-blue-fg}\n${hosts.map(h => `  {light-blue-fg}${hostLine(h, actor)}{/light-blue-fg}`).join('\n')}`
-        : `{light-blue-fg}Nothing overhead -- no host stands over this district.{/light-blue-fg}`);
     // THE DIVIDER DIVIDES NOTHING HERE. gridIcons puts the host's own icon
     // first and splices a "-- and NEAR it ... --" heading after it; this
     // block then pulls the host line OUT (it has its own HOSTS OVERHEAD
@@ -577,9 +583,51 @@ export function gridIconBlock(scene, actor, room, rooms) {
     const near = gridIcons(scene, actor, gridVicinity(actor))
         .filter(i => !isHostLine(i))
         .filter((i, idx) => !(idx === 0 && isNearDivider(i)));
-    out.push(near.length > 0
-        ? `{light-blue-fg}ICONS IN REACH:{/light-blue-fg}\n${near.map(i => `  {light-blue-fg}${i}{/light-blue-fg}`).join('\n')}`
-        : `{light-blue-fg}Nothing near -- background noise around your signal.{/light-blue-fg}`);
+    // THE WAN IS DRAWN AS A TREE (RXBaewsjGDZqqW8ba, Maka: "the heiarchy
+    // is confusing when using 'look' in the matrix. What 'host' does
+    // camera cluster attach to? ... let's make this a 'tree' view").
+    //
+    // The list was flat, so a host and the devices hanging off it sat in
+    // two separate sections with nothing joining them, and the only clue
+    // was the phrase "the site's host" -- which names no host. The
+    // structure was in the model the whole time and only the rendering
+    // hid it.
+    //
+    // WHAT IS ACTUALLY SLAVED, and the line is not "everything nearby":
+    // a WAN's slaves are DEVICES (p.233 -- "the slaves must be devices and
+    // the master must be a host"), which here means the room's own
+    // devices and its camera cluster. A person's commlink is their PAN,
+    // not the host's, and a persona is nobody's slave; those stay at top
+    // level where they belong.
+    //
+    // AND NOTHING NEW IS DISCLOSED. Checked against the books rather than
+    // assumed: Matrix Perception does NOT list a device's master among
+    // what a hit buys you (p.235), so this must not become a way to learn
+    // one. It doesn't -- the engine already told you these icons answered
+    // to "the site's host", and a room with a node has exactly one. The
+    // tree says the same thing in a shape that can be read; it does not
+    // reach for a relationship the player did not already have.
+    const hereRoom = gridVicinity(actor);
+    const master = hosts.find(h => h === hereRoom);
+    const isSlave = (i) => i.startsWith('▤') || i.startsWith('◎');
+    const slaved = master ? near.filter(isSlave) : [];
+    const loose = master ? near.filter(i => !isSlave(i)) : near;
+    out.push(hosts.length > 0
+        ? `{light-blue-fg}HOSTS OVERHEAD:{/light-blue-fg}\n${hosts.map(h => {
+            const line = `  {light-blue-fg}${hostLine(h, actor)}{/light-blue-fg}`;
+            if (h !== master || slaved.length === 0)
+                return line;
+            // Box-drawing, so the last child closes the branch and the eye can
+            // see where the WAN ends.
+            const kids = slaved.map((i, idx) => `  {light-blue-fg}${idx === slaved.length - 1 ? '└─' : '├─'} ${i}{/light-blue-fg}`);
+            return [line, ...kids].join('\n');
+        }).join('\n')}`
+        : `{light-blue-fg}Nothing overhead -- no host stands over this district.{/light-blue-fg}`);
+    out.push(loose.length > 0
+        ? `{light-blue-fg}ICONS IN REACH${slaved.length > 0 ? ' -- answering to nobody up there' : ''}:{/light-blue-fg}\n${loose.map(i => `  {light-blue-fg}${i}{/light-blue-fg}`).join('\n')}`
+        : slaved.length > 0
+            ? `{light-blue-fg}Nothing else near -- everything around you hangs off the host.{/light-blue-fg}`
+            : `{light-blue-fg}Nothing near -- background noise around your signal.{/light-blue-fg}`);
     // FARTHER OUT, WITHOUT AN ADDRESS (SR5 p.235, p.243): Matrix Perception
     // never tells you where a device physically sits -- that is Trace Icon,
     // two marks and an opposed test. So far icons are listed by the noise

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

@@ -65,7 +65,26 @@ function meatNameables(actor) {
     for (const device of room.openableDevices()) {
         push(out, seen, { glyph: '▤', name: device.name, what: 'a device' });
     }
+    // WHAT YOU HAVE ACTUALLY SEEN (yaw2btNX8aNEEF9D3, Maka: "if I can't
+    // percieve the thing, it shouldn't be on the tab list").
+    //
+    // This read the room's whole inventory, so Tab offered loot nobody had
+    // found yet -- and `look` (look.ts) and `take` (take.ts) both filter
+    // the same set and would have refused to show or hand over the very
+    // name Tab had just typed for you. Tab was a free `search`.
+    //
+    // The gate is take.ts's, verbatim in meaning: having cased the room
+    // reveals everything in it, and until then you know only what arrived
+    // in the open in front of you (Room.plainSightItems -- a dead NPC's
+    // scattered kit, a witnessed drop). Off-plane items are dropped for
+    // the same reason take.ts drops them: a matrix file on the floor is
+    // not a thing a body can pick up.
+    const cased = room.searchedBy.has(actor.name);
     for (const item of room.getItemsForActor(actor)) {
+        if (item.plane !== actor.plane)
+            continue;
+        if (!cased && !room.plainSightItems.has(item.name.toLowerCase()))
+            continue;
         push(out, seen, { glyph: '◇', name: item.name, what: 'on the ground' });
     }
     // WHAT YOU ARE CARRYING is nameable too -- "equip", "drop", "reload

package/bundle/typescript/src/commands/game/sideQuest/utilities/tab-cycle.js

@@ -0,0 +1,100 @@
+/**
+ * TAB AGAIN TAKES THE NEXT ONE (yaw2btNX8aNEEF9D3, Maka: "Then, tab can
+ * cycle through entities").
+ *
+ * The engine answers a Tab with the candidates and, when they share a
+ * head, fills the box as far as they agree (commands/complete.ts). That
+ * is the shell behaviour everyone has in their fingers for the FIRST
+ * press. The second press is where a shell offers the list and a good
+ * one walks it, and the report asks for the walk.
+ *
+ * WHY A PURE MODEL AND NOT A FEW LINES IN ui.ts. The whole feature is
+ * "what counts as the same Tab?" -- and that is a state question with
+ * exactly the shape that rots in an event handler: a player who types a
+ * letter, or recalls a command from history, or clears the box, must
+ * start a NEW cycle, and a player who just presses Tab again must not.
+ * Wiring belongs in ui.ts; the decision belongs here, where a test can
+ * press Tab four times in a row without a terminal.
+ *
+ * DELIBERATELY CLIENT-SIDE, AND CLI-ONLY FOR NOW. The engine stays
+ * stateless -- it answers the same question the same way however many
+ * times it is asked, which is what lets three clients share it. Cycling
+ * is a property of an input box, and only the CLI has one of these.
+ */
+/** A name the engine offered, as printed in a candidate line. */
+const CANDIDATE_LINE = /^\s{2}\S+\s+(.+?)\s+--\s/;
+/**
+ * The names out of a `complete` reply.
+ *
+ * Reads the LIST lines, not the marker line: the marker is what the box
+ * already holds. A reply with no list (one match, or a refusal) yields
+ * nothing and ends any cycle, which is correct -- there is nothing to
+ * walk.
+ */
+export function candidatesIn(reply) {
+    const out = [];
+    for (const line of reply.split('\n')) {
+        const m = CANDIDATE_LINE.exec(line);
+        if (m?.[1])
+            out.push(m[1]);
+    }
+    return out;
+}
+/**
+ * Split a box into the command so far and the fragment being typed --
+ * the SAME rule commands/complete.ts uses, deliberately duplicated
+ * rather than imported so the two can be compared by eye. A trailing
+ * space means an empty fragment.
+ */
+export function splitBox(raw) {
+    if (raw.length === 0 || raw.endsWith(' '))
+        return { head: raw, fragment: '' };
+    const cut = raw.lastIndexOf(' ');
+    return cut < 0 ? { head: '', fragment: raw } : { head: raw.slice(0, cut + 1), fragment: raw.slice(cut + 1) };
+}
+/**
+ * Begin a cycle from a reply, or return undefined when there is nothing
+ * to walk.
+ *
+ * ONE CANDIDATE IS NOT A CYCLE: the engine already filled the box with
+ * it, and a "cycle" of length one that rewrites the box on every press
+ * is just a key that appears to do nothing.
+ */
+export function startCycle(boxWhenPressed, reply) {
+    const names = candidatesIn(reply);
+    if (names.length < 2)
+        return undefined;
+    const { head } = splitBox(boxWhenPressed);
+    // `box` SEEDS TO THE BOX AS PRESSED, not to ''. The engine grows the
+    // box to the candidates' common head only when there IS one -- "hack
+    // s" with two s-names, but not "hack " with three unrelated ones. When
+    // it does not, nothing rewrites the box, so a cycle remembering ''
+    // would fail its own sameness test on the very next press and go back
+    // to the engine instead of walking. The caller overwrites this when a
+    // marker line did change the box.
+    return { head, names, index: -1, box: boxWhenPressed };
+}
+/**
+ * The next box contents, and the cycle to remember.
+ *
+ * Wraps at the end on purpose -- a walk you cannot get back to the start
+ * of is a walk you have to abandon by retyping.
+ */
+export function advance(cycle) {
+    const index = (cycle.index + 1) % cycle.names.length;
+    const box = `${cycle.head}${cycle.names[index]}`;
+    return { box, next: { ...cycle, index, box } };
+}
+/**
+ * Is this press a continuation of `cycle`?
+ *
+ * The box must be EXACTLY what the last press wrote. Not "starts with",
+ * not case-insensitive: a player who typed one more letter is narrowing
+ * their search and wants a fresh answer from the engine, and a cycle
+ * that swallowed that keystroke would be the most annoying possible
+ * version of this feature.
+ */
+export function continues(cycle, box) {
+    return cycle !== undefined && cycle.box === box && cycle.names.length > 1;
+}
+//# sourceMappingURL=tab-cycle.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/verb-index.js

@@ -0,0 +1,99 @@
+import { isPlaytester } from './playtester.js';
+/**
+ * THE VERBS A PLAYER MAY TYPE, in one place.
+ *
+ * This table WAS a private static on Game, read only by the help screen.
+ * Tab needed the same list (yaw2btNX8aNEEF9D3, Maka: "If someone presses
+ * 'tab' with nothing in the input box, the first list to reference is
+ * the 'command' list"), and a second hand-maintained copy of ~180 verbs
+ * is a copy that drifts -- so it moved here and `help` reads it from
+ * here too. There is exactly one list.
+ *
+ * ALIASES ARE FIRST-CLASS. Each entry is [primary, ...aliases], and help
+ * prints them as "primary (alias, alias)". Tab must match all of them:
+ * somebody typing "inventor<Tab>" is reaching for `inventory`, which is
+ * an alias of `inv`, and a completer that only knew primaries would
+ * leave them stuck on a word that works.
+ */
+export const 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', 'stun', 'knock'], ['grapple', 'restrain', 'clinch'], ['struggle'], ['release'], ['cover'], ['aim'], ['defend'], ['delay'], ['end-turn', 'endturn', 'done', 'pass'], ['initiative', 'tracker', 'turn'], ['nudge'], ['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
+    // players" / "crew street"); the bare verb still answers quietly.
+    { title: 'party', entries: [['crew', 'party'], ['hire'], ['dismiss'], ['train'], ['order'], ['lead'], ['command'], ['deploy'], ['recall'], ['stow']] },
+    { title: 'magic', entries: [['spells'], ['cast'], ['summon', 'conjure'], ['project', 'astral'], ['return'], ['assense'], ['counterspell']] },
+    { title: 'matrix', entries: [['jack'], ['jackpoint'], ['deck'], ['load'], ['unload'], ['hack'], ['force', 'brute', 'smash'], ['mark', 'marks'], ['unmark'], ['disable'], ['brick'], ['download'], ['enter'], ['exit-host'], ['hop'], ['tap', 'splice'], ['snoop'], ['overwatch', 'os'], ['hide'], ['edit'], ['erase', 'wipe'], ['pan'], ['ar'], ['aros'], ['silent'], ['reboot'], ['agent'], ['drone'], ['jump', 'rig']] },
+    // The Emerged get their own shelf (player request: "there MUST be
+    // resonance" -- matrix is the place, Resonance is the talent).
+    // `sustain` shelves here and not under magic: the command is
+    // technomancer-gated (a sprite task, SR5 p.256) and refuses anyone
+    // else, so the Emerged shelf is where its audience looks.
+    { title: 'resonance', entries: [['compile'], ['decompile'], ['thread'], ['unravel'], ['register'], ['standby'], ['sustain'], ['sprites']] },
+    { title: 'social', entries: [['say'], ['shout'], ['emote', 'me'], ['tell', 'talk-to'], ['call'], ['message'], ['end-call', 'end', 'hangup'], ['accept'], ['decline', 'deny', 'refuse'], ['haggle', 'negotiate'], ['persuade', 'convince'], ['ask'], ['contacts']] },
+    { title: 'street', entries: [['abandon'], ['browse', 'buy'], ['sell'], ['catalog'], ['source', 'procure'], ['work', 'gig'], ['jobs'], ['journal'], ['perform'], ['palm'], ['docwagon'], ['treat'], ['eat'], ['drink'], ['lifestyle'], ['garage'], ['pay']] },
+    { title: 'barriers', entries: [['pick'], ['breach'], ['dispel', 'dispell'], ['bluff'], ['unlock'], ['lock']] },
+    { title: 'character', entries: [['sheet', 'stats'], ['advance'], ['qualities', 'quality'], ['sin', 'sins', 'papers'], ['initiate', 'submerge'], ['install', 'chrome']] },
+    { title: 'session', entries: [['help'], ['hints'], ['time', 'clock'], ['note'], ['backlog'], ['review'], ['roles'], ['clear'], ['quit', 'exit']] },
+];
+/** Registered but deliberately UNLISTED: reachable as subcommands or
+ *  muscle-memory ("players" folded back under crew after playtesting
+ *  -- "crew players" is the advertised path; the bare verb still
+ *  answers). Without this, the uncategorized sweep resurrects them
+ *  in an "other" bucket. */
+// 'first' and 'apply' exist ONLY to catch the two-word phrasings
+// ("first aid", "apply first aid") that used to die at the parser. As
+// bare words they mean nothing, so they are claimed but not advertised
+// -- `heal` is the verb the help screen teaches.
+// `complete` is what Tab sends (commands/complete.ts) -- a question the
+// input box asks, not a verb anyone types, so it stays out of help.
+export const HIDDEN_VERBS = ['players', 'first', 'apply', 'complete'];
+/** Session verbs that only a play-tester (or admin) can actually use
+ *  -- the server role-gates both and 403s everyone else. Listed in
+ *  help ONLY for a confirmed play-tester; see helpCategories. `roles`
+ *  rides along because it is admin-only, a strictly narrower group. */
+export const PLAYTESTER_VERBS = new Set(['backlog', 'review', 'roles']);
+/**
+ * The help index as THIS account should see it (backlog wave 2, item
+ * D: "let's remove Seattle Backlog for non playtesters"). The backlog
+ * is role-gated on the server and 403s everyone else, so listing it
+ * for every player only advertises a refusal. Hidden unless the
+ * account is a CONFIRMED play-tester -- see utilities/playtester.ts
+ * for why "unknown" (offline, logged out) hides rather than shows,
+ * and why the verb itself stays registered and usable regardless.
+ */
+export function helpCategories() {
+    if (isPlaytester())
+        return HELP_CATEGORIES;
+    return HELP_CATEGORIES.map(c => c.title !== 'session' ? c : {
+        ...c,
+        entries: c.entries.filter(e => !PLAYTESTER_VERBS.has(e[0])),
+    });
+}
+/**
+ * EVERY WORD A PLAYER MAY TYPE AS A FIRST WORD, aliases included, in the
+ * order the help screen shelves them -- so an empty Tab reads like the
+ * help index rather than like an alphabetised dump.
+ *
+ * Role-aware through helpCategories(), for the reason given there: a
+ * completer that offers `backlog` to an account the server will 403 is
+ * advertising a refusal, and Tab is the worst place to learn about one.
+ */
+export function playerVerbs() {
+    return helpCategories().flatMap(c => c.entries.flat());
+}
+/** Which shelf a verb sits on, for the one-line hint Tab prints beside
+ *  it. Falls back to the primary spelling for an alias, because "walk"
+ *  is more useful annotated "moving -- see move" than not at all. */
+export function verbShelf(verb) {
+    for (const c of HELP_CATEGORIES) {
+        for (const entry of c.entries) {
+            if (entry.includes(verb))
+                return { category: c.title, primary: entry[0] };
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=verb-index.js.map

package/package.json

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