@maka/maka-cli 5.63.0 → 5.64.0

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

@@ -1,7 +1,7 @@
 import blessed from 'blessed';
 import { dirname } from 'path';
 import { capitalCase } from 'change-case';
-import { Category } from './types/shared/item-enum.js';
+import { Category, Size, Rating } from './types/shared/item-enum.js';
 import { Item } from './models/item.js';
 import { Room } from './models/_index.js';
 import { Door } from './models/door.js';
@@ -27,6 +27,9 @@ import { TakeCommand } from './commands/take.js';
 import { LootCommand } from './commands/loot.js';
 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 { RolesCommand } from './commands/roles.js';
 import { SinCommand } from './commands/sin.js';
 import { GoCommand } from './commands/go.js';
@@ -109,6 +112,7 @@ import { SellCommand } from './commands/sell.js';
 import { PayCommand } from './commands/pay.js';
 import { LifestyleCommand } from './commands/lifestyle.js';
 import { JobsCommand } from './commands/jobs.js';
+import { JournalCommand } from './commands/journal.js';
 import { TreatCommand } from './commands/treat.js';
 import { WorkCommand } from './commands/work.js';
 import { EatCommand } from './commands/eat.js';
@@ -127,6 +131,10 @@ import { OverwatchCommand } from './commands/overwatch.js';
 import { MarkCommand } from './commands/mark.js';
 import { SnoopCommand } from './commands/snoop.js';
 import { TapCommand } from './commands/tap.js';
+import { TimeCommand } from './commands/time.js';
+// The HUD's clock -- read in the engine so a shared run reads the
+// host's wall clock, never each client's own (item B).
+import { clockTime, worldNow } from './utilities/world-clock.js';
 import { AutoFight } from './utilities/auto-fight.js';
 import { CommandFactory } from './factories/command-factory.js';
 import { SceneSynthesizer } from './factories/scene-factory.js';
@@ -156,6 +164,12 @@ export default class Game {
     _quitArmed = false;
     _escArmedAt = 0;
     _statusBox;
+    /** The clock gutter left of the prompt, its ticker, and the face it
+     *  last painted -- compared so a repaint only happens on the minute
+     *  rollover (see paintClock). */
+    _clockBox;
+    _clockTimer;
+    _clockFace = '';
     _inputBox;
     /** The floating icon-minimap (map-overlay wave 2026-08-24). Optional:
      *  headless sessions never build widgets. */
@@ -172,6 +186,24 @@ export default class Game {
     _anonymous = false;
     _logFilePath = '';
     _tier = 1;
+    /**
+     * The run's difficulty tier. `activateRunScene` sets it from the tier
+     * the scene was generated at; a HEADLESS boot never calls that, so a
+     * shared run sat at the default 1 no matter what it was actually
+     * generated as (audit 2026-08-27).
+     *
+     * That does not sit still: the stored tier rides into the save
+     * snapshot and `continueToNextScene` reads `_tier + 1` for the next
+     * draft, so an under-recorded tier propagates forward into content
+     * that has not been generated yet. Exposed so the headless boot can
+     * state the tier it was handed instead of guessing.
+     */
+    get tier() {
+        return this._tier;
+    }
+    set tier(value) {
+        this._tier = value;
+    }
     // Guards against two overlapping continueToNextScene() calls -- found via
     // a real session where calling the fixer twice in a row (nothing stopped
     // it, and a 20-40+ second draft invites a second, impatient call) fired
@@ -865,6 +897,80 @@ export default class Game {
      * setCharacterLocation (the ONLY path that binds room observers), and
      * hand it the scene for its AI context.
      */
+    /**
+     * THE FIXER IS REACHABLE FROM THE FIELD (player go 2026-08-27: "on a
+     * multi-crew session, I should still be able to TALK to Mr. Krow if I
+     * need something").
+     *
+     * A shared run executes on a server whose Game has no hub scene, so
+     * `hubCast()` is empty and NOBODY from home is a call candidate --
+     * including the fixer. Solo mid-run they are (see call.ts's own note
+     * about "call Ratchet" bouncing while the roster promised a phone
+     * icon), so the same fiction behaved differently by mode, invisibly.
+     *
+     * The ruling that keeps the ROSTER home is untouched, because the
+     * roster and the fixer are different KINDS of thing. The roster is
+     * per-player relationship state -- your loyalty, your favours, your
+     * ledger -- which is not merely awkward on a shared server but
+     * meaningless there, since four players have four different Mama Wus.
+     * The fixer is world furniture: one fixed identity, the same Krow for
+     * everyone at the table, carrying no per-player state. A shared-run
+     * Krow is well-defined in a way a shared-run roster is not, so
+     * answering yes here costs nothing that ruling was protecting.
+     *
+     * Deliberately NOT the whole hub cast: that needs per-player contact
+     * identity on the server and would reopen the ruling.
+     *
+     * He is built lazily and kept OFF the scene -- he is a voice on a
+     * commlink, not a body in the room, so he must never appear in "look",
+     * be attacked, or be looted. Returns undefined in any session that
+     * already has a real one (a hub session, or a static scene that ships
+     * him as a cast member), so there is only ever one Krow.
+     */
+    remoteFixer() {
+        if (this.hasHub || !this.scene)
+            return undefined;
+        if (this.scene.allActors.some(a => isFixerName(a.name)))
+            return undefined;
+        if (this._remoteFixer)
+            return this._remoteFixer;
+        // His own private "room": never added to the scene, so nothing can
+        // walk into it. It exists because an NPC needs somewhere to stand
+        // for its own AI context to resolve.
+        const line = new Room({
+            name: 'On The Line',
+            description: 'Somewhere across the sprawl, a man takes a call he was expecting.',
+            roomType: 'void',
+        });
+        const npc = new NPC({
+            dialog: [
+                `Talk to me, chummer -- you're on the clock.`,
+                `I broker the work. What happens on site is your business.`,
+            ],
+            description: `The fixer who put this job together. He is not on site and never will be -- he brokers, he does not run. Reachable by commlink because that is the whole point of a fixer. He knows the JOB exists and who hired for it; he does NOT know the inside of the place, the codes, or what the runners are looking at right now.`,
+            playerConstructorConfig: {
+                playerName: FIXER_NAME,
+                startLocation: line,
+                combat: { body: 3, agility: 3, reaction: 3, willpower: 4, logic: 4, intuition: 4, charisma: 5, strength: 3, edge: 3 },
+            },
+        }, new CommandRegistry(this.scene));
+        // A fixer with no commlink is a contradiction, and call.ts gates on
+        // carrying one (hasCommlink) before it will connect.
+        // NOTE the enum VALUES here. A runtime Item validates against the
+        // enum's values ('tiny'); a SAVED item uses the enum KEYS ('Tiny').
+        // The two conventions are inverses and both are load-bearing.
+        npc.inventory.addItem(new Item({
+            name: 'Fixer\'s Commlink',
+            description: 'The number everyone has and nobody sells.',
+            size: Size.Tiny, category: Category.Commlink, shape: 'Rectangle',
+            color: 'Black', texture: 'Matte', rating: Rating.Common, weight: 0.1,
+        }));
+        npc.scene = this.scene;
+        this._remoteFixer = npc;
+        Logger.getInstance().write(`Remote fixer materialised for a hubless session: ${FIXER_NAME}.`);
+        return npc;
+    }
+    _remoteFixer;
     spawnCompanionShell(opts) {
         if (this.scene.getActor(opts.name)) {
             Logger.getInstance().write(`spawnCompanionShell: name "${opts.name}" already in scene -- refusing.`);
@@ -1466,6 +1572,24 @@ export default class Game {
     // state never is (runs are disposable); reconstructed fresh by
     // activateRunScene, settled into the roster by returnToHub.
     currentClient;
+    /**
+     * WHEN THE RUN STARTED -- the one fact the journal cannot derive.
+     *
+     * commands/journal.ts renders current state rather than recording
+     * events, deliberately: a journal that logs what happened can drift
+     * from the world it describes, and a derived one cannot disagree with
+     * the thing it is reading. Client, pay and objective all already exist
+     * elsewhere and are read live. Elapsed time is the exception -- its
+     * ORIGIN is not recoverable from any current state -- so this is the
+     * single new field the feature adds, said out loud rather than grown
+     * quietly into a record.
+     *
+     * Not saved, and does not need to be: like currentClient above, mid-run
+     * state never persists (runs are disposable -- a quit resumes to the
+     * hub with the job back on offer), so there is no save-schema change
+     * here. Stamped by activateRunScene, cleared by settleClientReputation.
+     */
+    runStartedAt;
     // Taxi warn-once (player ruling): leaving with the pay unclaimed
     // arms this; the second "call taxi" forfeits. Mirrors _quitArmed.
     forfeitArmed = false;
@@ -1541,6 +1665,7 @@ export default class Game {
     settleClientReputation(wrappedRun) {
         const client = this.currentClient;
         this.currentClient = undefined;
+        this.runStartedAt = undefined;
         this.forfeitArmed = false;
         if (!client)
             return '';
@@ -1799,6 +1924,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         CommandFactory.registerCommand('drink', DrinkCommand);
         CommandFactory.registerCommand('lifestyle', LifestyleCommand);
         CommandFactory.registerCommand('jobs', JobsCommand);
+        CommandFactory.registerCommand('journal', JournalCommand);
         CommandFactory.registerCommand('treat', TreatCommand);
         CommandFactory.registerCommand('work', WorkCommand);
         CommandFactory.registerCommand('gig', WorkCommand);
@@ -1827,6 +1953,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // "jackpoint" are what players reach for when they mean the same act.
         CommandFactory.registerCommand('tap', TapCommand);
         CommandFactory.registerCommand('splice', TapCommand);
+        // The wall clock (item B). "clock" too -- half of us type that.
+        CommandFactory.registerCommand('time', TimeCommand);
+        CommandFactory.registerCommand('clock', TimeCommand);
     }
     determineStartRoom() {
         return this.scene.determineStartRoom();
@@ -1928,6 +2057,12 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         this._saveFilePath = options.saveFilePath;
         this._owner = options.owner;
         this._anonymous = options.anonymousRunner === true;
+        // Ask the server, once, whether this account is a play-tester, so
+        // the help index can stop advertising a backlog that will only 403
+        // (item D). Fire-and-forget on purpose: it never blocks the boot,
+        // never throws, and an unanswered probe just leaves the menu entry
+        // hidden while the verb stays usable. See utilities/playtester.ts.
+        void probePlaytesterStanding({ anonymous: this._anonymous });
         // ONE loud notice the moment the AI provider refuses on ACCOUNT
         // grounds (empty credits, bad key). Without it a dead key mutes
         // every NPC and makes every job "fall through" invisibly -- a real
@@ -2041,6 +2176,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         equipIntoEmptySlots(this.player);
         this.warmNpcAppearancesInBackground();
         this.startPursuitHeartbeat();
+        this.startClockTicker();
         // The banner learns where we are only after the hub/scene bookkeeping
         // above settles.
         this.refreshLogLabel();
@@ -2761,7 +2897,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // playtest note: being yanked into the run the instant generation
         // finished was jarring). The player invokes it on their own time:
         // "call Mr. Johnson" delivers the offer (haggle window included --
-        // see call.ts), and "travel" actually goes (launchPendingRun).
+        // see call.ts), and "call taxi" actually goes (launchPendingRun).
         if (this.hasHub) {
             // The mid-generation race (see draftedForParty above): if the live
             // party changed while Krow was on the phone, this seed was quoted
@@ -2795,6 +2931,8 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         this.camPingedRooms.clear();
         this.sweptRooms.clear();
         this.sceneSeed = seed;
+        // The clock starts when the run does (commands/journal.ts).
+        this.runStartedAt = worldNow();
         // A call partner from the old scene wouldn't exist in the new one --
         // hang up before moving on, rather than leave a dangling reference.
         if (this.player.activeCallPartner) {
@@ -3007,6 +3145,45 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             });
         }
     }
+    /**
+     * THE CLOCK TICKER (playtest 2026-08-27). The gutter rendered once,
+     * whenever the pane happened to paint, and then showed that moment
+     * forever. Parked beside a live prompt it is under the player's eye
+     * for the whole run, so a stale one is worse than none at all -- and
+     * the move made that matter MORE, not less.
+     *
+     * Repaints on the MINUTE ROLLOVER, not on every tick: it wakes each
+     * second but only touches the screen when the rendered string
+     * actually changes. A forced once-a-second render would flicker the
+     * whole terminal and cost more than the feature is worth.
+     */
+    paintClock() {
+        if (!this._clockBox)
+            return;
+        const face = clockTime();
+        if (face === this._clockFace)
+            return;
+        this._clockFace = face;
+        this._clockBox.setContent(`{center}{cyan-fg}${face}{/cyan-fg}{/center}`);
+        this._screen?.render();
+    }
+    startClockTicker() {
+        // No gutter, nothing to repaint. Headless sessions have no screen,
+        // and a server hosting many of them should not spin one interval
+        // per session to call a function that early-returns.
+        if (!this._clockBox || this._clockTimer)
+            return;
+        this._clockTimer = setInterval(() => this.paintClock(), 1000);
+        // Never hold the process open for a clock: a session that is
+        // otherwise finished should exit, not linger for the next minute.
+        this._clockTimer.unref?.();
+    }
+    stopClockTicker() {
+        if (this._clockTimer) {
+            clearInterval(this._clockTimer);
+            this._clockTimer = undefined;
+        }
+    }
     stopPresenceHeartbeat() {
         if (this._presenceTimer) {
             clearInterval(this._presenceTimer);
@@ -3020,6 +3197,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      */
     async dispose() {
         this.stopPresenceHeartbeat();
+        // A stray interval outliving a closed shared session would be a
+        // nasty thing to find later, so it retires with the rest of them.
+        this.stopClockTicker();
         if (this._presenceEquipTimer)
             clearTimeout(this._presenceEquipTimer);
         this.stopPursuitHeartbeat();
@@ -3033,10 +3213,39 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
     }
     initInputBox(screen) {
         // Create an input box for user commands
-        const inputBox = blessed.textbox({
+        // THE CLOCK GUTTER (playtest 2026-08-27: "if it makes sense, the
+        // clock can be to the left of the input box"). A fixed-width pane
+        // at left:0 with the input narrowed to match.
+        //
+        // This is also where the truncation bug goes to die rather than
+        // move house. The clock used to be the LAST field on the Armor
+        // line, so it was the first thing clipped when that pane got tight
+        // -- which is why the player could not find it. A dedicated
+        // fixed-width gutter cannot be squeezed by its neighbours: the
+        // input field yields the columns instead, and long input already
+        // scrolls horizontally. The cost is CLOCK_GUTTER_W columns of
+        // typing room.
+        //
+        // A sibling widget does not touch the textbox's internal cursor --
+        // it just gets a narrower width -- so there is no cursor maths here.
+        const clockBox = blessed.box({
+            id: 'clockBox',
             bottom: 0,
             left: 0,
-            width: '100%',
+            width: Game.CLOCK_GUTTER_W,
+            height: 3,
+            tags: true,
+            border: { type: 'line' },
+            style: { border: { fg: 'cyan' } },
+            content: '',
+        });
+        this._clockBox = clockBox;
+        screen.append(clockBox);
+        this.paintClock();
+        const inputBox = blessed.textbox({
+            bottom: 0,
+            left: Game.CLOCK_GUTTER_W,
+            width: `100%-${Game.CLOCK_GUTTER_W}`,
             height: 3,
             tags: true,
             border: { type: 'line' },
@@ -3307,6 +3516,10 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      *  the inner width from it to right-justify the elevation bar. */
     static ROOM_DOCK_PCT = 0.23;
     /** Must track the mapBox's `width` below -- used to trim its caption. */
+    /** Columns the clock gutter takes from the input field. Wide enough
+     *  for "HH:MM" inside a border; adjustable if it costs too much
+     *  typing room in play. */
+    static CLOCK_GUTTER_W = 8;
     static MAP_DOCK_PCT = 0.12;
     initMapBox(screen) {
         const mapBox = blessed.box({
@@ -3554,6 +3767,14 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // decide whether calls land while you are away from your body.
         const { overlay, link } = arStatusSlots(player);
         const arSlot = player.plane === 'meat' ? `  |  ${overlay}` : '';
+        // THE WALL CLOCK rides the readiness line (item B). Rendered HERE,
+        // in the engine, which in a shared run is the server -- so every
+        // player's HUD shows the host's clock and "after midnight" is one
+        // moment for the whole table. utilities/world-clock.ts has the why.
+        // Time only, not the date: the date is what "time" is for.
+        // The clock LEFT this line for the gutter beside the prompt. It was
+        // the last field here, so it was the first thing clipped whenever
+        // the pane got tight -- the reason the player could not find it.
         lines.push(`${armorNote}${arSlot}  |  ${link}`);
         // Lines 4+: transient states, present only while active. Future
         // contexts (astral projection, VR hot-sim) join here the same way.
@@ -3913,10 +4134,10 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // resonance" -- matrix is the place, Resonance is the talent).
         { title: 'resonance', entries: [['compile', 'decompile'], ['thread'], ['register']] },
         { title: 'social', entries: [['say'], ['emote', 'me'], ['talk-to'], ['call'], ['end-call', 'end', 'hangup'], ['accept'], ['decline', 'deny', 'refuse'], ['haggle', 'negotiate'], ['persuade', 'convince'], ['ask'], ['contacts']] },
-        { title: 'street', entries: [['browse', 'buy'], ['sell'], ['catalog'], ['source', 'procure'], ['work', 'gig'], ['jobs'], ['perform'], ['palm'], ['docwagon'], ['treat'], ['eat'], ['drink'], ['lifestyle'], ['pay']] },
+        { title: 'street', entries: [['browse', 'buy'], ['sell'], ['catalog'], ['source', 'procure'], ['work', 'gig'], ['jobs'], ['journal'], ['perform'], ['palm'], ['docwagon'], ['treat'], ['eat'], ['drink'], ['lifestyle'], ['pay']] },
         { title: 'barriers', entries: [['solve'], ['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'], ['note'], ['backlog'], ['roles'], ['clear'], ['quit', 'exit']] },
+        { title: 'session', entries: [['help'], ['hints'], ['time', 'clock'], ['note'], ['backlog'], ['roles'], ['clear'], ['quit', 'exit']] },
     ];
     /** Registered but deliberately UNLISTED: reachable as subcommands or
      *  muscle-memory ("players" folded back under crew after playtesting
@@ -3924,6 +4145,11 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
      *  answers). Without this, the uncategorized sweep resurrects them
      *  in an "other" bucket. */
     static HIDDEN_VERBS = ['players'];
+    /** 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', 'roles']);
     /** 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.',
@@ -3937,17 +4163,37 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         const CommandClass = CommandFactory.getAllRegisteredCommands()[verb];
         return CommandClass?.getDescription() ?? 'No description available.';
     }
+    /**
+     * 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.
+     */
+    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])),
+        });
+    }
     getHelpMessage(args = []) {
         const registered = Object.keys(CommandFactory.getAllRegisteredCommands());
+        const helpCategories = this.helpCategories();
+        // The uncategorized sweep must not resurrect what helpCategories
+        // just hid, so the restricted verbs stay "covered" either way.
         const covered = new Set([...Game.HELP_CATEGORIES.flatMap(c => c.entries.flat()), ...Game.HIDDEN_VERBS]);
         const uncategorized = registered.filter(v => !covered.has(v));
         const query = args.join(' ').trim().toLowerCase();
         // "help <category>": that group, with full descriptions.
         if (query) {
-            const categoryNames = Game.HELP_CATEGORIES.map(c => c.title);
+            const categoryNames = helpCategories.map(c => c.title);
             const pickedCategory = fuzzyPickName(query, categoryNames);
             if (pickedCategory) {
-                const category = Game.HELP_CATEGORIES.find(c => c.title === pickedCategory);
+                const category = helpCategories.find(c => c.title === pickedCategory);
                 const lines = [`${category.title.toUpperCase()}`];
                 for (const [primary, ...aliases] of category.entries) {
                     lines.push(`${BULLET}${primary}${aliases.length > 0 ? ` (${aliases.join(', ')})` : ''}: ${this.describeVerb(primary)}`);
@@ -3962,7 +4208,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             const pickedVerb = fuzzyPickName(words[0], [...covered, ...uncategorized])
                 ?? fuzzyPickName(query, [...covered, ...uncategorized]);
             if (pickedVerb) {
-                const entry = Game.HELP_CATEGORIES.flatMap(c => c.entries).find(e => e.includes(pickedVerb));
+                const entry = helpCategories.flatMap(c => c.entries).find(e => e.includes(pickedVerb));
                 const primary = entry?.[0] ?? pickedVerb;
                 const aliases = entry?.slice(1) ?? [];
                 const CommandClass = CommandFactory.getAllRegisteredCommands()[primary];
@@ -4018,7 +4264,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // line outgrows the Mechanics column (help renders there now --
         // blessed's mid-list wrap lost the left-column alignment).
         const lines = ['COMMANDS'];
-        const pad = Math.max(...Game.HELP_CATEGORIES.map(c => c.title.length));
+        const pad = Math.max(...helpCategories.map(c => c.title.length));
         const pushWrapped = (title, verbs) => {
             const rows = [];
             let cur = '';
@@ -4037,7 +4283,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
             for (const r of rows.slice(1))
                 lines.push(`${' '.repeat(pad)}  ${r}`);
         };
-        for (const category of Game.HELP_CATEGORIES) {
+        for (const category of helpCategories) {
             pushWrapped(category.title, category.entries.map(e => e[0]));
         }
         if (uncategorized.length > 0) {