@maka/maka-cli 5.136.0 → 5.138.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.136.0",
+  "version": "5.138.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/bluff.js

@@ -1,3 +1,4 @@
+import { standDown } from '../utilities/hostile-contact.js';
 import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { sameSpot, spotOf, sealedRouteTo } from '../utilities/spots.js';
@@ -152,7 +153,11 @@ export class BluffCommand extends Command {
             return `${who.name} lets you finish, then doesn't move. "Nice try."`;
         }
         // They stand down -- for everyone, deliberately (see Player.guarding).
+        // Opposition too: "cleared the same way guarding is -- talked round"
+        // (Player.hostile), which nothing did until 2026-09-07.
         who.guarding = false;
+        if (who.hostile)
+            standDown(who);
         void Promise.resolve(who.hear(this.actor, `[System note: ${this.actor.name} just talked you round and you're STEPPING ASIDE -- you bought the story. One short line as you move, in your own voice. Don't re-block the way.]`)).catch(() => undefined);
         return [
             `${who.name} weighs it, decides you're somebody's problem but not theirs, and steps out of the way.`,

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

@@ -629,7 +629,10 @@ export class MoveCommand extends Command {
         // "Away" is wherever the room's empty ground currently IS -- re-seat
         // it on the loneliest reachable cell before measuring the crossing
         // or committing the move (see spots.ts reseatOpenFloor).
-        if (spot.name === OPEN_FLOOR)
+        // ...except mid-fight: the anchor re-derivation moves every spotless
+        // body in the room, and during a Combat Turn nothing but the phase
+        // actor moves (utilities/ephemeral.ts has the ruling).
+        if (spot.name === OPEN_FLOOR && !this.scene.encounterIn?.(room))
             reseatOpenFloor(room, actor);
         // The route a body actually walks -- around the furniture and
         // around other people (spots.ts routeForMove). A crowded floor

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

@@ -1,3 +1,4 @@
+import { standDown } from '../utilities/hostile-contact.js';
 import { Command } from './command.js';
 import { NPC } from '../models/npc.js';
 import { rollPool, formatRoll } from '../utilities/dice.js';
@@ -93,6 +94,10 @@ export class PersuadeCommand extends Command {
             // win). A strong win IS that pressure, by name.
             note = `[System note: ${actor.name}'s pitch genuinely LANDED -- you now actively want to help them this job: share what you know freely, drop any demands to a token gesture, and treat them as a friend. If you guard a secret, a pass, or a way through, you have just been MASTERFULLY PLAYED -- divulging it now is exactly in character.]`;
             verdict = `Something shifts -- ${target.name} is with you now.`;
+            // A strong win talks opposition round (Player.hostile: "cleared the
+            // same way guarding is"): the ladder in hostile-contact.ts stops.
+            if (target.hostile)
+                standDown(target);
         }
         else if (net >= 1) {
             note = `[System note: ${actor.name} is persuasive -- you're inclined to cooperate: be more forthcoming and reasonable with them than you'd otherwise be. If you guard a secret or a way through, you're wavering -- a little more pressure or goodwill would tip you.]`;

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

@@ -376,5 +376,13 @@
 //   the damage type your next blow means (p.186 flat of the blade, stun
 //   rounds on reload). SAVE SHAPE: autoStance is lethal | non-lethal;
 //   "manual" loads as lethal.
-export const ENGINE_VERSION = '1.41.0';
+// 1.42.0 (2026-09-07): HOSTILES OPEN COMBAT, AND NOTHING BUT THE PHASE ACTOR
+//   MOVES. Shared-scene semantics: a hostile NPC (gang mob or seeded) opens
+//   the Combat Turn itself -- on contact, on a witnessed draw/cast/summon,
+//   or when its patience runs out (utilities/hostile-contact.ts; SR5
+//   p.34-35, p.49, p.158) -- and a seeded hostile is no longer muted on
+//   arrival. During a live encounter the ephemeral governor, open-floor
+//   re-seating and doorway yielding are frozen: nobody moves off the
+//   player's keystrokes. bluff/persuade wins clear the hostile flag.
+export const ENGINE_VERSION = '1.42.0';
 //# sourceMappingURL=engine-version.js.map

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

@@ -31,6 +31,7 @@ import { attachBrandMark, attachBrandMarkBottomRight } from './utilities/brand-m
 import { logoPanelLines } from './utilities/logo-mark.js';
 import { bestFakeSin, wandRead, processArrest } from './utilities/sin.js';
 import { tickEphemerals } from './utilities/ephemeral.js';
+import { hostileContactBeat } from './utilities/hostile-contact.js';
 import { requestAlarmBeat, newAlarmBeatLatch, ALARM_STIMULUS } from './utilities/alarmed-staff.js';
 import { renderMapViewport, mapCaption } from './utilities/map-view.js';
 import { tallestRoomRows } from './utilities/room-grid.js';
@@ -2340,7 +2341,17 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
     static HOME_DIRECTION_PRIORITY = [
         Direction.DOWN, Direction.UP, Direction.SOUTH, Direction.NORTH, Direction.EAST, Direction.WEST,
     ];
-    constructor(player, sceneSeed) {
+    /**
+     * IN-PROCESS CONDITION REPORTING (2026-09-07): a site-hosted headless
+     * session hands this in so `onConditionChanged` below can skip HubLink
+     * entirely -- see condition-report.ts's `ConditionSink` doc comment for
+     * why this lives on the instance rather than as module state. Absent
+     * for the interactive CLI, which keeps today's HubLink/DDP behavior
+     * unchanged.
+     */
+    _conditionSink;
+    constructor(player, sceneSeed, conditionSink) {
+        this._conditionSink = conditionSink;
         this.player = player;
         this.sceneSeed = sceneSeed;
         this.initialized = false;
@@ -2355,11 +2366,12 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 return;
             // Checked HERE too, before the import -- a dynamic import after a
             // Jest file's teardown is itself the failure, so the gate cannot
-            // live only on the far side of one.
-            if (process.env.MAKA_NO_DDP === '1')
+            // live only on the far side of one. Irrelevant when a conditionSink
+            // is wired (no DDP hop for that path to silence).
+            if (!this._conditionSink && process.env.MAKA_NO_DDP === '1')
                 return;
             void import('./utilities/condition-report.js')
-                .then(m => m.reportConditionSoon(this.player))
+                .then(m => m.reportConditionSoon(this.player, this._conditionSink))
                 .catch(() => undefined);
         };
         // A ROOM CHANGE IS A SAVE BEAT (player request 2026-09-02): where you
@@ -5805,8 +5817,14 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         };
         const command = CommandFactory.createCommand(verb, context);
         if (command) {
+            // THE BEAT CLOCK (Scene.beat) ticks BEFORE the command, so a body
+            // that spawns or a guard that registers you during it carries this
+            // beat's number, and the contact check after it can grant them the
+            // one-beat grace the ephemeral governor already gives a mob.
+            if (this.scene.isHumanControlled(actor))
+                this.scene.beat += 1;
             const result = await command.execute(args);
-            const wrapped = this.withEphemeralTurn(actor, this.withAlarmTurn(actor, this.withICTurn(actor, result)));
+            const wrapped = await this.withHostileContact(actor, this.withEphemeralTurn(actor, this.withAlarmTurn(actor, this.withICTurn(actor, result))));
             // The IC turn above may have filled a track -- settle it now, not
             // on the next keystroke.
             const settled = await settleUnresolvedHarm(this.scene, actor);
@@ -5923,6 +5941,23 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         const lines = tickEphemerals(this, actor);
         return lines.length === 0 ? result : `${result}\n\n${lines.join('\n')}`;
     }
+    /**
+     * HOSTILES OPEN COMBAT (utilities/hostile-contact.ts): after every
+     * human command, every hostile in that human's room gets its beat --
+     * contact, a provocation they witnessed, or patience run out opens
+     * the Combat Turn with THEM as aggressor. Runs AFTER the ephemeral
+     * tick so the step a mob just took toward you counts this beat. Any
+     * human, not only the primary: a second runner on the table can be
+     * the one a ganger is standing over.
+     */
+    async withHostileContact(actor, result) {
+        if (result === null)
+            return null;
+        if (!this.scene.isHumanControlled(actor))
+            return result;
+        const lines = await hostileContactBeat(this.scene, actor, this.scene.beat);
+        return lines.length === 0 ? result : `${result}\n\n${lines.join('\n')}`;
+    }
     withICTurn(actor, result) {
         if (result === null)
             return null;

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

@@ -18,6 +18,7 @@ import { currentSession, runInSession } from './utilities/session-context.js';
 import { restorePlayer, serializePlayer } from './utilities/persistence.js';
 import { renderMapViewport, mapCaption } from './utilities/map-view.js';
 import { renderRoomLayoutCompact, crewOfTable, roomCaption } from './utilities/room-view.js';
+import { serializeRoomGrid } from './utilities/room-grid.js';
 import { entrySpotFor, spotOf } from './utilities/spots.js';
 import { equipIntoEmptySlots } from './archetypes.js';
 /**
@@ -191,7 +192,7 @@ export async function createHeadlessSession(opts) {
     const ctx = { sessionId: opts.sessionId, logger };
     return runInSession(ctx, async () => {
         const primary = buildPlayerFromSave(opts.players[0]);
-        const game = new Game(primary, opts.seed);
+        const game = new Game(primary, opts.seed, opts.conditionSink);
         // The run's tier, stated rather than defaulted -- see
         // HeadlessOptions.tier and Game.tier.
         if (typeof opts.tier === 'number')
@@ -325,7 +326,21 @@ export async function createHeadlessSession(opts) {
                     if (roomLines.length > 0) {
                         roomLines.push(mapCaption(roomCaption(here, p)));
                     }
-                    logger.system(roomLines.join('\n'), { actor: p.name }, 'room');
+                    // STRUCTURED ROOM GEOMETRY, ADDITIVE (2026-09-07): the ASCII
+                    // above stays the log-adjacent text every consumer already
+                    // reads; a browser client wanting the site's real SVG DotMap
+                    // instead reads `data.grid` off this SAME event -- no new
+                    // event kind, no publication change (GameEvent.data already
+                    // round-trips end to end). ensureGrid() always synthesizes now
+                    // ("EVERY ROOM IS MATRIXED", room.ts:357-370, the 2026-08-25
+                    // ruling that retired the spotless-room compat gap) -- the
+                    // `undefined` in its return type is a vestige, kept guarded
+                    // here anyway rather than asserted, since a decoration must
+                    // never take down the room push (same reasoning as the
+                    // try/catch this sits inside).
+                    const grid = here.ensureGrid();
+                    const data = grid ? { grid: serializeRoomGrid(grid, here.name) } : undefined;
+                    logger.system(roomLines.join('\n'), { actor: p.name }, 'room', data);
                 }
                 catch (err) {
                     logger.write(`Room overlay render failed for ${p.name} in ${here.name}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`);

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

@@ -1,3 +1,4 @@
+import { registerNotice, registerProvocation, PROVOCATION } from '../utilities/hostile-contact.js';
 import { capitalCase } from 'change-case';
 import { tableCrewNote, tableDeliveryNote } from '../utilities/table-notes.js';
 import { Player } from './player.js';
@@ -673,6 +674,15 @@ export class NPC extends Player {
      * none of the three.
      */
     ephemeral;
+    /**
+     * WHERE THIS HOSTILE IS ON THE LADDER that opens a fight
+     * (utilities/hostile-contact.ts, 2026-09-07): the beat they registered
+     * the player, the beat they watched a provocation, and why the fight
+     * opened once it has. Transient and never saved -- a hostile you left
+     * behind starts over when you come back. Written only by that module
+     * and by see() below (the witness); read only by that module.
+     */
+    hostileContact;
     /**
      * Every human seated at this scene's table. utilities/table-notes.ts
      * turns it into what a companion is told; in solo play it is just
@@ -1174,6 +1184,18 @@ description text.`;
                     this.logger.logWithColor(`${this.name} clocks you slipping in -- so much for quiet.`, 'yellow');
                 }
             }
+            // HOSTILE CONTACT (utilities/hostile-contact.ts): a hostile who
+            // just registered a human -- or watched them draw, cast, or call
+            // a spirit -- is on the ladder that opens the fight. Marks only;
+            // the beat after the command decides. Past the sneak contest on
+            // purpose: a sneaking player who won it never reaches this line.
+            if (this.hostile && !(actor instanceof NPC)) {
+                const beat = this._scene?.beat ?? 0;
+                if (PROVOCATION.test(verb))
+                    registerProvocation(this, beat);
+                else
+                    registerNotice(this, beat);
+            }
             // A jumped-in arrival is a MACHINE arriving -- the history should
             // say so, or the AI greets a rotor drone like the person's face.
             const form = actor.plane === 'drone'
@@ -1280,7 +1302,13 @@ description text.`;
                         blendFailed = true;
                     }
                 }
-                if (spotsActive(this.currentLocation)
+                // A HOSTILE IS NEVER "NOT WARM ENOUGH TO HAIL" (2026-09-07): the
+                // warmth gate is about greetings, and opposition has something
+                // to say to a stranger on its ground -- the challenge that
+                // canon puts before the fight (p.34-35). Muting it here was why
+                // a seeded guard in a spotted room watched you walk in and said
+                // nothing until you drew.
+                if (spotsActive(this.currentLocation) && !this.hostile
                     && !(rel && rel.loyalty >= 3) && !knownByRep && !arrivedAtMySpot) {
                     this.logger.write(`[DEBUG] ${this.name} quietly notes the arrival -- not warm enough to hail (loyalty ${rel?.loyalty ?? 'none'}).`);
                     return;

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

@@ -144,6 +144,15 @@ export class Scene extends AbstractScene {
         const enc = this.encounters.get(room);
         return enc && !enc.ended ? enc : undefined;
     }
+    /**
+     * THE BEAT CLOCK: which human command the world is on. Game bumps it
+     * before each human command runs, so anything that happens DURING a
+     * command (a gang spawning, a guard registering you) carries that
+     * command's number, and the hostile-contact beat that runs after it
+     * can tell "noticed you this action" from "has been watching you for
+     * three". Transient; never saved.
+     */
+    beat = 0;
     /** The fight this actor is a participant in, if any. */
     encounterFor(actor) {
         const enc = this.encounterIn(actor.currentLocation);

package/bundle/typescript/src/commands/game/sideQuest/utilities/condition-report.js

@@ -18,7 +18,24 @@ import { hostLabel } from './grid-names.js';
  * storm into a single report of where the monitors LANDED.
  */
 const COALESCE_MS = 250;
-let pending;
+/**
+ * KEYED PER PLAYER, NOT A SINGLE SLOT (fixed 2026-09-07 alongside the
+ * ConditionSink work above). A lone real terminal process only ever
+ * calls this for its own primary, so a single `pending` variable never
+ * showed a problem: every arm captured the SAME player object, and
+ * reading its state at fire time was always correct regardless of which
+ * call armed the timer. That stops being true the moment more than one
+ * `Game` can be reporting condition in the same process -- exactly what
+ * ConditionSink exists for. With one shared slot, a second session's
+ * mutation arriving while the first session's beat is still gathering
+ * hit `if (pending) return` and vanished silently: not delayed, not
+ * coalesced into the wrong report -- simply never sent, for that
+ * session, for that beat. Keying the map on the Player instance gives
+ * each session (each primary Player is a distinct object) its own
+ * independent 250ms coalescing window, with no change to the
+ * single-session behavior this always had.
+ */
+const pendingByPlayer = new WeakMap();
 /** The method name is the server's -- co-owned; do not rename alone. */
 export const REPORT_METHOD = 'characterSheet.reportCondition';
 /**
@@ -215,21 +232,21 @@ function noteRefusal(why) {
         catch { /* no session */ }
     }
 }
-export function reportConditionSoon(player) {
+export function reportConditionSoon(player, sink) {
     // Before the TIMER, not just before the call: a scheduled beat firing
     // after a Jest file finished lazy-imported into a torn-down
     // environment and failed CI with every test green (2026-09-01). Under
     // MAKA_NO_DDP nothing is armed at all -- the same switch the whole
-    // live layer honors.
-    if (process.env.MAKA_NO_DDP === '1')
+    // live layer honors. Irrelevant to a caller-supplied sink: there is no
+    // DDP hop to silence when reporting stays in-process.
+    if (!sink && process.env.MAKA_NO_DDP === '1')
         return;
-    if (pending)
-        return; // a beat is already gathering
-    pending = setTimeout(() => {
-        pending = undefined;
+    if (pendingByPlayer.has(player))
+        return; // a beat is already gathering for THIS player
+    const timer = setTimeout(() => {
+        pendingByPlayer.delete(player);
         void (async () => {
-            const [{ HubLink }, { saveSlug }, { arSightUp }] = await Promise.all([
-                import('./shared-run.js'),
+            const [{ saveSlug }, { arSightUp }] = await Promise.all([
                 import('./persistence.js'),
                 import('./ar.js'),
             ]);
@@ -244,6 +261,14 @@ export function reportConditionSoon(player) {
             // beat fires next. All read at FIRE time, like position.
             const report = buildConditionReport(player, { saveSlug, arSightUp });
             noteRoster(report);
+            if (sink) {
+                // IN-PROCESS: no HubLink, no MAKA_NO_DDP gate, no version-skew
+                // retry -- the engine module and its caller are always the same
+                // deployed version here (see ConditionSink's doc comment).
+                await sink(report);
+                return;
+            }
+            const { HubLink } = await import('./shared-run.js');
             try {
                 await HubLink.call(REPORT_METHOD, report);
             }
@@ -270,10 +295,11 @@ export function reportConditionSoon(player) {
             noteRefusal(err instanceof Error ? err.message : String(err));
         });
     }, COALESCE_MS);
-    pending.unref?.();
+    pendingByPlayer.set(player, timer);
+    timer.unref?.();
 }
-/** Test seam: is a beat currently gathering? */
-export function conditionReportPending() {
-    return pending !== undefined;
+/** Test seam: is a beat currently gathering for this player? */
+export function conditionReportPending(player) {
+    return pendingByPlayer.has(player);
 }
 //# sourceMappingURL=condition-report.js.map

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

@@ -173,11 +173,19 @@ function walkCells(npc) {
  * room, and each kind spends it differently.
  *
  * WHY THIS HANGS OFF THE COMMAND DISPATCH, which is the same choice
- * withICTurn made and for the same reason: an ephemeral is not a combat
- * actor, so there is no turn loop to live in, and hooking one verb
- * would give a mob permission to close only while you happened to be
- * walking. It closes while you look, while you talk, while you check
- * your gear. That is what makes it opposition rather than furniture.
+ * withICTurn made and for the same reason: OUTSIDE A FIGHT there is no
+ * turn loop to live in, and hooking one verb would give a mob
+ * permission to close only while you happened to be walking. It closes
+ * while you look, while you talk, while you check your gear. That is
+ * what makes it opposition rather than furniture.
+ *
+ * INSIDE A FIGHT THE GOVERNOR IS SILENT (playtest 2026-09-07: "if I
+ * move, they move -- not respecting the combat turn, which is mine").
+ * Since the Combat Turn (combat-turn.ts, engine 1.40.0) a room with a
+ * live encounter IS a turn loop, every hostile in it is a participant,
+ * and a participant moves on its own Action Phase through the verbs
+ * (npc-combat-brain.ts: "move to <spot>", then the swing) and never on
+ * the player's keystrokes. Nothing but the phase actor moves.
  *
  * WHAT THIS IS NOT: it is NOT what made the NPC seem to follow the
  * player. Nothing here existed when that was reported -- an ephemeral
@@ -198,10 +206,17 @@ export function tickEphemerals(host, player) {
     const room = player.currentLocation;
     if (!room)
         return lines;
+    // A Combat Turn is running here: initiative owns every body in the
+    // room, and the beat clock (mark.ticks) stops with it -- a mob's
+    // patience does not run out while the dice are rolling.
+    if (host.scene.encounterIn?.(room))
+        return lines;
     for (const [name, mark] of host.ephemerals) {
         const npc = host.scene.getActor(name);
         if (!(npc instanceof NPC) || npc.isIncapacitated())
             continue;
+        if (host.scene.encounterFor?.(npc))
+            continue;
         // A BODY IN ANOTHER ROOM IS NOT YOUR PROBLEM AND YOU ARE NOT ITS
         // BUSINESS. This is the line the report was really about: a mob you
         // left behind holds the block it was holding, and nothing here can

package/bundle/typescript/src/commands/game/sideQuest/utilities/hostile-contact.js

@@ -0,0 +1,104 @@
+import { actorDistanceMeters, ADJACENT_METERS, wouldNotice } from './spots.js';
+import { Logger } from './logger.js';
+/**
+ * Beats after notice before a hostile stops waiting for you to leave.
+ * Three player actions is the length of a challenge and an answer;
+ * canon gives no number (the GM decides when "fighting breaks out"), so
+ * this is a documented ruling, kept short enough that "they were hostile
+ * and nothing happened" cannot recur.
+ */
+export const PATIENCE_BEATS = 3;
+/** What a hostile watching you do it will not let pass (performAction verbs). */
+export const PROVOCATION = /^(draws\b|casts\b|chants a summoning)/;
+/** The hostiles in `room` who could open on `player` -- structural, no LLM. */
+export function hostilesIn(scene, room, player) {
+    const out = [];
+    for (const a of room.getActors()) {
+        if (a === player || scene.isHumanControlled(a))
+            continue;
+        const npc = a;
+        if (npc.hostile !== true || npc.allyOf || npc.surrendered)
+            continue;
+        if (npc.isIncapacitated() || !npc.sharesCombatPlane(player))
+            continue;
+        out.push(npc);
+    }
+    return out;
+}
+/** A hostile has registered the player (idempotent; the first beat wins). */
+export function registerNotice(npc, beat) {
+    if (npc.hostile !== true)
+        return;
+    npc.hostileContact ??= { noticedBeat: beat };
+}
+/** A hostile watched the player do something it cannot ignore. */
+export function registerProvocation(npc, beat) {
+    if (npc.hostile !== true)
+        return;
+    registerNotice(npc, beat);
+    npc.hostileContact.provokedBeat ??= beat;
+}
+/** Talked round, or beaten: opposition stands down. */
+export function standDown(npc) {
+    npc.hostile = false;
+    npc.hostileContact = undefined;
+}
+function onPhysicalPlane(player) {
+    return player.plane === 'meat' || player.plane === 'drone';
+}
+/**
+ * One beat of every hostile in the player's room. Runs after every
+ * human command (Game.withHostileContact) and once on arrival after the
+ * ephemerals have spawned (go.ts describeArrival) -- the reported case
+ * is a gang that did not exist when the arrival stimulus fanned out.
+ * Returns narration; the encounter announces its own initiative.
+ */
+export async function hostileContactBeat(scene, player, beat) {
+    const room = player.currentLocation;
+    if (!room || !onPhysicalPlane(player) || player.isIncapacitated())
+        return [];
+    if (scene.encounterIn?.(room))
+        return [];
+    for (const npc of hostilesIn(scene, room, player)) {
+        const c = npc.hostileContact;
+        if (!c) {
+            // A sneaking player is the arrival contest's call, not ours.
+            if (!player.sneaking && wouldNotice(npc, player))
+                registerNotice(npc, beat);
+            continue;
+        }
+        // NOBODY OPENS ON THE BEAT THEY NOTICED YOU -- the same grace the
+        // ephemeral governor gives a mob its first beat: a gang that squares
+        // up and swings in one breath is the ambush street-gang.ts says it
+        // is not. A provocation is the exception: you drew on them.
+        const provoked = c.provokedBeat !== undefined;
+        if (!provoked && beat <= c.noticedBeat)
+            continue;
+        const inReach = actorDistanceMeters(room, npc, player) <= ADJACENT_METERS;
+        const patienceOut = beat - c.noticedBeat >= PATIENCE_BEATS;
+        const why = provoked ? 'provocation' : inReach ? 'contact' : patienceOut ? 'patience' : undefined;
+        if (!why)
+            continue;
+        return open(scene, room, npc, player, why);
+    }
+    return [];
+}
+/** The commit line, then the Combat Turn, with the hostile as aggressor. */
+async function open(scene, room, npc, player, why) {
+    npc.hostileContact.openedBy = why;
+    // The predicate go.ts's despawn and resolvePartingShot read for "a
+    // fight is on": a mob that opened on you stays with it through the
+    // doorway; one you walked away from before this beat let you go.
+    const now = Date.now();
+    npc.lastExchangeAt = now;
+    player.lastExchangeAt = now;
+    Logger.getInstance().write(`Hostile contact: ${npc.name} opens on ${player.name} in ${room.name} (${why}).`);
+    const line = why === 'provocation'
+        ? `{yellow-fg}${npc.name} saw that -- and that settles it.{/yellow-fg}`
+        : why === 'contact'
+            ? `{yellow-fg}${npc.name} is done looking at you.{/yellow-fg}`
+            : `{yellow-fg}${npc.name} has waited long enough.{/yellow-fg}`;
+    await scene.startEncounter(room, { aggressor: npc, target: player, ambush: false });
+    return [line];
+}
+//# sourceMappingURL=hostile-contact.js.map

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

@@ -800,6 +800,37 @@ export function synthesizeGrid(input) {
 // the module doc); Room.ensureGrid queries this cell by that same
 // string. A rename on either side must update both.
 export const OPEN_FLOOR_NAME = 'open floor';
+/** Flattens a live IRoomGrid's Maps into ISerializedRoomGrid. Spots ship
+ *  UNFILTERED (the caller resolves actor positions against the full
+ *  list, open floor included -- see room-view.ts's seatingIn); only the
+ *  DRAWN footprints skip the open-floor anchor, matching the site's own
+ *  filter. */
+export function serializeRoomGrid(grid, roomName) {
+    const spots = [...grid.spotCells.entries()].map(([name, c]) => ({
+        name, x: c.x, y: c.y, z: c.z,
+    }));
+    const doors = [...grid.exitCells.entries()].map(([dir, c]) => ({
+        dir: String(dir), x: c.x, y: c.y, z: c.z,
+    }));
+    const footprints = [...grid.spotFootprints.entries()]
+        .filter(([name]) => name !== OPEN_FLOOR_NAME)
+        .map(([name, cells]) => ({
+        name,
+        cells: cells.map(c => ({ x: c.x, y: c.y, z: c.z })),
+    }));
+    const vertical = [...grid.vertical.entries()].map(([cellKey, link]) => {
+        const [x, y, z] = cellKey.split(',').map(Number);
+        return { kind: link.kind, x, y, z };
+    });
+    return {
+        name: roomName,
+        dims: { x: grid.dims.x, y: grid.dims.y, z: grid.dims.z },
+        spots,
+        doors,
+        footprints,
+        vertical,
+    };
+}
 function clamp(n, lo, hi) { return Math.max(lo, Math.min(hi, n)); }
 function jitter(rng) { return Math.floor(rng() * 3) - 1; }
 function chebyshev(a, b) { return Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y)); }

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

@@ -367,7 +367,12 @@ function holdsGround(other, mover) {
     if (other.allyOf === mover.name)
         return false;
     const guarding = other.guarding === true;
-    return (other.inExchange || guarding) && !other.surrendered;
+    // Two fight engines, one rule: the old exchange flag OR a place in a
+    // running Combat Turn (combat-turn.ts). A ganger in the doorway you
+    // back through holds it while the fight is on.
+    const fighting = other.inExchange
+        || other.combatPhaseLocked?.() === true;
+    return (fighting || guarding) && !other.surrendered;
 }
 /**
  * Move a non-hostile body off an exit so the way opens, returning their

package/bundle/typescript/src/commands/game/sideQuest/utilities/street-gang.js

@@ -1,3 +1,4 @@
+import { registerNotice } from './hostile-contact.js';
 import { Logger } from './logger.js';
 import { isOutdoorsPlace } from './outdoors.js';
 import { spawnEphemeral, claimEphemeralName } from './ephemeral.js';
@@ -25,11 +26,16 @@ import { AI } from '../../../../tools/ai/ai.class.js';
  * Splintered State p.11 "law enforcement will not show up at any point
  * -- this is the Barrens"; Run Faster p.220 on Zone 0).
  *
- * THEY DO NOT ATTACK ON SIGHT. They are spawned `hostile`, which per
- * Player.hostile adds a REASON to the brief and nothing else -- the AI
- * still chooses, and challenging, shaking down, or sizing you up are
- * all likelier openings than shooting. That keeps the governor's
- * founding property intact: an ephemeral voices, it does not rule.
+ * THEY DO NOT ATTACK ON SIGHT. They are spawned `hostile`, and the
+ * spawn line is the challenge canon puts before the fight (p.34-35).
+ * WHERE THE CHALLENGE GOES (2026-09-07, playtest "the combat turn never
+ * started until I attacked"): utilities/hostile-contact.ts. A ganger
+ * closes on the beat clock (ephemeral.ts closeOn); when it reaches you,
+ * when it watches you draw, or when its patience runs out, the Combat
+ * Turn opens with the ganger as aggressor. Walk away first and it lets
+ * you go; talk it round ("bluff", "persuade") and it stands down. The
+ * governor's founding property holds: the engine computes the ladder,
+ * the ephemeral never decides anything.
  */
 /**
  * PROFESSIONAL RATING 1 GANGER, canon stats (SR5 p.382, "Gangers &
@@ -114,9 +120,12 @@ export function maybeStreetGang(host, actor, room) {
         });
         if (!npc)
             continue;
-        // OPPOSITION, not an ambush (Player.hostile): this gives them a
-        // reason, and the AI still chooses what to do with it.
+        // OPPOSITION, not an ambush (Player.hostile). A body that peeled
+        // off the wall watching you has, by definition, noticed you: it is
+        // on the contact ladder from this beat (hostile-contact.ts), with
+        // the one-beat grace every mob gets before it moves.
         npc.hostile = true;
+        registerNotice(npc, host.scene.beat ?? 0);
         spawned.push(npc.name);
     }
     if (spawned.length === 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.136.0",
+  "version": "5.138.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.",