@maka/maka-cli 5.67.0 → 5.69.0

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

@@ -2,7 +2,7 @@ import blessed from 'blessed';
 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';
+import { ISaveFileV1, ISavedItem, SaveReason, IRegisteredSprite } 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
@@ -33,6 +33,7 @@ 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 type { CompanionKind } from './models/npc.js';
 import { AutoFight } from './utilities/auto-fight.js';
 import { IMainGameConfig } from './ui.js';
 import { PlayerEquipment } from './types/player-equipment.js';
@@ -329,7 +330,7 @@ export default class Game {
     private seedHomeTurfContacts;
     companions: {
         npc: NPC;
-        kind: 'spirit' | 'sprite' | 'agent' | 'drone' | 'ally';
+        kind: CompanionKind;
         services?: number;
         force: number;
         boundDevice?: Item;
@@ -340,9 +341,70 @@ export default class Game {
          *  survives travel and rides the save file. */
         registered?: boolean;
     }[];
-    /** A registered sprite folded for travel, waiting to re-shell at the
-     *  destination (the drone _pendingRedeploys school). */
-    private _pendingSpriteRedeploy?;
+    /** REGISTERED SPRITES WAITING IN THE RESONANCE (SR5 p.254-256):
+     *  folded for travel, or staged from a resumed save, waiting to
+     *  re-shell (the drone _pendingRedeploys school).
+     *
+     *  An ARRAY since 2026-08-28. It was a single slot back when one
+     *  sprite was the hard maximum; the canon cap is one COMPILED sprite
+     *  with registered ones exempt, up to LOGIC of them (register.ts), so
+     *  a single slot would have quietly dropped every registered sprite
+     *  but one at the next save or journey -- the same "your permanent
+     *  companion vanished" the fix is for, moved one step downstream. */
+    private _pendingSpriteRedeploy;
+    /** How many registrations are spent: the ones standing here plus the
+     *  ones waiting in the Resonance. register.ts bills this against
+     *  Logic. */
+    registeredSpriteCount(): number;
+    /** Registered sprites waiting in the Resonance, for the surfaces that
+     *  have to tell a player what they still have. A copy: the stash is
+     *  maintained by the movers above and nowhere else. */
+    registeredSpritesWaiting(): IRegisteredSprite[];
+    /**
+     * DISMISS half of Call/Dismiss Sprite (SR5 p.250, Simple Action):
+     * "send a sprite back to the Resonance, releasing it from any tasks it
+     * still owes you."
+     *
+     * The task release is canon and it is the expensive part -- p.256
+     * offers STANDBY (costs 1 task, keeps the rest) precisely because
+     * dismissing burns them all. So tasks go to 0 here rather than being
+     * carried, and the command that calls this says so out loud before a
+     * player spends a companion's usefulness to tidy the grid.
+     *
+     * Only a REGISTERED sprite has anywhere to go. A compiled one that is
+     * sent away is simply gone, which is decompile's job, not this one --
+     * so this refuses it rather than quietly destroying it.
+     */
+    dismissSpriteToResonance(entry: (typeof this.companions)[number]): boolean;
+    /**
+     * STANDBY (SR5 p.256, a registered sprite TASK): "tells the sprite to
+     * return to the Resonance but come when you call it. This keeps the
+     * sprite from giving away your presence or getting in harm's way."
+     * Costs ONE task.
+     *
+     * The middle option dismissal made visible. Dismissing is free at the
+     * door and costs everything the sprite owes you (p.250); standby
+     * costs one and keeps the rest, which is the whole reason the book
+     * sells it. Without this the only way to park a sprite was to spend
+     * its entire usefulness, and a player who wanted it out of sight for
+     * one room paid for that with every favour it had left.
+     *
+     * Returns false when there is no task to spend with. A registered
+     * sprite that owes you nothing cannot pay for standby -- and does not
+     * need to, because dismissing it releases nothing it still had. The
+     * caller says that out loud rather than silently doing the other one.
+     */
+    standbySpriteToResonance(entry: (typeof this.companions)[number]): boolean;
+    /**
+     * CALL half of Call/Dismiss Sprite (p.250): "You call a registered
+     * sprite you have waiting in the Resonance."
+     *
+     * `name` picks one when several wait; without it, the first. Returns
+     * the arrival line, or undefined when nothing answered -- the caller
+     * owns the refusal wording, because "you have none" and "you have
+     * some but not that one" are different things to be told.
+     */
+    callSpriteFromResonance(name?: string): string | undefined;
     private _pendingRedeploys;
     private _saveFilePath?;
     private _dead;
@@ -390,7 +452,7 @@ export default class Game {
     spawnCompanionShell(opts: {
         name: string;
         description: string;
-        kind: 'spirit' | 'sprite' | 'agent' | 'drone' | 'ally';
+        kind: CompanionKind;
         combat: Partial<import('./models/player.js').ICombatAttributes>;
         room: Room;
         plane: 'meat' | 'matrix' | 'astral';
@@ -433,11 +495,7 @@ export default class Game {
     /** Re-shell a registered sprite (travel arrival, or a resumed save).
      *  Returns the arrival line, or undefined when the shell can't land
      *  (name collision -- vanishingly rare). */
-    respawnRegisteredSprite(spec: {
-        spriteType: string;
-        level: number;
-        tasks: number;
-    }): string | undefined;
+    respawnRegisteredSprite(spec: IRegisteredSprite): string | undefined;
     /**
      * Records a real transaction with a hub NPC: first contact opens the
      * relationship at Loyalty 1 (a safeguard -- the hub cast is pre-seeded
@@ -654,6 +712,12 @@ export default class Game {
      */
     runStartedAt?: Date;
     forfeitArmed: boolean;
+    /** Set by "abandon": the next taxi WALKS OUT instead of running an
+     *  errand (mYTCzJbsdZxYsTsZo). The reversible trip is the default and
+     *  the irreversible one is asked for -- Notoriety, a forfeited payout
+     *  and a destroyed scene should require the deliberate word, and a
+     *  round trip you can undo by getting back in the cab should not. */
+    walkOutArmed: 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).
@@ -772,6 +836,66 @@ export default class Game {
      * state (a persona still jacked in, an astral projection, a sneak,
      * open combat bookkeeping) is settled on the way home.
      */
+    /**
+     * THE JOB YOU LEFT STANDING (mYTCzJbsdZxYsTsZo: "I'd like it to not
+     * fail the run -- I should be able to come and go to the job as I
+     * need (to get new gear)").
+     *
+     * Held in memory only, and deliberately NOT saved. Mid-run state
+     * never is -- "runs are disposable, a quit resumes to the hub with
+     * the job back on offer" -- so an errand is SESSION-SCOPED and needs
+     * no save-schema change. Quit mid-errand and you get exactly today's
+     * behaviour rather than a half-restored scene from a save that was
+     * never designed to hold one.
+     *
+     * The rooms survive because something finally holds them: returnToHub
+     * orphans a run "wholesale" only because nothing kept a reference.
+     */
+    private _openRun?;
+    /** Is there a job waiting for the runner to come back to it? */
+    get hasOpenRun(): boolean;
+    /** The room an open run is waiting in, for the surfaces that say so. */
+    get openRunSceneName(): string | undefined;
+    /**
+     * AN ERRAND IS NOT A HOMECOMING, and that is the whole design.
+     *
+     * returnToHub is a RITUAL, not a journey. Walking its full length
+     * twice per gear run would hand a player, free and on demand: a full
+     * stun heal at High lifestyle ("the shower runs hot until the run is
+     * a rumor"), every vendor's shelves restocked, a fresh legwork pull
+     * from every contact, the busking cycle reset, and a rerolled
+     * for-hire board -- while ALSO charging rent again and burning a
+     * twelfth of the DocWagon contract, whose year "ticks in homecomings".
+     * Wrong in both directions at once: the exploit and the punishment
+     * are the same line of code.
+     *
+     * So this is its own path rather than a flag on that one. Written as
+     * a separate method ON PURPOSE: parameterising the ritual would mean
+     * every future line added to it silently joins the errand too, and
+     * the failure would be invisible -- a restock nobody notices is not a
+     * crash. Here, anything an errand should do has to be written here.
+     *
+     * WHAT IT DOES: state hygiene the cab demands (a persona cannot ride
+     * in a taxi), companions fold and unfold as on any trip, and the
+     * scene swaps. Nothing else.
+     *
+     * WHAT IT DOES NOT DO, all of it deliberate: no client settlement, no
+     * crew settlement or disband, no jobsRun tally, no lifestyle upkeep,
+     * no restock, no rumor, no gig advance, no hire reroll, no DocWagon
+     * tick, no legwork refresh -- and NO per-job reset. A RETURN LEG IS
+     * NOT A NEW JOB: Edge does not refill, haggledThisJob does not clear,
+     * First Impression does not re-arm. You come back as you left, which
+     * is the difference between fetching a gun and starting over.
+     */
+    leaveRunForErrand(): string | undefined;
+    /** Back to the job you left standing. */
+    resumeOpenRun(): string | undefined;
+    /** Cross-plane and combat state that must not ride in a cab, shared
+     *  by both legs of an errand. A persona has no body to put in a taxi
+     *  and a fight does not travel. */
+    private settleTravelState;
+    /** The panel refresh both errand legs need. */
+    private refreshHubUi;
     private returnToHub;
     /**
      * KNIGHT ERRANT CHECKPOINT (SINs & getting caught, ruling 2026-08-24;