@maka/maka-cli 5.390.0 → 5.392.0

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

@@ -0,0 +1,70 @@
+import { NPC } from '../models/npc.js';
+import { rollPool, formatRoll } from './dice.js';
+import { wouldNotice, doorwayBlocker } from './spots.js';
+import { turnHostile } from './hostile-contact.js';
+/**
+ * A GUARDED DOOR (player-built runs, 2026-10-06). Two ways an NPC can own
+ * a doorway, and the author picks per exit:
+ *
+ *  - HELD BY: a bouncer standing in it, physically opposing passage
+ *    (Player.guarding + standing on the threshold; spots.ts holdsGround).
+ *  - GUARDED BY: someone watching it from wherever they stand
+ *    (Player.watching = the direction). They do not block -- but "will
+ *    be hostile if you attempt to move past it".
+ *
+ * And "by association, something that is heldBy is also guardedBy": the
+ * bouncer in the doorway watches it too.
+ *
+ * CAUGHT IN THE ACT (user ruling): a watcher who NOTICES the runner going
+ * for the door turns hostile and the fight opens right there, before the
+ * runner leaves -- the move does not happen. A runner who is sneaking
+ * gets the same opposed test a sneaking arrival does (NPC.see: Agility +
+ * Sneaking vs Intuition + Perception, ties to the watcher); one who is
+ * not is noticed whenever the watcher would notice them at all
+ * (spots.ts wouldNotice).
+ */
+export function doorWatchers(room, direction, mover) {
+    const dir = String(direction).toLowerCase();
+    const held = doorwayBlocker(room, direction, mover);
+    return room.getActors()
+        .filter((a) => a instanceof NPC && a !== mover)
+        .filter(n => !n.isIncapacitated() && n.allyOf !== mover.name && !n.surrendered)
+        .filter(n => n === held || String(n.watching ?? '').toLowerCase() === dir);
+}
+/**
+ * The watcher (if any) who catches `mover` going for the door. Rolls the
+ * sneak contest per watcher, as an arrival does; the first to spot them
+ * is returned, with the lines the player should see.
+ */
+export function caughtAtDoor(room, direction, mover, isPlayer) {
+    const lines = [];
+    for (const npc of doorWatchers(room, direction, mover)) {
+        if (!npc.canPerceive(mover))
+            continue;
+        if (mover.sneaking) {
+            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));
+            if (isPlayer)
+                lines.push(`Slip past ${npc.name}: ${formatRoll(sneak)} vs ${formatRoll(spot)} -- ${sneak.hits > spot.hits ? 'unseen.' : 'SPOTTED.'}`);
+            if (sneak.hits > spot.hits)
+                continue;
+        }
+        else if (!wouldNotice(npc, mover)) {
+            continue;
+        }
+        return { npc, lines };
+    }
+    // Nobody caught them -- but a sneak past a watcher still shows its dice.
+    return { lines };
+}
+/** Caught: the watcher turns hostile and the fight opens, now. */
+export async function springDoorWatch(scene, room, direction, mover, npc) {
+    turnHostile(npc, scene.beat ?? 0, `caught ${mover.name} going for the ${String(direction)} door of ${room.name}`);
+    if (!scene.encounterFor?.(mover)) {
+        await scene.startEncounter(room, { aggressor: npc, target: mover, ambush: false });
+    }
+    return `${npc.name} sees you go for the ${String(direction)} door -- and comes for you.`;
+}
+//# sourceMappingURL=door-watch.js.map

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

@@ -0,0 +1,27 @@
+import { rollPool, formatRoll } from './dice.js';
+import { fallDamageDVMeters } from './room-grid.js';
+/** SR5 p.172: falling damage carries AP -4. */
+export const FALL_AP = -4;
+/**
+ * A LANDING (SR5 p.172, RAG-checked 2026-10-06): a fall of more than three
+ * metres deals Physical damage with a DV equal to the metres fallen, AP -4,
+ * resisted with Body + Armor. One rule for every way down -- a climb that
+ * slips, a rappel that runs, a leap off a ledge -- so none of them can be
+ * the one that forgets the AP.
+ *
+ * The AP takes up to four points of ARMOR out of the soak pool (it cannot
+ * cut into Body). Returns the boxes taken and the mechanics line; the
+ * caller writes its own prose.
+ */
+export function resolveFall(actor, meters) {
+    const dv = fallDamageDVMeters(meters);
+    if (dv <= 0)
+        return { dv: 0, dealt: 0 };
+    const armorCut = Math.min(-FALL_AP, Math.max(0, actor.getArmorValue()));
+    const soak = rollPool(Math.max(0, actor.getSoakPool() - armorCut));
+    const dealt = Math.max(0, dv - soak.hits);
+    if (dealt > 0)
+        actor.takeDamage(dealt);
+    return { dv, dealt, meta: `Fall: DV ${dv}P (${Math.round(meters)}m, AP ${FALL_AP}) v. Body + Armor: ${formatRoll(soak)} -> ${dealt}` };
+}
+//# sourceMappingURL=falling.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/file-guard.js

@@ -0,0 +1,120 @@
+import { rollD6Total, rollPool, formatRoll } from './dice.js';
+import { hint } from './hints.js';
+import { noteHarm } from './harm-note.js';
+import { leaveMatrix } from './planes.js';
+import { hostLabel } from './grid-names.js';
+import { fuzzyPickName } from './fuzzy-match.js';
+import { showsMechanics, mechanicsActorPrefix } from './mechanics-audience.js';
+/** Splits a trailing "with <passcode>" / "passcode <x>" off a verb's words. */
+export function splitPasscode(words) {
+    const at = words.findIndex(w => /^(with|passcode|code)$/i.test(w));
+    if (at < 0 || at === words.length - 1)
+        return { rest: words };
+    return { rest: words.slice(0, at), passcode: words.slice(at + 1).join(' ') };
+}
+/**
+ * The gate every read/edit/copy/delete of a host file passes through,
+ * after the action is billed and before its roll. Fires an un-passcoded
+ * bomb, then refuses a protected file.
+ */
+export function guardFile(scene, logger, actor, host, file, touch, passcode) {
+    const lines = [];
+    const bomb = file.dataBomb;
+    // Spoken by its owner, typed by a runner: case, quotes and spacing are
+    // not the code (filePasscodeNote).
+    if (bomb && !(bomb.passcode && passcode && sameCode(passcode, bomb.passcode))) {
+        const blast = detonate(scene, logger, actor, host, file);
+        lines.push(...blast.lines);
+        if (blast.stop)
+            return { lines, stop: true };
+    }
+    if (file.protection && file.protection > 0) {
+        lines.push(`${file.name} is PROTECTED -- an encrypted file cannot be ${touch === 'copy' ? 'copied' : touch === 'delete' ? 'deleted' : touch === 'read' ? 'read' : 'changed'} until the protection is broken (p.239). ${hint(`"crack ${file.name}" (Crack File, p.238).`)}`);
+        return { lines, stop: true };
+    }
+    return { lines, stop: false };
+}
+/**
+ * THE BOMB GOES OFF (p.242): (Rating)D6 Matrix damage, resisted with
+ * Device Rating + Firewall like any Matrix damage (p.228 -- getSoakPool
+ * is exactly that on the matrix plane); the file goes too if it was set
+ * to; then the bomb is gone. Shared by the file gate and a failed
+ * Disarm (p.239: "If you fail, the Data Bomb activates").
+ */
+export function detonate(scene, logger, actor, host, file) {
+    const bomb = file.dataBomb;
+    file.dataBomb = undefined;
+    file.bombSeenBy.clear();
+    const dv = rollD6Total(bomb.rating);
+    const soak = rollPool(actor.getSoakPool());
+    const dealt = Math.max(0, dv - soak.hits);
+    if (showsMechanics(scene, actor)) {
+        logger.meta(`${mechanicsActorPrefix(scene, actor)}Data Bomb ${bomb.rating} -- ${bomb.rating}D6 = ${dv} DV v. Device Rating + Firewall: ${formatRoll(soak)} -> ${dealt}`);
+    }
+    logger.write(`${actor.name} set off a Rating ${bomb.rating} data bomb on "${file.name}": ${dv} DV, ${dealt} through.`);
+    const lines = [`{red-fg}${file.name} was BOMBED -- the moment you touch it the payload goes off in your face.{/red-fg}`];
+    let stop = false;
+    if (dealt <= 0) {
+        lines.push(`  {red-fg}Your firewall eats the blast.{/red-fg}`);
+    }
+    else if (actor.onLivingPersona()) {
+        // p.229: no Matrix Condition Monitor on a living persona -- stun.
+        noteHarm(actor, { by: 'a data bomb' });
+        actor.takeStun(dealt);
+        lines.push(`  {red-fg}It tears through your living persona -- ${dealt} stun: ${actor.stunSummary()}{/red-fg}`);
+    }
+    else {
+        actor.takeMatrixDamage(dealt);
+        lines.push(`  {red-fg}It burns ${dealt} box${dealt === 1 ? '' : 'es'} off your deck: ${actor.matrixSummary()}{/red-fg}`);
+        if (actor.matrixCrashed) {
+            lines.push(`  {red-fg}The deck BRICKS under it --{/red-fg}`);
+            lines.push(...leaveMatrix(scene, actor, { forced: true, reason: `The data bomb burns your deck out from under you.` }));
+            stop = true;
+        }
+    }
+    if (bomb.deletesFile) {
+        host.removeFile(file.name);
+        scene.addWorldEvent(`${file.name} was destroyed by its own data bomb in ${host.name}'s archive.`, { plane: 'matrix' });
+        lines.push(`  {red-fg}And the file goes with it -- ${file.name} is zeroed.{/red-fg}`);
+        // Gone is gone: an erase job's file is as erased by its own bomb.
+        const banner = scene.checkErased?.(file.name, actor.name);
+        if (banner)
+            lines.push(banner);
+        stop = true;
+    }
+    actor.noteConditionChanged();
+    scene.updateStatus();
+    return { lines, stop };
+}
+/**
+ * THE FILE A VERB NAMES, from inside the host that keeps it -- the same
+ * gates edit-file.ts walks (a persona, inside, the archive found by a
+ * Matrix Search or opened by a crack). A string is the refusal.
+ */
+export function pickHostFile(actor, query, verb) {
+    if (actor.plane !== 'matrix')
+        return `Files are worked by a persona. ${hint(`"jack in" first.`)}`;
+    const host = actor.hostInside;
+    if (!host)
+        return `A host's files are worked from INSIDE it (p.246). ${hint(`"enter" the host that keeps it.`)}`;
+    const files = host.files();
+    if (!query) {
+        return files.length === 0
+            ? `${hostLabel(host.over, { capital: true })} keeps no files.`
+            : `${verb} which file? ${hint(`("${verb} <file>". "search" lists the archive.)`)}`;
+    }
+    if (!host.searchedBy.has(actor.name) && !host.over.hostCracked) {
+        return `You haven't found ${hostLabel(host.over)}'s archive yet. ${hint(`"search" runs a Matrix Search inside the host (p.241).`)}`;
+    }
+    const picked = fuzzyPickName(query, files.map(f => f.name));
+    const file = picked ? files.find(f => f.name === picked) : undefined;
+    if (!file)
+        return `No file called "${query}" in ${hostLabel(host.over)}'s archive.`;
+    return { host, file };
+}
+/** Two passcodes match ignoring case, surrounding quotes and spacing. */
+function sameCode(a, b) {
+    const norm = (s) => s.toLowerCase().replace(/["'`]/g, '').replace(/\s+/g, ' ').trim();
+    return norm(a) === norm(b);
+}
+//# sourceMappingURL=file-guard.js.map

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

@@ -29,10 +29,14 @@ import { normalizeLoose } from './fuzzy-match.js';
 export function hostAliases(room) {
     const name = normalizeLoose(room.name);
     const bare = ['host', 'the host', 'node', 'the node', 'ice'];
+    // A NAMED HOST answers to its name too, with or without "the".
+    const named = room.host?.displayName ? normalizeLoose(room.host.displayName.replace(/^the\s+/i, '')) : '';
+    const own = named ? [named, `the ${named}`] : [];
     if (name.length === 0)
-        return bare;
+        return [...bare, ...own];
     return [
         ...bare,
+        ...own,
         // What the grid map calls it.
         name,
         // What look calls it, and what mark's own success line calls it.
@@ -74,6 +78,11 @@ export function matchesHostName(query, room) {
  * hand-written article again.
  */
 export function hostLabel(room, opts = {}) {
+    // A named host is called by its name ("the Kettle Row Grid"), not "the
+    // <room> host".
+    const named = room.host?.displayName?.replace(/^the\s+/i, '');
+    if (named)
+        return `${opts.capital ? 'The' : 'the'} ${named}`;
     const bare = room.name.replace(/^the\s+/i, '');
     return `${opts.capital ? 'The' : 'the'} ${bare} host`;
 }

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

@@ -5,7 +5,7 @@ import { tableNoteLine } from './drop-in.js';
 import { NPC } from '../models/npc.js';
 import { hostLabel, hostPurposeFor } from './grid-names.js';
 import { isLinked } from './comm-style.js';
-import { isWatched, camerasLive, canSnoopFeeds, cameraMasterHost, camerasBroadcast, cameraStateNote } from './surveillance.js';
+import { isWatched, camerasLive, canSnoopFeeds, cameraMasterHost, camerasBroadcast, cameraStateNote, lensLive, lensMaster } from './surveillance.js';
 import { wanDevices } from './wan.js';
 /**
  * The grid's icon inventory for one room -- everything a persona can
@@ -374,8 +374,17 @@ export function gridIcons(scene, actor, room) {
             // cable. It simply refused to say WHICH, in a district that has
             // exactly one, so the reader was left to guess at a fact the
             // engine had already handed them.
-            const owner = cameraMasterHost(scene.getRooms(), room);
-            icons.push(`◎ Camera cluster ${cameraDr(room, actor.name)}-- live, feeding ${owner ? hostLabel(owner) : `the site's host`}. Loud acts here travel. (own the host to loop them -- or walk in and "tap" a lens in the flesh: slaved to the host means a key to the host)`);
+            // EACH LIVE LENS'S OWN MASTER (surveillance.ts lensMaster): a strip's
+            // lenses can feed every shop along it.
+            const all = scene.getRooms();
+            const owners = [...new Set(room.ensureCameras().filter(c => lensLive(all, room, c)).map(c => lensMaster(all, room, c)))]
+                .filter((r) => !!r);
+            if (owners.length === 0) {
+                const fallback = cameraMasterHost(all, room);
+                if (fallback)
+                    owners.push(fallback);
+            }
+            icons.push(`◎ Camera cluster ${cameraDr(room, actor.name)}-- live, feeding ${owners.length > 0 ? owners.map(o => hostLabel(o)).join(' and ') : `the site's host`}. Loud acts here travel. (own the host to loop them -- or walk in and "tap" a lens in the flesh: slaved to the host means a key to the host)`);
         }
     }
     // THE DIVIDER (eJANPpm7qCaCAJBJw). Only when there is a host to be

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

@@ -1,5 +1,7 @@
 import { hostIsHunting, hostLaunchStep } from './ic.js';
 import { personasInside } from './matrix-roster.js';
+import { spidersIn } from './spider.js';
+import { turnHostile } from './hostile-contact.js';
 /**
  * THE HOST OWNS ITS FIGHT (2026-09-13, the Matrix joins the Combat Turn).
  *
@@ -27,12 +29,28 @@ import { personasInside } from './matrix-roster.js';
  * holds the Scene and the encounter.
  */
 const empty = () => ({ lines: [], meta: [], world: [] });
-/** Every program the host has running as an actor, seated in the fight. */
-function seatRunningIce(enc, host) {
+/**
+ * Every program the host has running as an actor, seated in the fight --
+ * and every SPIDER riding it (utilities/spider.ts). A host that is
+ * fighting an intruder has made one, and the deckers sitting in it are
+ * its security: they are told, and they turn on it (the owner-guard
+ * rule, owner-guard.ts, for the people inside the architecture).
+ */
+function seatRunningIce(enc, host, scene) {
     for (const ice of host.iceActors.values()) {
         if (!enc.has(ice) && !ice.isIncapacitated())
             enc.join(ice);
     }
+    if (!scene)
+        return;
+    for (const spider of spidersIn(scene, host)) {
+        if (spider.isIncapacitated() || spider.surrendered)
+            continue;
+        if (spider.hostile !== true)
+            turnHostile(spider, scene.beat ?? 0, `${host.name} is fighting an intruder`);
+        if (!enc.has(spider))
+            enc.join(spider);
+    }
 }
 /** Report one host step to the persona's watchers. */
 async function tell(enc, scene, turn) {
@@ -55,12 +73,12 @@ export async function hostTurnStart(scene, host, enc) {
     if (host.icLaunchDelay > 0) {
         host.icLaunchDelay -= 1;
         out.lines.push(`{light-blue-fg}Something in ${host.name}'s architecture is arguing with itself -- whatever it meant to bring up does not arrive.{/light-blue-fg}`);
-        seatRunningIce(enc, host);
+        seatRunningIce(enc, host, scene);
         await tell(enc, scene, out);
         return;
     }
     hostLaunchStep(host.over, scene, out);
-    seatRunningIce(enc, host);
+    seatRunningIce(enc, host, scene);
     await tell(enc, scene, out);
 }
 /** The fight goes on while the host is alert and someone human is still
@@ -95,7 +113,7 @@ export async function openHostEncounter(scene, host, intruder) {
         onNewTurn: e => hostTurnStart(scene, host, e),
         keepAlive: () => hostKeepsFighting(scene, host),
     });
-    seatRunningIce(enc, host);
+    seatRunningIce(enc, host, scene);
     if (out.lines.length > 0)
         await enc.announce(out.lines, out.meta);
     return enc;

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

@@ -120,6 +120,27 @@ export const IC_TYPES = [
     { name: 'Track IC', kind: 'track', attacks: true, hurtByFailure: true, marksNeeded: 2 },
     { name: 'Scramble IC', kind: 'scramble', attacks: true, hurtByFailure: true, marksNeeded: 3 },
 ];
+/**
+ * AN IC NAME AS AN AUTHOR WRITES IT -- "Probe", "probe ic", "Black IC" --
+ * to the engine's program, or undefined when the engine does not model
+ * it (Data Trails' Bloodhound, Tar Baby, Shocker, Crash).
+ */
+export function icTypeNamed(name) {
+    const n = name.trim().toLowerCase().replace(/\s+ic$/, '');
+    return IC_TYPES.find(t => t.name.toLowerCase().replace(/\s+ic$/, '') === n);
+}
+/** A host's launch order: the author's, resolved, else the default. */
+export function resolveICOrder(order) {
+    if (!order || order.length === 0)
+        return IC_TYPES;
+    const out = [];
+    for (const n of order) {
+        const t = icTypeNamed(n);
+        if (t && !out.includes(t))
+            out.push(t);
+    }
+    return out.length > 0 ? out : IC_TYPES;
+}
 const empty = () => ({ lines: [], meta: [], world: [] });
 /**
  * Does this host act at all this turn?
@@ -398,7 +419,12 @@ export function hostLaunchStep(room, scene, out) {
             crashIC(scene, host, kind);
             out.lines.push(`  {red-fg}${kind} shears apart -- crashed. The host is already recompiling it.{/red-fg}`);
         }
-        if (host.relaunchQueue.length > 0 && room.runningIC.length < room.hostRating) {
+        // THE BRICKED POLICY (Data Trails p.91-102): most hosts reboot a
+        // crashed program first; some continue down the line and reboot only
+        // once the lineup is spent.
+        const continueFirst = host.icBricked === 'continue'
+            && resolveICOrder(host.icOrder).some(t => !room.runningIC.includes(t.name) && !host.relaunchQueue.includes(t.name));
+        if (!continueFirst && host.relaunchQueue.length > 0 && room.runningIC.length < room.hostRating) {
             const kind = host.relaunchQueue.shift();
             room.runningIC.push(kind);
             if (scene)
@@ -409,7 +435,8 @@ export function hostLaunchStep(room, scene, out) {
         }
     }
     if (room.runningIC.length < room.hostRating) {
-        const next = IC_TYPES.find(t => !room.runningIC.includes(t.name) && !(host?.relaunchQueue.includes(t.name)));
+        // THE HOST'S OWN ORDER when its author wrote one (Data Trails p.91-102).
+        const next = resolveICOrder(host?.icOrder).find(t => !room.runningIC.includes(t.name) && !(host?.relaunchQueue.includes(t.name)));
         if (next) {
             room.runningIC.push(next.name);
             if (host && scene)

package/bundle/typescript/src/commands/game/sideQuest/utilities/ledge-jump.js

@@ -0,0 +1,86 @@
+import { hint } from './hints.js';
+import { roomAtCell, isVoid } from './district-plane.js';
+import { cellOnGrid, METERS_PER_LEVEL } from './room-grid.js';
+import { actorCell, spotForCell } from './spots.js';
+import { resolveFall } from './falling.js';
+import { Logger } from './logger.js';
+const STEP = { north: [0, -1], south: [0, 1], west: [-1, 0], east: [1, 0] };
+// Spelled out in full: a drop is never one letter away.
+const WORD = { north: 'north', south: 'south', east: 'east', west: 'west' };
+/** A compass word, spelled out ("leap off north"). */
+export function ledgeDirection(word) {
+    return word ? WORD[word.toLowerCase()] : undefined;
+}
+/**
+ * OFF THE EDGE, ON PURPOSE (user rulings 2026-10-06): the ground is
+ * walkable everywhere, but an outdoor area on any other storey -- a
+ * balcony, a catwalk, a rooftop -- is a ledge: walking stops at its edge,
+ * and "leap off <direction>" (commands/leap.ts) goes over it. You come down on whatever outdoor
+ * ground lies below that spot and take the landing (SR5 p.172: more than
+ * three metres is DV = metres, AP -4, Body + Armor -- utilities/falling.ts).
+ * A building's roof is not a place you can land on until someone draws
+ * it as one, so a jump that would land there is refused, as is one over
+ * nothing at all.
+ */
+export function ledgeJump(scene, actor, dir) {
+    const room = actor.currentLocation;
+    if (actor.plane !== 'meat')
+        return `Your body has to be there to jump.`;
+    const plane = room?.scene?.ensurePlane();
+    const at = plane?.placements.get(room.name.trim().toLowerCase());
+    if (!room || !plane || !at || !room.outdoors)
+        return `There is no ledge to jump from in here.`;
+    if (at.origin.z === 0)
+        return `You are on the ground already -- walk ("go ${dir}").`;
+    const cell = actorCell(room, actor);
+    if (!cell)
+        return `You need to be standing somewhere first.`;
+    const step = STEP[dir];
+    const next = { x: cell.x + step[0], y: cell.y + step[1], z: 0 };
+    const grid = room.ensureGrid();
+    if (grid && cellOnGrid(grid, next))
+        return `The edge isn't that way -- there is more ${room.name} to walk on ("go ${dir}").`;
+    const world = { x: at.origin.x + next.x, y: at.origin.y + next.y, z: at.origin.z };
+    if (!isVoid(plane, world))
+        return `That is not a drop -- ${roomAtCell(plane, world) ? `walk ("go ${dir}")` : 'there is a wall there'}.`;
+    // DOWN TO WHATEVER IS UNDER THAT SPOT.
+    let landing;
+    let landZ = world.z;
+    for (let z = world.z - 1; z >= Math.min(0, ...plane.storeys); z--) {
+        if (plane.walls.has(`${world.x},${world.y},${z}`))
+            return `There is a wall straight below -- nothing to land on.`;
+        const owner = roomAtCell(plane, { x: world.x, y: world.y, z });
+        if (!owner)
+            continue;
+        const r = Object.values(scene.getRooms()).find(x => x.name.trim().toLowerCase() === owner);
+        if (!r?.outdoors)
+            return `Below that edge is ${r ? `${r.name}'s roof` : 'a roof'} -- nothing anyone has made a place to land on.`;
+        landing = r;
+        landZ = z;
+        break;
+    }
+    if (!landing)
+        return `There is nothing mapped below that edge to land on.`;
+    const there = plane.placements.get(landing.name.trim().toLowerCase());
+    const local = { x: world.x - there.origin.x, y: world.y - there.origin.y, z: 0 };
+    const below = landing.ensureGrid();
+    if (!below || !cellOnGrid(below, local))
+        return `Something stands right where you would come down -- not there.`;
+    const meters = (world.z - landZ) * METERS_PER_LEVEL;
+    actor.currentLocation = landing;
+    actor.atCell = local;
+    actor.atSpot = spotForCell(landing, local);
+    actor.visitedRooms.add(landing.name);
+    actor.performAction('jumps down', `from ${room.name} to ${landing.name}`);
+    const fall = resolveFall(actor, meters);
+    if (fall.meta)
+        Logger.getInstance().meta(fall.meta);
+    scene.updateStatus?.();
+    const landingLine = fall.dv <= 0
+        ? `You land on ${landing.name} -- ${meters} m, and nothing worse than stinging soles.`
+        : fall.dealt > 0
+            ? `You come down hard on ${landing.name} -- ${meters} m -- and the landing costs you ${fall.dealt} box${fall.dealt === 1 ? '' : 'es'}: ${actor.conditionSummary()}`
+            : `You come down hard on ${landing.name} -- ${meters} m -- and the armor eats it.`;
+    return `You go over the ${dir} edge of ${room.name}. ${landingLine}${hint(' ("look" to see where you are.)')}`;
+}
+//# sourceMappingURL=ledge-jump.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/map-view.js

@@ -538,7 +538,8 @@ export function collectPlaneBodies(input) {
              * it is seeing the light they cast. What DOES stop it is the one
              * thing canon calls opaque astrally -- a ward (SG p.107).
              */
-            const wards = (room.warded ? 1 : 0) + (viewer.currentLocation?.warded && room !== viewer.currentLocation ? 1 : 0);
+            // A surface, not a fog: nothing to cross inside your own room.
+            const wards = room === viewer.currentLocation ? 0 : (room.warded ? 1 : 0) + (viewer.currentLocation?.warded ? 1 : 0);
             const auraLit = astral && at !== undefined
                 && castsAura(actor)
                 && auraVisible(distanceMeters(at, cell), wards);

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

@@ -34,6 +34,10 @@ export async function runNpcActionPhase(enc, npc) {
     // weapon to draw, no ground to close -- one test, by type.
     if (npc.icKind !== undefined)
         return runIcActionPhase(enc, npc);
+    // A SPIDER FIGHTS AS A PERSONA (utilities/spider.ts): no gun, no
+    // ground -- the Data Spike a player types.
+    if (npc.plane === 'matrix')
+        return runPersonaActionPhase(enc, npc);
     const logger = Logger.getInstance();
     if (npc.isIncapacitated() || npc.surrendered)
         return;
@@ -298,4 +302,29 @@ async function paceToward(npc, target) {
             return;
     }
 }
+/**
+ * A SPIDER'S ACTION PHASE (utilities/spider.ts): one Data Spike (p.239,
+ * a Complex Action) at the intruder it is already fighting, else the
+ * first in reach -- through `attack`, the verb a decker types, so the
+ * test, the bill and the refusals are a player's.
+ */
+async function runPersonaActionPhase(enc, npc) {
+    const logger = Logger.getInstance();
+    if (npc.isIncapacitated() || npc.surrendered)
+        return;
+    const enemies = enc.enemiesOf(npc);
+    if (enemies.length === 0)
+        return;
+    const target = npc.combatOpponent && enemies.includes(npc.combatOpponent) ? npc.combatOpponent : enemies[0];
+    npc.combatOpponent = target;
+    npc.lastExchangeAt = Date.now();
+    if (!enc.budgetOf(npc)?.complexAvailable)
+        return;
+    const r = await npc.actInCombat(`attack ${target.name}`);
+    logger.write(`Brain: ${npc.name} (persona) attack ${target.name} -> ${r.split('\n')[0]}`);
+    // The arena's own announce: a host's watchers are personas whose
+    // bodies are anywhere, which a room-scoped line would miss.
+    if (!enc.budgetOf(npc)?.attackTaken)
+        await enc.announce([`${npc.name}'s icon turns on ${target.name} and can't find the angle.`], []);
+}
 //# sourceMappingURL=npc-combat-brain.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/owner-guard.js

@@ -0,0 +1,77 @@
+import { NPC } from '../models/npc.js';
+import { wouldNotice } from './spots.js';
+import { turnHostile } from './hostile-contact.js';
+/**
+ * A ROOM'S OWNER GUARDS WHAT IS THEIRS (user ruling 2026-10-06: "a room
+ * owner also guards all its security devices, and hosts. That is, hostile
+ * actions that the guarder notices caused them to react. This can include
+ * marks made on the attacker").
+ *
+ * Two ways the owner comes to know, and they are different facts:
+ *
+ *  - INFORMED, through the Matrix. SR5 p.231 / p.236: on a FAILED SLEAZE
+ *    action "your target immediately gets one free mark on you (or its
+ *    owner does, if your target is a device) ... A device immediately
+ *    informs its owner"; a slaved device's mark goes to the device's
+ *    owner, not to its master (p.233). A SUCCESSFUL ATTACK action makes
+ *    the target aware it is under attack, and it "will almost always alert
+ *    its owner" (p.236). The owner need not be anywhere near.
+ *  - WITNESSED, in the meat: picking, breaching or smashing their lock or
+ *    their camera in front of them -- the same notice every act already
+ *    gets (spots.ts wouldNotice).
+ *
+ * What the owner DOES on knowing is not in canon ("depending on the
+ * owner's preferences and the gamemaster's judgment", p.236) -- that is
+ * the user's ruling: they turn hostile (hostile-contact.ts turnHostile,
+ * the one writer of provoked hostility; the ladder opens the fight).
+ */
+/** The NPC who owns `room` (room seed `owner`), if they are about. */
+export function ownerOf(scene, room) {
+    const name = room?.owner;
+    if (!scene || !name)
+        return undefined;
+    const actor = scene.getActor?.(name);
+    return actor instanceof NPC && !actor.isIncapacitated() ? actor : undefined;
+}
+/**
+ * THE OWNER IS INFORMED (Matrix). `device-sleaze`: the owner also takes the
+ * free mark on the hacker (p.231/p.236), held the way an NPC holds marks
+ * on a persona today (Player.panMarksBy, capped at 3 -- p.236). Either
+ * way they turn hostile. Returns the line the hacker should read, or
+ * undefined when the place has no owner.
+ */
+export function ownerInformed(scene, room, actor, how, what) {
+    const owner = ownerOf(scene, room);
+    if (!owner || owner === actor || owner.allyOf === actor.name)
+        return undefined;
+    // The free mark goes to the OWNER only when the target was a DEVICE
+    // (p.236 "or its owner does, if your target is a device"); a host keeps
+    // its own mark on you (hack.ts), and its owner is told.
+    if (how === 'device-sleaze') {
+        const held = actor.panMarksBy.get(owner.name) ?? 0;
+        if (held < 3)
+            actor.panMarksBy.set(owner.name, held + 1);
+    }
+    turnHostile(owner, scene?.beat ?? 0, how !== 'attack-landed'
+        ? `${what} told its owner about ${actor.name}'s failed intrusion`
+        : `${what} told its owner it was under attack by ${actor.name}`);
+    return how === 'device-sleaze'
+        ? `${what} tells its owner, ${owner.name} -- who now holds a mark on you, and knows your icon.`
+        : how === 'host-sleaze'
+            ? `${what} tells its owner, ${owner.name}, that someone is in.`
+            : `${what} raises the alarm with its owner, ${owner.name}.`;
+}
+/**
+ * THE OWNER WITNESSES (meat): in the room, conscious, and noticing the
+ * actor -- then they turn hostile. Returns the line, or undefined.
+ */
+export function ownerWitnesses(scene, room, actor, what) {
+    const owner = ownerOf(scene, room);
+    if (!owner || owner.allyOf === actor.name)
+        return undefined;
+    if (owner.currentLocation !== room || !owner.canPerceive(actor) || !wouldNotice(owner, actor))
+        return undefined;
+    turnHostile(owner, scene?.beat ?? 0, `watched ${actor.name} go at ${what}`);
+    return `${owner.name} sees you go at ${what} -- theirs -- and turns on you.`;
+}
+//# sourceMappingURL=owner-guard.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/path-run.js

@@ -1,6 +1,6 @@
 import { Door } from '../models/door.js';
 import { Direction } from '../types/shared/direction-enum.js';
-import { key, levelFootprint, isCellBlocked, METERS_PER_CELL } from './room-grid.js';
+import { key, levelFootprint, isCellBlocked, cellOnGrid, METERS_PER_CELL } from './room-grid.js';
 import { actorCell, furnitureCells, standingOccupants, openGroundBeyond, approachCellFor } from './spots.js';
 import { forgetLastStep } from './movement-cost.js';
 import { worldNow } from './world-clock.js';
@@ -130,7 +130,9 @@ function walkable(room, actor, z) {
         if (furniture.has(k))
             return false;
         const inBounds = c.x >= 0 && c.y >= 0 && c.x < grid.dims.x && c.y < grid.dims.y;
-        if (inBounds)
+        // A hole (another room's cell) is decided by the plane, like past
+        // the edge -- spots.ts stepFrom, the same rule.
+        if (inBounds && (z !== 0 || cellOnGrid(grid, c)))
             return floor.has(k);
         return outside(c);
     };

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

@@ -274,7 +274,9 @@ export function leaveMatrix(scene, actor, opts) {
     // deck stays live and the agent keeps its hunt; an idle agent (or any
     // forced dump) is a clean jack-out reboot that folds it.
     const game = scene.ownerGame;
-    const agentEntry = game?.companions.find(c => c.kind === 'agent');
+    // The table's agent rides a RUNNER's deck: a spider dumped out of its
+    // host (utilities/spider.ts) reboots its own deck, not theirs.
+    const agentEntry = scene.isHumanControlled?.(actor) === false ? undefined : game?.companions.find(c => c.kind === 'agent');
     if (agentEntry) {
         if (!opts?.forced && agentEntry.npc.objective) {
             lines.push(`You drop to AR instead of a hard jack-out -- the deck stays live in your bag, your agent stays on the grid working its directive, and its status ghosts across the same AR overlay your link feeds you.`);