@maka/maka-cli 5.13.0 → 5.14.0

package/bundle/typescript/src/commands/game/sideQuest/game.d.ts

@@ -3,8 +3,30 @@ import { ISceneSeedJson } from './types/seed/scene-seed.js';
 import { Item } from './models/item.js';
 import { Player, Inventory, Room, Scene } from './models/_index.js';
 import { ISaveFileV1, ISavedItem, SaveReason } from './types/save-file.js';
+/**
+ * One crew slot (see THE CREW block below): the persistent record a
+ * live 'ally' shell is rebuilt from each run. `ghost` marks a slot held
+ * by another PLAYER's character (Phase B): their share routes home via
+ * the ledger instead of evaporating as NPC pay.
+ */
+export interface ICrewMember {
+    name: string;
+    source: 'hired' | 'contact' | 'ghost';
+    archetypeName?: string;
+    description: string;
+    combat: Record<string, unknown>;
+    gear: ISavedItem[];
+    cutPct: number;
+    jobsRun: number;
+    trainedThisCycle?: boolean;
+    ghost?: {
+        slug: string;
+        owner: string;
+    };
+}
 import { IDocwagonContract } from './utilities/docwagon.js';
 import { ILifestyleTier } from './utilities/commerce.js';
+import { CommandQueue } from './utilities/command-queue.js';
 import { NPC } from './models/npc.js';
 import { AutoFight } from './utilities/auto-fight.js';
 import { IMainGameConfig } from './ui.js';
@@ -39,6 +61,7 @@ export default class Game {
         gigs: number;
         asked: boolean;
         role?: string;
+        note?: string;
     }>;
     pendingProcurements: {
         contact: string;
@@ -46,16 +69,57 @@ export default class Game {
         price: number;
     }[];
     docwagon?: IDocwagonContract;
+    crew: ICrewMember[];
+    commandRefusals: Record<string, number>;
     enlistedAlly?: {
         name: string;
         description: string;
         combat: Record<string, unknown>;
     };
-    commandRefusals: Record<string, number>;
+    /** Leadership fields the table: anyone runs with a partner, a leader
+     *  runs a team. Ceiling 5 -- the size of the future multiplayer table. */
+    get crewCap(): number;
+    /** The crew-change rule (player ruling): any roster change voids the
+     *  standing quote. Returns the line to show, or ''. */
+    scrapPendingRunForCrewChange(): string;
     performedThisCycle: boolean;
-    /** The recruited contact joins at the jobsite curb ("takes their own
-     *  ride and meets you there" -- the companion convention). */
-    spawnEnlistedAlly(): string[];
+    crewForHire: ICrewMember[];
+    private _presenceTimer?;
+    private static readonly PRESENCE_TICK_MS;
+    private beatPresence;
+    startPresenceHeartbeat(): void;
+    /** Ghost earnings home delivery: what YOUR runner made riding in
+     *  other players' crews since last time. Fire-and-forget from hub
+     *  arrival beats; pays onto the job credstick when anything landed. */
+    collectGhostEarnings(): Promise<void>;
+    private static readonly HIRE_NAMES;
+    /** Deal 2-3 fresh candidates. Names dodge the live cast and roster. */
+    rollHireCandidates(): void;
+    /** The crew joins at the jobsite curb ("took their own ride" -- the
+     *  companion convention): one 'ally' shell per member, carrying and
+     *  wearing their own gear. */
+    spawnCrew(): string[];
+    /**
+     * Homecoming settlement for the crew (returnToHub, BEFORE the fold --
+     * dismissCompanion sends shell cargo to the PLAYER, and crew gear is
+     * THEIRS): write each survivor's inventory+equipment back into the
+     * roster (loot they picked up stays with them), heal them (the cot
+     * convention), and bury the fallen -- crew death is PERMANENT, like
+     * everything else on this street. Returns homecoming lines.
+     */
+    settleCrewAfterRun(): string[];
+    /**
+     * The team's split, taken at every pay moment (canon: the crew shares
+     * the take; in multiplayer each player literally receives their
+     * share). Total cut capped at 60% -- the wheelman never out-earns the
+     * one holding the job. Ghost members' shares land on the local ledger
+     * for Phase B to sync home. Returns the player's share + the itemized
+     * line (empty crew: full amount, no line).
+     */
+    applyCrewCut(gross: number): {
+        share: number;
+        line: string;
+    };
     /** Bills a DocWagon fee: cred first, shortfall onto the rent tab (the
      *  street's one universal collections agency). Returns the line. */
     private billDocwagon;
@@ -260,6 +324,32 @@ export default class Game {
     clearPendingRun(): void;
     get pendingRun(): ISceneSeedJson | undefined;
     get pendingRunTier(): number | undefined;
+    currentClient?: {
+        name: string;
+        met: boolean;
+        advancePaid: number;
+        reported: boolean;
+        dead?: boolean;
+    };
+    forfeitArmed: boolean;
+    /**
+     * The meet and the wrap-up, triggered by the player's first/next real
+     * interaction with the client (talk-to, a connected call, a give).
+     * Returns the beat's text (advance/remainder lines) or null when this
+     * NPC isn't the client / nothing new happens. Canon p.28-29: half up
+     * front at the meet, the remainder on delivering proof. Completing the
+     * objective BEFORE ever meeting them collapses both beats into one.
+     */
+    onClientInteraction(npcName: string): string | null;
+    /**
+     * The client's verdict, filed at homecoming (returnToHub): whatever
+     * happened, their name joins the roster -- clean work opens a
+     * relationship (role 'Johnson', repeat clients deepen like gigs), a
+     * forfeited remainder or a walked-out job files a note the roster
+     * shows (p.368 already charged the walkout's notoriety at the curb).
+     * Clears currentClient; returns the homecoming line.
+     */
+    settleClientReputation(wrappedRun: boolean): string;
     /**
      * The cab that answers "call taxi" varies per job (player request: not
      * always a van) -- picked once when the pending run lands, so the
@@ -297,6 +387,13 @@ export default class Game {
     get metaBox(): blessed.Widgets.BoxElement;
     get inputBox(): blessed.Widgets.TextboxElement;
     init(options: IMainGameConfig, screen: blessed.Widgets.Screen): Promise<string>;
+    /** The blessed half of startup -- widgets only. Headless sessions
+     *  (Phase C) never call this; everything below survives without it
+     *  (updateStatus/refreshLogLabel/close are all screen-guarded). */
+    initUi(screen: blessed.Widgets.Screen): void;
+    /** The engine half of startup: scene synthesis, command registration,
+     *  hub seeding, resume overlay -- no widget contact. */
+    initEngine(options: IMainGameConfig): Promise<string>;
     /**
      * Everything a save restores beyond the seed synthesis: the player,
      * the hub world overlay, and the Game-level ledgers. Ordering inside
@@ -387,6 +484,13 @@ export default class Game {
      */
     launchPendingRun(): Promise<string>;
     close(): Promise<void>;
+    stopPresenceHeartbeat(): void;
+    /**
+     * Full per-session teardown (Phase C): everything init/play armed that
+     * outlives a turn -- for the hosting server's idle eviction and
+     * session close. Solo play never calls this (process exit does it).
+     */
+    dispose(): Promise<void>;
     private initInputBox;
     private initLogBox;
     /**
@@ -433,6 +537,12 @@ export default class Game {
      * and once on load/job transition.
      */
     updateStatus(): void;
+    /**
+     * The HUD as data: every status line for `player`, pure state reads --
+     * no widgets. updateStatus paints it for the local player; a shared-run
+     * server ships it per player as status events (Phase C).
+     */
+    statusLinesFor(player: Player): string[];
     updateEquipment(_playerEquipment: PlayerEquipment): void;
     updateExits(_room: Room): void;
     updateInventory(_playerInventory: Inventory, _currencyName?: string): void;
@@ -445,7 +555,32 @@ export default class Game {
      * correction call overwrites it with the corrected verb.
      */
     lastResolvedVerb: string;
+    /**
+     * Serializes every inbound command (see utilities/command-queue.ts):
+     * the engine's await points assume one command in flight, and a second
+     * human on a DDP connection must wait its turn, not interleave.
+     */
+    readonly commandQueue: CommandQueue;
+    /**
+     * Shared-run hook (Phase C): fires when a NON-primary human player
+     * dies in this scene, so the server can burn their save. The primary
+     * player's death keeps the solo path (Scene.endGame -> close(),
+     * permadeath).
+     */
+    onPlayerDeath?: (player: Player) => void;
     handleInput(input: string): Promise<string | null>;
+    /**
+     * Runs `input` AS the named human player -- the symmetric-multiplayer
+     * command entry: every human gets the same full privileged context the
+     * solo player always had. Queued; internal re-entries (typo
+     * correction, say.ts's speech-accept) run inline via the queue's
+     * re-entrancy guard.
+     */
+    handleInputAs(actorName: string, input: string): Promise<{
+        text: string | null;
+        verb: string;
+    }>;
+    private runInputAs;
     /**
      * The help taxonomy: every entry is [primary, ...aliases], grouped the
      * way a player thinks, not the order commands were registered. The