@maka/maka-cli 5.127.0 → 5.129.0

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

@@ -1,1677 +0,0 @@
-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, 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
- * 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;
-    /** Another player's runner. `liveOnly` marks a FRIEND INVITE ("crew
-     *  invite", Phase C): they ride only as a live player in shared runs
-     *  -- never AI-driven, never spawned locally, no cut (live runs pay
-     *  the canon team split instead). Absent/false = a hired ghost. */
-    ghost?: {
-        slug: string;
-        owner: string;
-        liveOnly?: boolean;
-    };
-}
-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 type { RunType } from './factories/scene-chunks.js';
-import { PlayerEquipment } from './types/player-equipment.js';
-export default class Game {
-    initialized: boolean;
-    private static instance;
-    private sceneSeed;
-    scene: Scene;
-    player: Player;
-    autoFight: AutoFight;
-    private _screen;
-    private _logBox;
-    private _metaBox;
-    private _quitArmed;
-    /**
-     * The quit verb already sealed this runner to the grid, so the
-     * process-exit hook has nothing left to do. Set ONLY after an awaited
-     * flush -- an optimistic set would make the exit hook skip the spill
-     * write on a push that never landed, which is the one way this design
-     * can silently lose a beat. (Mutation-checked: never setting it is
-     * caught, and so is setting it without the flush.)
-     */
-    private _quitSealed;
-    get quitSealed(): boolean;
-    private _escArmedAt;
-    private _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). */
-    private _clockBox?;
-    private _clockTimer?;
-    private _clockFace;
-    private _inputBox;
-    /** The floating icon-minimap (map-overlay wave 2026-08-24). Optional:
-     *  headless sessions never build widgets. */
-    private _mapBox?;
-    /** Its twin, docked to its right: the current room's own layout
-     *  (spatial-viz follow-up 2026-08-25). See utilities/room-view.ts. */
-    private _roomMapBox?;
-    /** The last string actually painted into each dock -- compared so a
-     *  repaint (and its scheduleRender cost) only happens when the
-     *  content genuinely changed, same reasoning as _clockFace above.
-     *  Read by setMapOverlay/setRoomOverlay; written there too. */
-    private _lastMapPaint?;
-    private _lastRoomPaint?;
-    /** The docked panels' HEARTBEAT (2FrYWFdLnh6uqFLcp, player: "I'd like
-     *  the area map to update on a heartbeat, not only when I issue a
-     *  command. That way I can tell where things are in 'real time'").
-     *
-     *  Every other panel refresh rides a player-typed command
-     *  (updateExits already fires on move/look/lock/unlock -- see its own
-     *  header) or a server push in a shared run. Nothing repainted it
-     *  while the player sat still watching an NPC close in. This ticker
-     *  is that missing beat for solo play, built on the clock's own
-     *  lesson one field up: call the SAME updateExits a command would,
-     *  and let the _lastMapPaint/_lastRoomPaint diff (not a second
-     *  change-detector) decide whether anything actually redraws. */
-    private _mapHeartbeatTimer?;
-    private static readonly MAP_HEARTBEAT_MS;
-    private _useAi;
-    private _aiRefusalAnnounced;
-    private _owner?;
-    private _anonymous;
-    private _bench;
-    private _reproItemId?;
-    private _closing;
-    private _logFilePath;
-    private _tier;
-    /**
-     * 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(): number;
-    set tier(value: number);
-    private _draftInProgress;
-    private _hubScene?;
-    private _hubName;
-    get hasHub(): boolean;
-    /**
-     * This play session's own directory -- the timestamped folder holding
-     * game.log, session.log, launch.json and any scenes drafted during
-     * the run. Derived from the log path the same way SceneSeedGenerator
-     * derives it (dirname), so everything a session produces lands
-     * together. undefined for harnesses and headless clients, which run
-     * with no log path at all -- callers must have a fallback.
-     */
-    /** Verbs that must run on the player's OWN machine even mid-shared-run:
-     *  they write local files or read local state, and mean nothing to the
-     *  table. See the guard in handleInput. */
-    private static readonly LOCAL_ONLY_VERBS;
-    /** The same rule at PHRASE level, for a local-only setting that hangs
-     *  off a verb which must stay remote. "map" reads the live scene and
-     *  belongs to the server in a shared run; "map overlay" only flips a
-     *  preference in ~/.meteor/.maka/global-config.json and belongs here.
-     *  Found 2026-08-27 -- this and `hints` were the last two instances of
-     *  the `note` bug fixed in v5.57.0: mid-shared-run they crossed the
-     *  wire, wrote the SERVER's config file, and the player's own toggle
-     *  silently did nothing. */
-    private static readonly LOCAL_ONLY_PHRASES;
-    /** An account-less runner: nothing about them leaves this machine.
-     *  Read by anything that would otherwise push to maka-cli.com -- the
-     *  backlog command among them. */
-    get isAnonymous(): boolean;
-    /**
-     * A REPRO BENCH: a scratch session stood up to reproduce one backlog
-     * item. Not a life -- no save, no street presence, no shared table.
-     *
-     * SEPARATE FROM `isAnonymous`, and the separation is the point. The
-     * bench first reused the anonymous flag, since both want the street
-     * left alone -- and that quietly took the BACKLOG with it, because
-     * anonymity is a promise about a RUNNER ("nothing about them leaves
-     * this machine") and the backlog is one of the things it forbids. So
-     * a play-tester standing in the bench built for their own report was
-     * refused when they tried to answer it, which is the one thing the
-     * bench exists for.
-     *
-     * Two different concerns wearing one flag: "this character is
-     * private" and "this session is scratch". A bench is not private --
-     * it is the opposite, a place to file and confirm from.
-     */
-    get isBench(): boolean;
-    /** The backlog item this bench was stood up for, if any.
-     *
-     *  The review commands read it so an answer needs no index. Player
-     *  ruling 2026-08-28: "I shouldn't have to pick from the list of
-     *  review items -- I AM reviewing an item." Making someone name which
-     *  report they mean, while they are standing in the scene built for
-     *  that report, is asking a question the session already answered. */
-    get reproItemId(): string | undefined;
-    /**
-     * CLOSE THE SESSION SHORTLY, leaving the last message on screen.
-     *
-     * For a bench that has just been answered (player request 2026-08-28:
-     * "after accepting or rejecting, give a 3s timeout and then close the
-     * session"). The pause is the point -- exiting the instant the post
-     * lands would wipe the confirmation before it could be read, and the
-     * confirmation is the only proof the answer went anywhere.
-     *
-     * Exits code 0, which is the same door `quit` goes through: the save
-     * seal in ui.ts fires (a no-op for a bench, which has no save path)
-     * and the launcher parent, which is the terminal's guaranteed
-     * janitor, restores the terminal exactly as it would after any other
-     * exit. No second teardown path.
-     *
-     * Idempotent: the first request wins, so answering twice in three
-     * seconds cannot stack timers.
-     */
-    closeAfter(ms: number, reason: string): void;
-    get sessionDir(): string | undefined;
-    /** The active job's name (seed name) -- notoriety incidents cite it. */
-    get currentJobName(): string | undefined;
-    contacts: Map<string, {
-        connection: number;
-        loyalty: number;
-        spent: number;
-        gigs: number;
-        asked: boolean;
-        role?: string;
-        note?: string;
-    }>;
-    pendingProcurements: {
-        contact: string;
-        itemConfig: ISavedItem;
-        price: number;
-    }[];
-    docwagon?: IDocwagonContract;
-    crew: ICrewMember[];
-    commandRefusals: Record<string, number>;
-    enlistedAlly?: {
-        name: string;
-        description: string;
-        combat: Record<string, unknown>;
-    };
-    /** 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 LIVE party's identity, as a comparable string -- which real
-     *  players hold seats at this table right now. Used to detect a party
-     *  that changed while a job was mid-generation (see draftNextScene). */
-    livePartyFingerprint(): string;
-    /** The crew-change rule (player ruling): any roster change voids the
-     *  standing quote. The SERVER draft survives (keepServerDraft) -- if
-     *  the same table re-forms, the next call gets the same job back.
-     *  Returns the line to show, or ''. */
-    scrapPendingRunForCrewChange(): string;
-    performedThisCycle: boolean;
-    private _runHeat;
-    private static readonly CHECKPOINT_HEAT;
-    private _camSeenRooms;
-    camPingedRooms: Set<string>;
-    sweptRooms: Set<string>;
-    venueBans: Set<string>;
-    /** The district is already on alert -- sweeps come more often. */
-    get runHeatIsHot(): boolean;
-    /** On a run (not the hub, not a classic hubless scene) -- the state
-     *  where heat, cameras, and the ride home all exist. */
-    get onRun(): boolean;
-    /** Bill the district's attention. No-op at the hub or in classic
-     *  (hubless) scenes -- only runs have a ride home to be caught on.
-     *  On CAMERA (surveillance.ts), the bill DOUBLES -- footage travels. */
-    addHeat(amount: number, why: string): void;
-    /** The HUD's read on the district (bands, never the number). */
-    private heatBand;
-    crewForHire: ICrewMember[];
-    private _presenceTimer?;
-    private static readonly PRESENCE_TICK_MS;
-    private presencePayload;
-    /** Equipment changed at the hub: the street should see the link state
-     *  NOW, not at the next 60s beat (debounced -- take/equip bursts). */
-    private _presenceEquipTimer?;
-    private notePresenceAffectingChange;
-    /**
-     * Does this runner hold a LIVE SEAT right now -- riding at someone's
-     * table, or leading one that a real player sits at? Both sides are
-     * already tracked synchronously (HubLink.syncRiding fills ridingWith;
-     * the leader's live seats are liveOnly crew), so this needs no new
-     * state and no await.
-     */
-    holdsLiveSeat(): boolean;
-    private beatPresence;
-    /**
-     * An IMMEDIATE presence beat that reports how it went -- the answer
-     * to "why can't my friend see me": the regular heartbeat is silent
-     * and up to 60s behind, so "crew players" and the hireable toggle
-     * push one right now and say so.
-     */
-    pushPresenceNow(): Promise<'ok' | 'logged-out' | 'offline'>;
-    startPresenceHeartbeat(): 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;
-    /**
-     * The band answers (SR5e p.450). 'htr': a High Threat Response team
-     * extracts a flatlining KO'd runner instead of the street deciding.
-     * 'resusc': clinical death reversed -- a free resuscitation or the
-     * 5,000 fee -- the sanctioned carve-out to permadeath (player ruling;
-     * overflow-past-Body instant death isn't modeled yet, so every death
-     * is currently within reach of the crash cart). Returns true when the
-     * rescue engages -- the caller must then NOT end the game.
-     */
-    tryDocwagonRescue(kind: 'htr' | 'resusc', opts?: {
-        standingHostiles?: string[];
-    }): boolean;
-    /** Each human player's contract, loaded from their own save doc by
-     *  the headless boot (their `save.game.docwagon`). Solo play never
-     *  touches this map -- the legacy single-contract path above is the
-     *  solo behavior, byte for byte. */
-    docwagonByPlayer: Map<string, IDocwagonContract>;
-    /** The cloud burn started by close(), awaited briefly so the death
-     *  screen can show the server-stamped time. */
-    private _burnInFlight?;
-    /** Shared-run hook: a player's HTR extraction (stabilized and carried
-     *  off the job). The hosting server writes their snapshot back and
-     *  marks them 'left'. */
-    onPlayerExtracted?: (player: Player) => void;
-    /**
-     * Shared-run hook: THE SCENE UNDERNEATH EVERYONE JUST CHANGED.
-     *
-     * `repaintForScene` is how this Game tells its own UI that the world
-     * moved. On a hosted table there IS no UI here -- `_mapBox` is
-     * undefined on the server, so `updateExits` (and with it both map
-     * panels) is a NO-OP, measured rather than assumed: a real headless
-     * boot emits map/room/status 1,1,1 and calling updateExits +
-     * updateStatus by hand leaves it at 1,1,1, while one `command` takes
-     * it to 2,2,2.
-     *
-     * So every rider's panels move only when headless.ts's pushMap /
-     * pushStatus run, and those run from `command`, `addPlayer` and boot
-     * -- nowhere else. A scene swap that does not happen inside somebody's
-     * command therefore changes the server's truth and sends NOTHING, and
-     * `draftNextSceneInBackground` is exactly that shape: fire-and-forget
-     * over 20-40 seconds, long after the command that started it returned
-     * and pushed the OLD scene.
-     *
-     * This hook is the missing wire, same shape as onPlayerDeath /
-     * onPlayerExtracted above and installed in the same place.
-     *
-     * HARDENING, NOT A BUG FIX. The inert joint is proven; the swap
-     * arriving outside a command is READ IN THE SOURCE AND NOT EXECUTED
-     * (continueToNextScene is gated on job completion, so the harness
-     * cannot drive it end to end). Nothing here is offered as the cause of
-     * a live report.
-     */
-    onSceneChanged?: () => void;
-    /**
-     * The per-player band (shared runs -- scene.players.length > 1):
-     * resolves the FALLEN player's own contract, bills THAT player
-     * (whatever their stick holds; a guest's shortfall is DocWagon's
-     * collections problem, not the rent tab's), and either stabilizes
-     * them in place ('resusc') or extracts them from the session ('htr'
-     * -- the member-leave flow, via onPlayerExtracted). Returns true when
-     * the rescue engages -- the caller must then NOT kill them.
-     */
-    tryDocwagonRescueFor(player: Player, kind: 'htr' | 'resusc', opts?: {
-        standingHostiles?: string[];
-    }): boolean;
-    /** Where the wagon drops you (player ruling: the CLINIC, not your own
-     *  cot): the district Street Doc's room, generically -- so generated
-     *  hubs work too. Falls back to the hideout if the hub has no doc. */
-    private docwagonDropOff;
-    /** The ride out on a stretcher: mid-run this is a homecoming (rent and
-     *  all), then the recovery bed at the clinic. */
-    private docwagonMedevac;
-    /** How much juice the name carries, read off the role. */
-    /**
-     * A contact's ROLE, the SR5e archetype list (p.98: fixer, arms dealer,
-     * smuggler, talismonger, street doc, mechanic, bartender...) -- same
-     * keyword school as connectionFor below. Stored on the contact entry
-     * at open time so the roster (and the save) carry it.
-     */
-    static roleOf(npc: {
-        name: string;
-        description?: string;
-    }): string;
-    static connectionFor(npc: {
-        name: string;
-        description?: string;
-    }): number;
-    /**
-     * HOME TURF: the hub is where the runner LIVES -- everyone in the
-     * district already knows them (player request: "all NPCs there should
-     * already know them"). Called at hub capture: the whole meat-plane
-     * cast opens at Loyalty 1 ("knows your name"), so legwork works from
-     * day one and only run-scene faces are ever strangers. Depth is still
-     * earned -- trade, gigs, patronage -- exactly as before. Ice and
-     * spirits don't do noodles: non-meat actors stay off the roster.
-     */
-    private seedHomeTurfContacts;
-    /**
-     * EPHEMERAL BODIES, and the reason this is a plain Map on the Game and
-     * not part of the save shape (7ALf6u7PvTg6TZSm7): ephemeral means
-     * ephemeral. Nothing here is ever written to a save file, so nothing
-     * here has to be reconciled on load -- see utilities/ephemeral.ts's
-     * despawnEphemerals for why the obvious mid-fight-save worry is
-     * already answered upstream.
-     */
-    ephemerals: import('./utilities/ephemeral.js').EphemeralRegistry;
-    /**
-     * Every ephemeral name this session has ever issued. Session-only like
-     * the registry above, but CUMULATIVE where that one is a census -- see
-     * IEphemeralHost.spentNames for why a name outliving its body is the
-     * whole point.
-     */
-    spentNames: Set<string>;
-    /** Corners that have already had their encounter -- once each, and
-     *  never saved, on the same session-only model as sweptRooms. */
-    gangedRooms: Set<string>;
-    /** Places already populated with texture -- once each, never saved. */
-    peopledRooms: Set<string>;
-    companions: {
-        npc: NPC;
-        kind: CompanionKind;
-        services?: number;
-        force: number;
-        boundDevice?: Item;
-        /** Sprites only: which SPRITE_TYPES entry built the shell -- needed
-         *  to re-shell a REGISTERED sprite after travel or a resume. */
-        spriteType?: string;
-        /** REGISTERED (commands/register.ts): the sprite persists -- it
-         *  survives travel and rides the save file. */
-        registered?: boolean;
-    }[];
-    /** 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;
-    private _resume?;
-    private _hubSeed?;
-    /**
-     * The one correct runtime NPC spawn (mirrors scene-factory's seed
-     * path): construct with a scene-bound registry, add to the scene
-     * (names must be unique -- addActor throws), place via
-     * 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(): NPC | undefined;
-    private _remoteFixer?;
-    /**
-     * The live-sheet read of everything this runner has out (contract
-     * 2026-09-02): the ledger's companions plus the drone they are jumped
-     * into. `where` is the room, or the host/grid for a construct;
-     * `damage` is the thing's OWN track -- a drone's hull, an agent's deck
-     * (shared monitor, p.246), a spirit's or sprite's shell.
-     */
-    companionsForBeat(player: Player): {
-        name: string;
-        kind: string;
-        deployed: boolean;
-        where?: string;
-        line?: string;
-        damage?: {
-            taken: number;
-            max: number;
-        };
-    }[];
-    spawnCompanionShell(opts: {
-        name: string;
-        description: string;
-        kind: CompanionKind;
-        combat: Partial<import('./models/player.js').ICombatAttributes>;
-        room: Room;
-        plane: 'meat' | 'matrix' | 'astral';
-        force: number;
-        services?: number;
-        boundDevice?: Item;
-    }): NPC | null;
-    /**
-     * The autonomous-drone shell, shared by the deploy command and
-     * arrival re-shelling: the frame's dog-brain (Pilot = 2 + quality)
-     * stands in for every attribute it lacks (RAW p.269-271).
-     */
-    private static readonly DRONE_CARGO_KG;
-    deployDroneShell(item: Item, room: Room): NPC | null;
-    /** Drops a companion's shell and its roster entry. */
-    dismissCompanion(entry: (typeof this.companions)[number], reason: string): void;
-    /**
-     * A FORM A SPRITE WAS CARRYING COMES HOME WHEN THE SPRITE GOES
-     * (SR5 p.256 Sustain Complex Form; see commands/sustain.ts).
-     *
-     * The task hands a technomancer's complex form to a registered sprite
-     * so the SPRITE eats the -2. That means the only entry point in the
-     * game that moves a form off its weaver is also the only one that
-     * could destroy it: dismiss, kill or park the sprite and the form
-     * would go into the Resonance with it, silently, looking exactly like
-     * a form the player had dropped on purpose.
-     *
-     * Canon says the technomancer "can then take over sustaining again",
-     * so taking over is the natural end of the arrangement -- and a sprite
-     * leaving is the arrangement ending whether or not anybody typed the
-     * verb. The weave was never the sprite's; it was only being carried.
-     *
-     * Called from BOTH teardown paths on purpose. dismissCompanion covers
-     * dismissal and standby (standbySpriteToResonance dismisses to park),
-     * onActorRemoved covers death. Either alone would leave a hole that
-     * only shows up as a missing form several minutes later.
-     */
-    private returnSustainedForms;
-    /**
-     * An actor left the world (Scene.removeActor). For a companion shell
-     * that DIED (not a deliberate dismissal -- those set deathClaimed
-     * first and prune themselves), settle the wreckage: a drone's frame is
-     * wrecked where it fell, an agent derezzes (the deck already ate the
-     * damage), a spirit is banished outright.
-     */
-    onActorRemoved(name: string): void;
-    /**
-     * Spirits with no services left depart once no exchange holds them
-     * (called from CombatExchange.finishExchange): the bargain is spent.
-     */
-    settleSpiritServices(): void;
-    private _pursuitTimer?;
-    private readonly _pursuitInFlight;
-    private static readonly PURSUIT_TICK_MS;
-    private startPursuitHeartbeat;
-    stopPursuitHeartbeat(): void;
-    spurCompanionPursuits(): void;
-    /** Pre-travel: every shell folds, each with its own goodbye. */
-    foldCompanionsForTravel(): string[];
-    /** Post-arrival: re-shell what was deployed when you left (drones). */
-    unfoldCompanionsOnArrival(): string[];
-    /** 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: 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
-     * by seedHomeTurfContacts); gigs raise it a point each (cap 6);
-     * cumulative spend raises it at each full 1,000 nuyen (cap 3).
-     * Returns a player-facing line when something changed, else null.
-     */
-    /** A hub-cast member by name, for roster displays that need the live
-     *  actor (contacts.ts reads their commlink to show reachability).
-     *  ROOM GRIDS wave (2026-08-25): falls back to the CURRENT run scene
-     *  so a live client (not yet a hub contact -- see onClientInteraction)
-     *  resolves too; call.ts already reaches them the same way. */
-    hubActor(name: string): Player | NPC | undefined;
-    /** The whole hub cast -- call.ts merges these into its candidates so
-     *  a linked contact answers from ANYWHERE (a real mid-run session:
-     *  "call Ratchet" bounced with "you don't know anyone by that name"
-     *  while the roster promised 📞). The hub Scene instance survives
-     *  runs, so these are live actors, not ghosts. */
-    hubCast(): (Player | NPC)[];
-    touchContact(name: string, kind: 'trade' | 'gig', spent?: number): string | null;
-    pendingSale?: {
-        itemName: string;
-        price: number;
-        fence: string;
-        haggled: boolean;
-    };
-    lifestyleTier: string;
-    /**
-     * LIFESTYLE OPTIONS (SR5 p.370, 2026-09-05): riders on the tier, by
-     * canonical key -- today only 'garage', the Special Work Area that
-     * parks a rigger's frames (utilities/commerce.ts LIFESTYLE_OPTIONS).
-     * Barred on Street; a slide to Street drops them (returnToHub).
-     */
-    lifestyleOptions: string[];
-    /** The Big Ten grid a High lifestyle rides (SR5 p.222). A placeholder default until chargen offers the pick (grids.ts). */
-    gridProvider: string;
-    rentDebt: number;
-    /** The active lifestyle tier's row (falls back to Squatter). */
-    get lifestyle(): ILifestyleTier;
-    hasLifestyleOption(key: string): boolean;
-    /** What the homecoming collects: the tier's share plus every option's. */
-    get lifestyleUpkeep(): number;
-    /**
-     * Drop every option the current tier bars (p.370: none on Street).
-     * Returns the keys dropped, so the caller can say the lease lapsed.
-     */
-    dropBarredLifestyleOptions(): string[];
-    /**
-     * Makes the hideout LOOK like what the rent buys: the room's description
-     * follows the active tier (player request -- an upgraded lifestyle read
-     * as the same windowless squat). Called wherever the tier moves: the
-     * lifestyle command, and the shortfall slide in returnToHub.
-     *
-     * THE GARAGE FOLLOWS THE OPTION (2026-09-05): the bay exists exactly
-     * while the lifestyle carries 'garage'. Reconciling here, on the same
-     * call every tier move already makes, is what keeps the furniture and
-     * the lease from disagreeing. Returns the names of any frames a lapsed
-     * lease spilled onto the floor, for the caller to mention.
-     */
-    syncHomeToLifestyle(): string[];
-    private static readonly RESTOCK_CATEGORIES;
-    private _restockSnapshot;
-    /** Captures every restockable shelf item's blueprint (hub capture time). */
-    private snapshotVendorStock;
-    /** Refills empty shelves from the snapshot; returns how many came back. */
-    private restockVendorShelves;
-    /** The fence moves merchandise: anything sold to a fence is sold ON. */
-    private fenceSellsOn;
-    gigAvailable?: {
-        from: string;
-        to: string;
-        itemName: string;
-        itemDescription: string;
-        pay: number;
-        brief: string;
-    };
-    activeGig?: {
-        from: string;
-        to: string;
-        itemName: string;
-        pay: number;
-    };
-    private _gigPool;
-    private _gigIndex;
-    /** Rotates the gig on offer (skipped while one is already in hand). */
-    private advanceGig;
-    /**
-     * WORK FROM A RELATIONSHIP (see commands/ask.ts): a contact puts THEIR
-     * errand on the table. Their seeded gigs get first claim -- spliced
-     * out of the rotating pool, so work handed to you personally never
-     * reappears on the ambient board -- and when the pool holds nothing of
-     * theirs, the relationship synthesizes one: a sealed parcel to another
-     * hub local, priced off Connection (their reach IS the stakes) with a
-     * Loyalty kicker. Loyalty 5+ pays the family rate (+25%). The offer
-     * lands as gigAvailable: the existing "work" pickup and "give"
-     * delivery handle the rest unchanged.
-     */
-    offerGigFrom(contactName: string): {
-        from: string;
-        to: string;
-        itemName: string;
-        itemDescription: string;
-        pay: number;
-        brief: string;
-        familyRate: boolean;
-    } | null;
-    fencedCategories: Set<string>;
-    private _rumorPool;
-    private _rumorIndex;
-    activeRumor?: string;
-    /** Rotates to the next rumor and plants it where NPCs will hear it. */
-    private advanceRumor;
-    /** The persistent hideout room -- go.ts's walk-home trigger checks it. */
-    get homeRoom(): Room | undefined;
-    private _pendingRunSeed?;
-    private _pendingRunTier?;
-    pendingRunAccepted: boolean;
-    /**
-     * The words the player ACTUALLY said, when speech routed itself to
-     * `accept` (commands/say.ts). It rides into the fixer's signoff note
-     * so his closing line answers what was said -- say.ts deliberately
-     * does not also speak it, and hear() is the only thing that writes
-     * his memory, so without this the deal would be struck with no
-     * record that the runner opened their mouth. Consumed by
-     * AcceptCommand: read once, cleared immediately.
-     */
-    spokenAcceptance?: string;
-    /**
-     * A SHARED run on offer (Phase C M4): the job was drafted on the
-     * SERVER for a live party -- the local pendingRun holds only Krow's
-     * pitch stub (name/story/client/ballpark), never the seed, and the
-     * taxi starts the remote session instead of activating a scene.
-     */
-    pendingSharedRun?: {
-        sessionID: string;
-        party?: string[];
-    };
-    /** Tables I SIT AT as an accepted member (leader runner names),
-     *  kept in sync by shared-run's seat stream. Crew exclusivity
-     *  (ruling 2026-08-24): riding a table means no solo quotes. */
-    ridingWith: string[];
-    /** One-shot: the jobs board's "take <n>" names WHICH standing draft
-     *  the next Krow call should pull (2026-08-24 playtest: reuse always
-     *  returned the newest match, ignoring the pick). Consumed by
-     *  draftNextScene's shared path. */
-    preferredDraftSessionID?: string;
-    /**
-     * A live shared run: every typed command delegates here (handleInput)
-     * and the panes render the server's event stream. Set/cleared by
-     * utilities/shared-run.ts.
-     */
-    remoteSession?: {
-        command(input: string): Promise<string | null>;
-        readonly id?: string;
-    };
-    /**
-     * THE STREET TRANSPORT (M4.5.1): how this engine reaches real players
-     * OUTSIDE the scene -- the crew-channel page rails behind call.ts and
-     * say.ts. Unset on the CLI (streetTransport() lazily wires the
-     * HubLink/REST default -- those modules must never enter the server's
-     * import graph); the server session-manager sets both hooks to talk
-     * to GameSocialPresence/GamePlayerPages directly, so paging works
-     * from inside a shared run too. `from` names the SENDING actor --
-     * multi-human server scenes resolve it to the right account.
-     */
-    listStreetPlayers?: (from: string) => Promise<{
-        playerName: string;
-        handle: string;
-    }[]>;
-    sendPage?: (opts: {
-        from: string;
-        handle: string;
-        text: string;
-    }) => Promise<{
-        online: boolean;
-        toRunner: string;
-    }>;
-    /** The transport, hooks-first, CLI default second; undefined =
-     *  offline/logged out/classic mode (callers degrade quietly). */
-    streetTransport(): Promise<{
-        list: (from: string) => Promise<{
-            playerName: string;
-            handle: string;
-        }[]>;
-        send: (opts: {
-            from: string;
-            handle: string;
-            text: string;
-        }) => Promise<{
-            online: boolean;
-            toRunner: string;
-        }>;
-    } | undefined>;
-    /**
-     * Hang up a player call from THIS side and TELL THE OTHER SIDE
-     * (player ruling: "the hang up should happen to everyone") -- the
-     * END_CALL_SENTINEL rides the pages rail fire-and-forget, so the
-     * remote client (or their next session, via backlog) closes its
-     * channel too. Returns the far runner's name, or undefined when no
-     * channel was open. Every path that closes a crewChannel goes
-     * through here so the remote side is never left holding a dead line.
-     */
-    hangUpCrewChannel(player: Player): string | undefined;
-    /** Trash the offer wholesale ("decline", and any future fixer snub).
-     *  keepServerDraft (crew-change scraps, player ruling 2026-08-24):
-     *  the LOCAL quote dies but the server-side draft stays standing --
-     *  createSession is fingerprint-keyed, so the same party re-forming
-     *  gets the same job back instead of paying for a regeneration. An
-     *  explicit DECLINE never passes it: a rejected job stays rejected. */
-    clearPendingRun(opts?: {
-        keepServerDraft?: boolean;
-    }): void;
-    /**
-     * EVERYTHING THAT BELONGS TO AN OFFER, RESET TOGETHER
-     * (8jZMqtXmxbLiACo3E: "I haven't pushed the number yet").
-     *
-     * An offer carries its own haggle window at the hub -- "call <fixer>"
-     * delivers it and `haggle` works on the spot. Push on one, decline
-     * it, hear the NEXT one, and nothing cleared the flag: not
-     * refreshEdge (departure only, and no ride was called), not
-     * returnToHub (no run to come home from). The first push on the new
-     * offer was then refused with "you already pushed on the number once
-     * this job" -- about a job the runner had turned down.
-     *
-     * THE THIRD HOLE IN ONE BOOLEAN, which is why this is a method and
-     * not another line at a call site. `haggledThisJob` had already been
-     * patched twice, each time for its own report and each time at the
-     * one site that report happened to name: returnToHub for
-     * d4yoYPcRAtWpLtm9y, the headless boot for the shared-run arrival.
-     * There are TWO places a fresh offer is installed -- the solo draft
-     * and the shared-run quote -- and both had the same gap, so a third
-     * per-site patch would have fixed one and left the other reporting
-     * the same sentence.
-     *
-     * NOT called from restoreFromSave, deliberately: a resumed pendingRun
-     * is the SAME offer, and clearing there would forget a push the
-     * runner really did make before they quit.
-     */
-    private resetForNewOffer;
-    get pendingRun(): ISceneSeedJson | undefined;
-    get pendingRunTier(): number | undefined;
-    currentClient?: {
-        name: string;
-        met: boolean;
-        reported: boolean;
-        dead?: boolean;
-    };
-    /**
-     * 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?: 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).
-     * Returns the beat's text or null when this NPC isn't the client /
-     * nothing new happens. LUMP SUM (player ruling 2026-08-25, replacing
-     * canon p.28's half-up-front: the advance beat kept misfiring in
-     * play): the meet sets the terms, the wrap-up pays the WHOLE number.
-     * Completing the objective before ever meeting them still collapses
-     * cleanly -- the wrap-up is the only beat that moves money.
-     */
-    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
-     * arrival and the ride read as ONE vehicle.
-     */
-    private static readonly RIDE_POOL;
-    private _pendingRide?;
-    /** The pending job's cab flavor -- "call taxi" narrates with it (see call.ts). */
-    get pendingRide(): {
-        arrive: string;
-        board: string;
-    } | undefined;
-    /**
-     * Generates NPC first-impression appearances ("look at <npc>") in the
-     * background, one at a time -- the only AI dressing still worth doing
-     * now that every scene arrives with real prose. Fire-and-forget: until
-     * an appearance lands, look-at just shows a bit less flavor.
-     */
-    private warmNpcAppearancesInBackground;
-    private _homeRoom;
-    /** The hub room a resume seated the player in, when it was not home. */
-    private _resumedAt?;
-    private _homeRoomExitDirection?;
-    private static readonly HOME_DIRECTION_PRIORITY;
-    constructor(player: Player, sceneSeed: ISceneSeedJson);
-    private registerCommands;
-    private determineStartRoom;
-    /**
-     * WHERE THE RUNNER IS STANDING, when the seed says.
-     *
-     * `startSpot` has been declared on player-seed.ts all along and
-     * nothing read it FOR THE PLAYER -- NPCs get theirs applied inside
-     * scene-factory, the runner got nothing. So spotOf() returned
-     * undefined for the one actor a person controls, and every
-     * SPOT-RELATIVE mechanic quietly did not apply to them: move.ts
-     * derives climbSteps from the actor's spot, so with none there is no
-     * path, no climb link and no climbing test at all. A repro bench with
-     * a catwalk walked you up it with no roll.
-     *
-     * APPLIED AFTER THE PLACEMENT, and the precise reason is worth
-     * stating because I first wrote it down wrong. The currentLocation
-     * setter clears atSpot only when the room actually CHANGES
-     * (`if (this._currentLocation !== room)`). On a fresh boot the player
-     * is already in the start room, so either order would work there --
-     * a reordering mutation stays green, and I am saying so rather than
-     * letting the comment claim a guarantee its test does not give.
-     *
-     * It matters on the TRAVEL path below, where the runner really does
-     * move from the hub into a new scene and the setter really does fire.
-     * Applying after placement is correct in both cases, which is why it
-     * is the order used in both -- resumeOpenRun documents the same
-     * ordering for the same reason.
-     *
-     * What IS covered by a red-on-removal test is the call existing at
-     * all: nothing read this field before.
-     *
-     * REFUSES A SPOT THE ROOM DOES NOT HAVE rather than setting a name
-     * nothing answers to: an atSpot with no cell behind it is the
-     * silently-inert state this codebase keeps finding, and the runner
-     * standing nowhere is strictly better than the runner standing
-     * somewhere imaginary.
-     *
-     * No shipped scene sets it -- scene1 and scene2 both leave it
-     * undefined -- so this changes nothing that exists today.
-     */
-    private applySeedStartSpot;
-    /**
-     * Wires a fresh, always-unlocked path between the persistent home base
-     * and wherever the player is starting the current job from. Clears the
-     * previous job's connection first (if any) so the home base never keeps
-     * a stale door into an abandoned scene's now-orphaned rooms -- only ever
-     * one way out at a time, pointing at whichever job is actually current.
-     */
-    private connectHomeRoom;
-    get logBox(): blessed.Widgets.BoxElement;
-    get metaBox(): blessed.Widgets.BoxElement;
-    get inputBox(): blessed.Widgets.TextboxElement;
-    get statusBox(): blessed.Widgets.BoxElement;
-    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>;
-    /**
-     * WHERE YOU LOGGED OUT IS WHERE YOU LOG IN (player request 2026-09-02:
-     * "a player that logs in, logs back in at the server location"). The
-     * save carries the hub room and named spot (types/save-file.ts
-     * ISavedLocation); every hub room change writes a "move" beat, and
-     * quit writes the exact spot. On resume the player is seated there
-     * when the room still exists in the synthesized hub -- a save from a
-     * hub whose seed dropped the room wakes at home, logged, as before.
-     * The cell is not carried: a reload seats you on the spot's own seat.
-     */
-    private restoreHubLocation;
-    /** The location a save carries: the current hub room and spot. */
-    /** Each host's seeded grid word ('public' | 'local' | 'global:<corp>') against this scene's local grid. */
-    private resolveHostGrids;
-    private hubLocationSnapshot;
-    /**
-     * Everything a save restores beyond the seed synthesis: the player,
-     * the hub world overlay, and the Game-level ledgers. Ordering inside
-     * matters less than its POSITION in init(): after seedHomeTurfContacts
-     * and snapshotVendorStock (both deliberately pre-overlay).
-     */
-    /**
-     * THE LIFESTYLE THE SAVE PAID FOR, applied -- for EVERY save, a birth
-     * certificate included (2026-09-05). This used to sit below the
-     * `creation` early return in applyResumeState, so a web-born runner who
-     * had paid a first month of High booted at the Squatter default, and
-     * the first hub-arrival save then serialised that Squatter and buried
-     * the tier for good. The lifestyle is Game-owned, not seed-owned; there
-     * is no "world" it waits on.
-     *
-     * CANONICAL ON RESTORE (2026-09-01): the web factory once wrote a
-     * lowercase 'street' that matched no LIFESTYLE_TIERS name, and this
-     * line handed it to a getter that fell through to Squatter -- then
-     * the next save SERIALIZED that Squatter, local and cloud, burying
-     * any server-side repair. Canonicalizing here closes the fall-through
-     * for every save that still carries the old spelling: 'street' means
-     * Street, the factory's intent. (It cannot restore a PAID tier the
-     * local file never knew -- that is the cloud repair's job, and the
-     * sync protocol's, see the repair-visibility ruling in cloud-saves.)
-     */
-    private applyLifestyleFromSave;
-    private applyResumeState;
-    /**
-     * IS THIS RUNNER'S LIFE THE SERVER'S? (server-only storage.)
-     *
-     * A bound runner has an account behind them; an anonymous one never
-     * leaves this machine, and a bench is a scratch session with nothing
-     * worth keeping. Every new branch in the save path gates on this, so
-     * the anonymous route is the code that was already here -- which is
-     * what the unmodified tripwire suites prove.
-     */
-    private get boundRunner();
-    /** Where this runner's crash journal lives, when they are bound. */
-    private get spillPath();
-    /**
-     * THE single save routine -- every safe beat funnels here. Guards make
-     * it a silent no-op anywhere a save would lie: mid-run (the "runs are
-     * disposable" ruling lives in the scene === _hubScene check), downed
-     * or KO'd, mid-exchange, dead, or before init finishes.
-     *
-     * SYNCHRONOUS BY DESIGN, AND FOR TWO DIFFERENT REASONS NOW. It always
-     * had to be, because `process.on('exit')` can run nothing
-     * asynchronous. For a BOUND runner that same constraint is what makes
-     * the spill the durability guarantee rather than the push: the beat
-     * writes `<slug>.spill` synchronously and returns, and the upload
-     * happens behind it on a queue that may never get the chance to
-     * finish. Nothing here awaits the grid, ever -- a save beat that could
-     * block on a network is a turn that can hang.
-     *
-     * PR1 KEEPS WRITING `<slug>.json` FOR BOUND RUNNERS TOO. That is
-     * deliberate and temporary: this PR is a superset of today's
-     * behaviour, so reverting it strands no data and loses no character.
-     * PR2 is where the bound branch stops writing the local slot, once
-     * the server contract is deployed and the launcher can source the menu
-     * from it.
-     */
-    requestSave(reason: SaveReason): void;
-    /**
-     * SEAL A BOUND RUNNER TO THE GRID -- the awaited counterpart of
-     * requestSave, for the two beats where "eventually" is a bug.
-     *
-     *   QUIT: nothing runs after this process. An unpushed beat is not
-     *   "late", it is gone until the next launch sweeps the spill -- and
-     *   the player was told their game was saved.
-     *
-     *   JOB ACCEPT: the shared run loads this character FROM THE SERVER.
-     *   An unpushed beat means the table plays a stale snapshot of them,
-     *   which is a real bug today (the unawaited push before shared runs)
-     *   and closes here for free.
-     *
-     * Returns true when the server has the newest save. FALSE IS NOT A
-     * FAILURE PATH -- it means the spill stands and the next launch
-     * uploads it, which is ruling 2 working exactly as designed. Callers
-     * report, they do not block the player.
-     *
-     * Anonymous and bench runners return true immediately: they have
-     * nothing to seal and must never be made to wait on a network.
-     */
-    flushBoundSave(reason: SaveReason): Promise<boolean>;
-    private buildSaveFile;
-    /**
-     * Synchronous readiness check for continueToNextScene() -- lets callers
-     * give instant feedback for the "not ready yet" cases (job not done, no
-     * AI configured) without waiting on anything async.
-     */
-    canDraftNextScene(): {
-        allowed: boolean;
-        message?: string;
-    };
-    /**
-     * Fires continueToNextScene() without waiting on it -- job generation can
-     * take 20-40+ seconds, and neither "continue" nor calling the fixer
-     * should freeze the rest of the session behind that. Self-announces the
-     * result once it resolves, styled the same as any other comms exchange,
-     * since by design nothing else is holding a reference to display it.
-     * Public: called directly by call.ts when the player calls the fixer
-     * after a job's done, not just from "continue" here in game.ts.
-     */
-    /**
-     * `runType` forces the KIND of job drafted. Omitted, the generator
-     * rolls it as it always has (pickRunType: deck-gated, 30% data) --
-     * this parameter exists so a player who ASKS for data work gets data
-     * work (ruoedrMTA6kCRNmEN), and it changes nothing for every other
-     * caller, of which there are three.
-     */
-    draftNextSceneInBackground(runType?: RunType): void;
-    /**
-     * Drafts and loads the next job once the current scene's win condition
-     * has been met. Reuses the same long-lived Player (and its inventory),
-     * so gear compounds across the session -- nothing is persisted to disk,
-     * it just carries forward for the life of this process. Re-checks
-     * canDraftNextScene() itself (callers are expected to check it first for
-     * instant feedback, but this stays safe to call directly too).
-     */
-    continueToNextScene(runType?: RunType): Promise<string>;
-    /**
-     * Re-points the world at the preserved hub scene after a run: the hub's
-     * whole state (NPCs, shop stock, anything dropped there) survived
-     * untouched because the INSTANCE survived. The player walks back in
-     * through their own hideout, firmly in the meat -- any lingering run
-     * 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. */
-    /**
-     * REPAINT EVERYTHING FOR THE SCENE YOU ARE NOW STANDING IN.
-     *
-     * These same four calls, in this same order, were written out three
-     * times -- here (as refreshHubUi), at the end of returnToHub, and at
-     * the end of activateRunScene. Three copies of one rule is how a
-     * fourth arrival gets two of them and reads as done, and it is the
-     * shape that has already cost this file twice.
-     *
-     * Public because a shared run's homecoming has to reach it: the ride
-     * home used to repaint the STATUS box alone, so a runner arrived back
-     * at the hub with the RUN's map still drawn beside the log -- the
-     * exact mirror of the hub's map surviving into a run, which is the bug
-     * blankRunPanels was added to end (575fc700). One boundary, repainted
-     * in one direction only, is a half-swept family.
-     *
-     * ORDER IS LOAD-BEARING at the shared-run call sites: updateExits
-     * early-returns while `remoteSession` is set, so this must be called
-     * AFTER SharedRunSession.finish() clears it, never before.
-     */
-    repaintForScene(): void;
-    private returnToHub;
-    /**
-     * KNIGHT ERRANT CHECKPOINT (SINs & getting caught, ruling 2026-08-24;
-     * canon p.363-368, verification values engine-adapted -- the RAG was
-     * down): past CHECKPOINT_HEAT, the ride home hits the wire and the
-     * SIN mechanic resolves. A CRIMINAL SIN broadcasts before the wand
-     * lifts -- shakedown, citation, notoriety. Otherwise your best FAKE
-     * SIN is tested: the scanner rolls its dice (R3 wand, R4 on the
-     * hottest nights) and BEATS the fake's rating to burn it -- burned
-     * means gone from every database at once, then processing. No SIN at
-     * all: fast-talk (Charisma + con) or zip ties. Heat always resets --
-     * the night ends either way.
-     */
-    private checkpointOnRideHome;
-    /**
-     * The actual drafting work, split out from continueToNextScene() purely
-     * so that method can wrap it in the try/finally that clears
-     * _draftInProgress -- every return path below (including the early
-     * "couldn't draft" one) needs that cleanup to run.
-     */
-    private draftNextScene;
-    /**
-     * Installs a drafted run as the live scene. Shared by the classic
-     * immediate path (hideout start) and the hub's "travel" (start-room
-     * start -- you rode there, you arrive AT the job).
-     */
-    private activateRunScene;
-    /**
-     * The needs check at every job departure (SR5e p.56 / p.172, scaled to
-     * job-cycle "days"). Fed AND slept since the last departure: edge
-     * refills and you head out sharp. Skip either: edge stays at whatever's
-     * left. Keep skipping: escalating fatigue (1S, 2S, 3S... per cycle),
-     * resisted Body + Willpower, landing as LOCKED stun no recovery touches
-     * until the need is met (Player.healStun / markFed / markSlept). A
-     * Sleep Regulator (augmentations.ts) halves the effective sleep debt.
-     * Fatigue is capped one box short of a knockout -- RAW would drop you,
-     * but collapsing INSIDE the departure transition would strand the
-     * session between scenes; "running on fumes" carries the spirit.
-     */
-    private applyDepartureNeeds;
-    /**
-     * "travel": takes the arranged transport to the pending job (see
-     * commands/travel.ts). The player arrives AT the run's start room --
-     * "You travel to <location>" -- not teleported onto their own cot.
-     * A haggle struck during the offer call already mutated the pending
-     * seed's payout, and stays spent across the transition (refreshEdge
-     * would otherwise re-arm it).
-     */
-    launchPendingRun(): Promise<string>;
-    /**
-     * `cause` is the engine's own death line ("💀 GAME OVER: ... was gunned
-     * down by ..."). It rides the burn to the server, which makes it the
-     * dossier's headline and the seed of the obituary (maka-cli-com-c3
-     * contract, 2026-09-04). A generic line here would produce a generic
-     * obituary, so the specific one is threaded all the way from the kill.
-     */
-    close(cause?: string): Promise<void>;
-    /**
-     * Waits BRIEFLY for the server to stamp the death and answer with the
-     * memorial. Raced against a timeout on purpose: the burn is already
-     * tombstoned locally and the launcher's sweep finishes it either way,
-     * so a slow or dead network costs the player a moment rather than the
-     * death screen itself.
-     */
-    private deathMemorial;
-    /**
-     * The death screen's offer. The URL is ALWAYS printed, for the same
-     * reason the chargen handoff prints its own: a headless or SSH session
-     * has no browser to open, so a link that exists only behind a keypress
-     * is no link at all. Headless sessions reach close() too (Phase C) and
-     * simply have no screen to bind -- the lines still land in the log.
-     */
-    private offerDossier;
-    /**
-     * 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.
-     */
-    private paintClock;
-    private startClockTicker;
-    stopClockTicker(): void;
-    /**
-     * THE PANELS' MISSING BEAT (2FrYWFdLnh6uqFLcp). updateExits already
-     * fires on everything the PLAYER does; nothing fired it for what
-     * everyone else in the room does while the player sits still and
-     * watches. Same lifecycle as startClockTicker one field up --
-     * headless-guarded, idempotent, unref'd -- because this is the same
-     * shape of thing: a UI-only convenience with nothing behind it for a
-     * session with no screen to paint.
-     */
-    private startMapHeartbeat;
-    stopMapHeartbeat(): void;
-    /**
-     * ONE TICK, and it does nothing clever: call the exact function a
-     * player's own move/look already calls. Whether anything actually
-     * repaints is _lastMapPaint/_lastRoomPaint's call, not this one's --
-     * see setMapOverlay/setRoomOverlay. That is deliberate: a second,
-     * bespoke "did the room change" detector here would be a second
-     * place for that answer to drift from what the panels actually paint.
-     *
-     * SKIPPED MID-EXCHANGE. Combat already repaints itself blow-by-blow
-     * (CombatExchange narrates and this.scene.updateStatus()/updateExits
-     * follow each strike) -- a wall-clock beat competing with that is
-     * noise at best. It also stays the RIGHT default once combat moves to
-     * a turn-based cadence (player's stated plan): pacing there is the
-     * turn structure's job, not a 2-second ticker's.
-     */
-    private mapHeartbeatTick;
-    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;
-    /**
-     * The Game Log banner names WHERE you are in the campaign (player
-     * request): the hub by name at home, "JOB #n: <name>" on a run --
-     * plus the scroll state the label already carried.
-     */
-    private buildLogLabel;
-    /** Re-stamps the banner after a scene change (init, run start, home). */
-    refreshLogLabel(): void;
-    /**
-     * Scroll the log to its tail -- unless the player has paged up to read
-     * history (followBottom off), in which case their place is left alone.
-     * Every "new line arrived" site goes through here.
-     */
-    followLog(): void;
-    /**
-     * The MECHANICS column (readability pass, player request: the log was
-     * a "wall of text"): dice anatomy and resource arithmetic land here
-     * (via Logger.meta) instead of the world log, so the narrative stays
-     * prose. A full-height COLUMN beside the world log, not a bottom
-     * strip -- the first playtest's 3-row ticker scrolled combat rolls
-     * away faster than they could be read. De-emphasis is the BLUE border
-     * -- gray is banned (ANSI bright-black, illegible on stock dark
-     * palettes). Follow-only (no keys); the full interleaved record lives
-     * in session.log. Roll lines wrap at the column width -- fine in a
-     * tall column. NO mouse (see initInputBox): never arm mouse tracking.
-     */
-    private initMetaBox;
-    /**
-     * The HUD: a fixed strip between the log and the input box for the
-     * important real-time state -- condition tracks, armed/link status,
-     * sustained spells, active call. Anything that changes moment to moment
-     * and shouldn't need a command to check lives here; everything slower
-     * (full inventory, slot-by-slot equipment, the map) is an on-demand
-     * command instead. Future contexts (astral projection, VR hot-sim) get
-     * their own line here the same way the call line did: small explicit
-     * pieces, not a status framework built ahead of need.
-     */
-    private initStatusBox;
-    /**
-     * THE MINIMAP (map-overlay wave 2026-08-24; split into a pair
-     * 2026-08-25 -- player ask: "ample space to split the existing map in
-     * two, one for the area, one for the room"): two small icon
-     * viewports DOCKED side by side at the top of the Mechanics column --
-     * not floated over the log (a float occluded log text and, being
-     * numerically anchored, drifted on terminal resize; percentage
-     * geometry re-solves both). The Mechanics pane shifts down while
-     * EITHER is shown and takes the space back only once both hide.
-     * keys:false -- a keyable box appended after the input steals focus
-     * (the "eexxiitt" bug, see initInputBox). Hidden until the first
-     * setMapOverlay/setRoomOverlay with content.
-     */
-    private static readonly MAP_DOCK_ROWS;
-    /** Must track the roomMapBox's `width` below -- updateExits derives
-     *  the inner width from it to right-justify the elevation bar. */
-    private static readonly ROOM_DOCK_PCT;
-    /** 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. */
-    private static readonly CLOCK_GUTTER_W;
-    private static readonly MAP_DOCK_PCT;
-    private initMapBox;
-    /** Shifts the Mechanics pane down (a map box is shown) or back up
-     *  (neither is). Driven by syncMapDock, never called directly. */
-    private dockMap;
-    /** Keeps the Mechanics pane's dock offset in sync with whichever
-     *  docked box(es) -- district, room, or both -- are currently shown. */
-    private syncMapDock;
-    /**
-     * Paints (or hides) the docked DISTRICT minimap. Solo: updateExits
-     * feeds it from the local scene; shared runs: SharedRunSession.route
-     * feeds it from the server's per-player kind:'map' events. The
-     * preference gates both this and setRoomOverlay in one place.
-     */
-    setMapOverlay(lines: string[]): void;
-    hideMapOverlay(): void;
-    /**
-     * Paints (or hides) the docked ROOM minimap -- the district box's
-     * twin, fed by updateExits from utilities/room-view.ts. Empty
-     * whenever the current room has no synthesized grid (spotless --
-     * THE COMPAT RULE) or the player is circulating in it (nothing fixed
-     * to center on): both read as "hide", same as an empty district.
-     */
-    setRoomOverlay(lines: string[]): void;
-    hideRoomOverlay(): void;
-    /**
-     * Refreshes the status box from current player state. Called after any
-     * command that can change what belongs there (currently "call"/"end-call")
-     * and once on load/job transition.
-     */
-    updateStatus(): void;
-    /** ui plumbing for session mode (utilities/shared-run.ts). */
-    get saveFilePath(): string | undefined;
-    screenRender(): void;
-    private _renderScheduled;
-    /**
-     * ONE REPAINT PER DRAIN, not one per event.
-     *
-     * blessed's render() redraws the whole terminal, and the docked map
-     * and room overlays each called it the moment their content changed.
-     * That is right for solo play, where a command produces one update --
-     * and wrong under a shared-run burst, where the server's events arrive
-     * in a flood. Measured from a real stalled run (session
-     * 2026-08-30T15-42-23-465Z): delivery stalled, then 80 events landed
-     * inside ONE SECOND, of which 19 were kind:'map' and 19 kind:'room' --
-     * 38 full-screen repaints where one would have shown the same final
-     * picture. The player sees the tearing, not the intermediate frames.
-     *
-     * setImmediate rather than a timer: it fires after the current I/O
-     * callbacks, so a batch of DDP messages delivered in one poll phase
-     * collapses into a single paint, and a lone update in an idle client
-     * still repaints on the very next tick -- imperceptible either way.
-     *
-     * Coalescing is safe because the widgets already hold the state: each
-     * setContent/show has landed by the time the paint runs, so the frame
-     * that is drawn is the newest one and the ones skipped were never
-     * visible.
-     */
-    scheduleRender(): 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).
-     */
-    /**
-     * What's in your hands, in one phrase. Three armed states on the meat
-     * plane: drawn, HOLSTERED (carried but riding leather -- "brandish"
-     * puts it in hand; combat auto-draws, so this is posture rather than
-     * readiness), or nothing at all. Off-plane the profile is attack
-     * programs / astral will and reads as Armed. White, not gray, for the
-     * same legibility reason as the stance it now sits beside.
-     */
-    /**
-     * THE DOCWAGON SLOT (user, 2026-09-04, after a Matrix fight killed Maka:
-     * "let's setup a status for docwagon level, so it's clear to see that I
-     * don't have one").
-     *
-     * NO CONTRACT IS THE STATE WORTH SEEING, so it is the one drawn in red
-     * and never omitted. A missing wristband is the difference between a
-     * bad fight and a dead character, and the panel that could have said so
-     * showed armor and an AR overlay and nothing about whether anyone was
-     * coming. It reads at a glance now, beside the two slots that already
-     * answer "how ready am I".
-     *
-     * The tier's resuscitations are what the band actually buys (p.450), so
-     * a contract with none left says that rather than the tier name alone --
-     * a Gold that has spent its one free resusc is closer to Basic than to
-     * Gold, and "GOLD" on its own would be a comforting lie.
-     */
-    private docwagonSlot;
-    private armedLine;
-    /**
-     * THE LOG WEARS THE PLANE (player request 2026-08-25). Jacking in or
-     * stepping out of your body changes what every line in that log even
-     * MEANS, and the only marker was a HUD row well below it. The border
-     * takes the plane's own established colour -- cyan for the Matrix,
-     * magenta for astral, yellow for a jumped-in drone, matching the
-     * tints those planes already use throughout the prose.
-     */
-    private planeBorderColor;
-    private paintPlaneBorder;
-    statusLinesFor(player: Player): string[];
-    updateEquipment(_playerEquipment: PlayerEquipment): void;
-    updateExits(_room: Room): void;
-    updateInventory(_playerInventory: Inventory, _currencyName?: string): void;
-    static getInstance(player: Player, sceneSeed: ISceneSeedJson, resume?: ISaveFileV1): Promise<Game>;
-    /**
-     * The verb the LAST handleInput actually ran, after typo correction
-     * ("sjeet" -> "sheet"). ui.ts routes menu output to the Mechanics
-     * panel on THIS, not the typed word -- a real session's corrected
-     * "sjeet" dumped the whole sheet into the world log. The recursive
-     * 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 HOST'S TURN, appended to whatever the player's action returned.
-     *
-     * This is the Combat Turn mapping from the IC design, and it is an
-     * ENGINE MAPPING rather than a rule: canon paces IC in Combat Turns
-     * (one program launched per turn, at the beginning of it) and this
-     * engine has no Matrix initiative structure, so ONE PLAYER ACTION
-     * TAKEN INSIDE AN ALERTED HOST counts as one turn. Not a citation, and
-     * not presented as one.
-     *
-     * It hangs off the single command dispatch rather than off hack.ts on
-     * purpose. Ice hunts you while you do ANYTHING in the host -- looking,
-     * moving, taking -- so hooking only the hacking verb would have made
-     * the host blind to every other action, which is the "fixed one verb,
-     * left its siblings" shape CLAUDE.md warns about.
-     *
-     * utilities/ic.ts decides whether anything happens at all
-     * (hostIsHunting); this only carries the result to the panes.
-     */
-    /**
-     * THE EPHEMERAL TURN, appended the same way the host's is.
-     *
-     * One player action is one beat for every passing face in the room --
-     * the same engine mapping withICTurn makes below, and hung off the
-     * same single dispatch for the same reason: a mob closes on you while
-     * you look, talk, or check your gear, not only while you walk. Hooking
-     * one verb is the "fixed one verb, left its siblings" shape CLAUDE.md
-     * warns about.
-     *
-     * utilities/ephemeral.ts decides what each kind does with its beat;
-     * this only carries the narration back. Only a mob ever produces any.
-     */
-    /** One beat in flight at a time (see utilities/alarmed-staff.ts). */
-    private _alarmBeat;
-    /**
-     * THE ALARMED SITE'S TURN, hung off the same single dispatch the host's
-     * and the ephemerals' are -- one player action is one beat for the
-     * people who work here.
-     *
-     * AN ENGINE MAPPING, NOT A RULE, in exactly the sense withICTurn says
-     * it: SR5 writes no general mechanics for how guards react to an alarm
-     * (asked twice, two wordings, same answer), and p.352's "delay the
-     * runner team" is conditioned on an HTR team being en route, which in
-     * a Zone 0 barrens it never is. Nothing here invents a response table,
-     * a convergence rate or an aggression dial. What changed is only this:
-     * NPC.act()'s two callers both live inside respondTo(), so a scene NPC
-     * was mute unless the player addressed it. The engine stops muzzling
-     * them while a site is alarmed. What any of them DOES with a beat is
-     * the judgment it already exercises when spoken to.
-     *
-     * IT APPENDS NOTHING, and that is worth saying because it makes the
-     * one thing this wrapper's POSITION was chosen for moot. The seam
-     * agreement put this inner to withEphemeralTurn so an alarmed guard
-     * would print above somebody eating noodles -- sound reasoning for an
-     * appending wrapper, and irrelevant to a fire-and-forget one that
-     * returns `result` untouched. The position is kept as agreed so the
-     * slot exists if this ever narrates inline; the ordering argument is
-     * recorded as not currently biting rather than quietly inherited.
-     *
-     * FIRE AND FORGET on the player's own ruling, offered three shapes:
-     * reactions "arrive a moment later" while play continues at full
-     * speed, one in flight so they never pile up. The precedent is
-     * draftNextSceneInBackground -- never make the player wait on a model
-     * call.
-     */
-    private withAlarmTurn;
-    private withEphemeralTurn;
-    private withICTurn;
-    /**
-     * The help taxonomy: every entry is [primary, ...aliases], grouped the
-     * way a player thinks, not the order commands were registered. The
-     * overview shows only verbs per category (the flat all-descriptions
-     * dump had grown past 45 lines); "help <category>" and "help <command>"
-     * drill into the real descriptions. Verbs registered but missing from
-     * this table surface in an "other" bucket rather than vanishing -- a
-     * future command can't silently fall out of help.
-     *
-     * AN ALIAS MEANS THE SAME COMMAND -- not "a related word"
-     * (ZJjWMKww2kstbkJCW: "'descend' is not in the list of moving
-     * commands"). Both readers of this table take the group's HEAD as the
-     * command: the overview prints e[0] and nothing else, and "help
-     * <word>" looks up the primary's class to describe it. So a distinct
-     * command parked at index 1 is invisible in the overview AND answers
-     * questions about it with another command's description -- `descend`
-     * was reported missing, but `help descend` was also quietly printing
-     * how to climb UP.
-     *
-     * Five groups had it: descend under climb, run and sprint under move,
-     * unfollow under follow, decompile under compile, kill under attack.
-     * Every one of them is its own class with its own description that no
-     * player could reach. They are split out here rather than taught to
-     * the renderer, because "a group is one command" is the assumption
-     * the renderer is ENTITLED to make -- the table was what lied.
-     * help-taxonomy.test.ts now holds that line for the whole table.
-     */
-    private static readonly HELP_CATEGORIES;
-    /** 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. */
-    private static readonly HIDDEN_VERBS;
-    /** 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. */
-    private static readonly PLAYTESTER_VERBS;
-    /** Descriptions for the verbs handled inline in handleInput() rather than registered. */
-    private static readonly BUILTIN_DESCRIPTIONS;
-    private describeVerb;
-    /**
-     * 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.
-     */
-    private helpCategories;
-    private getHelpMessage;
-}