@maka/maka-cli 5.116.0 → 5.118.0

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

@@ -0,0 +1,80 @@
+import type { Room } from './room.js';
+import type { NPC } from './npc.js';
+import type { Door } from './door.js';
+import type { Item } from './item.js';
+import type { Grid } from '../utilities/grids.js';
+/**
+ * A HOST (SR5 p.246-247), as its own object. Increment 1 of the Matrix
+ * position model (plan 2026-09-02): the host state that used to live as
+ * loose fields on Room moves here, and Room keeps delegating accessors
+ * so every existing reader and writer compiles and behaves unchanged.
+ *
+ * `over` is the physical room the host stands over in this engine: the
+ * site systems it masters bind through it -- a crack releases that room's
+ * maglocks and unseals the matrix items in its inventory, and the room's
+ * cameras answer to it (utilities/surveillance.ts). Canon puts no host at
+ * a physical address (p.246, "hosts don't have a physical location"); the
+ * anchor is the engine's mapping of "the network that runs this place",
+ * not a claim about where the host is.
+ *
+ * `grid` is optional and unset by default: canon says hosts are reached
+ * from any grid and pay to be accessible from all of them (p.246, Data
+ * Trails p.15); a seed may declare one, and only then does the cross-grid
+ * penalty apply to actions against it (increment 3).
+ *
+ * What persists: `cracked` only (utilities/persistence.ts). Marks, alert,
+ * running IC and the patrol clock are session state by design.
+ */
+export declare class Host {
+    static readonly DEFAULT_RATING = 3;
+    static readonly MIN_RATING = 1;
+    static readonly MAX_RATING = 12;
+    /** SR5 p.247: Host Rating 1-12; anything else is the default. */
+    static clampRating(rating: number | undefined): number;
+    readonly over: Room;
+    rating: number;
+    grid?: Grid;
+    /** The seed's word for the grid ('public' | 'local' | 'global:<corp>'); resolved against the scene's local grid by the factory. */
+    gridSeed?: string;
+    /** The one persisted field. A sanctioned host never remembers a crack. */
+    cracked: boolean;
+    /** player name -> marks the player holds on this host (max 3, p.236). */
+    marksBy: Map<string, number>;
+    /** player name -> marks the host holds on that player. */
+    marksOn: Map<string, number>;
+    /** Walls up: the host holds a mark on an intruder and its ice is hunting. */
+    alert: boolean;
+    /** IC running now, by kind name. Names, not actors -- until increment 5. */
+    runningIC: string[];
+    /** The running IC as actors, by kind (utilities/ic-actors.ts). Empty where no scene could host them. */
+    iceActors: Map<string, NPC>;
+    /** Kinds crashed this turn; the host relaunches them next turn (p.355-356). */
+    relaunchQueue: string[];
+    patrolCountdown?: number;
+    /** A haven (jackpoint.ts): never hunts, shows no rating, forgets cracks. */
+    sanctioned: boolean;
+    constructor(over: Room, opts?: {
+        rating?: number;
+        grid?: Grid;
+        sanctioned?: boolean;
+    });
+    /** The host is named for the place it stands over -- every alias the game prints derives from this. */
+    get name(): string;
+    /** So a Host can stand in for a Room wherever a reader only asks "is there a host here?". */
+    get hasNode(): true;
+    /**
+     * SR5 p.247: a host's four Matrix attributes are Host Rating, +1, +2, +3
+     * in some order. This engine's fixed order: Attack +1, Sleaze +0, Data
+     * Processing +3, Firewall +2.
+     */
+    attributes(): {
+        attack: number;
+        sleaze: number;
+        dataProcessing: number;
+        firewall: number;
+    };
+    /** The matrix-plane items the host keeps, from the room it stands over (until seeds carry host files). */
+    files(): Item[];
+    /** The locked doors of the room it stands over -- what a crack releases. */
+    maglocks(): Door[];
+}

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

@@ -0,0 +1,91 @@
+/**
+ * A HOST (SR5 p.246-247), as its own object. Increment 1 of the Matrix
+ * position model (plan 2026-09-02): the host state that used to live as
+ * loose fields on Room moves here, and Room keeps delegating accessors
+ * so every existing reader and writer compiles and behaves unchanged.
+ *
+ * `over` is the physical room the host stands over in this engine: the
+ * site systems it masters bind through it -- a crack releases that room's
+ * maglocks and unseals the matrix items in its inventory, and the room's
+ * cameras answer to it (utilities/surveillance.ts). Canon puts no host at
+ * a physical address (p.246, "hosts don't have a physical location"); the
+ * anchor is the engine's mapping of "the network that runs this place",
+ * not a claim about where the host is.
+ *
+ * `grid` is optional and unset by default: canon says hosts are reached
+ * from any grid and pay to be accessible from all of them (p.246, Data
+ * Trails p.15); a seed may declare one, and only then does the cross-grid
+ * penalty apply to actions against it (increment 3).
+ *
+ * What persists: `cracked` only (utilities/persistence.ts). Marks, alert,
+ * running IC and the patrol clock are session state by design.
+ */
+export class Host {
+    static DEFAULT_RATING = 3;
+    static MIN_RATING = 1;
+    static MAX_RATING = 12;
+    /** SR5 p.247: Host Rating 1-12; anything else is the default. */
+    static clampRating(rating) {
+        if (typeof rating !== 'number' || !Number.isFinite(rating))
+            return Host.DEFAULT_RATING;
+        return Math.min(Host.MAX_RATING, Math.max(Host.MIN_RATING, Math.round(rating)));
+    }
+    over;
+    rating;
+    grid;
+    /** The seed's word for the grid ('public' | 'local' | 'global:<corp>'); resolved against the scene's local grid by the factory. */
+    gridSeed;
+    /** The one persisted field. A sanctioned host never remembers a crack. */
+    cracked = false;
+    /** player name -> marks the player holds on this host (max 3, p.236). */
+    marksBy = new Map();
+    /** player name -> marks the host holds on that player. */
+    marksOn = new Map();
+    /** Walls up: the host holds a mark on an intruder and its ice is hunting. */
+    alert = false;
+    /** IC running now, by kind name. Names, not actors -- until increment 5. */
+    runningIC = [];
+    /** The running IC as actors, by kind (utilities/ic-actors.ts). Empty where no scene could host them. */
+    iceActors = new Map();
+    /** Kinds crashed this turn; the host relaunches them next turn (p.355-356). */
+    relaunchQueue = [];
+    patrolCountdown;
+    /** A haven (jackpoint.ts): never hunts, shows no rating, forgets cracks. */
+    sanctioned = false;
+    constructor(over, opts = {}) {
+        this.over = over;
+        this.rating = Host.clampRating(opts.rating);
+        this.grid = opts.grid;
+        this.sanctioned = opts.sanctioned ?? false;
+    }
+    /** The host is named for the place it stands over -- every alias the game prints derives from this. */
+    get name() {
+        return this.over.name;
+    }
+    /** So a Host can stand in for a Room wherever a reader only asks "is there a host here?". */
+    get hasNode() {
+        return true;
+    }
+    /**
+     * SR5 p.247: a host's four Matrix attributes are Host Rating, +1, +2, +3
+     * in some order. This engine's fixed order: Attack +1, Sleaze +0, Data
+     * Processing +3, Firewall +2.
+     */
+    attributes() {
+        const hr = this.rating;
+        return { attack: hr + 1, sleaze: hr, dataProcessing: hr + 3, firewall: hr + 2 };
+    }
+    /** The matrix-plane items the host keeps, from the room it stands over (until seeds carry host files). */
+    files() {
+        return this.over.inventory.getAllItems().filter(i => i.plane === 'matrix');
+    }
+    /** The locked doors of the room it stands over -- what a crack releases. */
+    maglocks() {
+        return Array.from(this.over.exits.values())
+            .filter((exit) => isDoor(exit) && exit.checkIfLocked());
+    }
+}
+function isDoor(exit) {
+    return typeof exit === 'object' && exit !== null && typeof exit.checkIfLocked === 'function';
+}
+//# sourceMappingURL=host.js.map

package/bundle/typescript/src/commands/game/sideQuest/models/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","sourceRoot":"","sources":["../../../../../../../src/commands/game/sideQuest/models/host.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,IAAI;IACf,MAAM,CAAU,cAAc,GAAG,CAAC,CAAC;IACnC,MAAM,CAAU,UAAU,GAAG,CAAC,CAAC;IAC/B,MAAM,CAAU,UAAU,GAAG,EAAE,CAAC;IAEhC,iEAAiE;IACjE,MAAM,CAAC,WAAW,CAAC,MAA0B;QAC3C,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,CAAC,cAAc,CAAC;QACvF,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAClF,CAAC;IAEQ,IAAI,CAAO;IACpB,MAAM,CAAS;IACf,IAAI,CAAQ;IACZ,mIAAmI;IACnI,QAAQ,CAAU;IAClB,0EAA0E;IAC1E,OAAO,GAAG,KAAK,CAAC;IAChB,yEAAyE;IACzE,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IACpC,0DAA0D;IAC1D,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IACpC,6EAA6E;IAC7E,KAAK,GAAG,KAAK,CAAC;IACd,4EAA4E;IAC5E,SAAS,GAAa,EAAE,CAAC;IACzB,wGAAwG;IACxG,SAAS,GAAG,IAAI,GAAG,EAAe,CAAC;IACnC,+EAA+E;IAC/E,aAAa,GAAa,EAAE,CAAC;IAC7B,eAAe,CAAU;IACzB,4EAA4E;IAC5E,UAAU,GAAG,KAAK,CAAC;IAEnB,YAAY,IAAU,EAAE,OAA+D,EAAE;QACvF,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC5C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,KAAK,CAAC;IAC7C,CAAC;IAED,uGAAuG;IACvG,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IACxB,CAAC;IAED,6FAA6F;IAC7F,IAAI,OAAO;QACT,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,UAAU;QACR,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QACvB,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,cAAc,EAAE,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,EAAE,GAAG,CAAC,EAAE,CAAC;IAClF,CAAC;IAED,0GAA0G;IAC1G,KAAK;QACH,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC;IAC7E,CAAC;IAED,4EAA4E;IAC5E,QAAQ;QACN,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;aACxC,MAAM,CAAC,CAAC,IAAI,EAAgB,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;IAC1E,CAAC;;AAGH,SAAS,MAAM,CAAC,IAAa;IAC3B,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,OAAQ,IAAa,CAAC,aAAa,KAAK,UAAU,CAAC;AACzG,CAAC"}

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

@@ -1,4 +1,6 @@
 import { PlayerEquipment } from '../types/player-equipment.js';
+import type { Grid } from '../utilities/grids.js';
+import type { Host } from './host.js';
 import { type Aspect } from '../aspects.js';
 import { LifestyleChoices } from '../types/seed/lifestyle-seed.js';
 import { Logger } from '../utilities/logger.js';
@@ -51,6 +53,19 @@ export declare function isPhysicalPlane(plane: Plane): boolean;
  * actors out of a Matrix target list; this function answers one question
  * and is not a second plane check.
  */
+/**
+ * A persona's place in the Matrix (SR5 p.239, p.246): out on a grid, or
+ * inside a host it entered from one -- and never on a street. See
+ * Player.matrixPosition.
+ */
+export type MatrixPosition = {
+    kind: 'grid';
+    grid?: Grid;
+} | {
+    kind: 'host';
+    host: Host;
+    from?: Grid;
+};
 export declare function sameHostSide(actor: Player, other: Player): boolean;
 export type SimMode = 'cold' | 'hot';
 /**
@@ -435,7 +450,32 @@ export declare class Player extends AbstractPlayer {
      * Session state like hostAlert and linkLockedBy: leaving the Matrix
      * ends it, so nothing here is persisted.
      */
-    insideHost?: Room;
+    /**
+     * WHERE THE PERSONA IS (increment 2 of the Matrix position model): on a
+     * grid, or inside a host it entered from one. Session-only, like
+     * bodyRoom. The body stays in currentLocation on every plane -- the
+     * persona never writes it. The setter fires the live-sheet beat, which
+     * is the beat the currentLocation setter used to fire on enter/exit.
+     * `grid` may be unknown (fixtures, and increment 2 itself): unknown is
+     * not "another grid", so it costs nothing.
+     */
+    private _matrixPosition?;
+    get matrixPosition(): MatrixPosition | undefined;
+    set matrixPosition(v: MatrixPosition | undefined);
+    /** The grid the persona rides, when it is on one. */
+    get currentGrid(): Grid | undefined;
+    /** The host the persona is inside, when it is inside one. */
+    get hostInside(): Host | undefined;
+    /**
+     * @deprecated compat through increment 4 -- read hostInside / write
+     * matrixPosition. The room a host stands over, when inside one. The
+     * setter still builds the position so every old writer keeps working.
+     */
+    private _compatInsideRoom?;
+    get insideHost(): Room | undefined;
+    set insideHost(room: Room | undefined);
+    /** The grid last stood on, so an exit built through the old setter returns there. */
+    private get lastGrid();
     /**
      * MATRIX ATTRIBUTES BURNED OFF BY IC (p.248): Acid eats Firewall,
      * Binder eats Data Processing, Jammer eats Attack, Marker eats Sleaze.
@@ -571,6 +611,10 @@ export declare class Player extends AbstractPlayer {
     private static readonly ATTR_EATER;
     private static readonly ATTR_NAME;
     /** The undamaged array, before any IC reduction. */
+    /** Set on an IC actor (utilities/ic-actors.ts): "IC uses the Matrix attributes of its host" (p.247). */
+    icHost?: Host;
+    /** The IC kind an IC actor was launched as -- the name the host's running list carries. */
+    icKind?: string;
     baseMatrixAttribute(kind: 'attack' | 'sleaze' | 'dataProcessing' | 'firewall'): number;
     /**
      * THE LIVE LINK -- what makes this runner reachable and lit (p.223,
@@ -1330,40 +1374,70 @@ export declare class Player extends AbstractPlayer {
      */
     sustainedNames(): string[];
     releaseSustainedWorkings(): number;
-    sustainedInvisibility: boolean;
-    sustainedReflexes: boolean;
+    private _sustainedInvisibility;
+    get sustainedInvisibility(): boolean;
+    set sustainedInvisibility(v: boolean);
+    private _sustainedReflexes;
+    get sustainedReflexes(): boolean;
+    set sustainedReflexes(v: boolean);
     /** The sustained PHYSICAL BARRIER spell (ruling 2026-08-24): seals
      *  one exit of one room while held -- go.ts and move refuse passage
      *  for everyone (the caster included; walls don't play favorites).
      *  Session-only, like every sustain. */
-    sustainedBarrier?: {
+    private _sustainedBarrier?;
+    get sustainedBarrier(): {
         roomName: string;
         direction: string;
         force: number;
-    };
+    } | undefined;
+    set sustainedBarrier(v: {
+        roomName: string;
+        direction: string;
+        force: number;
+    } | undefined);
     /** The MANA BARRIER twin (canon p.294, RAG-checked): blocks SPIRITS
      *  and astral forms at the sealed exit; living mundanes and physical
      *  objects pass freely. Same lifecycle as sustainedBarrier. */
-    sustainedManaBarrier?: {
+    private _sustainedManaBarrier?;
+    get sustainedManaBarrier(): {
         roomName: string;
         direction: string;
         force: number;
-    };
+    } | undefined;
+    set sustainedManaBarrier(v: {
+        roomName: string;
+        direction: string;
+        force: number;
+    } | undefined);
     /** `hits` is the original threading test's hits -- the number Kill
      *  Complex Form (p.250) eats away at. Optional so a form woven by
      *  anything that predates that bookkeeping still reads sanely;
      *  unravel.ts falls back to the Level. */
-    sustainedForms: {
+    private _sustainedForms;
+    /** Sustained complex forms. Writers push/splice it directly (sustain.ts,
+     *  thread.ts, game.ts), so the array itself is observed: every element
+     *  write fires the beat, and assigning a fresh array re-wraps it. */
+    get sustainedForms(): {
         key: string;
         level: number;
         hits?: number;
     }[];
+    set sustainedForms(v: {
+        key: string;
+        level: number;
+        hits?: number;
+    }[]);
+    private observedForms;
     /** Diagnostics: +2 to matrix action pools while sustained. */
     get formMatrixBonus(): number;
     /** Static Veil: +2 to matrix defense while sustained. */
     get formDefenseBonus(): number;
     get sustainingPenalty(): number;
-    astralPerceiving: boolean;
+    private _astralPerceiving;
+    /** Assensing (SR5 p.312): the live sheet shows it, so a change is a
+     *  condition beat. Accessor pair -- every writer compiles unchanged. */
+    get astralPerceiving(): boolean;
+    set astralPerceiving(v: boolean);
     sneaking: boolean;
     riggedDrone?: Item;
     /** Whether the ridden drone carries a weapon mount (name/description duck-typing). */

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

@@ -16,40 +16,11 @@ export const STANCE_CYCLE = ['manual', 'guarded', 'aggressive'];
 export function isPhysicalPlane(plane) {
     return plane === 'meat' || plane === 'drone';
 }
-/**
- * ARE THESE TWO STANDING ON THE SAME SIDE OF A HOST'S WALL?
- *
- * The companion to fileReach, and it exists for the same reason: the
- * boundary was being asked about in more than one place and the copies
- * disagreed. fileReach settled it for FILES; nothing settled it for
- * ICONS, so `look` honoured insideHost while every verb that picks a
- * target read the room's raw actor list and saw straight through the
- * wall. A technomancer standing inside a host was told "Empty
- * architecture -- turning geometry and nothing in it worth the trip" by
- * one surface and offered those same two IC as spike targets by the
- * next.
- *
- * CANON MAKES THE PANEL BINDING, not the target list. Inside a host you
- * see and interact with the icons inside it and not the ones outside,
- * and from the grid the inside is unreachable (p.246) -- and threading
- * adds its own half of the same rule: "You can only use complex forms
- * on icons you've spotted" (p.251). An icon the room refuses to name is
- * an icon nobody has spotted, so targeting it was never legal.
- *
- * BOTH IN THE SAME ROOM IS THE PRECONDITION, and every caller has it --
- * these are room-scoped target lists. Given that, comparing insideHost
- * directly is the whole rule: both undefined means both are out on the
- * open grid, both equal to the room means both are inside its
- * architecture. There is deliberately no third state.
- *
- * MEAT AND ASTRAL ACTORS PASS TRIVIALLY, which is correct and not an
- * oversight: insideHost is persona state, so a body in the room has
- * none. The plane filters the callers already apply are what keep those
- * actors out of a Matrix target list; this function answers one question
- * and is not a second plane check.
- */
 export function sameHostSide(actor, other) {
-    return actor.insideHost === other.insideHost;
+    // A real Player answers with its Host; a bare fixture ({ insideHost })
+    // answers with whatever it carries. Both sides read the same way.
+    const sideOf = (p) => p.hostInside ?? p.insideHost;
+    return sideOf(actor) === sideOf(other);
 }
 export const SKILL_NAMES = [
     'blades', 'clubs', 'unarmed', 'archery', 'free-fall',
@@ -426,7 +397,68 @@ export class Player extends AbstractPlayer {
      * Session state like hostAlert and linkLockedBy: leaving the Matrix
      * ends it, so nothing here is persisted.
      */
-    insideHost;
+    /**
+     * WHERE THE PERSONA IS (increment 2 of the Matrix position model): on a
+     * grid, or inside a host it entered from one. Session-only, like
+     * bodyRoom. The body stays in currentLocation on every plane -- the
+     * persona never writes it. The setter fires the live-sheet beat, which
+     * is the beat the currentLocation setter used to fire on enter/exit.
+     * `grid` may be unknown (fixtures, and increment 2 itself): unknown is
+     * not "another grid", so it costs nothing.
+     */
+    _matrixPosition;
+    get matrixPosition() { return this._matrixPosition; }
+    set matrixPosition(v) {
+        const same = v === this._matrixPosition
+            || (v !== undefined && this._matrixPosition !== undefined && v.kind === this._matrixPosition.kind
+                && (v.kind === 'host' ? v.host === this._matrixPosition.host
+                    : v.grid?.key === this._matrixPosition.grid?.key));
+        if (same)
+            return;
+        this._matrixPosition = v;
+        this.noteConditionChanged();
+    }
+    /** The grid the persona rides, when it is on one. */
+    get currentGrid() {
+        return this._matrixPosition?.kind === 'grid' ? this._matrixPosition.grid : undefined;
+    }
+    /** The host the persona is inside, when it is inside one. */
+    get hostInside() {
+        return this._matrixPosition?.kind === 'host' ? this._matrixPosition.host : undefined;
+    }
+    /**
+     * @deprecated compat through increment 4 -- read hostInside / write
+     * matrixPosition. The room a host stands over, when inside one. The
+     * setter still builds the position so every old writer keeps working.
+     */
+    _compatInsideRoom;
+    get insideHost() { return this.hostInside?.over ?? this._compatInsideRoom; }
+    set insideHost(room) {
+        if (room) {
+            // A room you are inside of IS a host. Fixtures (and older callers)
+            // set insideHost on a plain Room; install the Host they meant.
+            if (!room.host)
+                room.hasNode = true;
+            const host = room.host;
+            if (!host) {
+                // Not a real Room (a fixture stub): remember it so the getter and
+                // sameHostSide still answer, without a position to stand on.
+                this._compatInsideRoom = room;
+                return;
+            }
+            this._compatInsideRoom = undefined;
+            this.matrixPosition = { kind: 'host', host, from: this.currentGrid ?? this.lastGrid };
+        }
+        else {
+            this._compatInsideRoom = undefined;
+            if (this._matrixPosition?.kind === 'host')
+                this.matrixPosition = { kind: 'grid', grid: this._matrixPosition.from };
+        }
+    }
+    /** The grid last stood on, so an exit built through the old setter returns there. */
+    get lastGrid() {
+        return this._matrixPosition?.kind === 'host' ? this._matrixPosition.from : this._matrixPosition?.grid;
+    }
     /**
      * MATRIX ATTRIBUTES BURNED OFF BY IC (p.248): Acid eats Firewall,
      * Binder eats Data Processing, Jammer eats Attack, Marker eats Sleaze.
@@ -647,7 +679,13 @@ export class Player extends AbstractPlayer {
         dataProcessing: 'Data Processing', firewall: 'Firewall',
     };
     /** The undamaged array, before any IC reduction. */
+    /** Set on an IC actor (utilities/ic-actors.ts): "IC uses the Matrix attributes of its host" (p.247). */
+    icHost;
+    /** The IC kind an IC actor was launched as -- the name the host's running list carries. */
+    icKind;
     baseMatrixAttribute(kind) {
+        if (this.icHost)
+            return this.icHost.attributes()[kind];
         if (this.isTechnomancer()) {
             switch (kind) {
                 case 'attack': return this.charisma;
@@ -922,7 +960,13 @@ export class Player extends AbstractPlayer {
     /** Routes Matrix combat damage into the jacked-in deck's hardware track. */
     takeMatrixDamage(boxes) {
         const deck = this.getAnyCyberdeck();
-        return deck ? deck.takeDeckDamage(boxes) : 0;
+        const taken = deck ? deck.takeDeckDamage(boxes) : 0;
+        // DECK DAMAGE BEATS (web report 2026-09-02: "the damage to the deck is not moving in realtime"):
+        // the Item has no path to its owner, so the owner fires here, and the
+        // exchange and rest fire on their own deck writes.
+        if (taken > 0)
+            this.noteConditionChanged();
+        return taken;
     }
     get matrixCrashed() {
         return this.getAnyCyberdeck()?.isBricked ?? false;
@@ -2681,7 +2725,14 @@ export class Player extends AbstractPlayer {
         return this._sustainedArmor;
     }
     setSustainedArmor(bonus) {
-        this._sustainedArmor = Math.max(0, Math.floor(bonus));
+        const next = Math.max(0, Math.floor(bonus));
+        if (next === this._sustainedArmor)
+            return;
+        this._sustainedArmor = next;
+        // SUSTAINS BEAT ON FLIP (web report 2026-09-02: "I cast armor on myself
+        // and don't see it in the sustained list"): the sheet only caught up on
+        // the next unrelated beat. Every sustain mutator fires the hook now.
+        this.noteConditionChanged();
     }
     /**
      * REST BREAKS CONCENTRATION (yZSAdPAvwMpzjnTaM; SR5 p.251: "You
@@ -2734,17 +2785,45 @@ export class Player extends AbstractPlayer {
     // light around the bearer (+3 on sneak contests, npc.ts), increase
     // reflexes runs the nerves hot (+2 initiative). Each holds the standard
     // -2 sustaining burden; cast again to release (cast.ts).
-    sustainedInvisibility = false;
-    sustainedReflexes = false;
+    _sustainedInvisibility = false;
+    get sustainedInvisibility() { return this._sustainedInvisibility; }
+    set sustainedInvisibility(v) {
+        if (this._sustainedInvisibility === v)
+            return;
+        this._sustainedInvisibility = v;
+        this.noteConditionChanged();
+    }
+    _sustainedReflexes = false;
+    get sustainedReflexes() { return this._sustainedReflexes; }
+    set sustainedReflexes(v) {
+        if (this._sustainedReflexes === v)
+            return;
+        this._sustainedReflexes = v;
+        this.noteConditionChanged();
+    }
     /** The sustained PHYSICAL BARRIER spell (ruling 2026-08-24): seals
      *  one exit of one room while held -- go.ts and move refuse passage
      *  for everyone (the caster included; walls don't play favorites).
      *  Session-only, like every sustain. */
-    sustainedBarrier;
+    _sustainedBarrier;
+    get sustainedBarrier() { return this._sustainedBarrier; }
+    set sustainedBarrier(v) {
+        if (this._sustainedBarrier === v)
+            return;
+        this._sustainedBarrier = v;
+        this.noteConditionChanged();
+    }
     /** The MANA BARRIER twin (canon p.294, RAG-checked): blocks SPIRITS
      *  and astral forms at the sealed exit; living mundanes and physical
      *  objects pass freely. Same lifecycle as sustainedBarrier. */
-    sustainedManaBarrier;
+    _sustainedManaBarrier;
+    get sustainedManaBarrier() { return this._sustainedManaBarrier; }
+    set sustainedManaBarrier(v) {
+        if (this._sustainedManaBarrier === v)
+            return;
+        this._sustainedManaBarrier = v;
+        this.noteConditionChanged();
+    }
     // THREADED COMPLEX FORMS (M4.15, see commands/thread.ts): the
     // technomancer's sustained workings ride the same -2 rail as spells.
     // Instant forms never land here.
@@ -2752,7 +2831,30 @@ export class Player extends AbstractPlayer {
      *  Complex Form (p.250) eats away at. Optional so a form woven by
      *  anything that predates that bookkeeping still reads sanely;
      *  unravel.ts falls back to the Level. */
-    sustainedForms = [];
+    _sustainedForms = this.observedForms([]);
+    /** Sustained complex forms. Writers push/splice it directly (sustain.ts,
+     *  thread.ts, game.ts), so the array itself is observed: every element
+     *  write fires the beat, and assigning a fresh array re-wraps it. */
+    get sustainedForms() { return this._sustainedForms; }
+    set sustainedForms(v) {
+        this._sustainedForms = this.observedForms([...v]);
+        this.noteConditionChanged();
+    }
+    observedForms(arr) {
+        return new Proxy(arr, {
+            set: (target, key, value) => {
+                target[key] = value;
+                if (key !== 'length')
+                    this.noteConditionChanged();
+                return true;
+            },
+            deleteProperty: (target, key) => {
+                delete target[key];
+                this.noteConditionChanged();
+                return true;
+            },
+        });
+    }
     /** Diagnostics: +2 to matrix action pools while sustained. */
     get formMatrixBonus() {
         return this.sustainedForms.some(f => f.key === 'diagnostics') ? 2 : 0;
@@ -2782,7 +2884,16 @@ export class Player extends AbstractPlayer {
     // sustained state -- passive aura reads, at -2 dice to everything else.
     // Meat-plane only; projecting IS full astral senses (cleared on
     // project), and the Matrix has no auras at all.
-    astralPerceiving = false;
+    _astralPerceiving = false;
+    /** Assensing (SR5 p.312): the live sheet shows it, so a change is a
+     *  condition beat. Accessor pair -- every writer compiles unchanged. */
+    get astralPerceiving() { return this._astralPerceiving; }
+    set astralPerceiving(v) {
+        if (this._astralPerceiving === v)
+            return;
+        this._astralPerceiving = v;
+        this.noteConditionChanged();
+    }
     // Sneak-walking (see commands/sneak.ts): room entries become opposed
     // Sneaking-vs-Perception rolls per witness (NPC.see). Broken by any
     // loud act -- attacking, casting, speaking, brandishing, calling.