@maka/maka-cli 5.122.0 → 5.123.0

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

@@ -131,8 +131,9 @@ export type SimMode = 'cold' | 'hot';
  * this not-yet-carried list; all three are now real and hooked, one per
  * command file beside them.)
  */
-export type SkillName = 'blades' | 'clubs' | 'unarmed' | 'gunnery' | 'astral-combat' | 'cybercombat' | 'sneaking' | 'perception' | 'palming' | 'escape-artist' | 'disguise' | 'hacking' | 'locksmith' | 'computer' | 'electronic-warfare' | 'hardware' | 'negotiation' | 'con' | 'intimidation' | 'etiquette' | 'leadership' | 'performance' | 'instruction' | 'first-aid' | 'medicine' | 'assensing' | 'spellcasting' | 'counterspelling' | 'piloting' | 'conjuring' | 'compiling' | 'decompiling' | 'registering' | 'software' | 'impersonation' | 'ritual-spellcasting' | 'gymnastics' | 'running' | 'swimming' | 'automatics' | 'pistols' | 'longarms' | 'banishing' | 'summoning' | 'binding' | 'cybertechnology' | 'alchemy' | 'disenchanting' | 'artificing' | 'aeronautics-mechanic' | 'industrial-mechanic' | 'automotive-mechanic' | 'nautical-mechanic' | 'navigation' | 'tracking' | 'survival' | 'archery' | 'free-fall' | 'heavy-weapons' | 'throwing-weapons' | 'exotic-melee' | 'exotic-ranged';
-export declare const SKILL_NAMES: SkillName[];
+export { SKILL_NAMES } from '../skills.js';
+export type { SkillName } from '../skills.js';
+import type { SkillName } from '../skills.js';
 /**
  * Skills that fall back to the legacy `combatSkill` attribute when no
  * explicit rating is given -- this is what keeps every existing NPC seed
@@ -908,13 +909,42 @@ export declare class Player extends AbstractPlayer {
         essence: number;
         grade?: string;
     }): void;
-    /** Every effect that applies right now, with the rating it scales by. */
+    /**
+     * Which SOURCE an effect came from. The single accessor `bonus()`
+     * sums them all; the older per-source getters each sum their own,
+     * which is what lets the call sites migrate one at a time instead of
+     * in one unreviewable commit.
+     */
+    /** Every effect applying right now, with its source and its scale. */
     private applyingEffects;
+    /**
+     * Sums one kind of effect. `lanes` narrows to particular sources --
+     * omitted means EVERY source, which is what the unified `bonus()`
+     * wants; the legacy getters each pass their own single lane so that
+     * a call site still adding two of them by hand cannot double.
+     */
+    /**
+     * The spells being sustained, and what each scales by.
+     *
+     * READS THE STATE cast.ts ALREADY KEEPS rather than a second map:
+     * the armor spell stores its hits, and the other two are booleans
+     * whose rows carry a flat value, so 1 is the right multiplier for
+     * them. Adding a parallel store would be two places to forget to
+     * update, which is the shape this whole pass has been removing.
+     */
+    private sustainedMagnitudes;
     private sumEffects;
     /**
-     * Dice the gear adds to a pool or a skill's tests (cf. augBonus,
-     * qualityBonus): `kind` is a pool kind or a SkillName; `only` names a
-     * narrowing an effect may carry ('haggle', 'silent', 'matrix-search').
+     * Dice the GEAR LANE adds, and nothing else.
+     *
+     * A LANE READER, NOT A POOL. Every pool in the game reads `bonus()`
+     * now; this survives as the way to ask what one source contributes,
+     * which is what the behaviour fixture interrogates and what a "where
+     * did that die come from" answer would need. It has no production
+     * caller of its own, and that is the correct state for it rather than
+     * a sign it should go: deleting it would delete the fixture's ability
+     * to see the lanes apart, which is the only thing that can catch one
+     * lane being counted twice.
      */
     gearBonus(kind: string, opts?: {
         only?: string;
@@ -923,32 +953,164 @@ export declare class Player extends AbstractPlayer {
     gearLimit(kind: 'physical' | 'mental' | 'social' | 'accuracy', opts?: {
         only?: string;
     }): number;
-    /** A capability the gear grants (dni, smartlink, no-fog, low-light...), by key. */
-    hasCapability(key: string): boolean;
     /**
-     * The single tap every pool reads chrome through. Wired Reflexes tiers
-     * don't stack -- the higher tier wins (II supersedes I) -- but the
-     * synaptic-vs-wired conflict is the clinic's job, not this getter's.
+     * EVERY die the character has for this pool or skill, from every
+     * source -- gear, chrome, qualities, adept powers, metamagics, a
+     * metatype trait, a sustained spell.
+     *
+     * `only` names a narrowing an effect may carry ('haggle', 'silent',
+     * 'matrix-search'). `skill` lets a combat pool pick up dice that were
+     * declared against the SKILL being rolled rather than the pool --
+     * a smartlink says `firearms`, and the attack pool has to see it.
+     *
+     * The sources that have not yet moved onto the shared shape are added
+     * explicitly below, each named, so that migrating one is a matter of
+     * deleting its line here rather than hunting for what it fed.
+     */
+    bonus(kind: string, opts?: {
+        only?: string;
+        skill?: string;
+    }): number;
+    /**
+     * What a source adds to the initiative SCORE -- the number you roll
+     * against -- as opposed to `bonus('initiative')`, which is the DICE.
+     *
+     * The `initiative` effect arm has existed since the gear pass and
+     * was read by nothing at all until the Increase Reflexes spell came
+     * onto the lane (2026-09-04). Two different quantities sharing the
+     * word "initiative" is exactly why the arm is separate.
+     */
+    initiativeBonus(of: 'score' | 'dice'): number;
+    /** Every point on a LIMIT, from every source. */
+    limitBonus(kind: 'physical' | 'mental' | 'social' | 'accuracy', opts?: {
+        only?: string;
+    }): number;
+    /**
+     * How much further this character may raise one skill or attribute
+     * than anyone else -- Aptitude's chosen skill (p.72), Exceptional
+     * Attribute's chosen attribute (p.73-74).
+     *
+     * The book states absolute numbers against ITS ceilings (a skill at 7
+     * rather than 6 at creation, 13 rather than 12 after). This engine
+     * caps lower than the book does, so what carries across is the DELTA
+     * -- one step further than anyone else gets -- applied to whatever
+     * ceiling the engine is enforcing. Writing the book's 13 over a house
+     * cap of 7 would not be more faithful, only a bigger number in the
+     * wrong system.
+     *
+     * A `chosen` ceiling resolves through the holder's own pick, so a
+     * quality bought but never answered lifts nothing at all.
+     */
+    capBonus(of: 'skill' | 'attribute', name: string): number;
+    /**
+  
+  
+    /** A capability the character has, from any source, by key. */
+    can(key: string): boolean;
+    /**
+     * THE CHROME THAT ACTUALLY COUNTS: everything installed, minus the
+     * wired-reflex tiers a higher tier supersedes.
+     *
+     * Wired Reflexes I, II and III do not stack -- the best one wins (a
+     * synaptic booster is bioware and rides on top of whichever that is).
+     * That is a relationship BETWEEN rows, so no row can declare it and it
+     * has to live in code; it lives HERE, in the one place the resolver
+     * reads, rather than inside a getter, where only that getter would
+     * have been right and every other reader would have double-counted.
+     *
+     * The synaptic-vs-wired legality conflict remains the clinic's job.
+     */
+    private chromeThatCounts;
+    /**
+     * The chrome lane, by pool. A LANE READER, like gearBonus above.
+     *
+     * Every pool now reads `bonus()`, with exactly two deliberate
+     * exceptions, both in smartlinkTier and both commented there: that
+     * method asks which TIER of smartlink you have, implant or clip-on,
+     * and only the chrome lane can answer it.
      */
     augBonus(kind: AugBonusKind): number;
     /** Installed qualities, by catalog key (see QUALITIES). */
     qualities: Set<string>;
+    /**
+     * IS THIS SKILL OR ATTRIBUTE FORBIDDEN OUTRIGHT to this character?
+     *
+     * Reads the same lane every other rule reads, so a second quality
+     * (or a piece of chrome, or a metatype trait) that bars something
+     * needs no new reader. A `chosen` forbid resolves through the
+     * holder's pick, and where the pick names a skill GROUP the bar
+     * falls on every member -- which is what Incompetent actually is
+     * (p.81: "all skills in the skill group").
+     */
+    isForbidden(of: 'skill' | 'attribute', name: string): boolean;
+    /**
+     * Incompetent (p.81) names ONE skill group, and this is the only place
+     * that knows how to ask which. It was three separate reads of
+     * `hasQuality(`incompetent-${skill}`)` -- the slug convention -- and a
+     * fourth that counted slugs by prefix for notoriety. The quality is
+     * now 'incompetent' with a pick, and a legacy slug resolves to the
+     * same thing on load (qualities.ts LEGACY_CHOICE_KEYS), so this
+     * answers the same for an old save and a new one.
+     */
+    isIncompetentAt(skill: string): boolean;
     hasQuality(key: string): boolean;
     /**
      * Records a quality and applies its one-time creation effect. Lucky is
      * the only quality that edits an attribute (RAW raises the Edge ceiling;
      * with no attribute point-buy here, the point lands directly).
      */
+    /**
+     * WHAT THE HOLDER PICKED, per ROW that demands a pick (ICatalogChoice):
+     * slug -> the skill or attribute named.
+     *
+     * KEYED BY SLUG, NOT BY QUALITY (mjmcee, 2026-09-04). A Hardwire is an
+     * augmentation that gives +2 to a chosen skill and asks exactly the
+     * question Aptitude asks; a map that only qualities could reach would
+     * mean a second map for chrome and a third for spells. One map, one
+     * picker, one payload field.
+     */
+    picks: Map<string, string>;
+    /**
+     * The former name for `picks`, back when only qualities could ask.
+     * Kept as the SAME Map -- not a copy -- so a save written or read
+     * through the old name still lands in one place.
+     */
+    get qualityChoices(): Map<string, string>;
     /** Rating per rated quality (qualities.ts maxRating); absent = 1. */
     qualityRatings: Map<string, number>;
     /** The rating held, 0 when the quality is not held; a flat quality reads 1. */
     qualityRating(key: string): number;
     addQuality(rawKey: string, rating?: number): void;
+    /**
+     * A quality that MOVES AN ATTRIBUTE does it once, here, at install.
+     *
+     * Unlike a dice effect -- which qualityBonus re-reads on every roll
+     * -- an attribute is a stored number, so it is edited rather than
+     * summed. Lucky (p.76) is the long-standing case: RAW it raises the
+     * Edge CEILING, and with no attribute point-buy here the point lands
+     * directly. It used to be an `if (key === 'lucky')` in addQuality;
+     * it is data now, which is what let Ugly and Doesn't Care (Cutting
+     * Aces p.152-153) arrive as data too instead of as a second `if`.
+     *
+     * The floor is 1: no quality reduces an attribute below the minimum
+     * a metahuman can have, and Ugly and Doesn't Care says so in as many
+     * words ("minimum 1").
+     */
+    private applyQualityAttributes;
     /**
      * The single tap every pool reads qualities through (cf. augBonus).
      *
+     * DATA, NOT A SWITCH (2026-09-04). Every number below used to be a
+     * `case` here; each one now lives on its own quality in qualities.ts
+     * as an `effects` entry, in the same vocabulary gear and chrome
+     * already speak. A quality that adds dice therefore needs no edit to
+     * this method -- which is the property that matters, because the
+     * cost of the old shape was that the catalog could only ever print a
+     * quality's PROSE while its actual numbers lived somewhere a reader
+     * could not reach.
+     *
      * `perception` and `social` mirror the augBonus kinds of the same
-     * names, and are read at the same call sites, so a quality and a piece
+     * names and are read at the same call sites, so a quality and a piece
      * of chrome that do the same thing are added the same way.
      *
      * `sleaze` and `attack` are the two Matrix ACTIONS this engine names
@@ -957,9 +1119,36 @@ export declare class Player extends AbstractPlayer {
      * a mark IS one of those two. They exist because Codeslinger and
      * Codeblock (p.72 / p.80) modify ONE chosen Matrix action rather than
      * Matrix work in general, so a `hacking`-wide bonus would be a
-     * different quality wearing the name.
-     */
-    qualityBonus(kind: 'sneak' | 'athletics' | 'matrix' | 'hacking' | 'piloting' | 'soak' | 'healing' | 'perception' | 'social' | 'sleaze' | 'attack'): number;
+     * different quality wearing the name. In the DATA they are spelled
+     * `matrix-attack` / `matrix-sleaze`: EffectPool already spends the
+     * bare word `attack` on the COMBAT attack pool, and a quality that
+     * fired in a firefight because it shared a word with a Matrix action
+     * would be a bug nobody would look for.
+     */
+    qualityBonus(kind: 'sneak' | 'athletics' | 'matrix' | 'hacking' | 'piloting' | 'soak' | 'healing' | 'perception' | 'social' | 'sleaze' | 'attack' | 'leadership' | 'escape-artist' | 'biofeedback'): number;
+    /**
+     * Dice the QUALITIES add to one pool or skill. Deliberately its own
+     * summation rather than a source inside applyingEffects(): the pools
+     * are read as `augBonus(k) + qualityBonus(k)` at call sites that do
+     * NOT also add gearBonus(k), and folding qualities into the shared
+     * effect walk would have made every site that DOES add gearBonus
+     * count a quality twice, silently, in a number nobody prints.
+     */
+    /**
+     * How much further this character may raise one skill or attribute
+     * than anyone else -- Aptitude's chosen skill (p.72), Exceptional
+     * Attribute's chosen attribute (p.73-74).
+     *
+     * The book states absolute numbers against ITS ceilings (a skill at
+     * 7 rather than 6 at creation, 13 rather than 12 after). This engine
+     * caps lower than the book does, so what carries across is the DELTA
+     * -- one step further than anyone else gets -- applied to whatever
+     * ceiling the engine is enforcing. Writing the book's 13 over a house
+     * cap of 7 would not be more faithful, it would just be a bigger
+     * number in the wrong system.
+     */
+    qualityCap(of: 'skill' | 'attribute', name: string): number;
+    private sumQualityEffects;
     private _firstImpressionUsed;
     /** Spends the first impression: +2 for the social roll happening NOW. */
     consumeFirstImpression(): number;
@@ -1511,13 +1700,21 @@ export declare class Player extends AbstractPlayer {
      * Combat Sense. The Power Point metamagic stays what it always was --
      * a point of magic-as-muscle on the STRIKING side only.
      */
+    /**
+     * The COMPRESSED adept's flat bonus, or zero for anyone who chose
+     * powers. Split out of adeptAttackBonus so the combat pools can read
+     * `bonus()` for every other source without counting the chosen powers
+     * twice -- they arrive through the adept lane, and this is the only
+     * part of the adept that never became data.
+     */
+    private adeptCompressedBonus;
     adeptAttackBonus(): number;
     adeptDefenseBonus(): number;
     /** Mystic Armor (p.309): +1 Armor per level. Zero under the compressed
      *  model -- the flat pool bonus never granted armor, so none is owed. */
     adeptArmorBonus(): number;
-    /** Improved Reflexes (p.309): +level Reaction, read by the defence and
-     *  initiative math. Zero under the compressed model. */
+    /** Improved Reflexes (p.309): the initiative dice it adds. Zero under
+     *  the compressed model. */
     adeptReactionBonus(): number;
     /** Killing Hands (p.309): unarmed strikes deal PHYSICAL damage. */
     hasKillingHands(): boolean;
@@ -1623,7 +1820,7 @@ export declare class Player extends AbstractPlayer {
     /** Static Veil: +2 to matrix defense while sustained. */
     get formDefenseBonus(): number;
     /** The Force each sustained spell was cast at (cast.ts records it) -- Focused Concentration reads it. */
-    sustainedForces: Map<"armor" | "invisibility" | "reflexes", number>;
+    sustainedForces: Map<"armor" | "reflexes" | "invisibility", number>;
     noteSustainedForce(kind: 'armor' | 'invisibility' | 'reflexes', force: number): void;
     /** GREMLINS (p.81): the 1s a glitch needs, one fewer per rating, on external equipment -- the deck. */
     get deckGremlins(): number;