@maka/maka-cli 5.392.0 → 5.393.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.392.0",
+  "version": "5.393.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",

package/bundle/typescript/src/commands/game/sideQuest/commands/assense.js

@@ -68,7 +68,7 @@ export class AssenseCommand extends Command {
             return `${target.name} has no aura -- on the astral it is a featureless grey shadow of its frame, neither living nor magical (p.313). Nothing to read.`;
         }
         const skill = actor.skillRating('assensing');
-        const pool = Math.max(1, actor.intuition + (skill > 0 ? skill : -1) + actor.woundModifier - actor.sustainingPenalty);
+        const pool = Math.max(1, actor.intuition + (skill > 0 ? skill : -1) + actor.woundModifier - actor.sustainingPenalty - actor.backgroundCountPenalty);
         const roll = rollPool(pool);
         const lines = [`You read ${target.name}'s aura -- Assensing: ${formatRoll(roll)}`];
         if (roll.hits === 0) {

package/bundle/typescript/src/commands/game/sideQuest/commands/dispel.js

@@ -41,7 +41,7 @@ export class DispelCommand extends CastCommand {
     static description = 'Unweave a SUSTAINED SPELL -- Magic + counterspelling, opposed by its caster\'s grip: "dispel <name>", "dispel invisibility on <name>", "dispel barrier". No backlash; retry freely. A ward is not dispelled -- press through it or attack it from the astral.';
     dispelPool() {
         const skill = this.actor.skillRating('counterspelling');
-        return Math.max(1, this.actor.magic + (skill > 0 ? skill : -1) + this.actor.woundModifier - this.actor.sustainingPenalty);
+        return Math.max(1, this.actor.magic + (skill > 0 ? skill : -1) + this.actor.woundModifier - this.actor.sustainingPenalty - this.actor.backgroundCountPenalty);
     }
     async execute(args = []) {
         // The counter-weave is still an incantation -- it carries (sneak ends),

package/bundle/typescript/src/commands/game/sideQuest/commands/summon.js

@@ -57,7 +57,8 @@ export class SummonCommand extends Command {
             return bill;
         // The opposed test (p.300): Magic + conjuring vs the spirit's Force.
         const conjuring = actor.skillRating('conjuring');
-        const mine = rollPool(Math.max(1, actor.magic + (conjuring > 0 ? conjuring : -1) + actor.woundModifier - actor.sustainingPenalty));
+        // The background count bites every magic-linked test (SG p.32).
+        const mine = rollPool(Math.max(1, actor.magic + (conjuring > 0 ? conjuring : -1) + actor.woundModifier - actor.sustainingPenalty - actor.backgroundCountPenalty));
         const spirit = rollPool(force);
         const services = Math.max(0, mine.hits - spirit.hits);
         // Drain: 2x the SPIRIT's hits, min 2 (p.300), resisted with

package/bundle/typescript/src/commands/game/sideQuest/commands/time.js

@@ -19,7 +19,10 @@ export class TimeCommand extends Command {
     static verb = 'time';
     static description = 'Check the clock: the time of day, and whether you are in the small hours yet. In a shared run everyone reads the host\'s clock, so "after midnight" means the same moment for the whole team.';
     async execute(_args = []) {
-        const now = new Date();
+        // A RUN WITH A DISTRICT START TIME keeps its own hour (environment.ts,
+        // Scene.worldTime): 23:30 when it started, plus the game clock since.
+        const now = this.scene.worldTime?.() ?? new Date();
+        const gameTime = this.scene.district?.startTime !== undefined;
         // Asked ENGINE-SIDE, which is the only place that can answer it: in
         // a shared run this command executes on the server, where
         // `remoteSession` (the CLIENT's link to that server) is undefined.
@@ -55,6 +58,10 @@ export class TimeCommand extends Command {
             const wait = hrs > 0 ? `${hrs}h ${mins % 60}m` : `${mins}m`;
             lines.push(`  Not the small hours yet -- midnight is ${wait} out.`);
         }
+        if (gameTime) {
+            lines.push(`  {white-fg}This job keeps its own hour -- it started at ${this.scene.district.startTime}, and the clock runs as the night does.{/white-fg}`);
+            return lines.filter(l => l.length > 0).join('\n');
+        }
         lines.push(shared
             // Both lines name the zone, because the whole point is that this
             // is NOT your machine's clock. It used to say "runs on this

package/bundle/typescript/src/commands/game/sideQuest/engine-version.js

@@ -3415,5 +3415,15 @@
 //   press through on Magic + Charisma [Astral] v. Force x 2, "attack ward"
 //   from the astral; the ward device kind is gone and legacy ones migrate
 //   onto their room.
-export const ENGINE_VERSION = '1.204.0';
+// 1.205.0 (2026-10-07): THE DISTRICT. A seed's `district` sets the map's
+//   conditions and a room's `conditions` override them (utilities/
+//   environment.ts): a start time the game clock runs from (crowds and
+//   `time` read it); weather, wind and daylight outdoors as p.173-176
+//   environmental modifiers -- worst wins, ties bump, two at -6 make -10,
+//   range now combines instead of stacking, vision compensates -- on
+//   attacks and sight-based perception; background count (SG p.30-32) on
+//   every magic pool, wards and sustained spells reduced by it; spam and
+//   static zones (p.231) as noise on every Matrix action. An authored
+//   localGrid survives a hub ride-out.
+export const ENGINE_VERSION = '1.205.0';
 //# sourceMappingURL=engine-version.js.map

package/bundle/typescript/src/commands/game/sideQuest/factories/authored-run.js

@@ -1,3 +1,4 @@
+import { districtFaults } from '../utilities/environment.js';
 import { wallFixtureKindOf } from '../utilities/room-grid.js';
 import { roomGridWire } from '../utilities/ways-out.js';
 import { icTypeNamed, IC_TYPES, resolveICOrder } from '../utilities/ic.js';
@@ -486,6 +487,15 @@ export function authoredSpiderFaults(seed, built) {
     }
     return faults;
 }
+/**
+ * THE DISTRICT'S CONDITIONS (utilities/environment.ts, 2026-10-07): the
+ * start time, weather, wind, light, background count and Matrix zone, and
+ * any room's own -- each a value canon names, nothing else.
+ */
+export function authoredDistrictFaults(seed) {
+    return districtFaults(seed.district, (seed.rooms ?? []).map(r => ({ name: r.name, conditions: r.conditions })))
+        .map(message => ({ check: 'district', message, rooms: (seed.rooms ?? []).filter(r => message.includes(`"${r.name}"`)).map(r => r.name) }));
+}
 /**
  * WARDS ARE A ROOM'S (user 2026-10-06; SR5 p.297-298, p.315-316): a
  * warded room carries the ward's Force -- what pressing through and
@@ -558,7 +568,7 @@ export function authoredGroundFaults(seed) {
 }
 export async function validateAuthoredRun(seed) {
     const { faults, built } = await SceneSeedGenerator.auditSeed(prepareAuthoredSeed(seed).seed);
-    return [...authoredGroundFaults(seed), ...authoredItemFaults(seed), ...authoredSpotFaults(seed), ...authoredNpcFaults(seed), ...authoredSecurityFaults(seed), ...authoredDoorwayFaults(seed, built), ...authoredDoorstepFaults(seed, built), ...authoredSpiderFaults(seed, built), ...authoredWardFaults(seed, built), ...faults.map(f => ({ ...f, rooms: roomsNamed(f.message, seed) }))];
+    return [...authoredGroundFaults(seed), ...authoredItemFaults(seed), ...authoredSpotFaults(seed), ...authoredNpcFaults(seed), ...authoredSecurityFaults(seed), ...authoredDoorwayFaults(seed, built), ...authoredDoorstepFaults(seed, built), ...authoredSpiderFaults(seed, built), ...authoredWardFaults(seed, built), ...authoredDistrictFaults(seed), ...faults.map(f => ({ ...f, rooms: roomsNamed(f.message, seed) }))];
 }
 export function matrixWire(built) {
     const rooms = built.getRooms();
@@ -610,7 +620,7 @@ export async function previewAuthoredRun(seed, heads = 1) {
             rooms[room.name] = wire;
     }
     return {
-        faults: [...authoredGroundFaults(seed), ...authoredItemFaults(seed), ...authoredSpotFaults(seed), ...authoredNpcFaults(seed), ...authoredSecurityFaults(seed), ...authoredDoorwayFaults(seed, built), ...authoredDoorstepFaults(seed, built), ...authoredSpiderFaults(seed, built), ...authoredWardFaults(seed, built), ...faults.map(f => ({ ...f, rooms: roomsNamed(f.message, seed) }))],
+        faults: [...authoredGroundFaults(seed), ...authoredItemFaults(seed), ...authoredSpotFaults(seed), ...authoredNpcFaults(seed), ...authoredSecurityFaults(seed), ...authoredDoorwayFaults(seed, built), ...authoredDoorstepFaults(seed, built), ...authoredSpiderFaults(seed, built), ...authoredWardFaults(seed, built), ...authoredDistrictFaults(seed), ...faults.map(f => ({ ...f, rooms: roomsNamed(f.message, seed) }))],
         rooms,
         ...(built ? { matrix: matrixWire(built) } : {}),
         payout: prepared.seed.winCondition?.payout,

package/bundle/typescript/src/commands/game/sideQuest/factories/room-factory.js

@@ -50,6 +50,7 @@ export class RoomFactory {
             camerasSlavedTo: roomJson.camerasSlavedTo,
             // The crowd (utilities/crowd.ts) -- named here or this whitelist eats it.
             occupancy: roomJson.occupancy,
+            conditions: roomJson.conditions,
             // "At" spots ride through -- this whitelist SILENTLY DROPS any
             // field not named here (it already ate `owner` once; see the
             // scene-factory patch that re-applies it).

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-factory.js

@@ -1,3 +1,5 @@
+import { startSecondsOf } from '../utilities/environment.js';
+import { partOfDay } from '../utilities/world-clock.js';
 import { Scene } from '../models/scene.js';
 import { localGrid } from '../utilities/grids.js';
 import { ensureJackPoint } from '../utilities/jackpoint.js';
@@ -172,6 +174,12 @@ export class SceneSynthesizer {
             scene.neighborhood = json.neighborhood;
         if (typeof json.lawContract === 'string' && json.lawContract)
             scene.lawContract = json.lawContract;
+        // THE DISTRICT (environment.ts): the map's conditions, and the hour the
+        // run starts at. Rooms built so far took their crowd off the wall clock;
+        // with a start time they are re-derived for the run's own hour below,
+        // once every room exists.
+        if (json.district && typeof json.district === 'object')
+            scene.district = json.district;
         // Shared context handed to every ensureAI*() call below, so room
         // descriptions, NPC appearances, and puzzle riddles all stay
         // consistent with the same scene tone.
@@ -195,6 +203,13 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
             scene.addRoom(room);
             builtRooms.push(room);
         }
+        // THE RUN'S OWN HOUR (environment.ts): a district start time sets the
+        // crowds for that part of the day, not the wall clock's.
+        if (startSecondsOf(scene.district) !== undefined) {
+            const when = partOfDay(scene.worldTime());
+            for (const room of builtRooms)
+                room.rederiveCrowd(when);
+        }
         beat(`rooms:${builtRooms.length}`);
         if (useAi) {
             await enrichConcurrently(builtRooms, r => r.ensureAIDescription(sceneContext), (done, total) => beat(`rooms-dressed:${done}/${total}`));

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

@@ -8072,8 +8072,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         // forward), and no blocking AI-redressing pass either -- the chunked
         // rooms pass already wrote this scene's prose.
         this.scene = await SceneSynthesizer.synthesizeFromJson(seed, this.player, false, false);
-        // A run happens in the same metroplex: it rides the hub's local grid.
-        if (this._hubScene)
+        // A run happens in the same metroplex: it rides the hub's local grid --
+        // unless its seed names its own (a player-built run's District tab).
+        if (this._hubScene && !seed.localGrid)
             this.scene.localGrid = this._hubScene.localGrid;
         this.scene.initialize(this);
         this.resolveHostGrids();

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

@@ -1,3 +1,4 @@
+import { sightModifier } from '../utilities/environment.js';
 import { registerNotice, registerProvocation, PROVOCATION } from '../utilities/hostile-contact.js';
 import { hint } from '../utilities/hints.js';
 import { npcSilenceNote } from '../utilities/draft-failure-note.js';
@@ -1539,7 +1540,8 @@ description text.`;
                 // pool.
                 const sneak = rollPool(Math.max(1, actor.agility + (theirSkill > 0 ? theirSkill : -1) + actor.bonus('sneak') + actor.woundModifier));
                 const mySkill = this.skillRating('perception');
-                const spot = rollPool(Math.max(1, this.intuition + (mySkill > 0 ? mySkill : -1) + this.woundModifier));
+                // The watcher's side carries Visibility and Light (p.136, p.135).
+                const spot = rollPool(Math.max(1, this.intuition + (mySkill > 0 ? mySkill : -1) + sightModifier(this, this.currentLocation, actor.currentLocation) + this.woundModifier));
                 this.logger.write(`[SNEAK] ${actor.name} ${sneak.hits} vs ${this.name} ${spot.hits}.`);
                 // The dice are PLAYER-VISIBLE either way, like every other contest
                 // in the game -- a real session's sneaks read as "nothing

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

@@ -1,3 +1,4 @@
+import { backgroundPenalty, zoneNoise } from '../utilities/environment.js';
 import { carryMode, carryPhrase } from '../utilities/carry.js';
 import { getSoft, getProgram } from '../utilities/programs.js';
 import { GEAR_LANES, CHROME_LANES, QUALITY_LANES, ART_LANES, ADEPT_LANES, scaleOf } from '../utilities/effects.js';
@@ -1144,7 +1145,19 @@ export class Player extends AbstractPlayer {
      * nothing but some dropped calls.
      */
     get matrixActionPenalty() {
-        return this.runningSilent ? -2 : 0;
+        return (this.runningSilent ? -2 : 0) - this.matrixZoneNoise;
+    }
+    /**
+     * A SPAM OR STATIC ZONE where this persona is (p.230-231; the district's
+     * and room's conditions, utilities/environment.ts): its rating as noise
+     * on every Matrix action. Inside a host there is no zone -- p.235 gives a
+     * host no physical place for one to be.
+     */
+    get matrixZoneNoise() {
+        if (this.insideHost)
+            return 0;
+        const room = this.bodyRoom ?? this.currentLocation;
+        return room ? zoneNoise(room.scene, room) : 0;
     }
     /**
      * THIS PERSONA'S MATRIX ATTRIBUTE (p.226 for a deck's array, p.251
@@ -3096,6 +3109,7 @@ export class Player extends AbstractPlayer {
             this.leaveRoom();
             this.enterRoom(room);
             this._currentLocation = room;
+            this.fizzleUnderBackground();
             // The live sheet's "where" (2026-09-01): a room change reports
             // through the same hook the condition mutators fire -- position
             // rides every report, and this is the choke point every movement
@@ -4326,7 +4340,7 @@ export class Player extends AbstractPlayer {
             // astral with unarmed. That is a migration question, not a rules
             // one, and it is not this item's to answer.
             const astralSkill = Math.max(this.skillRating('unarmed'), this.skillRating('astral-combat'));
-            return Math.max(0, this.willpower + astralSkill + this.woundModifier - this.sustainingPenalty);
+            return Math.max(0, this.willpower + astralSkill + this.woundModifier - this.sustainingPenalty - this.backgroundCountPenalty);
         }
         // An adept's magic lives in their hands. Compressed model: half their
         // Power Points ride every strike. Chosen powers: Improved Ability
@@ -4417,7 +4431,8 @@ export class Player extends AbstractPlayer {
             return Math.max(0, this.intuition + this.matrixAttribute('firewall') + hot + this.bonus('matrix') + this.formDefenseBonus + this.woundModifier - this.sustainingPenalty);
         }
         if (this.plane === 'astral') {
-            return Math.max(0, this.intuition + Math.floor(this.magic / 2) + this.woundModifier - this.sustainingPenalty);
+            // Astral combat is magic-linked: the background count bites (SG p.32).
+            return Math.max(0, this.intuition + Math.floor(this.magic / 2) + this.woundModifier - this.sustainingPenalty - this.backgroundCountPenalty);
         }
         // Combat sense: the adept's magic reads the fight before it happens.
         // Wired reflexes read it faster still. Locked in someone's grapple
@@ -5430,6 +5445,34 @@ export class Player extends AbstractPlayer {
             .filter(i => i.category === Category.Focus)
             .sort((a, b) => (b.ratingValue ?? 0) - (a.ratingValue ?? 0))[0];
     }
+    /**
+     * BACKGROUND COUNT where this actor stands (Street Grimoire p.30-32;
+     * utilities/environment.ts): its absolute value, a dice pool penalty on
+     * every test linked to magic -- spellcasting, conjuring, counterspelling,
+     * assensing, astral combat. 0 anywhere the district and the room say
+     * nothing, which is every scene without a district.
+     */
+    get backgroundCountPenalty() {
+        const room = this.currentLocation;
+        return room ? backgroundPenalty(room.scene, room) : 0;
+    }
+    /**
+     * SPELLS UNDER A BACKGROUND COUNT (Street Grimoire p.32): sustained
+     * spells "are reduced by the background count"; at 0 or less they
+     * fizzle. Checked on arrival, for the spells worn on this character --
+     * a barrier stands where it was raised and is not carried in.
+     */
+    fizzleUnderBackground() {
+        const bc = this.backgroundCountPenalty;
+        if (bc <= 0)
+            return;
+        for (const w of this.wornWorkings()) {
+            if (w.kind !== 'spell' || w.key === 'barrier' || w.key === 'manabarrier')
+                continue;
+            if (w.force !== undefined && w.force - bc <= 0)
+                this.dropSustainedWorking(w.key);
+        }
+    }
     getMagicPool() {
         // A focus adds its Force to the tests it is bonded for (p.318): the
         // row's effects, scaled by Force (catalog v13).
@@ -5442,7 +5485,7 @@ export class Player extends AbstractPlayer {
         const base = this.isAwakened()
             ? (spellSkill > 0 ? this.magic + spellSkill : Math.max(Player.BASE_MAGIC_POOL, this.magic + 2))
             : Player.BASE_MAGIC_POOL + spellSkill;
-        return Math.max(0, base + focusBonus + this.woundModifier - this.sustainingPenalty);
+        return Math.max(0, base + focusBonus + this.woundModifier - this.sustainingPenalty - this.backgroundCountPenalty);
     }
     /**
      * A magician/mystic adept knows the spells in their CHOSEN spellbook

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

@@ -1125,10 +1125,27 @@ export class Room extends AbstractRoom {
         this.tags = config.tags;
         // THE CROWD (utilities/crowd.ts): the seed's headcount when it names
         // one, otherwise what this kind of place holds at this time of day.
+        this.conditions = config.conditions;
+        this.authoredOccupancy = config.occupancy !== undefined;
         this.crowd = freshCrowd(config.occupancy !== undefined
             ? clampHeadcount(config.occupancy)
             : deriveOccupancy({ name: this.name, roomType: this.roomType, tags: this.tags, outdoors: this.outdoors, size: this.size, dwelling: this.dwelling, residenceTier: this.residenceTier }));
     }
+    /** This room's own conditions (utilities/environment.ts conditionsAt). */
+    conditions;
+    /** Whether the seed named this room's headcount (then time never moves it). */
+    authoredOccupancy = false;
+    /**
+     * THE CROWD AT THE SCENE'S OWN HOUR (a district start time,
+     * environment.ts): a room built before the scene knew its clock derived
+     * its headcount from the wall clock; this re-derives it for the run's
+     * part of day. An authored headcount is the author's and stays.
+     */
+    rederiveCrowd(when) {
+        if (this.authoredOccupancy)
+            return;
+        this.crowd = freshCrowd(deriveOccupancy({ name: this.name, roomType: this.roomType, tags: this.tags, outdoors: this.outdoors, size: this.size, dwelling: this.dwelling, residenceTier: this.residenceTier }, when));
+    }
     /** The unnamed people in this room and how they are taking it (crowd.ts). */
     crowd;
     /**

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

@@ -1,3 +1,5 @@
+import { startSecondsOf } from '../utilities/environment.js';
+import { worldNow } from '../utilities/world-clock.js';
 import { Room, Item, NPC } from './_index.js';
 import { capitalCase } from 'change-case';
 import { localGrid as makeLocalGrid } from '../utilities/grids.js';
@@ -157,6 +159,21 @@ export class Scene extends AbstractScene {
     neighborhood;
     /** Who answers a call here (ISceneSeedJson.lawContract; law-response.ts). */
     lawContract;
+    /** The district's conditions (ISceneSeedJson.district; environment.ts). */
+    district;
+    /**
+     * THE WORLD'S TIME AT THIS TABLE. A district with a start time runs on
+     * game time -- that hour, today (UTC), plus the seconds the game clock
+     * has counted -- so a run set at 23:30 is night for everyone in it,
+     * whenever it is played. Without one, the world clock (world-clock.ts).
+     */
+    worldTime(now = new Date()) {
+        const start = startSecondsOf(this.district);
+        if (start === undefined)
+            return worldNow(now);
+        const day = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+        return new Date(day + (start + this.gameClock.seconds) * 1000);
+    }
     /** The law response called to this site, if any (law-response.ts). */
     lawResponse;
     /**

package/bundle/typescript/src/commands/game/sideQuest/utilities/combat-exchange.js

@@ -1,3 +1,4 @@
+import { environmentalModifier, rangeRowOf } from './environment.js';
 import { allBreached, damageFace, penetrationBoxes, pierces, BARRIER_FOG } from './barrier-geometry.js';
 import { recoilCompensation, recoilPenalty } from './recoil.js';
 import { Category } from '../types/shared/item-enum.js';
@@ -662,7 +663,14 @@ export class CombatExchange {
             if (a && d && this.scene.barrierOnLine?.(a, d, 'physical'))
                 fog = BARRIER_FOG;
         }
-        const rangeMod = range === 'out-of-range' ? -6 : range;
+        const rangeOnly = range === 'out-of-range' ? -6 : range;
+        // THE ENVIRONMENT (p.173-176; utilities/environment.ts): the district's
+        // weather, wind and daylight outdoors, a room's own light, the barrier's
+        // Light Fog, AND the range -- range is an environmental modifier too,
+        // so they combine (worst wins, ties bump a category) instead of
+        // stacking. A spell reads Light and Visibility only, as melee does.
+        const env = environmentalModifier(this.scene, [attacker.currentLocation, defender.currentLocation].filter(Boolean), attacker, { melee: isMelee || !!strike.isSpell, rangeRow: rangeRowOf(rangeOnly), extraVisRow: fog ? 1 : 0 });
+        const rangeMod = env.modifier;
         // p.190 grants the bonus to a defender who "uses a Take Cover
         // action" -- so the dice follow the ACTION, not the address.
         const coverDice = isInCover(defender)
@@ -706,7 +714,7 @@ export class CombatExchange {
         // charging, a running defender, surprise, Full Defense and the
         // dodge/block/parry interrupts -- see turnModifiers below.
         const turn = this.turnModifiers(attacker, defender, isMelee, strike, meta);
-        const attack = rollPool(strike.pool + directed + rangeMod + attackerFloor + targetDown + turn.attack + recoil + fog, attackLimit);
+        const attack = rollPool(strike.pool + directed + rangeMod + attackerFloor + targetDown + turn.attack + recoil, attackLimit);
         // A DIRECT SPELL IS NOT DODGED (p.283): the target opposes the
         // casting test with Body or Willpower, and only counterspelling (and
         // a teammate's inspiration) helps -- not cover, posture, surprise or
@@ -717,12 +725,14 @@ export class CombatExchange {
                 ? rollPool(0)
                 : rollPool(defender.getDefensePool() + inspired + counterspell + coverDice + proneDefence + turn.defense);
         const rangeNote = weaponClass && spatial.meters > 0
-            ? ` (${rangeMod !== 0 ? `${rangeMod} range` : `${rangeBracketName(spatial.meters, weaponClass)} range`} -- ~${Math.round(spatial.meters)} m)`
+            ? ` (${rangeBracketName(spatial.meters, weaponClass)} range -- ~${Math.round(spatial.meters)} m)`
             : '';
+        // The one environmental modifier that counted, and what made it.
+        const envNote = env.modifier !== 0 ? ` (${env.modifier} ${env.conditions.join(' + ')}${env.conditions.length > 1 ? ', tied' : ''}, p.175)` : '';
         const recoilNote = recoil < 0 && strike.weaponItem
             ? ` (${recoil} recoil -- round ${attacker.recoilRoundsFired} against RC ${recoilCompensation(attacker, strike.weaponItem)})`
             : '';
-        meta.push(`  Attack:  ${formatRoll(attack)}${directed > 0 ? ` (+${directed} directed)` : ''}${rangeNote}${recoilNote}${fog ? ` (${fog} through a force barrier, Light Fog p.175)` : ''}`);
+        meta.push(`  Attack:  ${formatRoll(attack)}${directed > 0 ? ` (+${directed} directed)` : ''}${rangeNote}${envNote}${recoilNote}${fog ? ' (through a force barrier: Light Fog)' : ''}`);
         const coverNote = coverDice > 0 ? ` (+${coverDice} cover -- the ${spotOf(defender)})` : '';
         meta.push(`  Defense: ${formatRoll(defense)}${inspired > 0 ? ` (+${inspired} inspired)` : ''}${counterspell > 0 ? ` (+${counterspell} counterspell${counterspellSource ? ` -- ${counterspellSource}'s cover` : ''})` : ''}${coverNote}`);
         const dryWarning = strike.weaponItem?.isFirearm() && strike.weaponItem.ammo === 0

package/bundle/typescript/src/commands/game/sideQuest/utilities/door-watch.js

@@ -1,3 +1,4 @@
+import { sightModifier } from './environment.js';
 import { NPC } from '../models/npc.js';
 import { rollPool, formatRoll } from './dice.js';
 import { wouldNotice, doorwayBlocker } from './spots.js';
@@ -45,7 +46,7 @@ export function caughtAtDoor(room, direction, mover, isPlayer) {
             const theirSkill = mover.skillRating('sneaking');
             const sneak = rollPool(Math.max(1, mover.agility + (theirSkill > 0 ? theirSkill : -1) + mover.bonus('sneak') + mover.woundModifier));
             const mySkill = npc.skillRating('perception');
-            const spot = rollPool(Math.max(1, npc.intuition + (mySkill > 0 ? mySkill : -1) + npc.woundModifier));
+            const spot = rollPool(Math.max(1, npc.intuition + (mySkill > 0 ? mySkill : -1) + sightModifier(npc, room) + npc.woundModifier));
             if (isPlayer)
                 lines.push(`Slip past ${npc.name}: ${formatRoll(sneak)} vs ${formatRoll(spot)} -- ${sneak.hits > spot.hits ? 'unseen.' : 'SPOTTED.'}`);
             if (sneak.hits > spot.hits)

package/bundle/typescript/src/commands/game/sideQuest/utilities/environment.js

@@ -0,0 +1,194 @@
+/** The p.175 rows, as the dice pool modifier each sits on. */
+const ROWS = [0, -1, -3, -6];
+const LIGHT_ROW = { full: 0, partial: 1, dim: 2, dark: 3 };
+/** clear 0, light -1, heavy -6: the rows canon names for rain/fog/smoke. */
+const VIS_ROW = { clear: 0, light: 1, heavy: 3 };
+const WIND_ROW = { calm: 0, light: 1, moderate: 2, strong: 3 };
+const LIGHTS = new Set(['full', 'partial', 'dim', 'dark']);
+const VISES = new Set(['clear', 'light', 'heavy']);
+const WINDS = new Set(['calm', 'light', 'moderate', 'strong']);
+export function isLight(v) { return typeof v === 'string' && LIGHTS.has(v); }
+export function isVisibility(v) { return typeof v === 'string' && VISES.has(v); }
+export function isWind(v) { return typeof v === 'string' && WINDS.has(v); }
+export function isMatrixZone(v) {
+    const z = v;
+    return !!z && (z.kind === 'spam' || z.kind === 'static') && (z.rating === 2 || z.rating === 4 || z.rating === 6);
+}
+export function isBackgroundCount(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= -24 && v <= 24;
+}
+/** "HH:MM", 00:00-23:59. */
+export function isStartTime(v) {
+    return typeof v === 'string' && /^([01]\d|2[0-3]):[0-5]\d$/.test(v);
+}
+/** The district a scene was built with, if any (an authored run). */
+export function districtOf(scene) {
+    return scene?.district;
+}
+/**
+ * WHAT IS TRUE IN THIS ROOM. Outdoors takes the district's weather, wind
+ * and daylight; indoors is full light, clear air, no wind. Background
+ * count and the Matrix zone are the district's everywhere. A room's own
+ * `conditions` win over all of it.
+ */
+export function conditionsAt(scene, room) {
+    const d = districtOf(scene) ?? {};
+    const own = room?.conditions ?? {};
+    const outside = room?.outdoors === true;
+    return {
+        light: own.light ?? (outside ? d.outdoorLight ?? 'full' : 'full'),
+        visibility: own.visibility ?? (outside ? d.weather ?? 'clear' : 'clear'),
+        wind: outside ? d.wind ?? 'calm' : 'calm',
+        backgroundCount: own.backgroundCount ?? d.backgroundCount ?? 0,
+        matrixZone: own.matrixZone ?? d.matrixZone,
+    };
+}
+export function visionOf(viewer) {
+    const can = (k) => typeof viewer?.can === 'function' ? viewer.can(k) : false;
+    return { lowLight: can('low-light'), thermographic: can('thermographic') };
+}
+/** One condition's row after the viewer's vision compensates (p.175). */
+function lightRow(light, vision) {
+    let row = LIGHT_ROW[light];
+    if (vision.lowLight && (light === 'partial' || light === 'dim'))
+        row = 0;
+    if (vision.thermographic)
+        row = Math.max(0, row - 1);
+    return row;
+}
+function visRow(vis, vision) {
+    const row = VIS_ROW[vis];
+    return vision.thermographic ? Math.max(0, row - 1) : row;
+}
+/**
+ * COMBINE CONDITIONS THE p.173-175 WAY: the most severe row only; two or
+ * more tied at it bump one category (-1 -> -3 -> -6), and two or more at
+ * the -6 row make -10. `rows` are row indexes, 0 (none) to 3 (-6).
+ */
+export function combineRows(rows) {
+    const worst = Math.max(0, ...rows);
+    if (worst === 0)
+        return 0;
+    const tied = rows.filter(r => r === worst).length;
+    if (tied < 2)
+        return ROWS[worst];
+    return worst >= 3 ? -10 : ROWS[worst + 1];
+}
+/**
+ * THE ENVIRONMENTAL MODIFIER for a sight-based test in `room` (p.173-176).
+ * `rangeRow` is the range category the caller already worked out (0 none,
+ * 1 medium, 2 long, 3 extreme) -- range is an environmental modifier and
+ * combines with the rest rather than stacking. Melee reads Light and
+ * Visibility only.
+ */
+export function environmentalModifier(scene, room, viewer, opts = {}) {
+    // BETWEEN TWO PLACES (a shot from a doorway into the rain): each column
+    // at its worst along the way -- the shooter's room and the target's.
+    const all = (Array.isArray(room) ? room : [room]).map(r => conditionsAt(scene, r));
+    const vision = visionOf(viewer);
+    const worstOf = (rowOf, pick) => {
+        let best = { row: -1, value: pick(all[0]) };
+        for (const c of all) {
+            const row = rowOf(c);
+            if (row > best.row)
+                best = { row, value: pick(c) };
+        }
+        return best;
+    };
+    const parts = [];
+    const lw = worstOf(c => lightRow(c.light, vision), c => c.light);
+    if (lw.row > 0)
+        parts.push({ row: lw.row, label: lw.value === 'dark' ? 'darkness' : `${lw.value} light` });
+    const vw = worstOf(c => visRow(c.visibility, vision), c => c.visibility);
+    const v = Math.max(vw.row, opts.extraVisRow ?? 0);
+    if (v > 0) {
+        const kind = districtOf(scene)?.weatherKind ?? 'rain';
+        parts.push({ row: v, label: vw.row >= (opts.extraVisRow ?? 0) && vw.value !== 'clear' ? `${vw.value} ${kind}` : 'light fog' });
+    }
+    if (!opts.melee) {
+        const ww = worstOf(c => WIND_ROW[c.wind], c => c.wind);
+        if (ww.row > 0)
+            parts.push({ row: ww.row, label: `${ww.value} wind` });
+        if ((opts.rangeRow ?? 0) > 0)
+            parts.push({ row: opts.rangeRow, label: 'range' });
+    }
+    const modifier = combineRows(parts.map(p => p.row));
+    const worst = Math.max(0, ...parts.map(p => p.row));
+    return { modifier, conditions: parts.filter(p => p.row === worst && worst > 0).map(p => p.label) };
+}
+/** A range modifier as the engine computes it (rangePenalty) -> its p.175 row. */
+export function rangeRowOf(rangeModifier) {
+    if (rangeModifier <= -6)
+        return 3;
+    if (rangeModifier <= -3)
+        return 2;
+    if (rangeModifier <= -1)
+        return 1;
+    return 0;
+}
+/** BACKGROUND COUNT here, as the penalty canon applies (SG p.32): its
+ *  absolute value, on every magic-linked test. */
+export function backgroundPenalty(scene, room) {
+    return Math.abs(conditionsAt(scene, room).backgroundCount);
+}
+/** A spam or static zone's noise here (p.231), 0 when there is none. */
+export function zoneNoise(scene, room) {
+    return conditionsAt(scene, room).matrixZone?.rating ?? 0;
+}
+/** The seconds past UTC midnight a district's start time names. */
+export function startSecondsOf(district) {
+    if (!isStartTime(district?.startTime))
+        return undefined;
+    const [h, m] = district.startTime.split(':').map(Number);
+    return h * 3600 + m * 60;
+}
+/** Faults in a district or a room's conditions, for the seed audit. */
+export function districtFaults(district, rooms) {
+    const out = [];
+    if (district !== undefined) {
+        const d = district;
+        if (typeof d !== 'object' || d === null)
+            return ['district must be an object'];
+        if (d.startTime !== undefined && !isStartTime(d.startTime))
+            out.push(`district start time "${String(d.startTime)}" must be HH:MM, 00:00-23:59`);
+        if (d.weather !== undefined && !isVisibility(d.weather))
+            out.push(`district weather must be clear, light or heavy`);
+        if (d.wind !== undefined && !isWind(d.wind))
+            out.push(`district wind must be calm, light, moderate or strong`);
+        if (d.outdoorLight !== undefined && !isLight(d.outdoorLight))
+            out.push(`district outdoor light must be full, partial, dim or dark`);
+        if (d.backgroundCount !== undefined && !isBackgroundCount(d.backgroundCount))
+            out.push(`district background count must be a whole number from -24 to 24 (Street Grimoire p.30)`);
+        if (d.matrixZone !== undefined && !isMatrixZone(d.matrixZone))
+            out.push(`district Matrix zone must be spam or static at rating 2, 4 or 6 (p.231)`);
+    }
+    for (const r of rooms) {
+        if (r.conditions === undefined)
+            continue;
+        const c = r.conditions;
+        if (c.light !== undefined && !isLight(c.light))
+            out.push(`"${r.name}": light must be full, partial, dim or dark`);
+        if (c.visibility !== undefined && !isVisibility(c.visibility))
+            out.push(`"${r.name}": visibility must be clear, light or heavy`);
+        if (c.backgroundCount !== undefined && !isBackgroundCount(c.backgroundCount))
+            out.push(`"${r.name}": background count must be a whole number from -24 to 24`);
+        if (c.matrixZone !== undefined && !isMatrixZone(c.matrixZone))
+            out.push(`"${r.name}": Matrix zone must be spam or static at rating 2, 4 or 6`);
+    }
+    return out;
+}
+/**
+ * SIGHT HERE (p.135: "Perception Tests involving vision ... use the same
+ * Visibility and Light modifiers as attacks do in combat"): the Light and
+ * Visibility rows only, combined the p.173 way, for whoever is looking,
+ * across the rooms between them and what they look at. The scene comes
+ * off the room (Room.scene). 0 or negative.
+ */
+export function sightModifier(viewer, ...rooms) {
+    const placed = rooms.filter((r) => !!r);
+    if (placed.length === 0)
+        return 0;
+    const scene = placed.find(r => r.scene)?.scene;
+    return environmentalModifier(scene, placed, viewer, { melee: true }).modifier;
+}
+//# sourceMappingURL=environment.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/grid-reach.js

@@ -223,6 +223,12 @@ function hostNamed(room, q) {
  * purpose: the party reads the rider's body as far away, and the rider
  * reads the job as far away, off this one line.
  */
+/**
+ * THE DISTANCE HALF OF NOISE (p.231's table). A spam or static zone's
+ * rating is the other half, and it applies to EVERY Matrix action taken
+ * there, near or far -- so it rides Player.matrixActionPenalty with
+ * running silent, not this per-target number.
+ */
 export function noiseFor(actor, room) {
     if (actor.insideHost)
         return 0;

package/bundle/typescript/src/commands/game/sideQuest/utilities/perception.js

@@ -1,3 +1,4 @@
+import { sightModifier } from './environment.js';
 import { mentalLimit } from './limits.js';
 /**
  * THE PERCEPTION TEST (SR5 core p.135-136), shared by every verb that
@@ -52,6 +53,8 @@ export function perceptionTest(actor, opts = {}) {
         + (skill > 0 ? skill : -1)
         + (opts.active ? ACTIVELY_LOOKING : 0)
         + actor.bonus('perception')
+        // Visibility and Light (p.135, p.173): the district and the room's.
+        + sightModifier(actor, actor.currentLocation)
         + actor.woundModifier
         - actor.sustainingPenalty);
     return { pool, limit: mentalLimit(actor) };

package/bundle/typescript/src/commands/game/sideQuest/utilities/spots.js

@@ -1,3 +1,4 @@
+import { sightModifier } from './environment.js';
 import { droneImmobile } from './drone-prose.js';
 import { Direction } from '../types/shared/direction-enum.js';
 import { isOpenGround, isVoid, roomAtCell, streetDoors, worldCell } from './district-plane.js';
@@ -2249,7 +2250,7 @@ export function wouldNotice(observer, target) {
         return true;
     const perception = observer.skillRating('perception');
     const pool = Math.max(1, observer.intuition + (perception > 0 ? perception : -1)
-        + observer.bonus('perception'));
+        + observer.bonus('perception') + sightModifier(observer, room));
     return Math.floor(pool / 4) + perceptionRangeModifier(meters) >= threshold;
 }
 /** A conversational voice. Also what earshot.ts's SPEECH_METERS is, so

package/bundle/typescript/src/commands/game/sideQuest/utilities/wards.js

@@ -1,11 +1,22 @@
 import { rollPool, formatRoll } from './dice.js';
 import { astralLimit } from './limits.js';
+import { backgroundPenalty } from './environment.js';
 import { pierces } from './barrier-geometry.js';
 /** Does this room's ward stop this form? Not its creator, and not the
  *  form holding a pass it just pressed for. */
+/**
+ * A WARD UNDER A BACKGROUND COUNT (Street Grimoire p.32): "wards and
+ * rituals ... are reduced by the background count" and collapse at 0 or
+ * less. The Force the ward actually stands at, here.
+ */
+export function effectiveWardForce(room) {
+    return room.wardForce - backgroundPenalty(room.scene, room);
+}
 export function wardHolds(room, actor) {
     if (!room?.warded)
         return false;
+    if (effectiveWardForce(room) <= 0)
+        return false;
     if (room.wardCreator !== undefined && room.wardCreator === actor.name)
         return false;
     return actor.wardPass !== room.name;
@@ -28,8 +39,9 @@ export function wardBetween(from, to, actor) {
  */
 export function pressThroughWard(scene, logger, actor, ward) {
     const press = rollPool(actor.magic + actor.charisma, astralLimit(actor));
-    const hold = rollPool(ward.wardForce * 2);
-    const meta = `Press through the ward (p.316): Magic + Charisma ${formatRoll(press)} v. Force ${ward.wardForce} x 2 ${formatRoll(hold)}`;
+    const force = effectiveWardForce(ward);
+    const hold = rollPool(force * 2);
+    const meta = `Press through the ward (p.316): Magic + Charisma ${formatRoll(press)} v. Force ${force} x 2 ${formatRoll(hold)}${force !== ward.wardForce ? ` (Force ${ward.wardForce}, less the background count)` : ""}`;
     if (press.hits - hold.hits <= 0) {
         actor.performAction('is stopped by a ward', ward.name);
         return { through: false, meta };
@@ -67,7 +79,7 @@ export function alertWard(scene, logger, ward, actor, how) {
 export function resolveWardStrike(scene, logger, attacker, ward) {
     const world = [];
     const meta = [];
-    const force = ward.wardForce;
+    const force = Math.max(1, effectiveWardForce(ward));
     const profile = attacker.getWeaponProfile();
     const roll = rollPool(attacker.getAttackPool(), attacker.getAttackLimit(null));
     meta.push(`Attack on the ward over ${ward.name} (unopposed, p.197): ${formatRoll(roll)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.392.0",
+  "version": "5.393.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",